JavaSe|【 JavaSE 】深入数组 javase|数组|java

目录
前言
一维数组
创建一维数组
一维数组的使用
数组作参数
认识 JVM 内存区域划分
数组做参数基本用法
理解引用类型
认识 null
数组作为方法的返回值
二维数组
二维数组的长度
二维数组的遍历
数组练习
前言本章主要讲解：

一维数组的定义和使用
数组在内存的基本存储知识
二维数组的定义和使用
数组练习

一维数组

什么是数组：

数组本质上就是让我们能 "批量" 创建相同类型的变量（相同的类型）

注：特别是表示大量的数据，用数组非常便捷

创建一维数组

基本语法：

// 动态初始化数据类型[] 数组名称 = new 数据类型 [] { 初始化数据 }; // 静态初始化数据类型[] 数组名称 = { 初始化数据 };

示例：

int[] arr = new int[]{1, 2, 3}; int[] arr = new int[3]; // 默认元素为0 int[] arr = {1, 2, 3};

注：静态初始化的时候, 数组元素个数和初始化数据的格式要一致

一维数组的使用

示例：

int[] arr = {1, 2, 3}; // 获取数组长度（本身属性） System.out.println("length: " + arr.length); // 执行结果: 3 // 访问数组中的元素 System.out.println(arr[1]); // 执行结果: 2 System.out.println(arr[0]); // 执行结果: 1 arr[2] = 100; System.out.println(arr[2]); // 执行结果: 100

注意：

使用arr.length能够获取到数组的长度：. 这个操作为成员访问操作符（进行修改和读取）

使用[ ]按下标取数组元素, 下标从0开始计数（[]写在变量名前后都行）

下标访问操作不能超出有效范围 [0, length - 1] ，否则会出现下标越界

数组类型中 [] 内不能写数值

示例：遍历数组

//循环遍历 int[] arr = {1, 2, 3}; for (int i = 0; i < arr.length; i++) { System.out.println(arr[i]); } //用 for-each 遍历 int[] arr = {1, 2, 3}; for (int x : arr) { System.out.println(x); } //使用 Arrays 类中的 toString 方法(toString的功能就是将当前的数组转换成字符串的形式返回) // 使用 Arrays 类前先导入它的包 import java.util.Arrays; public class TestDemo{ public static void main(Strings[] args){ int[] array = {1, 2, 3}; String ret = Arrays.toString(array); System.out.println(ret); } } // 输出结果：[1, 2, 3]

数组作参数认识 JVM 内存区域划分

一个 Java 文件的执行需要先通过编译变成字节码文件，字节码文件再通过 Java 虚拟机运行

JVM 内存划分：

文章图片

各区域作用：

程序计数器：是一个很小的空间，保存下一条执行的指令地址

Java 虚拟机栈：这就是我们平常说的栈，它重点是存储局部变量（如创建的数组的存储地址的引用就存在这里）

本地方法栈：本地方法栈与虚拟机栈的作用类似，只不过保存的内容是 Native 方法（ Java 中调用的一些 C++ 实现的函数）的局部变量

堆：这就是我们平常说的堆，是 JVM 所管理的最大的内存区，使用 new 创建的对象都是在堆上保存

方法区：用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据（方法编译出的字节码就是保存在这里）

运行时常量池：这个是方法区的一部分用来存放字面量（字符串常量）与符号引用（注意：从 JDK 1.8 开始，运行时常量池在堆上）

数组做参数基本用法

结论：数组为引用类型，数组做参数传递的是地址

示例：打印数组内容

public static void main(String[] args) { int[] arr = {1, 2, 3}; printArray(arr); } public static void printArray(int[] a) { for (int x : a) { System.out.println(x); } } //int[] a 是函数的形参, int[] arr 是函数实参

理解引用类型

示例：参数传内置类型

public static void main(String[] args) { int num = 0; func(num); System.out.println("num = " + num); } public static void func(int x) { x = 10; System.out.println("x = " + x); } // 执行结果 x = 10 num = 0

注：修改形参 x 的值, 不影响实参的 num 值（形参是实参的一份临时拷贝：开辟另一个空间来存实参的内容，修改形参与实参无关）

示例：参数传数组类型

public static void main(String[] args) { int[] arr = {1, 2, 3}; func(arr); System.out.println("arr[0] = " + arr[0]); } public static void func(int[] a) { a[0] = 10; System.out.println("a[0] = " + a[0]); } // 执行结果 a[0] = 10 arr[0] = 10

注：此时数组名 arr 是一个 "引用" ：当传参的时候, 是按照引用传参（找到对应元素空间，直接对元素内容）

简单类比：引用相当于一个 "别名", 也可以理解成一个指针
创建一个引用只是相当于创建变量来保存一个整数, 这个整数表示内存中的一个地址

图解：对于上述例题
文章图片

而修改 a[0]是根据 0x100 这样的地址找到对应的内存位置, 将内容改成 100

注：传地址可以避免对整个数组的拷贝(特别是长数组, 拷贝开销会很大）

认识 null

null 在 Java 中表示 "空引用" , 也就是一个无效的引用(不能进行访问)

作用类似C语言中NULL (空指针), 都是表示一个无效的内存位置，但Java并没有约定 null 和 0 号地址的内存有任何关联

示例：

int[] arr = null; System.out.println(arr[0]); //err

数组作为方法的返回值

示例：写一个方法, 将数组中的每个元素都 * 2

// 直接修改原数组 class Test { public static void main(String[] args) { int[] arr = {1, 2, 3}; transform(arr); printArray(arr); } public static void printArray(int[] arr) { for (int i = 0; i < arr.length; i++) { System.out.println(arr[i]); } } public static void transform(int[] arr) { for (int i = 0; i < arr.length; i++) { arr[i] = arr[i] * 2; } } } //破坏原有数组// 返回一个新的数组 class Test { public static void main(String[] args) { int[] arr = {1, 2, 3}; int[] output = transform(arr); printArray(output); } public static void printArray(int[] arr) { for (int i = 0; i < arr.length; i++) { System.out.println(arr[i]); } } public static int[] transform(int[] arr) { int[] ret = new int[arr.length]; for (int i = 0; i < arr.length; i++) { ret[i] = arr[i] * 2; } return ret; } } //返回的时候只是将这个数组的首地址返回给函数调用者, 没有拷贝数组内容, 从而比较高效

二维数组

二维数组本质上也就是一维数组, 只不过每个元素又是一个一维数组

基本语法：

数据类型[][] 数组名称 = new 数据类型 [行数][列数] { 初始化数据 };

示例：

int[][] arr = { {1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12} }; for (int row = 0; row < arr.length; row++) { for (int col = 0; col < arr[row].length; col++) { System.out.printf("%d\t", arr[row][col]); } System.out.println(""); } // 执行结果 1 2 3 4 5 6 7 8 9 10 11 12

注意：在 Java 当中的二维数组不能省略行，但可以省略列

示例：

int[][] array = new int[2][];

注意：但需要正常打印前，需要初始化，不然二维数组元素都为 null

//不规则二维数组(列是不确定) int[][] array = new int[2][]; array[0] = new int[4]; array[1] = new int[2]; System.out.println(Arrays.deepToString(array)); //打印结果为：[[0, 0, 0, 0], [0, 0]]

二维数组的长度

示例：

int[][] array = { {1, 2, 3}, {4, 5, 6}}; System.out.println(array.length); //array为整个二维数组 //输出结果：2（两个元素） System.out.println(array[0].length); //array[0]为二维数组第一个元素，即一维数组 System.out.println(array[1].length); // 输出结果：3 3

注：对于不规则二维数组求长度同样适用

二维数组的遍历

//使用 for 循环遍历打印 int[][] array = { {1, 2, 3}, {4, 5, 6}}; for(int i = 0; i < array.length; i++){ for(int j = 0; j < array[0].length; j++){ System.out.println(arrat[i][j] + " "); } } //使用 for-each 遍历打印 int[][] array = { {1, 2, 3}, {4, 5, 6}}; for(int[] arr : array){//二维数组的元素为一维数组，即int[] arr for(int x : arr){//一维数组的元素为int元素，即int x System.out.println(x); } } //使用 Arrays.deepToString 打印 int[][] array = { {1, 2, 3}, {4, 5, 6}}; System.out.println(Arrays.deepToString(array));

数组练习

例题1：数组转字符串（模拟实现 toString ）

示例：

public static String myToString(int[] array){ String str = "["; for(int i = 0; i < array.length; i++){ if(i == 0){ str +=array[i]; }else{ str +=", " + array[i]; } } str += "]"; return str; } //如果还想完善的话，注意数组长度为0或者数组为 null 的情况

例题2：数组拷贝

示例1：

// for 循环拷贝 public static int[] copyArray(int[] array){ int[] newArray = new int[array.length]; for(int i = 0; i < array.length; i++){ newArray[i] = array[i]; } return newArray; }

示例2：

//使用 Array 包的工具类 //copyOf(原数组，要返回的副本的长度)方法 int[] array = {1, 2, 3}; int[] ret1 = Arrays.copyOf(array ,array.length); System.out.println(Arrays.toString(ret1)); //copyOfRange(原数组，起始索引值，终点索引值的后一个值)方法 //这里的起点和终点(下标)范围是一个左闭右开区间，如下示例范围为：[1,3) （java中大部分都是如此） int[] ret2 = Arrays.copyOfRange(array ,1, 3); System.out.println(Arrays.toString(ret2)); // 输出结果：[2, 3]

示例3：

//本地方法（native） arraycopy(原数组（src）,原数组的起始位置（srcPos）,目的数组（dest）,目的数组（dest）的起始位置（destPos）) int[] array = {1, 2, 3}; int[] ret3 = new int[array.length]; // length 不能超过原数组的长度,否则越界 System.arraycopy(array, 0, ret5, 0, array.length); System.out.println(Arrays.toString(ret3)); // 输出结果：[1, 2, 3]

示例4：

//调用对象的 clone() 方法 int[] array = {1, 2, 3}; int[] ret4 = array.clone(); System.out.println(Arrays.toString(ret4)); // 输出结果：[1, 2, 3]

对于拷贝有深浅之分：

深拷贝：拷贝数组的数据（基本数据类型），修改拷贝数组不改变原数组数据
浅拷贝：拷贝数组的地址（引用类型），修改拷贝数组改变原数组数据

例题3：找数组中的最大元素

示例：

public static void main(String[] args){ int[] array = {1,4,5,9,2}; System.out.println(maxNum(array)); } public static int maxNum(int[] array){ int max = array[0]; for(int i = 1; i < array.length; i++){ if(array[i] > max){ max = array[i]; } } return max; }

例题4：查找数组中指定元素（顺序查找）

示例：

public static int findNum(int[] array, int x){ for(int i = 0; i < array.length; i++){ if(array[i] == x){ return i; } } return -1; }

例题5：检查数组的有序性（升序数组）

示例：

public static boolean isSorted(int[] array){ for(int i = 0; i < array.length - 1; i++){ if(array[i] > array[i+1]){ return false; } } return true; }

例题6：数组排序（冒泡排序）

示例：

public static void dubbleSort(int[] array){ for(int i = 0; i < array.length - 1; i++){ boolean flg = false; for(int j = 0; j < array.length - i - 1; j++){ if(array[j] > array[j + 1]){ int tmp = array[j]; array[j] = array[ j + 1]; array[j+ 1] = tmp; flg = true; } } if(flg == true){ break; } } }

例题7：数组数字排序（偶数放在数组前半部分，将所有的奇数放在后半部分）

示例：

public static void sort(int[] array){ int left = 0; int right = array.length - 1; while(left < right){ while(left < right && array[left] % 2 == 0){ left++; } while(left < right && array[right] % 2 != 0){ right--; } if(left < right){ int tmp =array[left]; array[left] = array[right]; array[right] =tmp; } } }

【JavaSe|【 JavaSE 】深入数组】