数组

数组的定义

1. 相同数据类型的有序集合
2. 按一定先后顺序排列组合而成
3. 每一个数据称作一个数组元素，可以通过下标访问

数组声明创建

1. 声明数组 在栈中声明一个array数组
   int[] array;
   int array[];
2. 使用new操作符创建数组 在堆中开辟空间方数据
   int[] array = new int[10];
3. 数组索引从0开始

数组边界

1. 下标的合法区域：[0，length-1]，如果越界就会报错
2. ArrarIndexOutOfBoundsException：数组下标越界异常

数组的基本特点

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

数组的使用

1. 打印所有数组元素

• for循环
• fo-Each
  JDK1.5，没有下标
  for（int array ： arrays）
• Arrays.toString()方法

Arrays工具类

• 给数组赋值：通过fill方法
• 给数组排序：通过sort方法，按升序
• 比较数组：通过equals方法比较数组中元素是否相等
• 查找数组元素，通过binarySearch方法能对数组进行二分法查找操作

int[] a = {12,51,51,1,21,4,6,3,9,153,9431};
        //1.打印数字元素
        System.out.println(Arrays.toString(a));
        //2.数组升序排序
        Arrays.sort(a);
        System.out.println(Arrays.toString(a));
        //3.数组填充
        Arrays.fill(a,1,2,0);
        System.out.println(Arrays.toString(a));

冒泡排序

//冒泡排序
    public static int[] sort(int[] array) {
        //临时变量，用于交换位置
        int k = 0;
        //外层循环，判断需比较多少次
        for (int i = 0; i < array.length - 1; i++) {
            //通过标签减少没有意义的比较，提高效率
            boolean flag = false;
            //内层循环，比较判断两个数，若第一个数比第二个数大，则交换位置
            for (int j = 0; j < array.length - 1 - i; j++) {
                if (array[j + 1] > array[j]) {
                    k = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = k;
                    flag = true;
                }
            }
            if (flag == false) {
                break;
            }
        }
        return array;
    }

稀疏数组

1. 当一个数组大部分元素为0或相同是，可用稀疏数组来 保存。
2. 通过记录一共有几行几列，有多少不通值进行储存。

public static void main(String[] args) {
        //1.创建一个二位数组11*11  0：没有棋子   1：黑棋   2：白棋
        int[][] array1 = new int[11][11];
        array1[1][2] = 1;
        array1[2][3] = 2;
        System.out.println("输出的原始数组：");
        for (int[] ints:array1) {
            for (int anInt:ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
        //转化为稀疏数组保存
        //1.获取有效值的个数
        int sum = 0;
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if(array1[i][j]!=0){
                    sum++;
                }
            }
        }
        //2.创建一个稀疏数组
        int[][] array2 = new int[sum+1][11];
        array2[0][0] = 11;
        array2[0][1] = 11;
        array2[0][2] = sum;
        //3.遍历二维数组，将非零的只，存放稀疏数组中
        int count = 0;
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if (array1[i][j] != 0) {
                    count++;
                    array2[count][0] = i;
                    array2[count][1] = j;
                    array2[count][2] = array1[i][j];
                }
            }
        }
        //输出稀疏数组
        System.out.println("稀疏数组");
        for (int i = 0; i < array2.length; i++) {
            System.out.println(
                    array2[i][0]+"\t"
                    +array2[i][1]+"\t"
                    +array2[i][2]+"\t"
            );
        }
        System.out.println("还原数组");
        //1.读取稀疏数组
        int[][] array3 = new int[array2[0][0]][array2[0][1]];
        //2.给其中的元素还原它的值
        for (int i = 1; i < array2.length; i++) {
            array3[array2[i][0]][array2[i][1]] = array2[i][2];
        }
        //打印还原数组
        for (int[] ints:array1) {
            for (int anInt:ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
    }