Java：数组

目录

• 学习资料
• 数组的定义
• 内存分析
• 数组的使用
• 多维数组
• Arrays类
• 冒泡排序
• 稀疏数组

学习资料

b站狂神说：https://www.bilibili.com/video/BV12J41137hu

数组的定义

数组是相同类型的有序集合.

通过下标来访问数组元素，下标从0开始。

数组也是对象，数组元素相当于对象的成员变量

数组的长度确定后是不可变的，如果越界出现异常：ArrayIndexOutofBounds

package com.zy7y.array;

import java.util.Arrays;

/**
 * @ProjectName: JavaSE
 * @PackageName: com.zy7y.array
 * @Author: zy7y
 * @Date: 2020/8/14 下午8:27
 * @Description: 数组
 */
public class ArrayStudy {
    public static void main(String[] args) {
        // 定义一个 int类型 的数组; 将nums存放在栈中
        int[] nums;
        nums = new int[10]; // 10 为 数组的长度； 将10个int类型数组放在堆中
        nums[0] = 1; //给数组赋值

        // Arrays.toString(数组) ,打印数组内容
        System.out.println(Arrays.toString(nums)); // [1, 0, 0, 0, 0, 0, 0, 0, 0, 0]

        int sum = 0;
        // 获取数组的长度
        for (int i = 0; i < nums.length; i++) {
            sum += nums[i];
        }
        System.out.println(sum);
        
        // 静态初始化: 创建 + 赋值
        int[] a = {1,2,3,4,5,6};
        System.out.println(a[0]);
        
        // 动态初始化：包含默认初始化
        int[] b = new int[]{1,2,3,4,5};
        System.out.println(b[1]);

    }
}

内存分析

graph LR Java内存--> 堆 堆-->存放new的对象和数组 堆--> 可以被所有的线程共享,不会存放别的对象引用 Java内存--> 栈 栈-->存放基本变量类型,包含这个基本类型的具体数值 栈-->引用对象的变量,存放这个引用在堆里面的具体地址 Java内存--> 方法区 方法区-->可以被所有的线程共享 方法区-->包含了所有的类和static变量

数组的使用

package com.zy7y.array;

import java.util.Arrays;

/**
 * @ProjectName: JavaSE
 * @PackageName: com.zy7y.array
 * @Author: zy7y
 * @Date: 2020/8/14 下午8:53
 * @Description:
 */
public class UseArray {
    public static void main(String[] args) {
        int[] arrays = {1,2,3,4,5};

        // 打印所有的元素
        for (int i = 0; i < arrays.length; i++) {
            System.out.println(arrays[i]);
        }

        for (int array: arrays) {
            System.out.println(array);
        }

        // 计算所有元素的和
        int sum = 0;
        for (int i = 0; i < arrays.length; i++) {
            sum += arrays[i];
        }
        System.out.println(sum);

        int total = 0;
        for (int array:arrays) {
            total += array;
        }
        System.out.println(total);

        System.out.println(Arrays.toString(reverse(arrays)));
    }

    // 反转数组
    public static int[] reverse(int[] arrays){
        int[] result = new int[arrays.length];
        // result.length -1 j一开始就是result的最大下标然后依次边小，i是最小下标依次变大
        for (int i = 0, j = result.length - 1 ; i < arrays.length; i++, j--) {
            result[j] = arrays[i];
        }
        return result;
    }
}

多维数组

数组里面嵌套数组

        // 定义一个二维数组并复制
        int[][] array = new int[][]{{1,23,1},{2,3}};
        System.out.println(array[0][1]); // 23,取数组中的第0个{1,23,1}，然后取里面的第一个23

Arrays类

package com.zy7y.array;

import java.util.Arrays;

/**
 * @ProjectName: JavaSE
 * @PackageName: com.zy7y.array
 * @Author: zy7y
 * @Date: 2020/8/14 下午9:16
 * @Description: Arrays类
 */
public class UseArrays {
    public static void main(String[] args) {
        int[] a = {1,23,445,123};
        int[] b = {1};
        System.out.println(Arrays.toString(a));

        // 排序
        Arrays.sort(a);
        System.out.println(Arrays.toString(a));

        // 比较两个数组
        boolean result = Arrays.equals(a,b);
        System.out.println(result);

        // 复制一个数组, Arrays.copyOf(数组, copy数组的长度)
        int[] c = Arrays.copyOf(a, a.length);
        System.out.println(Arrays.toString(c));

        printArray(c);
    }

    // 仿写一个 Arrays.toString
    public static void printArray(int[] arrays) {
        System.out.print("[");
        for (int array:arrays) {
            if (array == arrays[arrays.length-1]){
                System.out.print(array + "]");
            }else {
                System.out.print(array + ", ");
            }
        }
    }
}

冒泡排序

package com.zy7y.array;

import java.util.Arrays;

/**
 * @ProjectName: JavaSE
 * @PackageName: com.zy7y.array
 * @Author: zy7y
 * @Date: 2020/8/14 下午9:29
 * @Description: 冒泡排序
 */
public class Bubble {
    public static void main(String[] args) {
        // 比较数组中，相邻的两个元素，如果第一个大于第二个则进行交换
        // 每一次比较，都会产生一个最大或者最小的数字；
        // 下一轮则可少依次排序

        int[] arrays = {1,452,23,3455,7786,12,44};
        bubbleSort(arrays);


    }

    public static void bubbleSort(int[] arrays){
        // 长度为8，下标则为7，但是排序最终有一个是不会变动位置的
        for (int i = 0; i < arrays.length - 1; i++) {
            // 给个标示位
            boolean off = false;
            for (int j = 0; j < arrays.length - 1 - i; j++) {
                if (arrays[j] > arrays[j + 1]) {
                    int temp = arrays[j];
                    arrays[j] = arrays[j + 1];
                    arrays[j + 1] = temp;
                    off = true;
                }
            }
            // 当交换完成时break;
            if (!off){
                break;
            }
        }
        System.out.println(Arrays.toString(arrays));
    }
}

稀疏数组

二维数组的很多值是默认值0，记录了黑多没有意义的数据

package com.zy7y.array;

/**
 * @ProjectName: JavaSE
 * @PackageName: com.zy7y.array
 * @Author: zy7y
 * @Date: 2020/8/14 下午9:54
 * @Description:
 */
public class SparseArray {
    public static void main(String[] args) {
        // 生成一个 11 * 11 的二维数组
        int[][] array = new int[11][11];
        array[3][9] = 27;
        array[1][10] = 10;
        array[5][8] = 40;
        array[0][3] = 30;
//        printArrays(array);
        printArray(array);
        System.out.println("====压缩成稀疏数组====");
        System.out.println("行  列  值");
        printArray(packedArray(array));
        System.out.println("====从稀疏数组还原======");
        printArrays(revivification(packedArray(array)));
    }

    // 打印二维数组的方法
    public static void printArrays(int[][] array){
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                System.out.print(array[i][j] + "	");
            }
            System.out.println();
        }
    }
    // 打印二维数组的第二种方法
    public static void printArray(int[][] array){
        for (int[] arr:array) {
            for (int a:arr) {
                System.out.print(a + "	");
            }
            System.out.println();
        }
    }

    // 压缩成稀疏数组
    public static int[][] packedArray(int[][] array){
        // 统计有效值的个数,得到行数
        int count = 0;
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                if (array[i][j] != 0) {
                    count += 1;
                }
            }
        }
        int[][] packed = new int[count+1][3];
        // 原数组行数
        packed[0][0] = 11;
        // 原数组列数
        packed[0][1] = 11;
        // 原数组有效值个数
        packed[0][2] = count;

        int row = 0;

        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                if (array[i][j] != 0) {
                    // 统计有效值的个数，即作为所在的行数
                    row += 1;
                    packed[row][0] = i;
                    packed[row][1] = j;
                    packed[row][2] = array[i][j];
                }
            }
        }
        return packed;
    }

    // 还原成稀疏数组
    public static int[][] revivification(int[][] array) {
        int[][] arrays = new int[array[0][0]][array[0][1]];
        for (int i = 1; i < array.length; i++) {
            arrays[array[i][0]][array[i][1]] = array[i][2];
        }
        return arrays;
    }
}