『Java』数组中值得说的那些事

前言

如果你学过C语言，谈到数组，想必你一定对此非常熟悉了，那么在Java阶段还有介绍的必要吗？当然有了，不然我还写这篇博客干嘛对吧😁其实对于Java中的数组还是有一些值得说一说的东西的，下面我就撇开大家熟悉的概念，总结一下Java数组中值得说一说的那些事！

------------------ （正文开始）------------------

一、数组的创建及初始化

🌳1、数组的创建

Java数组语法格式：

数组的创建举例：

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

🌳2、数组的初始化

🍑（1）动态初始化

在创建数组时，直接指定数组中元素的个数

语法格式：T[] 数组名 = new T[整形];

int[] array1 = new int[10];//10个int类型元素的数组
boolean[] array2 = new boolean[3];//3个boolean类型元素的数组

对于动态初始化的方式，指定数组的大小后，数组中元素有其默认值：

说明：'/u0000'是一个Unicode码的字符。‘/u0000’ 是一个空的字符，它与null和""不同，是特殊的“空”,是不可打印的。

注： 如果数组中存储元素类型为引用类型，默认值为null

🍑（2）静态初始化

在创建数组时不直接指定数据元素个数，而直接将具体的数据内容进行指定

语法格式： T[] 数组名称 = {data1, data2, data3, ..., datan};

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[]{"Hello", "Java", "!!!"};

省略格式：

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

注意：

1. 静态初始化虽然没有指定数组的长度，编译器在编译时会根据{}中元素个数来确定数组的长度。
2. 静态初始化时, {}中数据类型必须与[]前数据类型一致。
3. 静态初始化可以简写，省去后面的new T[]。(只是表面上省略了，在编译阶段还是会还原new T[])

注： 静态和动态初始化也可以分为两步，但是省略格式不可以，省略格式只能一步到位。

int[] array1;
array1 = new int[10];

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

//省略格式：
int[] array3={1,2,3};
// 注意省略格式不可以拆分, 否则编译失败
// int[] array3;
// array3 = {1, 2, 3};

二、数组的使用

🌳1、数组中元素访问

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

public static void main(String[] args) {
    int[]array = new int[]{10, 20, 30};
    //通过下标访问
    System.out.print(array[0]+" ");
    System.out.print(array[1]+" ");
    System.out.println(array[2]);
    // 也可以通过[]对数组中的元素进行修改
    array[0] = 100;
    System.out.println(array[0]);
}

注意：

1. 数组是一段连续的内存空间，因此支持随机访问，即通过下标访问快速访问数组中任意位置的元素
2. 下标从0开始，介于[0, N）之间不包含N，N为元素个数，不能越界，否则会报出下标越界异常。

🌳2、遍历数组

🍑（1）使用for循环

注意：在数组中可以通过 数组对象.length 来获取数组的长度

public static void main(String[] args) {
    int[]array = new int[]{10, 20, 30, 40, 50};
    for(int i = 0; i < array.length; i++){
        System.out.print(array[i]+" ");
    }
}

🍑（2）使用for-each遍历

for-each 是 for 循环的另外一种使用方式. 能够更方便的完成对数组的遍历. 可以避免循环条件和更新语句写错。

public static void main(String[] args) {
    int[] array = {1, 2, 3,4,5,6,7};
    for (int x : array) {
        System.out.print(x+" ");
    }
}

三、数组与引用类型

🌳1、初识JVM内存分布

想要了解引用类型，我们首先了解一下内存的分配。为了便于内存的管理，JVM也对所使用的内存按照功能的不同进行了划分：

现在我们只需简单关心堆和虚拟机栈这两块空间，简单了解一下方法区，后序还会对JVM有更详细介绍。

🌳2、基本类型变量与引用类型变量

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

数组是引用类型

📝例1：基本类型变量与引用类型变量的内存分布

public static void main(String[] args) {
    int a=10;
    int[] array=new int[]{1,2,3};
}

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

注： 引用变量并不直接存储对象本身，可以简单理解成存储的是对象在堆中空间的起始地址。通过该地址，引用变量便可以去操作对象。

📝例2：引用指向对象而不指向引用

public static void main(String[] args) {
    int[] array1=new int[]{1,2,3};
    int[] array2=new int[]{100,200,300,400};

    array1=array2;//表示array1这个引用指向array2这个引用指向的对象
    array1[1]=99;
}

总结:

所谓的 "引用" 本质上只是存了一个地址. Java 将数组设定成引用类型, 这样的话后续进行数组参数传参, 其实只是将数组的地址传入到函数形参中. 这样可以避免对整个数组的拷贝(数组可能比较长, 那么拷贝开销就会很大).

🌳3、认识null

null 在 Java 中表示 “空引用” , 也就是一个不指向对象的引用，它的作用类似于 C 语言中的 NULL (空指针), 都是表示一个无效的内存位置。因此不能对这个内存进行任何读写操作。一旦尝试读写, 就会抛出NullPointerException

四、二维数组

🌳1、二维数组的创建和初始化

//静态初始化
int[][] array1=new int[][]{{1,2,3},{4,5,6}};
int[][] array2={{1,2,3},{4,5,6}};//省略形式
//int[][] array={1,2,3,4,5,6,7};这种方式是错误的
//动态初始化
int[][] array3=new int[2][3];

🌳2、不规则二维数组

在Java中我们可以由此创建出不规则的二维数组：

方式1：

//在Java中行不能省略，列能省略
public static void main16(String[] args) {
    //不指定列时，默认为null
    int[][] array=new int[2][];
    System.out.println(array[0]);
    System.out.println(array[1]);
    
    //这里充分体现了Java中二维数组是特殊的一维数组
    array[0]=new int[]{1,2,3};
    array[1]=new int[]{4,5,6,7};
}

方式2：

int[][] array={{1,2,3},{4,5,6,7}};

注：Java中充分体现了二维数组是特殊的一维数组。 如图：

🌳3、二维数组的遍历

🍑（1）for循环遍历

 public static void main(String[] args) {
    int[][] array = {{1,2,3},{4,5,6,7}};
    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();//换行
    }
}

1. array,length相当于二维数组的行号。
2. array[i].length相当于每一行的列号。

🍑（2）使用for-each遍历

public static void main(String[] args) {
    for (int[] ret : array) {
        for (int x : ret) {
            System.out.print(x+" ");
        }
      System.out.println();//换行
    }
}

在二维数组中还有一些其他的用法，不过和一维数组并没有明显差别, 同理, 还存在 “三维数组”, “四维数组” 等更复杂的数组, 只不过出现频率都很低，因此这里就不再赘述了。

五、常用的数组方法

在java.util包为我们提供了一个Arrays类，导入包后（import java.util.Arrays;）我们就可以直接使用Arrays提供的一些方法，下面我就为大家介绍一下Arrays类下常用的方法：

🌳1、toString()

作用：以字符串打印一维数组

语法格式：toString(数组名);

🌳2、copyOf()

作用：数组拷贝，扩容

语法格式：copyOf(数组名,新数组长度);

🌳3、copyOfRange()

作用：范围拷贝，起始下标与终止下标遵循左闭右开[起始下标 , 终止下标)

语法格式：copyOfRange(数组名 , 起始下标 , 终止下标);

🌳4、fill()

作用：数组填充

语法格式：

fill(数组名,填充值);

fill(数组名,起始下标 , 终止下标,填充值);

🌳5、equals()

作用：判断数组对应元素是否相同，相同返回true，否则返回false

语法格式：equals(数组名1,数组名2);

🌳6、sort()

作用：升序排序数组

语法格式：sort(数组名);

🌳7、binarySearch()

作用：二分查找（前提数组有序），找到返回下标，找不到返回负数

语法格式：binarySearch(数组名,查找值);

🌳8、deepToString()

作用：以字符串打印二维数组

语法格式：deepToString(二维数组名);

总结

本篇全部内容到这里就全部结束了，简单回顾一下，本篇着重介绍了Java中数组的创建及使用，初步了解了引用类型，最后盘点了数组中常用的一些方法。相信通读全文，你一定有所收获！

------------------ （下期见！）------------------