Java学习第五天

数组

数组用于存储相同类型的一组数据，它是一种数据结构，也是java中的一种类型。

• 一个数组有多个数据（元素）

• 一个数组里面的元素都是相同类型

• 数组中的元素用序号（下标，从0开始）来访问

• 数组一旦初始化后，长度不能改变

定义数组

定义数组跟变量定义类似，变量类型后加【】

• 只定义数组，没有分配内存空间

• 没有长度

注：数组可以按 int arr[]; 定义，不推荐

        int[] arrInt;   //定义数组跟变量定义类似，变量类型后加【】
        char[] arrChar;
        boolean[] arrBoolean;
        String[] arrStr;

初始化数组

指定长度、分配内存空间、每个元素给初始化的值

• new 类型【长度】

• new 类型【】{ 赋值 }

• 定义的时候 类型【】 数组变量 = { } 直接赋值

如果数组初始化的时候没有赋值，按下面的规则给数组赋默认的值

数据类型	默认值
float、double	00
char	“\u0000”不可见字符
boolean	false
引用类型（类、接口、数组）	null
byte、short、int、long	0

给数组赋值：

        arrInt = new int[5];//长度为5,int类型数组默认初始值为0
        arrChar = new char[]{'a','b','c'};//初始化的同时赋值，赋几个值长度就为几
        arrStr = new String[] {"Tom","Jack"};
        float[] arrFloat = {3.12F,2.5F};//数组定义的时候用{}直接赋值

使用数组

数组变量名【下标】，就可以读写数组的元素

• 下标不能越界，否则会抛出异常

• 数组变量有一个lenght属性，可以获取数组的长度

        //数组的使用
        System.out.println(arrInt[0]);//数组变量名【下标】，读取数组指定元素的值
        System.out.println(arrStr[1]);
        System.out.println(arrFloat[2]);
​
        //数组的赋值
        arrInt[0] = 88;
        arrStr[1] = "世界";
        arrFloat[2] = 8.88F;
        System.out.println(arrInt[0]);
        System.out.println(arrStr[1]);
        System.out.println(arrFloat[2]);
​
        //访问数组元素时，超出范围会抛出异常：ArrayIndexOutOfBoundsException（数组下标越界）
        arrInt[5] = 100;

        //数组变量有一个lenght属性，就是数组的长度
        System.out.println(arrInt.length);//打印数组的长度

用循环遍历数组

• for循环

• foreach

  for（类型 变量名： 数组名）{

  //变量的值就是数组里元素

  }

        System.out.println("======顺序遍历数组======");
        for (int i = 0; i < arrInt.length; i++) {
            System.out.println(arrInt[i]);
        }
​
        System.out.println("======倒序遍历数组=======");
        for (int i = arrInt.length - 1; i >= 0; i--) {
            System.out.println(arrInt[i]);
        }
​
        System.out.println("========遍历数组并赋值========");
        for (int i = 0; i < arrInt.length; i++) {
            arrInt[i] = i;
        }
        for (int i = 0; i < arrInt.length; i++) {
            System.out.println(arrInt[i]);
        }
​
        System.out.println("=====foreach=====");
        //foreach,增强的for循环    不能给数组赋值
        for(int i : arrInt){  //i是用于接受每一次循环的变量
            System.out.println(i); //不能倒序
        }

多维数组

        int[][] arrInt1 = new int[5][3];//外层的数组和内层的数组都指定初始化长度
        int[][] arrInt2 = new int[5][];//初始化时内层可以不指定长度
        int[][] arrInt3 = new int[][]{{3,5},{1,6,9}};//内层长度可以不一致

        //二维数组
        int[][] arrInt = {{1,2,3},
                          {4,5,6},
                          {7,8,9}};
        System.out.println(arrInt[1][1]);//第一个【】第几个数组，第二个【】数组里的位置
​
        //用循环嵌套遍历二维数组
        for (int i = 0; i < arrInt.length; i++) {//循环外层数组
            for (int j = 0; j < arrInt[i].length; j++) {//循环数组里面的元素
                System.out.println(arrInt[i][j]);//打印每一层每一个
            }
        }

Arrays类的使用

        String[] arrStr = {"abc","123","456","世界"};
        //在数组里搜索一个元素，搜到返回元素的下标，没有搜到返回负数
        int i = Arrays.binarySearch(arrStr,"世界");
        System.out.println(i);
​
        //复制一个新数组，第一个参数就是原数组，第二个参数是新数组的长度
        String[] arrNew = Arrays.copyOf(arrStr,5);
        System.out.println(arrNew.length);
​
        //toString把数组转为字符串
        System.out.println(Arrays.toString(arrStr));//打印数组
​
        //对数组进行排序
        Arrays.sort(arrStr);
        System.out.println(Arrays.toString(arrStr));

数组冒泡排序

        //对原始数组排序
        int[] arrInt = {20,6,49,4,2};
        //外层循环决定排多少个数，数组长度 - 1
        for (int i = 0; i < arrInt.length - 1; i++) {
            //用第一个元素依次跟后一个元素比较
            //每排好一个数，最大的下标数减一，arrInt.length - 1 - i
            for (int j = 0; j < arrInt.length - 1 - i; j++) {
                //相邻两个数比较，大的往后排（交换）
                if(arrInt[j] > arrInt[j + 1]){
                    int temp = arrInt[j + 1];
                    arrInt[j + 1] = arrInt[j];
                    arrInt[j] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(arrInt));