Java提高篇之数组（1）

待我称王封你为后i 2022-12-21 04:40 211阅读 0赞

**目录**

（零）数组为什么特殊？

（一）数组概述

（二）一维数组

（三）二维数组

理解JAVA中的各个维度的数组模型

--------------------

最近学习JAVA数组相关知识，写篇博客，作为学习笔记，以便查阅，主要从四个方面简介（0）数组为什么特殊？（1）数组简介 （2）一维数组，定义，声明，初始化，使用，内存分析，（3）二维数组，定义，声明·，初始化，使用，内存分析。（4）数组array类及其方法时使用，增删改查。数组中涉及到排序算法相关，如冒泡排序，最小二分法等相关在数据结构和算法中介绍，此处数组的应用只介绍数组中数据的增删改查。

### **（零）数组为什么特殊？** ###

JAVA中有大量其他方式持有对象，那么，到底是什么使得数组与众不同呢？

数组与其他类型的容器之间的区别有三个方面：**效率，类型和保存基本类型的能力**，在Java中，数组是一种效率最高的存储和随机访问对象序列的方式，数组为简单的线性序列，这使得元素访问的速度非常快，但是这种速度所付出的代价为数组对象的大小固定，且其生命周期不可变。数组之所以优于泛型之类的容器，因为你可以创建一个数组去持有某个具体的类型，这意味着你可以通过编译器检查，防止插入错误信息和抽取不当类型。

那么，为什么要定义数组呢？

定义100个整型变量，其结构如下：

int i1, i2, i3, ... i100;

这样的定义方式非常麻烦，因为这些变量彼此之间没有任何的关联，当你要输出这100个变量的内容，意味着你要编写`System.out.println()`语句`100`次，或用for循环打印100次。

其实数组指的就是一组相关类型的变量集合，并且这些变量可以按照统一的方式进行操作，即为相同数据类型的集合，通过这样的方式来保存数据，以实现数据的增删改查。数组本身属于引用数据类型。

### **（一）数组概述** ###

数组(Array)，是多个相同类型数据按一定顺序排列 的集合，并使用一个名字命名，并通过编号的方式 对这些数据进行统一管理。数组中常用的概念有，数组名，下标，元素，和数组长度等。

>  *  数组本身是引用数据类型，而数组中的元素可以是任何数据类型，包括 基本数据类型和引用数据类型。
>  *   创建数组对象会在内存中开辟一整块连续的空间，而数组名中引用的是 这块连续空间的首地址。
>  *   数组的长度一旦确定，就不能修改。
>  *   我们可以直接通过下标(或索引)的方式调用指定位置的元素，速度很快。
>  *   数组的分类：  按照维度：一维数组、二维数组、三维数组、… ； 按照元素的数据类型分：基本数据类型元素的数组、引用数据类型元素的数组(即对象数组)

数组的声明方式有两种，静态初始化和静态初始化

数组的静态初始化：

*  数据类型 \[\] 数组名称 = `new` 数据类型\[\]\{元素1，元素2，元素3，.....\}；如 int \[\] sa=new int\[\]\{1,2.3\};

数组动态初始化：

*  声明并开辟数组：
    
     *  数据类型 \[\] 数组名称 = `new` 数据类型\[长度\];如 int \[\] a=new int\[5\];
     *  数据类型  数组名称\[\] = `new` 数据类型\[长度\];如int a\[\]=new int\[4\];

那么当数组开辟空间之后，就可以采用如下的方式的操作：

*  数组的访问通过索引完成，即：“数组名称\[索引\]”，如a\[2\]  ;  数组的索引从`0`开始，索引的范围就是`0` ~ 数组长度-`1`，例如开辟了`3`个空间的数组，所以可以使用的索引是：0,1,2，如果此时访问的时候超过了数组的索引范围，会产生`java.lang.ArrayIndexOutOfBoundsException` 异常信息；
 *  当我们数组采用动态初始化开辟空间后，数组里面的每一个元素都是该数组对应数据类型的默认值；且每种数据类型都有其自身的默认值。
 *  数组本身是一个有序的集合操作，所以对于数组的内容操作往往会采用循环的模式完成，数组是一个有限的数据集合，所以应该使用 `for` 循环。
 *  在 `Java` 中提供有一种动态取得数组长度的方式：数组名称.length

public class ArrayDemo {
    	public static void main(String args[]) {
    		int data[] = new int[3]; /*开辟了一个长度为3的数组*/
    		data[0] = 10; // 第一个元素
    		data[1] = 20; // 第二个元素
    		data[2] = 30; // 第三个元素
    		for(int x = 0; x < data.length; x++) {
    			System.out.println(data[x]); //通过循环控制索引
    		}
    	}
    }
    /*
    输出结果为
    10
    20
    30
    
    */

### （二）一维数组 ###

一维数组是由同一数据类型组成的数据集合。由一维数据组成，如下图：

![20201115193025492.png][]

（1）声明

一维数组的声明方式有两种：type var\[\] 或 type\[\] var，比如说 int a\[\]；或int \[\]a;

（2）初始化

初始化方式由两种，动态初始化和静态初始化。

*  动态初始化：数组声明且为数组元素分配空间与赋值的操作分开进行

![2020111518514271.png][]

*  静态初始化：在定义数组的同时就为数组元素分配空间并赋值。

![20201115185257521.png][]

（3）引用

>  *  定义并用运算符new为之分配空间后，才可以引用数组中的每个元素；
>  *  数组元素的引用方式：数组名\[数组元素下标\]
>  *   数组元素下标可以是整型常量或整型表达式。如a\[3\] , b\[i\] , c\[6\*i\];
>  *  数组元素下标从0开始；长度为n的数组合法下标取值范围: 0 —>n-1；如int a\[\]=new int\[3\]; 可引用的数组元素为a\[0\]、a\[1\]、a\[2\]
>  *  每个数组都有一个属性length指明它的长度，例如：a.length 指明数组a的长 度(元素个数)
>  *  数组一旦初始化，其长度是不可变的

（4）默认初始化值

数组是引用类型，它的元素相当于类的成员变量，因此数组一经 分配空间，其中的每个元素也被按照成员变量同样的方式被隐式初始化。如下程序，a\[3\]的默认初始化址为0；

public class Test {
    public static void main(String argv[]){
    int a[]= new int[5];
    System.out.println(a[3]); //a[3]的默认值为0
    }
    }

通常而言，其他数据类型的默认值为：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTc5MjE2Mg_size_16_color_FFFFFF_t_70][]

（5）内存分析

Java中jvm内存简化图为

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTc5MjE2Mg_size_16_color_FFFFFF_t_70 1][]

那么，对于如下程序，其运行过程为：

package strings;
    
    /**
     * Created with IntelliJ IDEA.
     * User:  yongping Li
     * Date: 2020/11/14
     * Time: 15:10
     * Description: No Description
     */
    public class Test{
        public static void main(String args[]){
            int[] s;
            s = new int[10];
            for ( int i=0; i<10; i++ ) {
                s[i] =2*i+1;
                System.out.println(s[i]);
            }
        }
    }

在int\[\] s;                                                                            在s = new int\[10\]处;                                                           在s\[i\] =2\*i+1;处：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTc5MjE2Mg_size_16_color_FFFFFF_t_70 2][]               ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTc5MjE2Mg_size_16_color_FFFFFF_t_70 3][]          ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTc5MjE2Mg_size_16_color_FFFFFF_t_70 4][]

对于如下程序，其内存分析为

public class ArrayDemo {
    	public static void main(String args[]) {
    		int data[] = null;
    		data = new int[3]; //开辟一个长度为3的数组
    		int temp[] = null; //声明对象
    		data[0] = 10;
    		data[1] = 20;
    		data[2] = 30;
    		temp = data;  //int temp[] = data;
    		temp[0] = 99;
    		for(int i = 0; i < temp.length; i++) {
    			System.out.println(data[i]);
    		}
    	}
    }

内存分析：

![è¿éåå¾çæè¿°][70]

int[] arr1 = new int[4];
    arr1[0] = 10;
    arr1[2] = 20;
    String[] arr2 = new String[3];
    arr2[1] = “刘杰”；
    arr2 = new String[5];

内存分析：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTc5MjE2Mg_size_16_color_FFFFFF_t_70 5][]

int[] arr = new int[]{1,2,3};
    String[] arr1 = new String[4];
    arr1[1] = “刘德华”;
    arr1[2] = “张学友”;
    arr1 = new String[3];
    sysout(arr1[1]);//null

内存分析：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTc5MjE2Mg_size_16_color_FFFFFF_t_70 6][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTc5MjE2Mg_size_16_color_FFFFFF_t_70 7][]

一维数组程序代码示例：

package arrays;//: arrays/ArrayOptions.java
    // Initialization & re-assignment of arrays.
    import java.util.*;
    
    
    public class ArrayOptions {
      public static void main(String[] args) {
        // Arrays of objects:
        BerylliumSphere[] a; // Local uninitialized variable
        BerylliumSphere[] b = new BerylliumSphere[5];
        // The references inside the array are
        // automatically initialized to null:
        System.out.println("b: " + Arrays.toString(b));
        BerylliumSphere[] c = new BerylliumSphere[4];
        for(int i = 0; i < c.length; i++)
          if(c[i] == null) // Can test for null reference
            c[i] = new BerylliumSphere();
        // Aggregate initialization:
        BerylliumSphere[] d = { new BerylliumSphere(),
          new BerylliumSphere(), new BerylliumSphere()
        };
        // Dynamic aggregate initialization:
        a = new BerylliumSphere[]{
          new BerylliumSphere(), new BerylliumSphere(),
        };
        // (Trailing comma is optional in both cases)
        System.out.println("a.length = " + a.length);
        System.out.println("b.length = " + b.length);
        System.out.println("c.length = " + c.length);
        System.out.println("d.length = " + d.length);
        a = d;
        System.out.println("a.length = " + a.length);
    
        // Arrays of primitives:
        int[] e; // Null reference
        int[] f = new int[5];
        // The primitives inside the array are
        // automatically initialized to zero:
        System.out.println("f: " + Arrays.toString(f));
        int[] g = new int[4];
        for(int i = 0; i < g.length; i++)
          g[i] = i*i;
        int[] h = { 11, 47, 93 };
        // Compile error: variable e not initialized:
        //!print("e.length = " + e.length);
        System.out.println("f.length = " + f.length);
        System.out.println("g.length = " + g.length);
        System.out.println("h.length = " + h.length);
        e = h;
        System.out.println("e.length = " + e.length);
        e = new int[]{ 1, 2 };
        System.out.println("e.length = " + e.length);
      }
    } /* Output:
    b: [null, null, null, null, null]
    a.length = 2
    b.length = 5
    c.length = 4
    d.length = 3
    a.length = 3
    f: [0, 0, 0, 0, 0]
    f.length = 5
    g.length = 4
    h.length = 3
    e.length = 3
    e.length = 2
    *///:~

运行结果为：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTc5MjE2Mg_size_16_color_FFFFFF_t_70 8][]

### （三）二维数组 ###

一维数组可以将其看成一行数据；如下图：

![20201115193025492.png][]

而二维数组可以将其看成为一个列表，如下图：

![20201115193124948.png][]

因此，二维数组可以将其看成两个一维数组的组合。

（1）声明及初始化

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTc5MjE2Mg_size_16_color_FFFFFF_t_70 9][]

二维数组的初始化：

*  数组的动态初始化：数据类型 对象数组\[\]\[\] = new 数据类型\[行个数\]\[列个数\];
 *  数组的静态初始化：数据类型 对象数组\[\]\[\] = new 数据类型\[行个数\]\[列个数\]\{ \{值, 值,…\}, \{值, 值,…\},…\};

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTc5MjE2Mg_size_16_color_FFFFFF_t_70 10][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTc5MjE2Mg_size_16_color_FFFFFF_t_70 11][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTc5MjE2Mg_size_16_color_FFFFFF_t_70 12][]

（2）内存分析

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTc5MjE2Mg_size_16_color_FFFFFF_t_70 13][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTc5MjE2Mg_size_16_color_FFFFFF_t_70 14][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTc5MjE2Mg_size_16_color_FFFFFF_t_70 15][]

## **理解JAVA中的各个维度的数组模型** ##

![0e90f952979f21651e1aeee65362d40e.png][]

[20201115193025492.png]: /images/20221120/6e010e6a2c824c148c6157c12c6dbfa1.png
[2020111518514271.png]: /images/20221120/b0fed0cc50164ce6b17374cae94e90e3.png
[20201115185257521.png]: /images/20221120/2a50d69c72ce48f780996e4508e0a41f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTc5MjE2Mg_size_16_color_FFFFFF_t_70]: /images/20221120/2f9c231da2ea4a0e84f0f534f86dac35.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTc5MjE2Mg_size_16_color_FFFFFF_t_70 1]: /images/20221120/fc8903dea7184872b3a900475a31aaf0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTc5MjE2Mg_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20201115190313273.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTc5MjE2Mg==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTc5MjE2Mg_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20201115190410691.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTc5MjE2Mg==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTc5MjE2Mg_size_16_color_FFFFFF_t_70 4]: /images/20221120/5c7043928c7a433bbaa1d55e25565df2.png
[70]: /images/20221120/4ec979e7a4cd4ed78c10cba547039b08.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTc5MjE2Mg_size_16_color_FFFFFF_t_70 5]: /images/20221120/303d48726a834d96a395443bb7565724.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTc5MjE2Mg_size_16_color_FFFFFF_t_70 6]: /images/20221120/e9b7228218e344c3bd2edee3fa6ab449.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTc5MjE2Mg_size_16_color_FFFFFF_t_70 7]: /images/20221120/2a380406579e431d8012d064933abb68.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTc5MjE2Mg_size_16_color_FFFFFF_t_70 8]: /images/20221120/40351dcac5ca4be8bde42e8f8d74bf4a.png
[20201115193124948.png]: /images/20221120/cc14bb6fcd45485dabb2394a13c90e61.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTc5MjE2Mg_size_16_color_FFFFFF_t_70 9]: /images/20221120/c390c6148776408ba46bc87d3c76c563.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTc5MjE2Mg_size_16_color_FFFFFF_t_70 10]: /images/20221120/8abb3f3c07a944d6b596e8d0c7433327.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTc5MjE2Mg_size_16_color_FFFFFF_t_70 11]: /images/20221120/f0dab7c3aea44863896cf3a5e65ffab9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTc5MjE2Mg_size_16_color_FFFFFF_t_70 12]: /images/20221120/8aec919c21cc4999b02ba68d752327da.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTc5MjE2Mg_size_16_color_FFFFFF_t_70 13]: /images/20221120/f38ee66d57ac452f97003234918105eb.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTc5MjE2Mg_size_16_color_FFFFFF_t_70 14]: /images/20221120/c41827ccf7d048468caedbaa4f17c494.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTc5MjE2Mg_size_16_color_FFFFFF_t_70 15]: /images/20221120/07fa647465304ed7bb3faeb6259c84c3.png
[0e90f952979f21651e1aeee65362d40e.png]: /images/20221120/3ac0df1471cf4e95a09453b424c716ea.png