《JavaSE-第六章》之容器数组

用户10517932

发布于 2023-10-07 14:13:02

1640

发布于 2023-10-07 14:13:02

文章被收录于专栏：929KC

前言

本章大家介绍一个存储相同数据类型的容器----数组，以及便于我们对数组操作的工具类Arrays类的使用。

博客主页：KC老衲爱尼姑的博客主页博主的github，平常所写代码皆在于此共勉：talk is cheap, show me the code 作者是爪哇岛的新手，水平很有限，如果发现错误，一定要及时告知作者哦！感谢感谢！

🏆为什么要使用数组?

假设我们要存储5个学生其期末考试的成绩，凭借目前的知识我们只能用五个整型的变量的去储存。

代码示例

public class Demo7 {
    public static void main(String[] args) {
        int score1 = 70;
        int score2 = 80;
        int score3 = 85;
        int score4 = 60;
        int score5 = 90;
        System.out.print(score1 + " ");
        System.out.print(score2 + " ");
        System.out.print(score3 + " ");
        System.out.print(score4 + " ");
        System.out.print(score5);
    }
}

上述打码确实可以存储5个学生的期末考试成绩，但是实际上一个学校里通常都是几百上千的学生，如果我们再用上述的方式去存储学生的成绩是非常麻烦且无聊的，我们可以发现上述代码中的5个变量都是整型变量，那么是否有存储相同类型数据的类型吗?答案是有的，就是本篇要讲解的数组。

🚀什么是数组?

通过上面的分析，我们可以知道数组是用来储存相同类型数据的内存区域或者是容器。通俗点来说就是一个比较大的可回收垃圾的垃圾桶，专门用来存放可回垃圾。

Java中的数组如同现实中的车库，从上图我们可以看

数组存放的元素类型是相同
数组在内存中的空间是连续的
数组的每个区域都有自己的编号，起始位置为0，即数组的下标。

知道什么是数组后，我们要会创建数组，接下来就来一一走入数组的创建

🔥数组的创建和初始化

🚩数组的创建

T[] 数组名 = new T[N];

T：表示数组中存放元素的类型 T[]：表示数组的类型 N：表示数组的长度

####🚩 创建数组的实例

int[] array1 = new int[10]; // 创建一个可以容纳10个int类型元素的数组
double[] array2 = new double[5]; // 创建一个可以容纳5个double类型元素的数组
String[] array3 = new double[3]; // 创建一个可以容纳3个字符串元素的数组

🚩数组的初始化

数组的初始化主要分为两种动态初始化和静态初始化

1.动态初始化：在创建数组时，直接指定数组中元素的个数

数据类型[]  数组名 = new 数据类型[10];
double[] scores = new double[10];

动态初始化示例代码

int[] array1 = new int[10];
double[] array2 = new double[3];
String[] array3 = new String[10];

动态初始化数组堆内存情况

2.静态初始化：在创建数组时不直接指定数据元素个数，而直接将具体的数据内容进行指

数据类型[]  数组名 = new 数据类型[]{元素1，元素2 ，元素3… };
double[] scores = new double[]{89.9, 99.5, 59.5, 88.0};

静态初始化示例代码

int[] array1 = new int[]{0,1,2,3,4,5,6,7,8,9};
double[] array2 = new double[]{1.0, 2.0, 3.0, 4.0, 5.0};
String[] array3 = new String[]{"hell", "Java", "!!!"};

静态初始化数组堆内存情况

注意事项

静态初始化虽然没有指定数组的长度，编译器在编译时会根据{}中元素个数来确定数组的长度。
静态初始化可以简写，省去后面的new T[]。
动态初始化：只指定数组长度，后期赋值，适合开始知道数据的数量，但是不确定具体元素值的业务

数组也可以按照如下C语言个数创建，不推荐

int arr[] = {1, 2, 3}

因为我们平时定义一个变量时是int a=0;int 是类型，a是变量名，同理我们看到int []arr 时，可以更加直观理解int []是类型，arr是这种类型的一个变量，采用C语言明显是不符合习惯的，也有点让人不好理解.

静态和动态初始化也可以分为两步，但是省略格式不可以拆分开

int[] array1;
array1 = new int[10];
int[] array2;
array2 = new int[]{10, 20, 30};

注意：静态初始化和动态初始化不能混用比如int [] arr=new int[3]{12,24,36};这是错误的

🚩默认值规则

如果没有对数组进行初始化，数组中元素有其默认值

数据类型	明细	默认自
	byte,short,int,long	0
	double	0.0
	float	0.0f
	char	/u0000
	boolean	false
引用类型	String,类，接口,数组	null

🚩 数组的使用

🚩 数组中元素的访问

数组在内存中是一段连续的空间，空间的编号都是从0开始的，依次递增，该编号称为数组的下标，数组可以通过下标访问其任意位置的元素。

比如

public class Demo10 {
    public static void main(String[] args) {
        int[]array = new int[]{10, 20, 30, 40, 50};
        System.out.println(array[0]);
        System.out.println(array[1]);
        System.out.println(array[2]);
        System.out.println(array[3]);
        System.out.println(array[4]);
    }
}

也可以通过[]对数组中的元素进行修改

public class Demo10 {
    public static void main(String[] args) {
        int[]array = new int[]{10, 20, 30, 40, 50};
        array[0] = 100;
        System.out.println(array[0]);
    }
}

🚩数组常见的Bug

1.索引越界

代码示例

public class Demo11 {
    public static void main(String[] args) {
    int arr[]=new int[]{12,14,15,16};
     System.out.println(arr[7]);
    }
}

控制台输出结果

遇到索引越界，检查数组的下标是否超过合法范围。

2.空指针异常

代码示例

public class Demo11 {
    public static void main(String[] args) {
        int arr[] = new int[]{12, 14, 15, 16};
        System.out.println(arr[7]);
        arr = null;
        System.out.println(arr[0]);
    }
}

控制台抛出结果

一旦遇到空指针异常，需检查引用类型是否为null，null在java中表示空引用，就是一个不指向对象的引用，而在java中对象就要有对应的引用指向它，不然我们是无法对它进行操作，因为没有引用指向它，它就会JVM中垃圾回收站直接当做垃圾给回收。

注意

null的作用类似于C语言中的NULL，都是表示一个无用的内存区域，因此不能对此区域进行任何读写操作，一旦尝试读写，就会抛出空指针
Java 中并没有约定 null 和 0 号地址的内存有任何

遍历

所谓 “遍历” 是指将数组中的所有元素都访问一遍, 访问是指对数组中的元素进行某种操作，比如：

代码示例

public class Demo11 {
    public static void main(String[] args) {
        int[] arr = new int[]{90, 790, 20};
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
    }
}

上述代码可以起到对数组中元素遍历的目的，但问题是：现在是三个元素我们可以这样使用，如果有成千上百个元素，那不得写输出语句写的累死，此时就需要通过观察代码可以发现，上述代码存在大量的重复，因为唯一的不同就是数组的下标在不断的变化，所以我们可采用for循环来遍历数组

for循环

代码示例

public class Demo11 {
    public static void main(String[] args) {
        int[] arr = new int[]{90, 790, 20};
        for (int i = 0; i < 3; i++) {
            System.out.print(arr[i]+" ");
        }
    }
}

改成循环之后，大量的重复解决了，但是我们该如何获取数组的长度呢?是否是如同C语言中使用sizeof()计算，自然是不好在java中直接数组对象.length 来获取数组的长度，没有必要像C语言中使用sizeof()，java中把这些事已经办好了

代码示例

public class Demo11 {
    public static void main(String[] args) {
        int[] arr = new int[]{90, 790, 20};
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");
        }
    }
}

增强for循环(for-each

代码示例

public class Demo11 {
    public static void main(String[] args) {
        int[] arr = new int[]{90, 790, 20};
        for (int i : arr) {
            System.out.println(i);
        }
    }
}

i为数组array中的元素，当不需要使用下标时采用增强for，需要使用下标则for

数组是引用类型

java中的数组是对象，它是通过new出来的，数组对象生存在堆区，有一个在栈区的引用变量指向该对象，为了更好的理解，我们来看看JVM的内存分布

🚩初始JVM的内存

内存是一段连续的存储空间，主要用来存储程序运行时数据的。

比如

程序运行时代码需要加载到内存
程序运行产生的中间数据要存放在内存
程序中的常量也要保存到内存
有些数据可能需要长时间存储，而有些数据当方法运行结束后就要被销毁

如果对内存中存储的数据不加区分的随意存储，那对内存管理起来将会非常麻烦。比如一个干净的房间和一个杂乱的房间

因此JVM也对所使用的内存按照功能的不同进行了划分

程序计数器 (PC Register): 只是一个很小的空间, 保存下一条执行的指令的地址
虚拟机栈(JVM Stack): 与方法调用相关的一些信息，每个方法在执行时，都会先创建一个栈帧，栈帧中包含有：局部变量表、操作数栈、动态链接、返回地址以及其他的一些信息，保存的都是与方法执行时相关的一些信息。比如：局部变量。当方法运行结束后，栈帧就被销毁了，即栈帧中保存的数据也被销毁了。
本地方法栈(Native Method Stack): 本地方法栈与虚拟机栈的作用类似. 只不过保存的内容是Native方法的局部变量. 在有些版本的 JVM 实现中(例如HotSpot), 本地方法栈和虚拟机栈是和虚拟机栈是一起的
堆(Heap): JVM所管理的最大内存区域. 使用 new 创建的对象都是在堆上保存 (例如前面的 new int[]{1, 2, 3} )，堆是随着程序开始运行时而创建，随着程序的退出而销毁，堆中的数据只要还有在使用，就不会被销毁。
方法区(Method Area): 用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据. 方法编译出的的字节码就是保存在这区域。

我们只需关心虚拟机栈和堆区已经方法区即可。

基本类型变量与引用类型变变量

基本数据类型创建的变量，称为基本变量，该变量空间中直接存放的是其所对应的值；而引用数据类型创建的变量，一般称为对象的引用，其空间中存储的是对象所在空间的地

代码示例

public class Demo12 {
    public static void main(String[] args) {
        func();
    }

    private static void func() {
        int a = 10;
        int b = 20;
        int[] arr = new int[]{1, 2, 3};
    }
}

在上述代码中，a、b、arr，都是函数内部的变量，因此其空间都在main方法对应的栈帧中分配。 a、b是内置类型的变量，因此其空间中保存的就是给该变量初始化的值。 array是数组类型的引用变量，其内部保存的内容可以简单理解成是数组在堆空间中的首地址。

从上图可以看到，引用变量并不直接存储对象本身，而是存储对象的在堆空间的起始地址。通过该地址，引用变量便可以去操作对象。有点类似C语言中的指针，但是Java中引用要比指针的操作更简单,没有指针的加减。

两个数组引用变量指向同一个数组对象

代码示例

public class Demo9 {
    public static void main(String[] args) {
        int[] arr1 = new int[]{11, 22, 33};
        int[] arr2 = arr1;
        System.out.println(arr1);
        System.out.println(arr2);
        arr2[1] = 90;
        System.out.println(arr1[1]);
        System.out.println(arr2[1]);
    }
}

图解上述内存

🚩数组的应用场景

🚩作为函数的参数

参数传基本数据类型

代码示例

public class Demo13 {
    public static void main(String[] args) {
        int num = 0;
        func(num);
        System.out.println("num = " + num);
    }

    private static void func(int x) {
        x = 10;
        System.out.println("x = " + x);
    }
}

因为func()方法在栈区开辟栈帧创建局部变量x并赋值为10，一旦出了该方法，func()方法栈帧就会被销毁。所以并没有影响到num值的改变，依然是0。

参数传数组类型(引用数据类型)

代码示例

public class Demo14 {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3};
        func(arr);
        System.out.println("arr[0] = " + arr[0]);

    }

    private static void func(int[] arr) {
        arr[0] = 10;
        System.out.println("a[0] = " + arr[0]);
    }
}

发现在func方法内部修改数组的内容, 方法外部的数组内容也发生改变. 因为数组是引用类型，按照引用类型来进行传递，是可以修改其中存放的数组内容。

总结: 引用就是存放数组对象的地址，java将数组设置为引用类型，是为了方便传参，因为形参是实参的一份拷贝，如果不传地址的话，就要将数组的内容都进行一份拷贝对于内存的开销十分大，为了节约内存，故将数组设置为引用类型。

比如：获取斐波那契数列

class TestArray {
    public static int[] fib(int n) {
        if (n <= 0) {
            return null;
        }
        int[] arr = new int[n];
        arr[0] = arr[1] = 1;
        for (int i = 2; i < n; ++i) {
            arr[i] = arr[i - 1] + arr[i - 2];
        }
        return arr;
    }

    public static void main(String[] args) {
        int[] arr = fib(10);
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");
        }
    }
}

🚀数组工具类Arrays

Arrays类是工具类，被static修饰我们使用其成员方法直接类型.方法名();来调用。

🚀Arrays类常用API

方法	说明
public static String toString(类型 [],a)	将数组转换成字符串
public static void sort(类型 [] a)	对数组排序(默认升序)
public static int binarySearch(int [] a,int key)	二分查找数组中的数据，存在返回索引不存在返回-1
public static fill(int [].int val)	执定的数值填充到数组中
public static void sort(类型 [] a,Comparator<? super T> c)	将使用比较器对象自定义比较
boolean equals(int [] arr1,int [] arr2)	判断两个数组的内容是否一致

接下来我们就来使用Arrays类，体验它的强大。

🚀数组转字符串

代码示例

public class Demo2 {
    public static void main(String[] args) {
        int [] arr=new int[]{12,145,6,7,8,9,876543};
        System.out.println(Arrays.toString(arr));
    }
}

最左边的括号和最右边的括号都是toString()；给拼接上的，以后打印数组的内容可以采用这种快捷的方式。

🚀数组的拷贝

🚀Arrays.copyOf();

代码示例

public class Demo3 {
    public static void main(String[] args) {
        int [] arr={1,2,3,4,5,6,7};
        int [] newArr=arr;
        System.out.println(arr);
        newArr[0]=10;
        System.out.println("arr:"+Arrays.toString(arr));
        System.out.println("newArr:"+Arrays.toString(newArr));

        arr[0]=1;
        newArr=Arrays.copyOf(arr,arr.length);
        System.out.println(newArr);
        System.out.println("newArr:"+Arrays.toString(newArr));
        System.out.println("arr:"+Arrays.toString(arr));

        arr[0]=99;
        System.out.println("newArr:"+Arrays.toString(newArr));
        System.out.println("arr:"+Arrays.toString(arr));

        //拷贝某个范围
        int [] newArr2= Arrays.copyOfRange(arr,2,4);
        System.out.println("newArr2"+Arrays.toString(newArr2));
    }
}

运行结果

对于上述代码首先我们将arr赋值给newArr后此时这两个引用都指向同一块堆内存，所以打印出来也是一样的，然后将newArr[0]改为10，因为newArr指向数组对象arr,所以可以修改第一个元素，当我们使用copyOf();后，使用arr[0]=99后再将这两个数组的内容打印出来，会发现arr[0]的修改并不会影响到newArr[0].这就说明copyOf之后newArr不在指向arr所指向的对象，newArr指向了一个新的数组对象。

图解上述代码

图一

图二

for循环拷贝

代码示例

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

    public static int [] copyArray(int [] arr){
          int [] tmp=new int[arr.length];
          for(int i=0;i<arr.length;i++){
              tmp[i]=arr[i];
          }
          return tmp;
    }
}

for拷贝本质是利用一个中间数组接收原数组数据

🚀clone()方法

代码示例

public class Demo11 {
    public static void main(String[] args) {
        int[] arr = new int[]{1, 2, 3, 4, 5, 6};
        int[] ret = new int[arr.length];
        ret = arr.clone();
        System.out.println(Arrays.toString(ret));
    }
}

clone()方法属于Object类，而Object是java中的祖宗类是所有类默认都继承的，所以可以使用数组对象调用。

🚀System.arraycopy()方法

方法	说明
System.arraycopy(Object src,int srcPos,Object dest,int destPos,int length)	从要拷贝的数组的某一位置拷贝到目的数组的某一位置，最后一个参数为要拷贝的长度

native修饰的方法底层基于C/C++实现.好处就是速度快。

代码示例

public class Demo11 {
    public static void main(String[] args) {
        int[] arr = new int[]{1, 2, 3, 4, 5, 6};
        int[] ret = new int[arr.length];
          System.arraycopy(arr, 0, ret, 0, ret.length);
        System.out.println(Arrays.toString(ret));
    }
}

🚀查找数组中指定元素

给定一个数组, 再给定一个元素, 找出该元素在数组中的位置。

代码示例

public class Demo4 {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 10, 5, 6};
        System.out.println(find(arr, 10));
    }

    private static int find(int[] arr, int data) {
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == data) {
                return i;
            }
        }
        return -1; // 表示没有找到
    }

}

🚀二分查找(折半查找)

针对有序数组, 可以使用更高效的二分查找.什么是有序数组? 有序分为 “升序” 和 “降序” 如 1 2 3 4 , 依次递增即为升序. 如 4 3 2 1 , 依次递减即为降序.以升序数组为例, 二分查找的思路是先取中间位置的元素, 然后使用待查找元素与数组中间元素进比较。

如果相等，即找到了返回该元素在数组下标
如果小于，以类似方式到数组左半侧查找
如果大于，以类似方式到数组右半侧查找

代码示例

public class Demo5 {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5, 6};
      	//System.out.println(Arrays.binarySearch(arr,6));
        System.out.println(MyBinarySearch(arr, 6));
    }

    private static int MyBinarySearch(int[] arr, int toFind) {
        int left = 0;
        int right = arr.length - 1;
        while (left <= right) {
            int mid = (left + right) / 2;
            if (toFind < arr[mid]) {
            // 去左侧区间找
                right = mid - 1;
            } else if (toFind > arr[mid]) {
            // 去右侧区间找
                left = mid + 1;
            } else {
            // 相等, 说明找到了
                return mid;
            }
        }
            // 循环结束, 说明没找到
        return -1;
    }
}

可以看到，二分查找每次查找都能缩小一半的范围，针对一个长度为 10000 个元素的数组查找, 二分查找只需要循环 14 次就能完成查找. 随着数组元素个数越多, 二分的优势就越大.在Aarrays中有个二分查找的方法，以后我们就不用再手写二分了，直接用Arrays中的即可

🚀Arrays中的二分查找

代码示例

public class Demo5 {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5, 6};
        System.out.println(Arrays.binarySearch(arr,6));
    }

🚀数组排序(冒泡排序)

给定一个数组, 让数组升序 (降序)排序

假设

将数组中相邻元素从前往后依次进行比较，如果前一个元素比后一个元素大，则交换，一趟下来后最大元素就在数组的末尾，依次从上上述过程，直到数组中所有的元素到排列好。

代码示例

public class Demo6 {
    public static void main(String[] args) {
        int[] arr = {13,45,67,79,2,56};
         //bubbleSort(arr);
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));
    }

    private static void bubbleSort(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            for (int j = 1; j < arr.length - i; j++) {
                if (arr[j - 1] > arr[j]) {
                    int tmp = arr[j - 1];
                    arr[j - 1] = arr[j];
                    arr[j] = tmp;
                }
            }
        }
    }
}

Arrays中也有一个更高效的排序算法sort()

代码示例

public class Demo6 {
    public static void main(String[] args) {
        int[] arr = {13,45,67,79,2,56};
       // bubbleSort(arr);
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));
    }
}

判断数组的内容是否相等

代码示例

public class Demo8 {
    public static void main(String[] args) {
        int [] arr=new int[]{1,2,3,4,5,6,7,8,9,10};
        int [] arr2=new int[]{1,2,3,4,5,6,7,8,9,10};
        int [] arr3=new int[]{1,2,3,4,5,6,7,8,9,1};
        System.out.println(Arrays.equals(arr, arr2));
        System.out.println(Arrays.equals(arr, arr3));
    }
}

运行结果

🚀将指定的元素填充到数组中

填充数组，该方法会将已有的元素

代码示例

public class Demo5 {
    public static void main(String[] args) {
        int [] arr=new int[]{1,2,3,4,5,6,7,8};
        Arrays.fill(arr,23);
        System.out.println(Arrays.toString(arr));
    }
}

用比较器对象自定义比较

首先创建一个Student类

package task3;

public class Student {
    private String name;
    private int age;
    private double height;

    public Student() {
    }

    public Student(String name, int age, double height) {
        this.name = name;
        this.age = age;
        this.height = height;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public double getHeight() {
        return height;
    }

    public void setHeight(double height) {
        this.height = height;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", height=" + height +
                '}';
    }
}

创建测试类

package task3;

import java.util.Arrays;
import java.util.Comparator;

public class ArraysDemo2 {
    public static void main(String[] args) {
        int[] ages = {34, 12, 42, 23};
        Arrays.sort(ages);
        System.out.println(Arrays.toString(ages));
        Integer[] ages1 = {34, 12, 42, 23};
        Arrays.sort(ages1, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                // 指定比较规则。
                //if(o1 > o2){
                //   return 1;
                //}else if(o1 < o2){
                //return -1;
                //}
                //return 0;
                // return o1 - o2; // 默认升序
                return o2 - o1; //  降序
            }
        });
        System.out.println(Arrays.toString(ages1));

        System.out.println("-------------------------");
        Student[] students = new Student[3];
        students[0] = new Student("吴磊", 23, 175.5);
        students[1] = new Student("谢鑫", 18, 185.5);
        students[2] = new Student("王亮", 20, 195.5);
        System.out.println(Arrays.toString(students));

        // Arrays.sort(students);  // 直接运行奔溃
        Arrays.sort(students, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                // 自己指定比较规则
                // return o1.getAge() - o2.getAge(); // 按照年龄升序排序！
                // return o2.getAge() - o1.getAge(); // 按照年龄降序排序！！
                // return Double.compare(o1.getHeight(), o2.getHeight()); // 比较浮点型可以这样写 升序
                return Double.compare(o2.getHeight(), o1.getHeight()); // 比较浮点型可以这样写  降序
            }
        });
        System.out.println(Arrays.toString(students));
    }
}

Arrays.sort();无法比较定义类型，如果要比较自定义类型的数据需要使用比较器对象，自己指定比较规则来对自定义类型中的数据进行排序。

🚀数组逆序

设定两个下标, 分别指向第一个元素和最后一个元素. 交换两个位置的元素. 然后让前一个下标自增, 后一个下标自减, 循环继续即可。

思路

设定两个下标, 分别指向第一个元素和最后一个元素. 交换两个位置的元素.
然后让前一个下标自增, 后一个下标自减, 循环继续即可.

代码示例

public class Demo7 {
    public static void main(String[] args) {
        int[] arr = {12,34,56,67,89,6};
        reverse(arr);
        System.out.println(Arrays.toString(arr));
    }

    private static void reverse(int[] arr) {
        int left = 0;
        int right = arr.length - 1;
        while (left < right) {
            int tmp = arr[left];
            arr[left] = arr[right];
            arr[right] = tmp;
            left++;
            right--;
        }
    }
}

⭐二维数组

二维数组其实就是一一维数组为元素的数组，在底层就是一个一维数组。

⭐ 二维数组的动态初始化

格式1：类型 [] []arr=new 类型 [X] [T]; //X,T是大于等于0的整数。

int [] [] arr=new int [3][2];

定义了一个名称为arr的二维数组，该数组中包含3个一维数组，每个一维数组的元素是2个。三个一维数组的名称分别为arr[0],arr[1],arr[2],如果想给一维数组中的第一个元素赋值可以这样写，arr[0] [1]=19;

格式二：int [] [] arr=new int [3] [];

定义了一个有三个一维数组的二维数组，每个一维数组都是默认初始化值为null，可以分别对这三个一维数组进行初始化arr[0]=new int [3]; arr[1]=new arr[1];,arr[2]=new int[2].

⭐二维数组的静态初始化

格式：类型 [] [] arr=new [] []{{元素1，元素2，元素3},{元素1，元素2},{元素1，元素2，元素3}};

定义一个名为arr的二维数组，该数组中有三个一维数组。对二维数组中地方一维数组进行初始化arr[0]={1,2,3};arr[1]={1,2,3};arr[2]={1,2,3};。

注意特殊写法：int [] x,y[];x是一维数组，y时二维数组。

二维数组的内存解析

public class Demo8 {
    public static void main(String[] args) {
        int[][] arr = new int[4][];
        arr[1] = new int[]{1,2,3};
        arr[2] = new int[4];
        arr[2][1] = 30;
    }
}

图解

首先main加载到栈区，创建一个有4个未初始化的一维数组的二维数组，在堆区就会开辟4个一维数组，因为一维数组属于引用类型所以默认值为null,然后将第2个一维数组进行初始化为1,2,3,再将第3个数组初始化其默认值为0，最后将其第二个元素赋值为30。

⭐使用二维数组打印杨辉三角

如图所示

代码

public class Demo9 {
    public static void main(String[] args) {
        int [] [] arr=new int[10][];
        for(int i=0;i<arr.length;i++){
            arr[i]=new int[i+1];
            arr[i][0]=arr[i][i]=1;

            for(int j=1;j<arr[i].length-1;j++){
                arr[i][j]=arr[i-1][j-1]+arr[i-1][j];
            }
        }

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

本文参与腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。

如有侵权请联系 cloudcommunity@tencent.com 删除

容器