Java 中数组的使用

1.数组的使用方式

1.1 数组的定义
1.1.1 动态初始化
  1. 数据类型 数组名[] = new 数据类型[大小]
int a[] = new int[5]; //创建了一个数组，名字为a, 存放 5 个 int 类型的值
  • 1.
  1. 先声明数组，再 new 分配空间
double scores[]; //声明数组，此时 scores 是 null
scores = new double[5]; //分配内存空间，可以存放数据
  • 1.
  • 2.
1.1.2 静态初始化

语法： 数据类型 数组名[] = {元素值，元素值，······}

int a[] = {1,2,3,4,5,6,7,8,9,0};
//如果知道数组有多少元素和他们的具体值
//上面的用法相当于：
int a[] = new int[9];
a[0] = 1;
a[1] = 2;
//·······
a[9] = 0;
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
1.2 数组使用的注意事项和细节
  1. 数组是多个相同类型数据的组合，实现对这些数据的统一管理
  2. 数组中的元素可以是任何数据类型，包括基本类型和引用类型，但是不能混用。
  3. 数组创建后，如果没有赋值，有默认值
    int 0，short 0, byte 0, long 0, float 0.0,double 0.0，char \u0000，boolean false，String null
  4. 使用数组的步骤 1. 声明数组并开辟空间 2. 给数组各个元素赋值 3. 使用数组
  5. 数组的下标是从 0 开始的。
  6. 数组下标必须在指定范围内使用，否则报：下标越界异常，int [] arr=new int[5]; 则有效下标为 0-4
  7. 数组属引用类型，数组型数据是对象(object)
1.3 数组的赋值机制
  • 基本数据类型赋值，这个值就是具体的数据，而且相互不影响。
    int n1 = 2; int n2 = n1;
  • 数组在默认情况下是引用传递，赋的值是地址。

看一个案例，并分析数组赋值的内存图(重点, 难点. )

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

Java 中数组的使用(一维数组和二维数组)_java基础

可以看到，进行 arr2 = arr1 的操作时，arr2 获取的是 arr1 的地址，arr2 并没有单独再开辟一个新的空间，而是指向 arr1 所开辟的空间。所以，改变 arr2 中的值，arr1 中也会同步改变。

1.4 数组添加/扩容

要求： 实现动态的给数组添加元素效果，实现对数组扩容。

  1. 原始数组使用静态分配 int[] arr = {1,2,3}
  2. 增加的元素 4，直接放在数组的最后 arr = {1,2,3,4}
  3. 用户可以通过如下方法来决定是否继续添加，添加成功，是否继续？y/n
import java.util.Scanner;
public class ArrayAdd {
    public static void main(String[] args) {
        /*
			要求：实现动态的给数组添加元素效果，实现对数组扩容。ArrayAdd.java
			1.原始数组使用静态分配 int[] arr = {1,2,3}
			2.增加的元素 4，直接放在数组的最后 arr = {1,2,3,4}
            3.用户可以通过如下方法来决定是否继续添加，添加成功，是否继续？y/n
            思路分析
            1. 定义初始数组 int[] arr = {1,2,3}//下标 0-2
            2. 定义一个新的数组 int[] arrNew = new int[arr.length+1];
            3. 遍历 arr 数组，依次将 arr 的元素拷贝到 arrNew 数组
            4. 将 4 赋给 arrNew[arrNew.length - 1] = 4;把 4 赋给 arrNew 最后一个元			素
            5. 让 arr 指向 arrNew ; arr = arrNew; 那么 原来 arr 数组就被销毁
            6. 创建一个 Scanner 可以接受用户输入
            7. 因为用户什么时候退出，不确定，使用 do-while + break 来控制
		*/
        Scanner myScanner = new Scanner(System.in);
        //初始化数组
        int arr[] = {1,2,3};
        
        do{
            int[] arrNew = new int[arr.length + 1];
            //将 arr 数组拷贝给 arrNew 数组
            for(int i = 0;i < arr.length;i++){
                arrNew[i] = arr[i];
            }
            System.out.println("请输入你要添加的元素");
            int addNum = myScanner.nextInt();
            //把 addNum 赋给 arrNew 最后一个元素
			arrNew[arrNew.length - 1] = addNum;
			//让 arr 指向 arrNew, 
            arr = arrNew;
			//输出 arr 看看效果
			System.out.println("====arr 扩容后元素情况====");
			for(int i = 0; i < arr.length; i++) {
				System.out.print(arr[i] + "\t");
			}
			//问用户是否继续
			System.out.println("是否继续添加 y/n");
			char key = myScanner.next().charAt(0);
			if(key == 'n') {//如果输入n,就结束
                break;
            }
        }while(true);
        
        System.out.println("你退出了添加...");
    }
}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.
  • 19.
  • 20.
  • 21.
  • 22.
  • 23.
  • 24.
  • 25.
  • 26.
  • 27.
  • 28.
  • 29.
  • 30.
  • 31.
  • 32.
  • 33.
  • 34.
  • 35.
  • 36.
  • 37.
  • 38.
  • 39.
  • 40.
  • 41.
  • 42.
  • 43.
  • 44.
  • 45.
  • 46.
  • 47.
  • 48.
  • 49.

思路总结：

  1. 创建一个新数组 arrNew, 在其初始化时实现对数组长度的调整。
  2. 把原数组 arr 拷贝给 arrNew 数组。
  3. 在 arrNew 的基础上，实现对其的添加/缩减。
  4. 执行操作 arr = arrNew , 使 arr 指向 arrNew 所表示数组，arr 原指向数组则失去引用被自动回收。

2.二维数组的使用

2.1 二维数组的内存形式

理解： 二维数组的每个元素是一个一维数组。

int arr[][] = new int[2][3];
//解释：表示二维数组 arr 有2个元素，每个元素是一个一维数组
//每个一维数组有3个元素
// arr[0].length = 3
arr[1][1] = 8;
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.

Java 中数组的使用(一维数组和二维数组)_二维数组_02

2.2 二维数组的定义
2.2.1 动态初始化
  1. 语法: 类型[]\[] 数组名 = new 类型[大小]\[大小]
int a[][]=new int[2][3];
  • 1.
  1. 先声明，再分配空间
int arr[][];
arr = new int[2][3];
  • 1.
  • 2.
  1. 列数不确定

要求： 动态创建下面二维数组，并输出。


j = 0

j = 1

j = 2

i = 0

1



i = 1

2

2


i = 2

3

3

3

public class TwoDimensionalArray {
    public static void main(String[] args) {
        /*
        看一个需求：动态创建下面二维数组，并输出
        i = 0: 1
        i = 1: 2 2
        i = 2: 3 3 3 一个有三个一维数组, 每个一维数组的元素是不一样的
        */
		//创建 二维数组，一个有 3 个一维数组，但是每个一维数组还没有开数据空间
        int[][] arr = new int[3][];
        
        for(int i = 0; i < arr.length; i++) {//遍历 arr 每个一维数组
            //给每个一维数组开空间 new
            //如果没有给一维数组 new ,那么 arr[i]就是 null
            arr[i] = new int[i + 1];
            //遍历一维数组，并给一维数组的每个元素赋值
            for(int j = 0; j < arr[i].length; j++) {
            	arr[i][j] = i + 1;//赋值
            }
        }
        System.out.println("=====arr 元素=====");
        //遍历 arr 输出
        for(int i = 0; i < arr.length; i++) {
        //输出 arr 的每个一维数组
            for(int j = 0; j < arr[i].length; j++) {
            System.out.print(arr[i][j] + " ");
            }
            System.out.println();//换行
        }
    }
}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.
  • 19.
  • 20.
  • 21.
  • 22.
  • 23.
  • 24.
  • 25.
  • 26.
  • 27.
  • 28.
  • 29.
  • 30.
  • 31.

思路分析：

  • 创建二维数组，为其分配3个元素的空间，但是没有给每一个一维数组开辟空间
int[][] arr = new int[3][];
  • 1.
  • 根据需求，动态的为其每一个一维数组开辟空间
arr[0] = new int[1]; //为二维数组的第1个元素，分配1个 int 的空间
arr[1] = new int[2]; //为二维数组的第2个元素，分配2个 int 的空间
arr[3] = new int[3]; //为二维数组的第3个元素，分配3个 int 的空间
  • 1.
  • 2.
  • 3.
2.2.2 静态初始化

定义 类型 数组名[][] = {{值 1,值 2..},{值 1,值 2..},{值 1,值 2..}}

int[][] arr = {{1,1,1}, {8,8,9}, {100}};
  • 1.

解读：

  1. 定义了一个二维数组 arr
  2. arr 有三个元素(每个元素都是一维数组)
  3. 第一个一维数组有 3 个元素 , 第二个一维数组有 3 个元素, 第三个一维数组有 1 个元素
2.3 二维数组的注意事项及细节
  1. 一维数组的声明方式有:
int[] x;
//或者  int x[];
  • 1.
  • 2.
  1. 二维数组的声明方式有: int[]\[] y 或者 int[] y[] 或者 int y[]\[]
int[][] y;
// int[] y[];
// int y[][];
  • 1.
  • 2.
  • 3.
  1. 二维数组实际上是由多个一维数组组成的，它的各个一维数组的长度可以相同，也可以不相同。

比如： map[][] 是 一个二维数组 int map [][] = {{1,2},{3,4,5}}

由 map[0] 是一个含有两个元素的一维数组 ，map[1] 是一个含有三个元素的一维数组构成，

我们也称为列数不等 的二维数组。