Java基础语法系列（1）

1. 基本语法展示

1.1 字符串

• 字符串作为操作对象：核心操作就是字符串的字符列表转化（string.toCharArray()）；字符串的分割（string.split()）
• 类型转化，记住两点：需要转化为字符串就是用String.valueOf();转化为其他就是用Integer.valueOf(），把需要转化的对象放在前面

    public static void main(String[] args) {
        // 1)字符串的定义，分割，类型转化（变为char[]类型），输出
        String str1 = "apple";
        String str2 = "127.0.1";
        String str3 = "apple banana tomato";
        String str4 = "abc_dfg_ghi";

        char[] str1ToChar = str1.toCharArray();
        String[] strings1 = str2.split("\\.");  //特殊字符，需要先转义
        String[] strings3 = str3.split(" ");
        String[] strings4 = str4.split("_");

        System.out.println("str1ToChar=" + Arrays.toString(str1ToChar)); //str1ToChar=[a, p, p, l, e]
        System.out.println("string2=" + Arrays.toString(strings1)); //string2=[127, 0, 1]
        System.out.println("string3=" + Arrays.toString(strings3)); //string3=[apple, banana, tomato]
        System.out.println("string4=" + Arrays.toString(strings4)); //string4=[abc, dfg, ghi]

        //字符之间的转化：其他类型转变为字符串
        int trans1 = 3;
        double trans2 = 3.2;
        boolean trans3 = false;
        char trans4 = 'a';

        String ints = String.valueOf(trans1);  //ints=3
        String doubles = String.valueOf(trans2);  
        String booleans = String.valueOf(trans3);
        String chars = String.valueOf(trans4);

        System.out.println("ints=" + ints);  //ints=3
        System.out.println("doubles=" + doubles); //doubles=3.2
        System.out.println("booleans=" + booleans); //booleans=false
        System.out.println("chars=" + chars); //chars=a

        //字符之间的转化：字符串转变为其他类型
        int trans11 = Integer.valueOf(ints);
        double trans22 = Double.valueOf(doubles);
        boolean trans33 = Boolean.valueOf(booleans);
        System.out.println("trans11=" + trans11); //trans11=3
        System.out.println("trans22=" + trans22); //trans22=3.2
        System.out.println("trans33=" + trans33); //trans33=false

        // 字符串间比较大小
        String stringBig="zbbc";
        String stringSmall="zaca";
        System.out.println("the bigger one="+stringBig.compareTo(stringSmall)); //the bigger one=1

        // StringBuilder的使用(统一变为字符串，进行拼接)
        StringBuilder stringBuilder=new StringBuilder();
        stringBuilder.append(2);
        stringBuilder.append(444);
        stringBuilder.append("aaaa");
        stringBuilder.append(false);
        System.out.println("stringBuilder="+stringBuilder);    //stringBuilder=2444aaaafalse
    }

1.2 数组

    public static void main(String[] args) {
        //思考：数组的排序核心依赖Arrays函数，排序，填充初值，输出字符串都靠这个

        //1)数组定义
        int[] ints1 = new int[2];
        int[] ints2;
        int[] ints4 = new int[]{1, 2, 3};
        int[][] ints5 = new int[2][3];

        //2）数组赋值和拷贝
        ints1[0] = 1;
        Arrays.fill(ints4, -1); //批量赋初值
        int[] intsCopy = Arrays.copyOf(ints4, ints4.length);
        intsCopy[1] = 2;
        System.out.println("ints4的值" + Arrays.toString(ints4)); //ints4的值[-1, -1, -1]
        System.out.println("intsCopy的值" + Arrays.toString(intsCopy)); //intsCopy的值[-1, 2, -1]

        //3）数组遍历
        for (int i = 0; i < ints4.length; i++) {
            System.out.println("ints4[" + i + "]=" + ints4[i]);
        }
        //ints4[0]=-1
        //ints4[1]=-1
        //ints4[2]=-1

        //4）数组排序
        //4。1：一维数组排序(sort是正序，集合类才能使用new Comparator)
        int[] sortArray = new int[]{2, 3, 4, 1, 5};
        System.out.println("初始的排序=" + Arrays.toString(sortArray));//初始的排序=[2, 3, 4, 1, 5]
        
        Arrays.sort(sortArray);
        System.out.println("默认的正序=" + Arrays.toString(sortArray));//默认的正序=[1, 2, 3, 4, 5]

        Integer[] sortArray1 = new Integer[]{2, 3, 4, 1, 5};
        System.out.println("初始的排序=" + Arrays.toString(sortArray1));//初始的排序=[2, 3, 4, 1, 5]
        Arrays.sort(sortArray1);
        System.out.println("默认的正序=" + Arrays.toString(sortArray1));//默认的正序=[1, 2, 3, 4, 5]
        Arrays.sort(sortArray1, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2 - o1;
            }
        });
        System.out.println("集合类使用函数的逆序=" + Arrays.toString(sortArray1));
        //集合类使用函数的逆序=[5, 4, 3, 2, 1]

        //4。2：二维数组排序(sort是正序，非集合类就能使用new Comparator)
        //排序规则：第一个数字从小到大排列，如果遇到相等的就按照第二个的大小从大到小排列
        int[][] sortArrays = new int[][]{{2, 1, 3}, {1, 2, 3}, {2, 2, 2}};
        System.out.println("二维数组默认排序不合法=" + Arrays.deepToString(sortArrays));
        //二维数组默认排序不合法=[[2, 1, 3], [1, 2, 3], [2, 2, 2]]
        Arrays.sort(sortArrays, new Comparator<int[]>() {
            @Override
            public int compare(int[] o1, int[] o2) {
                if(o1[0]==o2[0]){
                    return o2[1]-o1[1];
                }
                return o1[0]-o2[0];
            }
        });
        System.out.println("二维数组排序=" + Arrays.deepToString(sortArrays));
        //二维数组排序=[[1, 2, 3], [2, 2, 2], [2, 1, 3]]
    }

补充：进制转换

进制转化核心使用的是Integer的两个函数：Integer.valueOf()和Integer.toB,toO,toH的类函数

    public static void main(String[] args) {
        // 十进制转化为二进制，八进制和十六进制
        int tenTag=10;
        String twoTag=Integer.toBinaryString(tenTag);
        String eightTag=Integer.toOctalString(tenTag);
        String sixteenTag=Integer.toHexString(tenTag);
        String sixteenTagUpperCase=Integer.toHexString(tenTag).toUpperCase();
        System.out.println("十进制转二进制="+twoTag); //十进制转二进制=1010
        System.out.println("十进制转八进制="+eightTag); //十进制转八进制=12
        System.out.println("十进制转十六进制莫默认小写="+sixteenTag); //十进制转十六进制大写=a
        System.out.println("十进制转十六进制大写="+sixteenTagUpperCase); //十进制转十六进制大写=A

        //二进制，八进制和十六进制转化为十进制
        int twoToTen =Integer.valueOf(twoTag,2);
        int eightToTen =Integer.valueOf(eightTag,8);
        int sixteenToTen =Integer.valueOf(sixteenTag,16);
        System.out.println("二进制转十进制="+twoToTen); //二进制转十进制=10
        System.out.println("八进制转十进制="+eightToTen); //八进制转十进制=10
        System.out.println("十六进制转十进制="+sixteenToTen); //十六进制转十进制=10

        //二进制，八进制和十六进制转化：首先均转化为十进制，然后再从十进制转化为其他的进制
        //1)例子：把二进制111，转变为十六进制
        String two="111";
        String sisTeen=Integer.toHexString(Integer.valueOf(two,2));
        System.out.println("二进制转化为十六进制="+sisTeen); //二进制转化为十六进制=7
    }