Java 数组
数组是最为常见的一种数据结构，是相同类型的用一个标识符封装到一起的基本类型数据序列或对象序列。可以用一个统一的数组名和下标来唯一确定数组中的元素。实质上，数组是一个简单的线性序列，因此访问速度很快。
文章目录
1. 什么是数组
数组的定义：
- 数组是相同类型数据的有序集合。
- 数组描述的是相同类型的若干个数据，按照一定的先后顺序排列组合而成。
- 其中，每一个数据称作一个数组元素，每个数组元素可以通过一个下标来访问它们。
2. 数组的声明和创建
数组的声明
首先必须声明数组变量，才能在程序中使用数组。下面是声明数组变量的语法：
dataType[] arrayRefVar; // 首先的方法
// 或
dataType arrayRefVar[]; // 效果相同，但不是首选的方法
数组的创建
Java 语言使用 new 操作符来创建数组，语法如下：
dataType[] arrayRefVar = new dataType[arraySize];
拓展
-
数组的元素是通过索引访问的，数组索引从0开始。
-
获取数组的长度：
array.length -
创建一个数组并赋值，求出数组所有元素的和，实例代码如下：
public class Demo{ public static void main(String[] args){ // 声明一个数组 int[] numbers; // 创建一个数组 numbers = new int[5]; // 给数组元素赋值 numbers[0] = 1; numbers[1] = 2; numbers[2] = 3; numbers[3] = 4; numbers[4] = 5; //求和 int sum = 0; for(int i = 0;i < numbers.length;i++){ sum = sum + numbers[i]; } // 输出结果 System.out.println("numbers数组元素和为：" + sum); } }运行结果为：
3. 三种初始化及内存分析
内存分析
Java 内存里面有这三个区域：堆、栈、方法区。（Java 内存里不止这些区域）
- 堆：
- 存放 new 的对象和数组。
- 可以被所有的线程共享，不会存放别的对象引用。
- 栈：
- 存放基本变量类型（会包含这个基本类型的具体数值）。
- 引用对象的变量（会存放这个引用在堆里面的具体地址）。
- 方法区：
- 可以被所有的线程共享。
- 包含了所有的 class 和 static 变量。
声明一个数组，本质上，数组是不存在的，没有分配空间。
创建一个数组才会有数组的内存空间。所以声明和创建就可以解决这个问题。
-
如果输出数组不存在的下标元素，系统会报一个数组下标越界异常（
java.lang.ArrayIndexOutOfBoundsException）。 -
例如：
public class Demo{ public static void main(String[] args){ // 声明一个数组 int[] numbers; // 创建一个数组 numbers = new int[5]; // 给数组元素赋值 numbers[0] = 1; numbers[1] = 2; numbers[2] = 3; numbers[3] = 4; numbers[4] = 5; // 输出结果 System.out.println(numbers[5]); // 输出数组中不存在的元素 } }运行结果：
三种初始化
-
静态初始化
int[] array = {1,2,3}; Man[] mans = {new Man(1,1),new Man(2,2)}; -
动态初始化
int[] array = new int[2]; arrray[0] = 1; array[1] = 2; -
数组的默认初始化
数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。
-
下面一一列举三种初始化，代码如下：
public class Demo{ public static void main(String[] args){ // 静态初始化 ： 创建 + 赋值 int[] array1 = {1,2,3,4,5,6,7,8}; // 这里赋值时，里面写入多少数，该数组就有多少个元素。但是一旦定义，后面就不会改变 for(int x:array1){ System.out.print(x +" "); // 输出数组里的元素 } System.out.println(); System.out.println("======================="); // 分割线 // 动态初始化 : 声明 + 创建内存空间 （包含默认初始化：赋值前，数组元素就已经有默认值了） int[] array2 = new int[10]; // 后面再进行赋值 array2[0] = 1; System.out.println(array2[0]); System.out.println(array2[1]); // 证明没被赋值的元素是否有值 } }运行结果为：
4. 下标越界及小结
数组的四个基本特点
- 其长度是确定。数组一旦被创建，它的大小就是不可以改变的。
- 其元素必须是相同类型，不允许出现混合类型。
- 数组中的元素可以是任何数据类型，包括基本类型和引用类型。
- 数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。数组本身就是对象，Java 中对象是在堆中，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中。
数组边界
-
下标的合法区间：[ 0 , length - 1 ]，如果越界就会报错；
public static void main(String[] args){ int[] array = new int[2]; System.out.println(array[2]); } -
ArrayIndexOutOfBoundException：数组下标越界异常！
小结
- 数组是相同数据类型（数据类型可以为任意类型）的有序集合。
- 数组也是对象。数组元素相当于对象的成员变量。
- 数组长度是确定的、不可变的。如果越界，则报：
ArrayIndexOutOfBoundException
5. 数组的使用
数组的使用无非有四种：
- 普通的 for 循环
- For - each 循环
- 数组作方法入参
- 数组作返回值
下面一一举例说明。
-
普通的 for 循环
public class Demo{ public static void main(String[] args){ int[] array = {1,2,3,4,5,6,7,8}; // 打印全部的数组元素 for(int i = 0;i < array.length;i++){ System.out.println("第"+ i +"个元素为："+ array[i]); } System.out.println("==============="); // 计算数组所有元素的总和 int sum = 0; for(int i = 0;i < array.length;i++){ sum += array[i]; } System.out.println("数组元素的总和为："+ sum); // 查找最大的数 int max = array[0]; for(int i = 1;i < array.length;i++){ if(array[i] > max){ max = array[i]; } } System.out.println("数组最大的元素为："+ max); } }运行结果为：
-
For - each 循环
public class Demo{ public static void main(String[] args){ int[] arrays = {1,2,3,4,5,6,7,8}; // 使用 for-each 语句遍历数组 for(int x : arrays){ // JDK1.5开始才有的语句 , 没有下标 System.out.println(x); } } }运行结果：
遍历数组用for- each循环更加便捷，但不能获取数组中特定的元素。
-
数组作方法入参
public class Demo{ public static void main(String[] args){ int[] array = {1,2,3,4,5,6,7,8}; // 调用打印方法 printArray(array); } // 打印数组元素 public static void printArray(int[] array){ for(int i = 0;i < array.length;i++){ System.out.print(array[i] +" "); } } }运行结果为：
-
数组作返回值
public class Demo{ public static void main(String[] args){ int[] array = {1,2,3,4,5,6,7,8}; // 调用反转方法 int[] reverse = reverseArray(array); for (int i : reverse) { System.out.print(i +" "); } } // 反转数组 public static int[] reverseArray(int[] array){ int[] result = new int[array.length]; // 创建一个新的数组，保证数组长度与输入的数组长度一致 // 调转数组元素 int j = array.length; // 定义一个int型变量 for(int i = 0;i < array.length;i++){ result[i] = array[j - 1]; j--; } // 返回数组 return result; } }运行结果为：
数组既可以作方法中的参数，也可以作返回值输出。
6. 二维数组
多维数组的定义：
多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组。
二维数组：
-
语法：
int a[][] = new int[2][5];以上的二维数组 a 可以看成一个两行五列的数组。
-
遍历一个二维数组，实例代码如下：
public class Demo{ public static void main(String[] args){ int[][] arrays = {{1,2,3},{4,5,6},{7,8,9}}; // 创建一个二维数组 // 遍历二维数组 for(int i = 0;i < arrays.length;i++){ // 第一层循环相当于遍历外一维数组的元素，其元素是一个单独的一维数组（内一位数组） for(int j = 0;j < arrays[i].length;j++){ // 第二层循环遍历了内一维数组的元素 System.out.print(arrays[i][j] +" "); // 输出元素 } System.out.println(); } } }运行结果为：
-
其实二维数组相当于矩阵。例如：
// int[][] array = {{1,2},{2,3},{3,4},{4,5}}; /* 1 2 array[0] 2 3 array[1] 3 4 array[2] 4 5 array[3] */int[][] array;前面的 [] 代表“行”，后面的 [] 代表“列”，下标都是从0开始。这相当于数学中的 x y 轴，其中要确定一个点，必须在 x y 轴上找出值，例如：（3,4），（4,5）这就跟二维数组中的array[3][4]，array[4][5]相类似。
7. Arrays 类
- 数组的工具类
java.util.Arrays。 - 由于数组对象本身并没有什么方法可以供我们调用，但 API 中提供一个工具类 Arrays 供我们使用，从而可以对数据对象进行一些基本操作。
- 查看 JDK 帮助文档。
- Arrays 类中的方法都是 static 修饰的静态方法，在使用的时候可以直接使用类名进行调用，而“不用”使用对象来调用。（注意是“不用”，而不是“不能”）
- 具有以下常用功能：
- 给数组赋值：通过 fill 方法。
- 对数组排序：通过 sort 方法。按升序排列。
- 比较数组：通过 equals 方法比较数组中元素是否相等。
- 查找数组元素：通过 binarySearch 方法能对排序好的数组进行二分查找法操作。
下面简单介绍Array类的常用方法，实例如下：
public class Demo{
public static void main(String[] args){
int[] array = {12,45,33,23,344,78,66,445};
// 打印数组元素 ：Arrays.toString();
System.out.println(Arrays.toString(array));
System.out.println();
// 调用打印方法 对比差距
printArray(array);
// 数组排序（升序）：Arrays.sort();
Arrays.sort(array);
System.out.println(Arrays.toString(array));
// 数组填充：Arrays.fill();
Arrays.fill(array,0);
System.out.println(Arrays.toString(array));
}
// 打印数组的方法
public static void printArray(int[] array){
for(int i = 0;i < array.length;i++){
if(i == 0){
System.out.print("[");
}
if(i == array.length - 1){
System.out.print(array[i] +"]");
}else{
System.out.print(array[i] +", ");
}
}
}
}
运行结果：
这些 Arrays 类里的方法，我们都可以自己去写，而且能保证运行结果一致。
Arrays.fill();就是利用新的值将数组元素覆盖（重新赋值）。可以选择连续的某一段下标元素进行覆盖，例如 Arrays.fill(array,2,5,0);，代码意思是用0替换掉 array 数组下标从2~5的元素。
8. 冒泡排序
冒泡排序无疑是最为出名的排序算法之一，总共有八大排序！
- 冒泡的代码还是相当简单的，两层循环，外层冒泡轮数，里层依次比较，江湖中人人尽皆知
- 我们看到嵌套循环，应该立马就可以的得出这个算法的时间复杂度为 O (n*n)。
- 冒泡排序的核心思想：
- 比较数组中两个相邻的元素。升序排列，前一个数如果大于后一个数，就交换它们的位置；降序排列，前一个数如果小于后一个数，则交换其位置。
- 每一次比较，都会产生一个最大，或者最小的数字。
- 每比较一次，循环则减少一次，排序也就少一次。
- 最后，依次循环，直到结束。
例子：对无序数组排序，实例代码如下：
public class Demo{
public static void main(String[] args){
// 创建一个无序数组
int[] array = {3,6,4,34,21,54,66,9};
// 调用冒泡排序方法
int[] sort = bubblingSorting(array);
// 打印所有数组元素
System.out.println(Arrays.toString(sort));
}
// 冒泡排序方法
public static int[] bubblingSorting(int[] array){
// 定义一个临时变量
int temp;
// 外层循环，判断循环的次数
for(int i = 0;i < array.length - 1;i++){
// 优化 定义一个Boolean型变量
boolean = false // 通过flag标识位，减少没有意义的比较
// 内层循环，判断前后两数的大小，并交换位置
for(int j = 0;j < array.length - 1 - i;j++){
if(array[j] > array[j + 1]){
temp = array[j];
array[j] = array[j + 1];
array[j+1] = temp;
flag = true; // 每次排序后，就将true赋值给flag
}
}
if(flag == false){
break; // 如果没有比较，就跳出循环
}
}
// 返回排序好的数组
return array;
}
}
运行结果为：
9. 稀疏数组
-
当一个数组中大部分元素为0，或者为同一值的数组时，可以使用稀疏数组来保存该数组。
-
稀疏数组的处理方式是：
- 记录数组一共有几行几列，有多少个不同值。
- 把具有不同值的元素和行列及值记录在一个小规模的数组中，从而缩小程序的规模。
-
如下图，左边是原始数组，右边是稀疏数组。
-
原始数组与稀疏数组间的转换，实例代码如下：
public class Demo{ public static void main(String[] args){ // 创建一个二维数组 11*11， 0：没有棋子 1：黑棋 2：白棋 int[][] array = new int[11][11]; // 赋值 array[2][2] = 1; array[3][3] = 2; // 输出原始的数组 System.out.println("输出原始的数组："); for(int[] ints:array){ for(int anInt:ints){ System.out.print(anInt +"\t"); } System.out.println(); } System.out.println("====================="); // 转换为稀疏数组来保存 // 获取有效值的个数 int sum = 0; for(int i = 0;i < 11;i++){ for(int j = 0;j < 11;j++){ if(array[i][j] != 0){ sum++; } } } System.out.println("有效值的个数为："+sum); // 创建一个稀疏数组的数组 int[][] array2 = new int[sum + 1][3]; array2[0][0] = 11; // 多少行 array2[0][1] = 11; // 多少列 array2[0][2] = sum; // 有效值个数 // 遍历二维数组，将有效值存放在稀疏数组中 int count = 0; for(int i = 0;i < array.length;i++){ for(int j = 0;j < array[i].length;j++){ if(array[i][j] != 0){ count++; array2[count][0] = i; array2[count][1] = j; array2[count][2] = array[i][j]; } } } // 输出稀疏数组 System.out.println("输出稀疏数组："); for(int[] ints:array2){ for(int anInt:ints){ System.out.print(anInt +"\t"); } System.out.println(); } System.out.println("====================="); // 还原数组 System.out.println("输出还原数组："); // 1.读取稀疏数组 int[][] array3 = new int[array2[0][0]][array2[0][1]]; // 2.给其中的元素还原它的值 for(int i = 1;i < array2.length;i++){ array3[array2[i][0]][array2[i][1]] = array2[i][2]; } // 3.输出原始数组 for(int[] ints:array3){ for(int anInt:ints){ System.out.print(anInt +"\t"); } System.out.println(); } } }运行结果为：
稀疏数组了解即可，知道其原理就行。如果在某些场合看见了，认得出是稀疏数组，能明白其大概的逻辑步骤即可。
10. 总结
本篇介绍的是数组的创建及使用方法。需要注意的是，数组的下标是从 0 开始的，最后一个元素的表示总是“数组名[length - 1]“。重点是遍历数组的方法以及使用Arrays 类中各种方法对数组进行操作，如填充替换数组等。此外，Arrays 类还提供了其他的操作数组的方法，有兴趣的，可以查阅 jdk帮助文档。
扫一扫
2787
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
