【JAVA基础学习笔记7】

斜体样式## 数组声明和初始化

• 数组必须先声明变量，才能在程序中使用
• 使用new创建数组
• 通过索引进行访问
• 声明一个数组int[] array = null;在内存里只有栈里有array。使用new关键字创建int[] array = new int[5];在堆里开辟一个初始大小的空间，并默认初始化值为0.

 public static void main(String[] args) {
        //静态初始化，+初始化
        int[] a = {1,2,3,4};
        //动态初始化，默认初始化
        int[] num = new int[10];
        //num初始化
        for (int i = 0; i < num.length; i++) {
            num[i] = i;
        }
        System.out.println(num[8]);
    }

数组特点

• 数组长度是确定的，一旦被创建，将不能被改变
• 元素必须是相同类型的
• 数组中元素可以是任何数据类型
• 数组变量属于引用类型，可以看成对象，数组对象本身是在堆中的

数组使用

• 可以自己手写某些功能

  public static void main(String[] args) {
        int[] d = {1,2,3,4,5};
//        //JDK1.5之后出现，不用下标输出数组 d.for
//        for (int i : d) {
//            System.out.println(i);
//        }
        printArray(d);
        printArray(reverse(d));
    }
    //打印数组
    public static void printArray(int[] a){
        for (int i = 0; i < a.length; i++) {
            System.out.println(a[i]);
        }
    }
    //反转数组
    public static int[] reverse(int[] a){
        int[] result = new int[a.length];
        for (int i = 0,j = result.length-1; i < a.length; i++,j--) {
            result[j] = a[i];
        }
        return result;
    }

• 也可以直接调用类Arrays：阅读JDK帮助文档，进行调用

 public static void main(String[] args) {
        int[] a = {12,14,5,8,90,25,45,234,2354,345};
        int[] b = {23,23,34,546,66,76,543};
        //fill 填充
        Arrays.fill(a,2,4,5);
        System.out.println(Arrays.toString(a));
        //sort 排序
        Arrays.sort(a);
        System.out.println(Arrays.toString(a));
        //equals 比较数组中的元素是否相等
        System.out.println(Arrays.equals(a,b));
        //binarySearch 对排序号好的数组进行二分法查找操作
        System.out.println(Arrays.binarySearch(a,45));//false
    }

• 练习：冒泡排序

 public static void main(String[] args) {
        int[] a = {23,34,56,67,678,45,34,2,32,312,21,2};
        int third = 0;
        for (int i = 0; i < a.length-1; i++) {
            boolean flag = false;//添加flag是为了优化计算，已经比较过的不再进行比较
            for (int j = 0; j < a.length-i-1; j++) {
                if(a[j+1]>a[j]){
                    third = a[j+1];
                    a[j+1] = a[j];
                    a[j] = third;
                    flag = true;
                }
            }
            if(flag==false){
                break;
            }
        }
        System.out.println(Arrays.toString(a));
    }

稀疏数组

• 当一个数组中大部分元素是相同的，那么可以用稀疏数组保存
• 稀疏数组记录原始数组的行列，以及不同的元素所处位置
• 下面通过将一个数组压缩和还原，进行举例

public static void main(String[] args) {
        //1.创建一个11*11的二维数组，除了两个位置为1，2，其他位置都为0
        int[][] a = new int[11][11];
        a[1][2] = 1;
        a[2][3] = 2;
        System.out.println("原始数组：");
        printArray(a);
        //2.寻找数组中不为0的数字个数
        int num1 = 0;
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a[0].length; j++) {
                if(a[i][j]!=0){
                    num1++;
                }
            }
        }
        //3.创建压缩数组
        int[][] a1 = new int[num1+1][3];
        //4.找出压缩数组的表头，a1[0][0]原始数组的行 a1[0][0]原始数组的列 a1[0][0]原始数组除零外数字个数
        a1[0][0] = a.length;
        a1[0][1] = a[0].length;
        a1[0][2] = num1;
        //5.便利原始数组，将除零外的数字的行、列、数字对应填入压缩数组的三列之中
        int count = 0;
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a[0].length; j++) {
                if(a[i][j]!=0){
                    count++;
                    a1[count][0] = i;
                    a1[count][1] = j;
                    a1[count][2] = a[i][j];
                }
            }
        }
        System.out.println("压缩数组为：");
        printArray(a1);
        //5.还原数组建立
        int[][] a2 = new int[a1[0][0]][a1[0][1]];//取出行、列
        //6.便利压缩数组填充还原数组
        for (int i = 1; i < a1.length; i++) { //i要从1开始，因为压缩数组0是头部信息
            a2[a1[i][0]][a1[i][1]]=a1[i][2];
        }
        System.out.println("还原数组为：");
        printArray(a2);
        //判断还原数组是否和原始数组相等
        System.out.println(Arrays.equals(a,a2));//两个数组相同，但显示结果为false，因为它无法比较二维数组
    }
    //输出原始数组
    public static void printArray(int[][] a){
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a[0].length; j++) {
                System.out.print(a[i][j]+"\t");
            }
            System.out.println();
        }
    }

• 在代码最后，想验证一下，还原的数组与原始数组是否相同采用Arrays.equals(a,a2)显示结果为false，实际上它们是相同的，原因是equals()方法不能比较二维数组