之前所学的整理（截止到面向对象编程）

package 课堂test;

import java.lang.reflect.Array;
import java.util.Arrays;

public class 所学内容汇总 {
    static int a2 = 5;          //这是一个成员变量
    public static void main(String[] args) {
        System.out.println("输出一句简单的话");        //开始接触java所学的第一堂课，输出。
        
        //基本的数据类型，4种类型，8种数据
        byte a = 8;              //数据类型中8位等于一个字节
        short b = 16;
        int c = 32;        float f = 32;           //int和float位数是一样的，注意float型如果赋值为小数后面必须加 f ，赋值为整数的时候可以不加
        long d = 64;       double g = 64;     //long和double位数是一样的，double后面不需要加d
        char e = 16;
        boolean h;          //布尔型数据只有两个值true or false
        
        //常用的转义字符，课本P43
        char c1 = '\\';      char c2 = '\u2605';
        System.out.println(c1+"\n"+c2+" \' ");
        System.out.println(0);
        //标识符和关键字，java是严格区分大小写的，标识符规则是，不能用关键字做标识符，不能以数字开头，组成部分可以是字母，下划线，$
        //常用关键字，课本P44。
        //声明常量
        final int a1 = 1;        //只能被赋值一次，并且不能被更改
        //局部变量与成员变量，第4行程序为静态成员变量，在整个类中都可以使用，第22行为局部变量，只能在方法体中使用。
        //算数运算符
        System.out.println("a+b求和"+(a + b));
        System.out.println("a+b="+a + b);         //加法运算如果不加括号+就变成了连接符
        System.out.println("b-a求差"+(b - a));
        System.out.println("a,b求积"+a * b);
        System.out.println("d,a求商"+d / a);
        System.out.println("d对5取余"+d % a2);
        System.out.println(1);
        //比较运算符，比较运算符的返回结果全部为布尔型数据
        System.out.println(a > b);
        System.out.println(a < b);
        System.out.println(a == b);
        System.out.println(a <= b);
        System.out.println(a >= b);
        System.out.println(a != b);
        System.out.println(2);
        //逻辑运算符(与&)，(或|)，(非！)，操作元必须是布尔型的，所以返回值也是布尔型的，注意有一个短路写法(与&&)，(或||)★★★
        //运算符的优先级，课本P55。
        //数据类型的转换
         int a3 = a + (int)f;      //在标识符前面加个括号里面写上要转成的类型
         
         //复合语句，又称块语句，以一个区域为单位
         
         //条件语句和循环语句
         if(a > 0) {
             System.out.println("a是大于0的");
         }
         System.out.println(3);
         
         if(a < 0) {
             System.out.println("a是小于0的");
         }
         else {
             System.out.println("a是大于0的");
         }
        System.out.println(4);
        
        if(a > 0) {
            System.out.println("a是大于0的");
        }
        else if(a == 0) {
            System.out.println("a是等于0的");
        }
        else {
            System.out.println("a是小于0的");
        }
        System.out.println(5);
        
        //switch case多分支语句
        switch(a + b)            //switch里面可以是一个字符串，也可以是任何能表达的一个条件式
        {
             case 1:         //case后面的值必须为常量
                 System.out.println("haha");
                 break;            //如果不加break，系统会执行这个的语句块
             case 2:
                 System.out.println("hehe");
                 break;
             default:
                 System.out.println("hoho");
                 break;
        }
        System.out.println(6);
        
        while(a < 50)
        {
            System.out.print(a + " ");
            a++;
            a++;
        }
        System.out.println();
        System.out.println(7);
        
        do
        {
            System.out.print(a2 + " ");
            a2++;
            a2++;
            a2++;
            a2++;
        }
        while(a2 < 50);
        System.out.println();
        System.out.println(8);
        
        //for循环，计算1加到100的值
        int a6 = 0;
        for(int a4 = 1; a4<=100; a4++)
        {
            a6 = a6 + a4;
        }
        System.out.println("1+2+...+99+100="+a6);
        
        //字符串，字符串的定义
        String s;
        //两种定义方法
        s = "我们都是好学生";
        
        char[] ss = {'我', '们', '都', '是', '好', '学', '生'};            //这句本身就是在定义一个字符串
        s = new String(ss);
        System.out.println(s);
        s = new String(ss, 2, 5);      //代表的意义是从索引值为2的字符开始一共5个字符组成的字符串
        System.out.println(s);
        System.out.println(9);
        String String = "StringString";    //String 可以做变量名
        System.out.println(String); 
        //字符串的操作
        //1，获取字符串的长度
        String str = "What's tHe Matter?           ";
        int b1 = str.length();
        //2，查找字符串
        int b2 = str.indexOf("t");
        int b3 = str.lastIndexOf("t");
        int b4 = str.lastIndexOf("");                  //可以作为检验字符串长度的方法
        System.out.println("b1的值为"+b1+"\nb2的值为"+b2+"\nb3的值为"+b3+"\nb4的值为"+b4);
        System.out.println(str.charAt(9)+" "+str.charAt(8));               //输出指定索引位置的字符
        //截取字符串
        String str1 = str.substring(4);
        String str2 = str.substring(5, 11);
        System.out.println(str.trim().length()+"\n"+str1+"\n"+str2);
        System.out.println(10);
        //字符串的替换
        String str3 = str.replace("what", "How");             //替换之后要有一个变量来装下替换后的字符串
        //判断字符串的开始和结尾，注意返回值的类型为布尔型的
        boolean b5 = str.startsWith("W");
        boolean b6 = str.endsWith("?");
        System.out.println(str3+"\n"+b5+"\n"+b6);
        System.out.println(11);
        
        //判断字符串是否相等
        String str4 = "How are you";
        String str5 = "How are you";
        String str6 = new String("How are you");
        String str7 = new String("How are you");
        boolean x = str4==str5;
        boolean y = str6==str7;
        boolean z = str6.equals(str7);
        System.out.println("x的值为"+x);
        System.out.println("y的值为"+y);
        System.out.println("z的值为"+z);
        String str8 = str4.toUpperCase();           //也是需要一个新的字符串变量来装下新的编程大写的字符串
        String str9 = str.toLowerCase();
        System.out.println(str8+"\n"+str9);
        //字符串分割
        String[] str0 = str.split("t");         //字符串分割后就变成了一个字符型数组，注意用新的变量成装的时候加"[]"
        for(int s1 = 0; s1 < str0.length; s1++)       //for语句循环遍历
        {
            System.out.print(str0[s1]+" ");
        }
        System.out.println();
        System.out.println(12);
        for(String s2 : str0)           //foreach循环遍历
        {
            System.out.print(s2+" ");
        }
        System.out.println();
        //格式化字符串，课本P91。
        //字符串生成器 StringBuilder
        StringBuilder sb = new StringBuilder();
        sb.append("q");
        sb.append('w');
        sb.append(4);
        sb.append(true);
        sb.append(3.1314);
        System.out.println(sb);
        sb.insert(2, "X");            //在这个索引值位置的前面插入字符
        System.out.println(sb);
        sb.delete(2, 6);
        System.out.println(sb);
        
        //一维数组
        //创建数组是一个数据元素类型和一个[]
        //分别定义和初始化一个数组
        int[] arr = new int[5];      //此为定义一个数组，必须有的是数组元素的数据类型和数组的长度
        int[] arr1 = {16, 11, 81, 10, 21, 13, 41, 25};
        int[] arr2 = new int[] {12, 23, 34, 45, 56};          //此为两个数组的赋值，记住一定要加上[]
        arr1[2] = 7;
        //一维数组的遍历
        for(int c3 = 0; c3 < arr1.length; c3++)
        {
            System.out.print(arr1[c3]+" ");
        }
        System.out.println();
        //foreach语句的遍历
        for(int c4 : arr2)
        {
            System.out.print(c4+" ");
        }
        System.out.println();
        System.out.println(13);
        //声明二维数组
        int[][] arr3;
        int arr4[][];
        //为二维数组赋值，也可以只赋值前面几行，但是不能只赋值后面的列。
        int[][] arr5 = new int[3][];
        int[][] arr6 = new int[3][5];
        //不规则的二维数组
        int[][] arr7 = {{12, 34, 5}, {34, 7, 89, 45}, {29}};
        arr7[1][1] = 24;             //直接给一个二维数组的一个元素赋值，这个办法同样适用于一维数组
        //遍历二维数组
        for(int c5 = 0; c5 <arr7.length; c5++)
        {
            for(int c6 = 0; c6<arr7[c5].length; c6++)
            {
                System.out.print(arr7[c5][c6]+" ");
            }
            System.out.println();
        }
        System.out.println(13);
        //foreach遍历二维数组
        for(int[] c7 : arr7)
        {
            for(int c8 : c7)
            {
                System.out.print(c8+" ");         //课本P108，有疑问
            }
            System.out.println();
        }
        //数组的操作，填充，替换，复制，排序
        Arrays.fill(arr, 3);
        for(int c3 = 0; c3 < arr.length; c3++)
        {
            System.out.print(arr[c3]+" ");
        }
        System.out.println();
        Arrays.fill(arr, 2, 5, 8);
        for(int c3 = 0; c3 < arr.length; c3++)
        {
            System.out.print(arr[c3]+" ");
        }
        System.out.println();
        Arrays.sort(arr1);
        for(int c3 : arr1)
        {
            System.out.print(c3+" ");
        }
        System.out.println();
        int[] arr8 = new int[4];
        arr8 = Arrays.copyOf(arr1, arr8.length);          //复制操作的返回值为一个新的数组，并不是一个方法，所以也是需要赋值给别的变量
        for(int c3 : arr8)
        {
            System.out.print(c3+" ");
        }
        System.out.println();
        arr8 = Arrays.copyOf(arr1, 12);         //复制操作的返回值为一个新的数组，并不是一个方法，所以也是需要赋值给别的变量
        for(int c3 : arr8)
        {
            System.out.print(c3+" ");
        }
        System.out.println();
        int d1 = Arrays.binarySearch(arr1, 41);            //道理同上，也是需要赋值给一个变量
        int d2 = Arrays.binarySearch(arr1, 1, 7, 25);
        System.out.println(d1+" "+d2);
    }

}

package 汇总;

public class lei {
    public lei()            //构造方法必须和类名相同
    {
        System.out.println("选择排序算法");
    }
    public int n;
    public int i = 0;
    public int j = 0;
    public void maopaoPX(int[] arr)           //类中的方法函数，定义成员方法
    {
        System.out.println("冒泡排序");
        for(j = 0; j <= arr.length; j++)
        {
            for(i = 1; i <= arr.length - j - 1; i++)
            {
                if(arr[i - 1] < arr[i])
                {
                    n = arr[i - 1];
                    arr[i - 1] = arr[i];
                    arr[i] = n;
                }
            }
        }
        for(int m : arr)
        {
            System.out.print(m+" ");
        }
        System.out.println();
    }
    public void fanzhuanPX(int[] arr)
    {
        System.out.println("反转排序");
        for(i = 0; i < arr.length/2; i++)
        {
            n = arr[arr.length - i - 1];
            arr[arr.length - i - 1] = arr[i];
            arr[i] = n;
        }
        for(int m : arr)
        {
            System.out.print(m+" ");
        }
        System.out.println();
    }
    
}

package 汇总;

public class testlei {

    public static void main(String[] args) {
        int[] arr = new int[]{12, 47, 55, 22, 10, 11, 3, 43};
        int[] arr1 = new int[]{13, 56, 23, 33, 41, 42, 5, 2, 9};
        int[] arr2 = new int[]{2, 14, 3, 7, 12, 19};
        //arr[] = {12, 22, 10, 11, 45, 98, 43};
        lei we = new lei();
        we.maopaoPX(arr);
        we.maopaoPX(arr1);
        we.fanzhuanPX(arr2);
    }
}

 

eclipse显示结果：

输出一句简单的话
\
★ '
0
a+b求和24
a+b=816
b-a求差8
a,b求积128
d,a求商8
d对5取余4
1
false
true
false
true
false
true
2
a是大于0的
3
a是大于0的
4
a是大于0的
5
hoho
6
8 10 12 14 16 18 20 22 24 26 28 30 32 34 36 38 40 42 44 46 48
7
5 9 13 17 21 25 29 33 37 41 45 49
8
1+2+...+99+100=5050
我们都是好学生
都是好学生
9
StringString
b1的值为29
b2的值为3
b3的值为14
b4的值为29
e H
18
's tHe Matter?
s tHe
10
What's tHe Matter?
true
false
11
x的值为true
y的值为false
z的值为true
HOW ARE YOU
what's the matter?
Wha 's He Ma er?
12
Wha 's He Ma er?
qw4true3.1314
qwX4true3.1314
qwue3.1314

16 11 7 10 21 13 41 25
12 23 34 45 56
13
12 34 5
34 24 89 45
29
13
12 34 5
34 24 89 45
29
3 3 3 3 3
3 3 8 8 8
7 10 11 13 16 21 25 41
7 10 11 13
7 10 11 13 16 21 25 41 0 0 0 0
7 6

 

选择排序算法
冒泡排序
55 47 43 22 12 11 10 3
冒泡排序
56 42 41 33 23 13 9 5 2
反转排序
19 12 7 3 14 2

 

 

一些之前上课的时候没留心的问题，

1，复合语句，又称块语句，以一个区域为单位。

2，char[] ss = {'我', '们', '都', '是', '好', '学', '生'}; 这句本身就是在定义一个字符串。

3，在对字符串进行操作的时候，比如替换，截取，更改大小写等操作的时候，只是创建了一个新的字符串，对原字符串并不会有改动。并且也需要将新的字符串赋值给一个变量来保存下来。

4，String不是一个关键字，可以用来作为标识符。

5，字符串生成器中可以添加boolean型的字符，就是true和false，添加进去之后就变成字符串了

6，int b1 = str.length();  s1 < str0.length;一个是方法，一个是属性，这里代表的含义是一样的，但得到最后结果的方法不同

7，二维数组赋值，可以只赋值前面几行，但是不能只赋值后面的列。比如，int arr[][] = new int[3][];是可以的，int arr[][] = new int[][3]不行;

8，arr7[1][1] = 24;直接给一个二维数组的一个元素赋值，这个办法同样适用于一维数组