第七章 数组

一、数组的定义

数组是多个相同类型数据的组合

数组变量是引用类型变量（对象）

数组中的元素可以是基本数据类型变量，也可以是引用类型变量

数组变量的数据类型与数组中元素的数据类型相同

数组是一个容器，存储到数组中的每个元素都有自己的自动编号，最小值为0

二、数组的创建

public class ArrayTest01 {
    //创建数组对象，动态初始化
    //[]便是当前的定义是一个数组类型的数据
    //数组类型是一个引用类型的数据
    ///[]中不能写任何的值，位置随意在对象名的前后都行
    public static void main(String[] args) {


        int [] a; // 声明内存不发生变化
        Student s[];
        //数据一旦创建成功，长度就不会发声改变
        //内存开始发生变化，创建一个长度为5的数组，且数组中的值都是默认初值0
        a = new int[5];
        //内存开始发生变化，创建一个一个长度为5的数组，且数组中的值都是默认初值null
        s = new Student[5];
        //重新给数组a赋值，原来的数组变成了垃圾，新数组的长度由元素列表中的个数决定
        //且值为{1，2，3，4，5}
        a = new int[]{1,2,3,4,5};
        Student s1 = new Student();
        Student s2 = new Student();
        Student s3 = new Student();
        Student s4 = new Student();
        Student s5 = new Student();
        //重新给数组s赋值，原来的数组变成了垃圾，新数组的长度由元素列表的个数决定
        //且值为{s1,s2,s3,s4,s5}
        s = new Student[]{s1,s2,s3,s4,s5};
        //声明的同时初始化，也叫静态初始化
        int[] b =new int[5];
        int[] c =new int[]{1,2,3,4,5};
        int[] d ={1,2,3,4,5};

    }

}

三、数组遍历

public class ArrayTest02 {
    public static void main(String[] args) {
        int[] a ={1,2,3,4,5};
        //使用数据的前提是必须要先进行初始化
        //使用方式为数组名[下标]下标又称索引
        // 索引从0开始，最大值为数据的长度减1，如果超过这个是就会发生数组越界
        System.out.println(a[4]);
        //数组遍历，将数组中的元素拿出来进行相关操作
        for (int i=0;i<5;i++){
            System.out.print(a[i] +" ");

        }
        System.out.println();
        //foreach循环
        for (int i:a){
            System.out.print(i+" ");
        }
    }

}

四、数组复制

public class ArrayTest03 {
    public static void main(String[] args) {
        int[] a ={1,2,3,4,5,6};
        //length属性用于获取数组长度的，也就是表示数组中元素的个数
        System.out.println(a.length);
        //数组复制，将原数组中的数据复制到新数组中，不够的位置用默认初值表示
        int b[] = Arrays.copyOf(a,10);
        //数组复制，将原数组中的指定位置开始的数据指定位置结束的数据进行复制
        //开始位置的索引指代的数据要复制，结束位置索引指代的数据不复制
        int c[] = Arrays.copyOfRange(a,1,5);
        int d[] = new int[10];
        //从指定位置开始复制，到新数组的指定位置
        //第一个参数是原数组，第二个参数是开始复制的起始位置的索引，第三个参数是新数组
        //第四个参数是新数组中开始复制的起始位置，第五个参数个复制多长
        System.arraycopy(a,1,d,3,4);
        //数组初始化方法，将数组中的值全部复制和成同一个值
        Arrays.fill(d,5);
        for (int i:d){
            System.out.print(i+" ");
}
    }

}

五、二分查找法

public class ArrayTest04 {
    public static void main(String[] args) {
        //数组排序
        int a[] = {7,1,2,8,9,6,3,4,5};
        Arrays.sort(a);
        //升序排序 二分查找法，先升序排序在查找，返回的是查到值的索引
        int b = Arrays.binarySearch(a,8);
        System.out.println(b);
        for (int i : a)
        {System.out.print(i + " ");
//降序排序
            //   for(int i= 0;i<a.length-1;i++){
            //      for(int j = i+1;j<a.length;j++){
            //         if(a[i]<a[j]){
            //             int temp = a[i];
            //             a[i] = a[j];
            //             a[j] = temp;
        }
    }

}
// for (int i:a){
//     System.out.println(i+" ");
//  }
//   }

//}

六、二维数组

public class ArrayTest05 {
    public static void main(String[] args) {
        //二维数组，如果一个一维数组中保存的还是一个一维数组，那么这个数组被称为二维数组
        //动态初始化，先声明在赋值
        int[][] a;
        //new的时候，前面第一个[]中一定要写数组长度，第二个[]中的数组长度可以不写
        //如果写了表示二维数据中所有是一维数组都是一样长度的
        a = new int[3][4];
        //使用元素列表的形式初始化
        a = new int[][]{{1,2,3},{4},{5,6,7,8}};
        //给二维数组中第一个一维数组进行初始化
        a[0] = new int[3];
        //静态初始化，声明的同时初始化
        int[][] b = new int[3][];
        int[][] c = new int[][]{{1,2,3},{4},{5,6,7,8}};
        //属于静态初始化独有的写法，也是比较常用的方式之一
        int[][] d = {{1,2,3},{4},{5,6,7,8}};

    }

}

七、二维数组的遍历

public class ArrayTest06 {
    public static void main(String[] args) {

        //二维数组如何遍历
        int[][] d = {{1, 2, 3}, {4}, {5, 6, 7, 8}};
        for (int i = 0; i < d.length; i++) {
            for (int j = 0; j < d[i].length; j++) {
                System.out.print(d[i][j] + " ");
            }
            System.out.println();
        }
    }

}