Java中数组的使用（一维数组和二维数组）

Java 中数组的使用

1.数组的使用方式

1.1 数组的定义

1.1.1 动态初始化

1. 数据类型 数组名[] = new 数据类型[大小]

int a[] = new int[5]; 
//创建了一个数组，名字为a, 存放 5 个 int 类型的值

2. 先声明数组，再 new 分配空间

double scores[]; //声明数组，此时 scores 是 null
scores = new double[5]; //分配内存空间，可以存放数据

1.1.2 静态初始化

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

int a[] = {1,2,3,4,5,6,7,8,9};
//如果知道数组有多少元素和他们的具体值
//上面的用法相当于：
int a[] = new int[9];
a[0] = 1;
a[1] = 2;
//·······
a[8] = 9;

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;

可以看到，进行 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. 创建一个新数组 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;

---

2.2 二维数组的定义

2.2.1 动态初始化

1. 语法: 类型[][] 数组名 = new 类型[大小][大小]

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

2. 先声明，再分配空间

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

3. 列数不确定

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

	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();//换行
        }
    }
}

思路分析：

• 创建二维数组，为其分配3个元素的空间，但是没有给每一个一维数组开辟空间

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

• 根据需求，动态的为其每一个一维数组开辟空间

  arr[0] = new int[1]; //为二维数组的第1个元素，分配1个 int 的空间
  arr[1] = new int[2]; //为二维数组的第2个元素，分配2个 int 的空间
  arr[2] = new int[3]; //为二维数组的第3个元素，分配3个 int 的空间
  

---

2.2.2 静态初始化

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

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

解读：

1. 定义了一个二维数组 arr

2. arr 有三个元素(每个元素都是一维数组)

3. 第一个一维数组有 3 个元素 , 第二个一维数组有 3 个元素, 第三个一维数组有 1 个元素

---

2.3 二维数组的注意事项及细节

1. 一维数组的声明方式有:

   int[] x;
   //或者  int x[];
   

2. 二维数组的声明方式有: int[][] y 或者 int[] y[] 或者 int y[][]

   int[][] y;
   // int[] y[];
   // int y[][];
   
   

3. 二维数组实际上是由多个一维数组组成的，它的各个一维数组的长度可以相同，也可以不相同。
   比如： map[][] 是 一个二维数组 int map [][] = {{1,2},{3,4,5}}
   由 map[0] 是一个含有两个元素的一维数组 ，map[1] 是一个含有三个元素的一维数组构成。