【JavaSE】10-数组

①.什么是数组

定义：数组是相同数据类型的有序集合。它是若干相同类型的数据，按照一定的先后顺序排列组合而成。
每一个数据称作一个数组元素，每个数组元素可以通过一个下标来访问他们。

②.数组的声明与创建

• 首先需要声明，才能使用数组：
  dataType[ ] arrayRefVar; //Java声明数组推荐的呀
  dataType arrayRefVar[ ]; //效果相同，但不推荐这样的用法
• 通过new关键字创建数组
  dataType[ ] arrayRefVar = new dataType[ arraySize];

数组中的元素是通过索引访问的，数组的索引从0开始。
获取数组长度的语法：arrays.length

Array内存分析

Java中的内存：

• 堆：
  存放new的对象和数组
  可以被所有线程共享，不会存放别的对象引用
• 栈：
  存放基本变量类型(包含基本类型的具体数值)
  引用对象的变量(会存放引用在堆里边的地址)
• 方法区：
  可以被所有的线程共享
  包含了所有的class和static变量

数组的初始化

三种初始化：

• 静态初始化：
  int[ ] a = {1,2,3,5,6};
  Man[ ] men = { new Man (1,1),new Man (1,2) }; //引用类型的初始化
• 动态初始化：
  int[ ] a = new int[10];
  a[0] = 10;
  a[1] = 20; …
• 默认初始化：
  数组是引用类型，他的元素相当于类的实例变量，因此数组一旦分配了空间，其中的每个元素也会被按照实例变量同样的方式被隐式初始化。

③.数组的基本特点

• 数组的长度是确定的。一旦被创建，大小不可改变
• 数组的元素必须是相同类型的，不允许出现混合类型。
• 数组中的元素可以是任何的数据类型，包括基本类型和引用类型。
• 数组的变量属于引用类型，数组也可以看成是对象，数组中的每一个元素就相当于数组的成员变量。
  因为数组本身就是对象，而Java的对象是保存在堆中的，因此无论数组保存的是原始类型还是其他的对象类型，数组对象本身是在堆中的。

数组的边界

-数组下边的合法区间[0,length - 1],如果越界将会报错。
ArrayIndexOutOfBoundsException : 数组下标越界异常

④.数组的使用

• For-Each循环：
  数组可以通过for循环来进行遍历，也可以通过增强的for( : )循环来进行操作
• 数组可以作为方法入参
• 数组也可以作为返回值

public class ArrayUse {
    public static void main(String[] args) {
        int[] arrays = {1, 2, 3, 4, 5};    //定义一个数组，并赋值
        int [] reverse = reverse(arrays);  // 定义反转数组，用于存储反转后的值
        //打印所有元素
        for (int i = 0; i < reverse.length; i++) {
            System.out.println(reverse[i]);
        }
    }

    static int[] reverse(int[] arrays /*数组作为参数*/){ //反转方法
        int[] result = new int[arrays.length];  //定义数组与长度

        //反转操作
        for(int i = 0,j = result.length - 1;i < arrays.length;i++,j--){
            result[j] = arrays[i];
        }
        return result;  //数组作为返回值
    }
}

⑤.多维数组

多维数组，可以看成数组的数组
二维数组：int[ ] [ ] array = { {12,13,14} , {22,23,24} ,{32,33,34} , {…} , …}

public class ArrayTwo {
    public static void main(String[] args) {
        /*
            1 , 2 array[0]
            3 , 4 array[1]
            5 , 6 array[2]
            7 , 8 array[3]
         */
        int[][] array = {{1,2},{3,4},{5,6},{7,8}};

        System.out.println(array[0][1]);  //输出 2 {1，2}
        System.out.println(array.length);  //输出 4{{}，{}，{}，{}}
        System.out.println(array[1].length); // 输出 2 {3，4}
        //遍历数组元素
        for(int i = 0;i < array.length;i++){
            for(int j = 0;j < array[i].length;j++){
                System.out.println(array[i][j] + " ");
            }
        }
    }
}

⑥.Arrays类

定义：Arrays类是数组的工具类，在java.util.Arrays当中。

public class ClassArrays {
    public static void main(String[] args) {
        int[] a = {1,34,45,56,67,87,89,56,4,35,34,34242,3,1313};
        System.out.println(Arrays.toString(a));    //输出：[1, 34, 45, 56, 67, 87, 89, 56, 4, 35, 34, 34242, 3, 1313]
        printArray(a);       //输出数组的类也可以自定义。 输出：[1, 34, 45, 56, 67, 87, 89, 56, 4, 35, 34, 34242, 3, 1313]
        //与官方文档不同的是，官方文档会返回一个String对象，而自己写的方法暂时没有返回值

        //对数组进行排序
        Arrays.sort(a);
        System.out.println("\n" + Arrays.toString(a));  //输出：[1, 3, 4, 34, 34, 35, 45, 56, 56, 67, 87, 89, 1313, 34242]

        //填充数组元素
//        Arrays.fill(a,0);
//        printArray(a);   //输出：[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

        Arrays.fill(a,2,6,0);
        printArray(a);   //输出：[1, 3, 0, 0, 0, 0, 45, 56, 56, 67, 87, 89, 1313, 34242]
    }

    static void printArray(int[] a){

        for (int i = 0; i < a.length; i++) {
            //检测是否为头一个元素，是则输出括号
            if (i == 0) System.out.print("[");
            //检测是否为最后一个元素，是则输出最后的元素和反括号
            if (i == a.length - 1) System.out.print(a[i] + "]");
            //否则输出, 分隔符
            else System.out.print(a[i] + ", ");
        }
    }
}

冒泡排序法

将相邻两个数相比较，如果一方比另一方大则交换位置，依次排序。

public class ArrayBulbble {
    public static void main(String[] args) {
        //冒泡排序
        //1，比较较相邻两个元素的大小，如果第一个数比第二个数大，则交换他们的顺序
        //2，每一轮比较都会产生一个最大或者最小数字
        //3，下一轮可相应减少一次排序
        //4，依次循环，直到结束

        int[] a = {34,45,56,5,6,7,8689,7,8972,3,12,3,1,22,3,53,45,46,4,6,45,64,566};
        a = sort(a);
        System.out.println(Arrays.toString(a));

    }

    static int[] sort(int[] a){
        int temp = 0;  //转移数据的临时变量

        for (int i = 0; i < a.length - 1; i++) { // 两两比较，遍历时会少一个元素
            //比较两个相邻元素，前一个比后一个大的话，交换位置
            for (int j = 0; j < a.length - 1 - i; j++) {
                if(a[j + 1] < a[j]){
                    temp = a[j];
                    a[j] = a[j + 1];
                    a[j + 1] = temp;
                }
            }
        }
        return a;
    }
}

⑦.稀疏数组

需求：编写五子棋游戏中，实现存盘和记录上一盘的功能。
分析问题：因为二维数组中很多值都是0，记录了很多没有意义的数据。
稀疏数组的使用：当一个数组中大部分的元素为0或者为同一个值时，可以用稀疏数组来存储该组数据。
处理方式：

• 记录数组有几行几列，有多少个不同的值。
• 把具有不同值的元素和行列的值记录在一个小规模数组当中，进而压缩程序规模。

public class ArrayZip {
    public static void main(String[] args) {
        int[][] a = new int[11][11];
        a[1][2] = 1;
        a[2][3] = 2;
        //初始化原始数组
        /*
            0	0	0	0	0	0	0	0	0	0	0
            0	0	1	0	0	0	0	0	0	0	0
            0	0	0	2	0	0	0	0	0	0	0
            0	0	0	0	0	0	0	0	0	0	0
            0	0	0	0	0	0	0	0	0	0	0
            0	0	0	0	0	0	0	0	0	0	0
            0	0	0	0	0	0	0	0	0	0	0
            0	0	0	0	0	0	0	0	0	0	0
            0	0	0	0	0	0	0	0	0	0	0
            0	0	0	0	0	0	0	0	0	0	0
            0	0	0	0	0	0	0	0	0	0	0
         */

        //打印原始数据
        for (int[] ints : a) {
            for (int anInt : ints) {
                System.out.print(anInt + "\t");
            }
            System.out.println();
        }

        //转换为稀疏数组保存
        //获取有效值的个数
        int sum = 0;
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a[i].length; j++) {
                if(a[i][j] != 0) sum++;
            }
        }
        System.out.println("有效值个数" + sum);

        //创建一个稀疏数组
        int[][] a2 = new int[sum + 1][3];
        //原数组有几行  几列  几个有效数字
        a2[0][0] = a.length;
        a2[0][1] = a[0].length;
        a2[0][2] = sum;

        //遍历二维数组，将非零值存放在稀疏数组中
        int count = 0;
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a[i].length; j++) {
                if(a[i][j] != 0){
                    count++;                //用于存放稀疏数组的行数据
                    a2[count][0] = i;       //保存原数组的行信息
                    a2[count][1] = j;       //保存原数组的列信息
                    a2[count][2] = a[i][j]; //保存原数组的值信息
                }
            }
        }

        //检查数据是否存储正确
        for (int[] ints : a2) {
            for (int anInt : ints) {
                System.out.print(anInt + "\t");
            }
            System.out.println();
        }

        //定义还原数组
        int[][] a3 = new int[a2[0][0]][a2[0][1]];
        //给还原数组赋值
        for (int i = 1; i < a2.length; i++) {
            a3[a2[i][0]][a2[i][1]] = a2[i][2];
        }

        //打印还原的数据
        for (int[] ints : a3) {
            for (int anInt : ints) {
                System.out.print(anInt + "\t");
            }
            System.out.println();
        }
    }
}