Java的数组是啥？

1.数组是啥？

数组是一块连续的内存，用来存储相同类型的数据

（1）如何定义数组？

1.int[] array = {1,2,3,4} = new int[]{1,2,3,4};//这里的new是一个关键字，用来创建对象

2.数组就是一个对象

动态初始化

int[] array = new int[10];//这个数组没有初始化时，默认将数组初始化为0

静态初始化

 T[] 数组名称 = {data1, data2, data3, ..., datan};

还可以这样初始化

int[] array4;//局部变量
array4 = new int[10];

错误初始化

可以改成这样：

int[] array5 = null;//存储类型是引用类型时，用null

各类型数组初始化

（2）数组的创建

T[] 数组名 = new T[N];//N是数组长度

（3）数组越界

int[] array = {1,2,3,4}

获取数组长度：

int len = array.length;
System.out.println(len);

（4）遍历数组

        //第一种遍历方式
        int[] array = {1,2,3,4};
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + " ");
        }
        System.out.println();

        //第二种：增强for循环：for-each
        for(int x: array){//在遍历这个数组的时候，把数组中的元素进行赋值给x
            System.out.print(x + " ");
        }
        System.out.println();

区别：for遍历数组有带下标，for-each没有

---

2.数组是引用类型

（1）JVM的内存分布

虚拟机栈 (JVM Stack): 与方法调用相关的一些信息， 每个方法在执行时，都会先创建一个栈帧 ，栈帧中包含有：局部变量表 、 操作数栈 、 动态链接 、 返回地址 以及其他的一些信息，保存的都是与方法执行时相关的一些信息。比如：局部变量。当方法运行结束后，栈帧就被销毁了，即栈帧中保存的数据也被销毁了 。
堆 (Heap) : JVM 所管理的最大内存区域 . 使用 new 创建的对象都是在堆上保存 ( 例如前面的 new int[]{1, 2, 3} ) ， 堆是随着程序开始运行时而创建，随着程序的退出而销毁，堆中的数据只要还有在使用，就不会被销 毁 。

---

（2）数组-->引用

public static void func() {
    int a = 10;
    int b = 20;
    int[] arr = new int[]{1,2,3};//描述为arr这个引用指向了一个数组对象
}

用arr里面的地址去操作对象里面的值

---

尝试分析下面的代码

    public static void func() {
        int[] array1 = new int[3];
        array1[0] = 10;
        array1[1] = 20;
        array1[2] = 30;
        int[] array2 = new int[]{1,2,3,4,5};
        array2[0] = 100;
        array2[1] = 200;
        array1 = array2;
        array1[2] = 300;
        array1[3] = 400;
        array2[4] = 500;
        for (int i = 0; i < array2.length; i++) {
            System.out.println(array2[i]);
        }
    }

⚠array1和array2的值都是地址

array2的值把array1原来的值顶掉了，array1从原来的0x89变成0x99

所以，通过array1这个引用，可以修改array2这个引用所指向的对象

---

（3）null

array = null 表示当前引用不指向任何对象，所以谈长度是没道理的

---

⚠Java里面null和0号地址没有任何关联

⚠一个引用不能同时指向多个对象（跟变量一样，只能一一对应存对象）

⚠对象不能指向对象，只有引用才能指向对象

---

3.数组的应用

（1）作为函数参数

（改变引用的值？改变引用对象的值？）

public static void main(String[] args) {
    int[] array = {1,2,3,4};
    /*
        当我 分开调用func1和 func2
        func1();
        func2();
        array这个数组 里面的值 分别是多少？
     */
    //func1(array);
    func2(array);
    for (int x : array) {
        System.out.print(x+" ");
    }
    System.out.println();

}

    public static void func1(int[] array) {
        array[0] = 99;
    }
    public static void func2(int[] array) {
        array = new int[]{11, 22, 33, 44, 55};
    }

运行结果

1.99 2 3 4

2.1 2 3 4

func1修改的是实参array下标为0的元素，打印出来就是99，2，3，4

而func2把形参从指向{1,2,3,4}改成指向{11,22,33,44,55}，不影响实参，实参该是什么就是什么，所以是1，2，3，4

（2）作为函数返回值

    public static void main(String[] args) {
        int[] ret = func3();
        for (int i = 0; i < ret.length; i++) {
            System.out.println(ret[i]);
        }
    }
    public static int[] func3(){
        int[] ret = new int[2];
        ret[0] = 99;
        ret[1] = 199;
        return ret;//作为返回值的形式进行传递
    }

4.数组练习

（1）数组转字符串

一个打印数组比较便捷的方式，比for循环快多了

    public static void main(String[] args) {
        int[] array = {1,2,3,4,5};
        String ret = Arrays.toString(array);
        System.out.println(ret);
    }

（2）数组排序

使用Array的包

Arrays.sort(array,0,3);//区间排序，在[0，3)这个区间里面从大到小排序

我们自己做一个数组打印方法

    public static String myToString(int[] array){
        if (array == null){
            return "null";
        }
        if (array.length == 0){
            return "[]";
        }
        String ret = "[";
        for (int i = 0; i < array.length; i++) {
            ret += array[i];
            if (i != array.length-1){//最后一个不打印","
                ret+=", ";
            }
        }
        ret += "]";
        return ret;
    }

（3）不妨再做一个sort的方法（冒泡排序）

排序[8,12,5,7,9]

现在已经是有序状态，但是系统不一定知道已经是有序的，所以我们要给机器一个验证

i是趟数，j是交换的次数

    public static void bubbleSort(int[] array){
        if(array == null){
            return;
        }
        //i代表遍历趟数
        for (int i = 0; i < array.length-1; i++) {
            //每次比上一次少一个,优化：比较趟数
            boolean flg = false;//优化：比较结果
            //j代表元素下标，相当于C里面的指针
            for (int j = 0; j < array.length-1-i; j++) {//这里可以画图来看看
                if(array[j] > array[j+1]){
                    int tmp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = tmp;
                    flg = true;
                }
            }
            if(!flg){
                //没有交换
                return;
            }
        }
    }
    public static void main(String[] args) {
        int[] array = {8,12,5,7,9};
        System.out.println(myToString(array));
        bubbleSort(array);
        System.out.println(myToString(array));
    }

（4）逆置数组排序

    public static void reverse(int[] array){
        if (array == null){
            return;
        }
        int i = 0;
        int j = array.length-1;
        while(i < j){
            int tmp = array[i];
            array[i] = array[j];
            array[j] = tmp;
            i++;
            j--;
        }
    }

5.数组拷贝

    public static void main(String[] args) {
        int[] array1 = {2, 4, 6, 3};
        int[] array2 = {2,4,6,3,10};
        System.out.println(Arrays.equals(array1, array2));//equals判断数组是否相同
        int[] array = new int[10];
        System.out.println(Arrays.toString(array));
        Arrays.fill(array, 9);
        Arrays.fill(array, 0, 3, 9);
        System.out.println(Arrays. toString(array));
    }

    public static void func(){
        // copyOf方法在进行数组拷贝时，创建了一个新的数组
        // arr和newArr引用的不是同一个数组
        arr[0] = 1;
        newArr = Arrays.copyOf(arr, arr.length);//扩容
        System.out.println(Arrays.toString(newArr));
        // 因为arr修改其引用数组中内容时，对newArr没有任何影响
        arr[0] = 10;
        System.out.println(Arrays.toString(arr));
        System.out.println(Arrays.toString(newArr));
        // 拷贝某个范围.
        int[] newArr2 = Arrays.copyOfRange(arr, 2, 4);
        System.out.println(Arrays.toString(newArr2));
        int[] copy = new int[array1.length];
        System.arraycopy(array1,0,copy,0,array1.length);
    }

arraycopy的底层代码

6.二维数组

如何创建二维数组？

        int[][] array = {{1,2,3},{4,5,6}};
        //System.out.println(array[1][2]);
        int[][] array2 = new int[][]{{1,2,3},{4,5,6}};
        int[][] array3 = new int[2][3];

        //定义二维数组行不能省略
        //int[][] array4 = new int[][3];这种是错误的

        //不规则二维数组
        int[][] array5 = new int[2][];

打印二维数组

我们常规以为的二维数组

所以就有下面的打印代码

        for (int i = 0; i < 2; i++) {
            for (int j = 0; j < 3; j++) {
                System.out.print(array[i][j] + " ");
            }
            System.out.println();
        }

而真正的二维数组是这样的

        int[][] array = {{1,2,3},{4,5,6}};
        System.out.println(array.length);
        System.out.println(array[1].length);
        System.out.println(array[2].length);
        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();
        }

还有另外一种写法

        for (int[] tmp:array) {
            for (int x : tmp) {
                System.out.println(x + " ");
            }
            System.out.println();
        }

给这个二维数组规定每行有哪些数