本文深入探讨了Java中的数组，包括数组的基本用法、作为方法参数和返回值的处理，以及二维数组的操作。详细讲解了数组的创建、初始化、遍历、长度获取、越界访问、数组传参的原理、引用概念、内存区域划分等内容，并通过实例展示了数组在实际问题中的应用，如数组拷贝、遍历、查找等操作。
目录
一、数组的基本用法
🍎什么是数组
数组本质上就是让我们能 "批量" 创建相同类型的变量。
🍓数组：存储一组相同数据类型的集合。
💦例如:
- 如果需要表示两个数据, 那么直接创建两个变量即可 int a; int b
- 如果需要表示五个数据, 那么可以创建五个变量 int a1; int a2; int a3; int a4; int a5;
- 但是如果需要表示一万个数据, 那么就不能创建一万个变量了. 这时候就需要使用数组, 帮我们批量创建.
💥注意事项: 在 Java 中, 数组中包含的变量必须是相同类型。
🍎创建数组
⭐基本语法
// 动态初始化
数据类型[] 数组名称 = new 数据类型 [] { 初始化数据 };
// 静态初始化
数据类型[] 数组名称 = { 初始化数据 };🌊代码示例：
public class TestDemo {
public static void main(String[] args) {
int[] arr = new int[3]; //创建一个数组未初始化
int[] arr1 = new int[]{1, 2, 3}; //创建数组并初始化
int[] arr2 = {1, 2, 3}; //虽然没写new，实际上也是一个对象
}
}
💥注意事项:
- 静态初始化的时候, 数组元素个数和初始化数据的格式是一致的.
- int [] 数组名，[ ]中不可以指定大小，因为 int 和 [ ] 是一个整体，表示它是一个整型的数组，int [ ] 是一个类型，如果字 [ ]中写了一个数字就会破坏它的类型。
💧补充：
- 其实数组也可以写成：int arr[] = {1, 2, 3}; 这样就和 C 语言更相似了. 但是我们还是更推荐写成 int[] arr 的形式. int和 [] 是一个整体.
🍎数组的使用
🍓获取长度，访问元素。
🌊代码示例：
public class TestDemo {
public static void main(String[] args) {
int[] arr = {1, 2, 3};
System.out.println("length = " + arr.length);
System.out.println(arr[0]);
System.out.println(arr[1]);
arr[2] = 100;
System.out.println(arr[2]);
}
}运行结果
💥注意事项
- 使用 arr.length 能够获取到数组的长度. . 这个操作为成员访问操作符. 后面在面向对象中会经常用到.
- 使用 [ ] 按下标取数组元素. 需要注意, 下标从 0 开始计数
- 使用 [ ] 操作既能读取数据, 也能修改数据.
- 下标访问操作不能超出有效范围 [0, length - 1] , 如果超出有效范围, 会出现下标越界异常。
🍓数组越界访问
🌊代码示例：
public class TestDemo {
public static void main(String[] args) {
int[] arr = {1, 2, 3};
System.out.println(arr[3]);
}
}
🍓遍历数组
Java中遍历数组有三种方式：for循环、for-each、Java的操作数组的工具类 Arrays。
🌊代码示例：使用for循环遍历数组
public class TestDemo {
public static void main(String[] args) {
int[] arr = {1, 2, 3};
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
}
}🌊代码示例：使用 for-each（增强for循环） 遍历数组
public class TestDemo {
public static void main(String[] args) {
int[] arr = {1, 2, 3};
for (int x : arr) {
System.out.print(x + " ");
}
}
}运行结果
- for-each 是 for 循环的另外一种使用方式. 能够更方便的完成对数组的遍历。 可以避免循环条件和更新语句写错。
✨for循环与 for-each 的区别：
- for循环是可以拿到数组下标的
- for-each 是拿不到数组下标的
🌊代码示例：借助Java的操作数组的工具类 Arrays
import java.util.Arrays;
public class TestDemo {
public static void main(String[] args) {
int[] arr = {1, 2, 3};
//Arrays.toString 是将参数的数组以字符串的形式输出
String ret = Arrays.toString(arr);
System.out.println(ret);
// System.out.println(Arrays.toString(arr));
}
}运行结果
👀Java 中提供了 java.util.Arrays 包, 其中包含了一些操作数组的常用方法
💦补充：什么是包?
- 例如做一碗油泼面, 需要先和面, 擀面, 扯出面条, 再烧水, 下锅煮熟, 放调料, 泼油.
- 但是其中的 "和面, 擀面, 扯出面条" 环节难度比较大, 不是所有人都能很容易做好. 于是超市就提供了一些直接已经扯好的面条, 可以直接买回来下锅煮. 从而降低了做油泼面的难度, 也提高了制作效率.
- 程序开发也不是从零开始, 而是要站在巨人的肩膀上.
- 很多程序写的过程中不必把所有的细节都自己实现, 已经有大量的标准库(JDK提供好的代码)和海量的第三方库(其他机构组织提供的代码)供我们直接使用. 这些代码就放在一个一个的 "包" 之中. 所谓的包就相当于卖面条的超市. 只不过, 超市的面条只有寥寥几种, 而我们可以使用的 "包" , 有成千上万。
二、数组作为方法的参数
🍎数组传参
🌊代码示例
import java.util.Arrays;
public class TestDemo {
public static void func1(int[] arr) {
arr[0] = 66;
}
public static void main(String[] args) {
int[] arr = {1, 2, 3, 4, 5};
System.out.println(Arrays.toString(arr));
func1(arr);
System.out.println(Arrays.toString(arr));
}
}代码分析
运行结果
🌌 数组传参在函数内部修改数组内容, 函数外部也发生改变.此时数组名 arr 是一个 "引用"。 当传参的时候, 是按照引用传参。
🌊代码示例
import java.util.Arrays;
public class TestDemo {
public static void func2(int[] arr) {
arr = new int[]{21, 23, 25, 24, 26};
}
public static void main(String[] args) {
int[] arr = {1, 2, 3, 4, 5};
System.out.println(Arrays.toString(arr));
func2(arr);
System.out.println(Arrays.toString(arr));
}
}代码分析
运行结果
- 这里的内容没被修改是因为在func2方法中重新创建了一个arr数组，此时func2方法中的数组与实参传过去的数组在堆区指向的是两块不同的空间。
- 在func2中只是创建了新的数组，并没有改变main方法中传过去的数组，所以func2方法（函数）外部没有发生变化。
💦补充：如何理解内存?
- 内存就是指我们熟悉的 "内存". 内存可以直观的理解成一个宿舍楼. 有一个长长的大走廊, 上面有很多房间.
- 每个房间的大小是 1 Byte (如果计算机有 8G 内存, 则相当于有 80亿 个这样的房间).
- 每个房间上面又有一个门牌号, 这个门牌号就称为地址。
🍓什么是引用?
- 引用相当于一个 "别名", 也可以理解成一个指针.
- 创建一个引用只是相当于创建了一个很小的变量, 这个变量保存了一个整数, 这个整数表示内存中的一个地址。
✨总结:
- 所谓的 "引用" 本质上只是存了一个地址. Java 将数组设定成引用类型, 这样的话后续进行数组参数传参, 其实只是将数组的地址传入到函数形参中. 这样可以避免对整个数组的拷贝(数组可能比较长, 那么拷贝开销就会很大)。
🍎认识 null
✨null 在 Java 中表示 "空引用" , 也就是一个无效的引用
- null 的作用类似于 C 语言中的 NULL (空指针), 都是表示一个无效的内存位置. 因此不能对这个内存进行任何读写操作. 一旦尝试读写, 就会抛出 NullPointerException.
💥注意: Java 中并没有约定 null 和 0 号地址的内存有任何关联。
内容总结：
🍎初识 JVM 内存区域划分
- 一个宿舍楼会划分成几个不同的区域: 大一学生, 大二学生... 计算机专业学生, 通信专业学生....内存也是类似, 这个大走廊被分成很多部分, 每个区域存放不同的数据.
🎄JVM 的内存被划分成了几个区域,
- 程序计数器 : 只是一个很小的空间, 保存下一条执行的指令的地址.
- 虚拟机栈（Java栈）: 重点是存储局部变量表(当然也有其他信息). 刚才创建的 int[] arr 这样的存储地址的引用就是在这里保存.
- 本地方法栈：本地方法栈与虚拟机栈的作用类似. 只不过保存的内容是Native方法的局部变量. 在有些版本的 JVM 实现中(例如HotSpot), 本地方法栈和虚拟机栈是一起的.
- 堆：JVM所管理的最大内存区域. 使用 new 创建的对象都是在堆上保存 (例如前面的 new int[]{1, 2,3,4,5} )
- 方法区： 用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据. 方法编译出的的字节码就是保存在这个区域.
- 运行时常量池： 是方法区的一部分, 存放字面量(字符串常量)与符号引用. (注意 从 JDK1.7 开始, 运行时常量池在堆上)。
🍉本地方法栈：
- JVM 是一个基于 C++ 实现的程序. 在 Java 程序执行过程中, 本质上也需要调用 C++ 提供的一些函数进行和操
- 作系统底层进行一些交互. 因此在 Java 开发中也会调用到一些 C++ 实现的函数.
- 这里的 Native 方法就是指这些 C++ 实现的, 再由 Java 来调用的函数
🍉了解栈和堆：
- 局部变量和引用保存在栈上, new 出的对象保存在堆上.
- 堆的空间非常大, 栈的空间比较小.
- 堆是整个 JVM 共享一个, 而栈每个线程具有一份(一个 Java 程序中可能存在多个栈)。
三、数组作为方法的返回值
🌊代码示例：写一个方法, 将数组中的每个元素都 * 2。
import java.util.Arrays;
public class TestDemo {
public static void fun(int[] arr1) {
for (int i = 0; i < arr1.length; i++) {
arr1[i] = arr1[i] * 2;
}
}
public static void main(String[] args) {
int[] arr1 = {1, 2, 3, 4, 5, 6};
fun(arr1);
System.out.println(Arrays.toString(arr1));
}
}代码分析
运行结果
- 这个代码虽然可行, 但是破坏了原有数组。
- 有时候不希望破坏原数组, 就需要在方法内部创建一个新的数组, 并由方法返回。
🌊代码示例
import java.util.Arrays;
public class TestDemo {
public static int[] fun1(int[] arr1) {
int[] ret = new int[arr1.length];
for (int i = 0; i < arr1.length; i++) {
ret[i] = arr1[i] * 2;
}
return ret;
}
public static void main(String[] args) {
int[] arr1 = {1, 2, 3, 4, 5, 6};
int[] ret = fun1(arr1);
System.out.println(Arrays.toString(ret));
System.out.println(Arrays.toString(arr1));
}
}代码分析
运行结果
- 这种方式不会破坏原有数组，另外由于数组是引用类型, 返回的时候只是将这个数组的首地址返回给函数调用者, 没有拷贝数组内容, 从而比较高效。
四、数组练习
🎄 模拟实现toString方法
public class TestDemo {
public static String myToString(int[] array) {
if (array == null) return "null";
String str = "[ ";
for (int i = 0; i < array.length; i++) {
str += array[i];
if (i != array.length - 1) {
str += ",";
}
}
str += " ]";
return str;
}
public static void main(String[] args) {
int[] array ={1,2,3,4,5};
System.out.println(myToString(array));
}
}运行结果
🎄 找数组中的最大元素
public class TestDemo {
public static int findMax(int[] array) {
//判断数组如果是没有元素或是null，则返回-1
if (array == null || array.length == 0) return -1;
int max = array[0];
for (int i = 1; i < array.length; i++) {
if (max < array[i]) {
max = array[i];
}
}
return max;
}
public static void main(String[] args) {
int[] array = {12, 1, 6, 99, 84, 3};
System.out.println(findMax(array));
}
}🎄 求数组中元素的平均值
public class TestDemo {
public static double avg(int[] array) {
if (array == null || array.length == 0) return 0;
int sum = 0;
for (int i : array) {
sum += i;
}
return (double) sum / array.length;
}
public static void main(String[] args) {
int[] array = {1, 2, 3, 5, 6};
System.out.println(avg(array));
}
}🎄 查找数组中指定元素(顺序查找)，返回其所在位置的下标
public class TestDemo {
public static int find(int[] array, int key) {
for (int i = 0; i < array.length; i++) {
if (array[i] == key) {
return i; //返回找到值的下标
}
}
return -1; //如果没找到就返回-1
}
public static void main(String[] args) {
int[] arr = {14, 15, 16, 3, 8, 2};
System.out.println(find(arr, 2));
}
}🎄查找数组中指定元素(二分查找)，返回其所在位置的下标。
- 二分查找只能查找有序（升序或降序）的数组。
- 以升序数组为例, 二分查找的思路是先取中间位置的元素, 看要找的值比中间元素大还是小. 如果小, 就去左边找; 否则就去右边找。
public class TestDemo {
public static int binarySearch(int[] array, int key) {
int left = 0; //左下标
int right = array.length - 1; //右下标
while (left <= right) {
int mind = (left + right) / 2;
if (key > array[mind]) {
left = mind + 1;
} else if (key < array[mind]) {
right = mind - 1;
} else if (key == array[mind]) {
return mind;
}
}
return -1;
}
public static void main(String[] args) {
int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9};
System.out.println(binarySearch(arr, 7));
}
}🎄检查数组的有序性
- 给定一个整型数组, 判断是否该数组是有序的(升序)
public class TestDemo {
public static boolean isSort(int[] array) {
for (int i = 0; i < array.length - 1; i++) {
if (array[i] > array[i + 1]) {
return false;
}
}
return true;
}
public static void main(String[] args) {
int[] array = {1, 3, 6, 8, 9};
System.out.println(isSort(array));
}
}🎄冒泡排序
public class TestDemo {
public static void bubbleSort(int[] array) {
for (int i = 0; i < array.length - 1; i++) {
boolean flag = false;
for (int j = 0; j < array.length - 1 - i; j++) {
if (array[j] > array[j + 1]) {
int tmp = array[j];
array[j] = array[j + 1];
array[j + 1] = tmp;
flag = true;
}
if (flag == false) {
return;
}
}
}
}
public static void main(String[] args) {
int[] array = {9, 1, 2, 6, 8, 4, 5, 3, 7, 10};
bubbleSort(array);
System.out.println(Arrays.toString(array));
}
}🎄数组逆序
public class TestDemo {
public static void reverse(int[] array) {
int left = 0;
int right = array.length - 1;
while (left < right) {
int tmp = array[left];
array[left] = array[right];
array[right] = tmp;
left++;
right--;
}
}
public static void main(String[] args) {
int[] array = {1, 2, 3, 4, 5};
reverse(array);
System.out.println(Arrays.toString(array));
}
}🎄数组数字排列
- 给定一个整型数组, 将所有的偶数放在前半部分, 将所有的奇数放在数组后半部分
public class TestDemo {
public static void func(int[] arr) {
int left = 0;
int right = arr.length - 1;
while (left < right) {
while (left < right && arr[left] % 2 == 0) {
left++;
}
while (left < right && arr[right] % 2 != 0) {
right--;
}
int tmp = arr[left];
arr[left] = arr[right];
arr[right] = tmp;
}
}
public static void main(String[] args) {
int[] arr = {1, 2, 3, 6, 8, 4, 7};
func(arr);
System.out.println(Arrays.toString(arr));
}
}🍓数组拷贝
（1）代码1
import java.util.Arrays;
public class TestDemo {
public static int[] copOf(int[] arr) {
int[] ret = new int[arr.length];
for (int i = 0; i < arr.length; i++) {
ret[i] = arr[i];
}
return ret;
}
public static void main(String[] args) {
int[] arr = {1, 2, 3, 4, 5};
int[] ret = copOf(arr);
System.out.println(Arrays.toString(ret));
}
}（2）代码2
import java.util.Arrays;
public class TestDemo {
public static void main(String[] args) {
int[] arr = {1, 2, 3, 4, 5};
int[] ret = Arrays.copyOf(arr,arr.length);
System.out.println(Arrays.toString(ret));
}
}
（3）代码3 ：拷贝指定位置的元素
public class TestDemo {
public static void main(String[] args) {
int[] arr = {1, 2, 3, 4, 5};
int[] ret = Arrays.copyOfRange(arr,0,3);// [ )
System.out.println(Arrays.toString(ret));
}
}（4）代码4
import java.util.Arrays;
public class TestDemo {
public static void main(String[] args) {
int[] arr = {1, 2, 3, 4, 5};
int[] copy = new int[arr.length];
//从arr数组的0位置开始，拷贝到copy数组中，从copy数组的0位置，长度为arr数组的长度
System.arraycopy(arr,0,copy,0,arr.length);
System.out.println(Arrays.toString(copy));
}
}（5）代码5
import java.util.Arrays;
public class TestDemo {
public static void main(String[] args) {
int[] arr = {1, 2, 3, 4, 5};
int[] copy = arr.clone();
System.out.println(Arrays.toString(copy));
}
}🍓深拷贝与浅拷贝
- 深拷贝：创建了一个新的数组, 拷贝原有数组中的所有元素到新数组中（拷贝的是对象【元素】）. 因此, 修改原数组, 不会影响到新数组。
- 浅拷贝：创建了一个新数组，新数组与原数组都指向同一个对象（拷贝的是地址）。因此，修改原始值，会影响新数组。
- 浅拷贝变为深拷贝：将原数组指向的对象再拷贝一份，使新数组指向拷贝后的对象。（原数组与新数组指向了不同的对象，修改新数组的内容不会影响原数组）
- 至于是深拷贝、还是浅拷贝主要看拷贝的内容是什么。
五、二维数组
🍓二维数组本质上也就是一维数组, 只不过每个元素又是一个一维数组。
🍎创建二维数组
⭐基本语法
数据类型[][] 数组名称 = new 数据类型 [行数][列数] { 初始化数据 };🌊代码示例
public class TestDemo {
public static void main(String[] args) {
int[][] array1 = {{1, 2, 3}, {4, 5, 6}};
int[][] array2 = new int[][]{{1, 2, 3}, {4, 5, 6}};
int[][] array3 = new int[2][3];
}
}内存布局
🍎 遍历二维数组
🌀方法一：
public class TestDemo {
public static void main(String[] args) {
int[][] array = {{1, 2, 3}, {4, 5, 6}};
for (int i = 0; i < array.length; i++) {
for (int j = 0; j < array[i].length; j++) {
System.out.print(array[i][j] + " ");
}
System.out.println();
}
}
}🌀方法二：
public class TestDemo {
public static void main(String[] args) {
int[][] array = {{1, 2, 3}, {4, 5, 6}};
for (int[] ret : array) {
for (int x : ret) {
System.out.print(x + " ");
}
System.out.println();
}
}
}🌀方法三：
public class TestDemo {
public static void main(String[] args) {
int[][] array = {{1, 2, 3}, {4, 5, 6}};
System.out.println(Arrays.deepToString(array));
}
}运行结果
🍎不规则二维数组
public class TestDemo {
public static void main(String[] args) {
int[][] array = {{1, 2}, {4, 5, 6}};
for (int i = 0; i < array.length; i++) {
for (int j = 0; j < array[i].length; j++) {
System.out.print(array[i][j] + " ");
}
System.out.println();
}
}
}运行结果
✨Java中定义二维数组时不可以省略行但是可以省略列。
public class TestDemo {
public static void main(String[] args) {
int[][] arr = new int[2][];
arr[0] = new int[2];
arr[1] = new int[3];
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr[i].length; j++) {
System.out.print(arr[i][j] + " ");
}
System.out.println();
}
}
}内存布局
运行结果
二维数组的用法和一维数组并没有明显差别，具体的使用方式可以参考一维数组的使用方式。
271
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
