【Java|基础篇】全面解析数组,数组知识点汇总

墨蓝 2023-09-27 12:29 133阅读 0赞

#### 文章目录 ####

*  1.数组的概念
 *  2.一维数组
 *  3.一维数组的定义
 *  4.访问数组的元素
 *  5.遍历数组
 *   *  for循环遍历数组
     *  for each遍历数组
     *  toString遍历数组
 *  6.数组的初始化
 *   *  静态初始化
     *  动态初始化
 *  数组元素的默认值
 *  7.二维数组
 *  8.二维数组的遍历
 *   *  for循环进行遍历
     *  for each进行遍历
     *  deepToString
 *  9.数组的拷贝
 *   *  for循环拷贝数组
     *  Arrays.copyOf方法
     *  Arrays.copyofRange方法
     *  System.arraycopy方法
     *  clone方法
 *  10.总结

## 1.数组的概念 ##

什么是数组？ 数组就是相同数据类型元素的集合。在内存中是一段连续的空间。在会使用到很多相同数据类型的变量时，使用数组可以更加方便，减少程序的代码量。

## 2.一维数组 ##

## 3.一维数组的定义 ##

数组的定义有3中方式,具体定义方式如下:

int[] arr1 = {
        1,2,3};
    int[] arr2 = new int[]{
        1,2,3};
    int[] arr3 = new int[3];

注意:arr1、arr2和arr3是引用变量.用来存放地址的哈希值，可以理解为地址。  
**int\[\]表示的是数据的类型**，是一维数组。\[\]中间不需要加数字。  
虽然也能像C语言那样 写成 int arr\[\] =\{1,2,3\} ,但是不推荐！

## 4.访问数组的元素 ##

对于访问数组的元素,我们可以使用 数组名+\[合法的下标\] 对数组的元素进行访问.  
注:**合法的下标就是下标不能超过数组的长度,也不能是负数**。  
数组支持随机访问，即通过下标访问快速访问数组中任意位置的元素。  
Java数组的下表是从0开始,对于一个有N个元素的数组来说，下标的合法位置就介于\[0, N）不包含N,不能越界，否则会报出下标越界异常。  
对于二维数组来说，同样可以使用下标来进行访问，不过要同时指正行和列。

## 5.遍历数组 ##

遍历数组常见的方式有3种,for循环进行遍历,for each进行遍历以及toString进行遍历.对于数组的长度,Java给我们提供了一个简单的方法,直接通过数组名.length() 我们就可以直接得到数组的长度了.

### for循环遍历数组 ###

> 语法格式:  
> for (int i = 0; i < 数组名.length; i++) \{  
> System.out.print(数组名\[i\]);  
> \}

for循环遍历数组,就是通过循环,将下标从0开始一直到数组的最后一个元素打印出来.

public static void main(String[] args) {
        
            int[] arr = {
        1,2,3,4,5};
            for (int i = 0; i < arr.length; i++) {
        
                System.out.print(arr[i]+" ");
            }
        }

### for each遍历数组 ###

for each在遍历数组的时候，我们要创建一个与数组的数据类型相同的临时变量,数组会把的每一个元素都复制给临时变量,然后进行输出.

> 语法格式:  
> for(数据类型 变量:数组名)\{  
> System.out.print(变量);  
> \}

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

### toString遍历数组 ###

toString是将数组的元素以字符串的方式打印出来。  
要使用toString 必须要导入一个包 **import java.util.Arrays;**  
**使用方式：String 变量 = Arrays.toString(数组名)** 然后打印字符串变量就可以了

> 语法格式:  
> String 变量= Arrays.toString(数组名);  
> System.out.println(变量);

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

## 6.数组的初始化 ##

> 数组的初始化分为两种：一种是**静态初始化**，另外一种是**动态初始化**。

### 静态初始化 ###

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

int[] arr1 = {
        1,2,3};
    int[] arr2 = new int[]{
        1,2,3};

arr1和arr2就是静态初始化的数组。  
注意:虽然在定义数组的时候没有指定大小，但是编译器会根据\{\}中元素的个数来确定数组的长度。  
arr1和arr2是一样的，都是静态初始化的数组，我们就可以使用arr1的那种形式来简化代码.

### 动态初始化 ###

动态初始化就是在定义数组时，指定数组的长度。

int[] arr3 = new int[3];

arr3就是动态初始化的数组。动态初始化完不能不能扩充数组，arr3就只能放3个元素。

## 数组元素的默认值 ##

在Java中,我们定义局部变量是没有初始值的,因此我们在**使用局部变量时必须要赋值**,但是数组不一样, 对于数组来说,即使不赋值,也会有默认值.  
不同数据类型的数组的默认值如下:

<table> 
 <thead> 
  <tr> 
   <th>数据类型</th> 
   <th>默认值</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>int</td> 
   <td>0</td> 
  </tr> 
  <tr> 
   <td>short</td> 
   <td>0</td> 
  </tr> 
  <tr> 
   <td>long</td> 
   <td>0</td> 
  </tr> 
  <tr> 
   <td>byte</td> 
   <td>0</td> 
  </tr> 
  <tr> 
   <td>float</td> 
   <td>0.0f</td> 
  </tr> 
  <tr> 
   <td>double</td> 
   <td>0.0</td> 
  </tr> 
  <tr> 
   <td>char</td> 
   <td>/u0000</td> 
  </tr> 
  <tr> 
   <td>boolean</td> 
   <td>false</td> 
  </tr> 
 </tbody> 
</table>

## 7.二维数组 ##

二维数组就是特殊的一维数组

int[][] arr1 = {
        {
        1,2,3},{
        4,5,6}};
    int[][] arr2 = new int[][]{
        {
        1,2,3},{
        4,5,6}};
    int[][] arr3 = new int[2][3];

在arr1和arr2的定义中，虽然我们没有给它定义行和列，但是通过\{\}也能让编译器知道行和列。  
注意：**二维数组在java中是可以省略列的**

## 8.二维数组的遍历 ##

### for循环进行遍历 ###

二维数组是特殊的一维数组，那我们就可以把二维数组的行看成一维数组的长度，把列看成一维数组行的长度  
因此要遍历一个二维数组就可以使用下面这种方法：

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

### for each进行遍历 ###

对于二维数组，我们要先用for each把二维数组的每一行放到一维数组中，然后在使用for each打印一维数组中的每一个元素。  
使用方式如下：

for (int[] arr:arr1) {
        
                for (int x:arr) {
        
                    System.out.print(x+" ");
                }
                System.out.println();
            }

### deepToString ###

对于deepToString方法，在使用前要先导入import java.util.Arrays 这个包  
使用方式如下：

int[][] arr1 = {
        {
        1,2,3},{
        4,5,6}};
    System.out.println(Arrays.deepToString(arr1));

## 9.数组的拷贝 ##

对于数组的拷贝，除了使用for循环拷贝数组，Java还为我们提供了一些非常便利的方法。

### for循环拷贝数组 ###

for循环拷贝数组，就是利用循环将要拷贝的数组的元素逐个赋值给新的数组。  
具体代码实现如下：

public static void main(String[] args) {
        
            int[] arr = {
        1,2,3,4,5};
            int[] copy = new int[arr.length];
            for (int i = 0; i < arr.length; i++) {
        
                copy[i] = arr[i];
            }
        }

### Arrays.copyOf方法 ###

Arrays.copyOf方法可以拷贝的数组类型有很多，具体类型如下：  
![在这里插入图片描述][fed1f81b69764cb2a6aaf8d1105019ac.png]  
在使用Arrays.copyOf方法，我们先看看拷贝整型数组的Arrays.copyOf方法的原码：

public static int[] copyOf(int[] original, int newLength) {
        
            int[] copy = new int[newLength];
            System.arraycopy(original, 0, copy, 0,
                             Math.min(original.length, newLength));
            return copy;
        }

我们可以看到Array.copyOf方法的返回值是是一个数组，而形参是有两个参数，一个是数组，另外一个是一个整型的变量。  
形参中的int\[\] original就是我们要拷贝数组的数组名  
形参中的int newLength就是我们要拷贝数组的长度  
因为是有返回值的，所以我们在使用Arrays.copyOf方法的时候，要有数组来接收返回值。  
使用方式如下：

public static void main(String[] args) {
        
            int[] arr = {
        1,2,3,4,5};
            int[] copy =Arrays.copyOf(arr,arr.length);
        }

> 注意:拷贝的长度是可以超过要拷贝数组的长度的，如果超过了拷贝数组的长度的话，那么多出来的元素值就为0； 比如：我要拷贝arr数组，但是arr数组的大小为5，如果我在拷贝的时候，将arr.length\*2了，那么copy这个数组大小就是变成10，并且6~10个元素值为0.这也算是扩容。

### Arrays.copyofRange方法 ###

Arrays.copyofRange方法能拷贝的数组类型也有很多，如下：  
![在这里插入图片描述][a66758c157ad485facd3fad0339d187c.png]  
如果我们要**拷贝数组的一部分**，就可以使用Arrays.copyRange这个方法。同上一样，也是用拷贝整型数组进行讲解，我们先看一下它底层的原码：

public static int[] copyOfRange(int[] original, int from, int to) {
        
            int newLength = to - from;
            if (newLength < 0)
                throw new IllegalArgumentException(from + " > " + to);
            int[] copy = new int[newLength];
            System.arraycopy(original, from, copy, 0,
                             Math.min(original.length - from, newLength));
            return copy;
        }

通过Arrays.copyRange的原码可以看到返回值是一个数组，而形参是一个数组，两个整型的变量。  
形参中的**数组就是要拷贝的数组的数组名**  
形参中的两个**整型变量from和to就是要拷贝数组元素的范围**，范围是\[form，to)是左闭右开的  
使用方式如下：

public static void main(String[] args) {
        
            int[] arr = {
        1,2,3,4,5};
            int[] copy = Arrays.copyOfRange(arr,1,3);
        }

**注意：数组下标是从0开始的，1~3号的元素是指2，3，4.但是右边是开区间，所以不包括4，因此copy这个数组知识拷贝了2和3这两个元素。**

### System.arraycopy方法 ###

其实细心的话，就会发现在前面两个方法的原码中都有System.arraycopy方法。  
前面两个方法的底层也是靠System.arraycopy方法来实现的。System.arraycopy方法是看不了原码的，只能看到形参。如下：

public static native void arraycopy(Object src,  int  srcPos,
                                            Object dest, int destPos,
                                            int length);

各个形参的意思如下：  
![在这里插入图片描述][03e44eb35f694ca5bc6e113e0174ce2e.png]  
System.arraycopy是看不到实现的原码的，**原因在于native,它的底层是C/C++来实现的。**  
因为是C/C++实现的，因此native方法的优点就是执行速度非常快  
使用方法代码如下：

public static void main(String[] args) {
        
            int[] arr = {
        1,2,3,4,5};
            int[] copy = new int[arr.length];
            System.arraycopy(arr,0,copy,0,arr.length);
        }

### clone方法 ###

最后一个是数组名.clone这个方法，这个方法了解即可。

public static void main(String[] args) {
        
            int[] arr = {
        1,2,3,4,5};
            int[] copy = arr.clone();
        }

这种方法主要是产生了对象的一个副本，地址还是不一样的。

## 10.总结 ##

数组在Java中还是比较常用的，主要是总结了数组的定义、遍历、通过下标对数组的元素进行访问等一些问题的总结（如有错误，欢迎指正！）

> 感谢你的观看!  
> Java专栏持续更新中~ 希望与君共勉,携手并进!  
> ![在这里插入图片描述][d06848a488dc411d9bcfc898a8d8e8eb.png_pic_center]

[fed1f81b69764cb2a6aaf8d1105019ac.png]: https://img-blog.csdnimg.cn/fed1f81b69764cb2a6aaf8d1105019ac.png
[a66758c157ad485facd3fad0339d187c.png]: https://img-blog.csdnimg.cn/a66758c157ad485facd3fad0339d187c.png
[03e44eb35f694ca5bc6e113e0174ce2e.png]: https://img-blog.csdnimg.cn/03e44eb35f694ca5bc6e113e0174ce2e.png
[d06848a488dc411d9bcfc898a8d8e8eb.png_pic_center]: https://img-blog.csdnimg.cn/d06848a488dc411d9bcfc898a8d8e8eb.png#pic_center