本文详细介绍了Java中的数组，包括数组的概述、一维数组的声明、初始化和遍历，以及二维数组的使用。此外，还讲解了数组的常见算法，如数组的赋值与复制、元素反转、查找和排序。最后，提到了Arrays工具类的使用和数组可能遇到的异常，如数组角标越界和空指针异常。
数组
数组的概述
1. 数组的理解：
数组(Array)，是多个相同类型数据一定顺序排列的集合，并使用一个名字命名，并通过编号的方式对这些数据进行统一管理。
2.数组的常见概念：
数组名
元素
角标、下标、索引
数组的长度：元素的个数
3.数组的特点：
1）有序排列
2）数组属于引用类型数据变量，数组的元素，既可以是基本数据类型，也可以是引用数组类型
3）创建数组对象会在内存中开辟一整块连续的空间
4）数组的长度一旦确定，就不能修改
4.数组的分类：
①按照维数：一维数组、二维数组、多维数组…
②按照数组元素的类型：基本数据类型元素的数组、引用数据类型元素的数组
一维数组
一维数组的使用：
① 一维数组的声明和初始化
② 如何调用数组指定位置的元素
③ 如何获取数组的长度
④ 如何遍历数组
⑤ 数组元素的默认初始化值
⑥ 数组的内存解析
1.一维数组的声明与初始化
示例代码：
正确的方式：
//1 一维数组的声明和初始化
//1.1静态初始化：数组的初始化和数组元素的赋值操作同时进行
int[] ids;
ids = new int[] {1001,1002,1003,1004};
int[] ids1 = {1001,1002,1003,1004};
//1.2动态初始化：数组的初始化和数组元素的赋值操作分开进行
String[] names = new String[5];
错误的方式：
// int[] arr1 = new int[];
// int[5] arr2 = new int[];
// int[5] arr2 = new int[5];
// int[] arr2 = new int[3] {2,1,3};
2.一维数组元素的引用：通过角标的方式调用。
示例代码：
//数组的角标（或索引从0开始的，到数组的长度-1结束。
names[0] = "老婆：";
names[1] = "迪丽热巴";
names[2] = "张子枫";
names[3] = "佟丽娅";
names[4] = "李沁";
3.数组的属性：length
示例代码：
System.out.println(names.length);
System.out.println(ids.length);
4.一维数组的遍历
示例代码：
for(int i = 0;i < names.length;i++) {
System.out.println(names[i]);
}
5.一维数组元素的默认初始化值
* > 数组元素是整型：0
* > 数组元素是浮点型： 0.0
* > 数组元素是char型： 0 或 '/u0000' 而非 '0'
* > 数组元素是boolean型：false
*
* > 数组元素是引用数据类型：null
6.一维数组的内存结构
二维数组的使用
规定：二维数组分为外层数组的元素，内层数组的元素
int[] arr = new int[4][3];
外层元素：arr[0],arr[1]等
内层元素：arr[0][0],arr[1][2]等
1.理解
数组属于引用数据类型，
数组的元素也可以是引用数据类型，
一个一维数组A的元素如果还是一个以为数组类型的，则，此数组A称为二维数组。
我们可以看成是一维数组array1又作为另一个一维数组array2的元素而存在。
其实，从数组底层的运行机制来看，其实没多维数组。
2.二维数组的使用：
① 二维数组的声明和初始化
② 如何调用数组指定位置的元素
③ 如何获取数组的长度
④ 如何遍历数组
⑤ 数组元素的默认初始化值
⑥ 数组的内存解析
1.二维数组的声明与初始化
示例代码：
正确的方式：
// 静态初始化
int[][] arr1 = new int[][] { { 1, 2, 3 }, { 4, 5 }, { 6, 7, 8 } };
// 动态初始化1
String[][] arr2 = new String[3][2];
// 动态初始化2
String[][] arr3 = new String[3][];
// 这也是正确的
int[] arr1[] = new int[][] { { 1, 2, 3 }, { 4, 5 }, { 6, 7, 8 } };
int[] arr1[] = { { 1, 2, 3 }, { 4, 5 }, { 6, 7, 8 } };//类型推断
2.如何调用二维数组元素:
System.out.println(arr1[0][1]);// 2
System.out.println(arr2[1][1]);// null
arr3[1] = new String[4];// arr3[1]是指arr3这个二维数组的第一行
System.out.println(arr3[1][0]);// 空指针错误：java.lang.NullPointerException
3.二维数组的属性：
System.out.println(arr1.length);// 3
System.out.println(arr1[0].length);// 3
System.out.println(arr1[1].length);// 2
4.遍历二维数组元素
for (int i = 0; i < arr1.length; i++) {
for (int j = 0; j < arr1[i].length; j++) {
System.out.print(arr1[i][j] + " ");
}
System.out.println();
}
5.二维数组元素的默认初始化值
* 规定：二维数组分为外层数组的元素，内层数组的元素
* int[][] arr = new int[4][3];
* 外层元素：arr[0],arr[1]等
* 内层元素：arr[0][0],arr[1][2]等
* 针对初始化方式一：比如int[][] arr4 = new int[4][3];
* 外层元素的初始化值为：地址值
* 内层元素的初始化值为：与一维数组初始化情况相同
*
* 针对初始化方式二：比如int[][] arr4 = new int[4][];
* 外层元素的初始化值为：null
* 内层元素的初始化值为：不能调用，否则报错
6.二维数组的内存结构
数组的常见算法
1.数组的创建与元素赋值：
杨辉三角（二维数组）、 回形数（二维数组）（这个还没学会，以后有机会在更新）
示例代码：
/*
* 使用二维数组打印一个 10 行杨辉三角。
【提示】
1. 第一行有 1 个元素, 第 n 行有 n 个元素
2. 每一行的第一个元素和最后一个元素都是 1
3. 从第三行开始, 对于非第一个元素和最后一个元
素的元素。即：
yanghui[i][j] = yanghui[i-1][j-1] + yanghui[i-1][j];
*/
public class YangHuiSanJiaoTest {
public static void main(String[] args) {
//1.声明并初始化二维数组
int[][] yangHui = new int[10][];
//2.给元素赋值
for(int i = 0;i < yangHui.length;i++) {
yangHui[i] = new int[i + 1];
//2.1 给首末元素赋值
yangHui[i][0] = yangHui[i][i] = 1;
//2.2 给非首末元素赋值
//if(i > 1){
for(int j = 1;j < yangHui[i].length - 1;j++) {
yangHui[i][j] = yangHui[i-1][j-1] + yangHui[i-1][j];
}
//}
}
//3.遍历二维数组
for(int i = 0;i < yangHui.length;i++) {
for(int j = 0;j < yangHui[i].length;j++) {
System.out.print(yangHui[i][j] + " ");
}
System.out.println();
}
}
}
2.针对于数值型的数组：
最大值、最小值、总和、平均数等
/*
* 算法的考察：求数值型数组中元素的最大值、最小值、平均数、总和等
*
* 定义一个int型的一维数组，包含10个元素，分别赋一些随机整数，
* 然后求出所有元素的最大值，最小值，和值，平均值，并输出出来。
* 要求：所有随机数都是两位数。
* 提示；
* [0,1) * 90 ——>[0,90) + 10 ——> [10,100) ——> [10,99]
* (int)(Math.random() * 90 + 10)
*
* 公式： 求 [a,b] 范围内的随机数，则为： (int)(Math.random() * (b - a + 1) + a)
*/
public class ArrayTest1 {
public static void main(String[] args) {
int[] arr = new int[10];
for(int i = 0;i < arr.length;i++) {
arr[i] = (int)(Math.random() * 90 + 10);
}
for(int i = 0;i < arr.length;i++) {
System.out.print(arr[i] + "\t");
}
System.out.println();
//所有元素的最大值
int max = arr[0];
for(int i = 0;i < arr.length;i++) {
if(arr[i] > max) {
max = arr[i];
}
}
System.out.println("所有元素的最大值为：" + max);
//所有元素的最小值
int min = arr[0];
for(int i = 0;i < arr.length;i++) {
if(arr[i] < min) {
min = arr[i];
}
}
System.out.println("所有元素的最小值为：" + min);
//所有元素的和值
int sum = 0;
for(int i = 0;i < arr.length;i++) {
sum += arr[i];
}
System.out.println("所有元素的和值：" + sum);
//所有元素的平均值
//double avg = (sum + 0.0) / 10;
double avg = sum / 10.0;
System.out.println("所有元素的平均值：" + avg);
}
}
3.数组的赋值与复制
条件：
int[] array1,array2;
array1 = new int[]{1,2,3,4};
3.1 赋值：
array2 = array1
如何理解：将array1保存的数组的地址赋给了array2，使得array1和array2共同指向堆空间中的同一个数组实体。
图片理解：
3.2 复制：
array2 = new int[]{array1.length};
for(int i = 0;i < array1.length;i++){
array2[i] = array1[i];
}
如何理解：我们通过new的方式，给array2在堆空间中新开辟的数组的空间。将array1数组中元素值一个一个赋值给array2数组中。
图片理解：
/*
* 使用简单数组
拓展：修改题目，实现array2对array1数组的复制
*/
public class ArrayExer2 {
public static void main(String[] args) {
int[] array1,array2;
array1 = new int[] {2,3,5,7,11,13,17,19};
//显示array1的内容。
for(int i = 0;i < array1.length;i++) {
System.out.print(array1[i] + " ");
}
System.out.println();
//赋值array2变量等于array1
//只是把array1的地址给了array2，不能说是数组的复制
//array2 = array1;
array2 = new int[array1.length];
for(int i = 0;i < array2.length;i++) {
array2[i] = array1[i];
}
//修改array2中的偶索引元素，使其等于索引值(如array[0]=0,array[2]=2
for(int i = 0;i < array2.length;i++) {
if(i % 2 == 0) {
array2[i] = i;
}
}
//打印出array1
for(int i = 0;i < array1.length;i++) {
System.out.print(array1[i] + " ");
}
System.out.println();
//打印出array2
for(int i = 0;i < array2.length;i++) {
System.out.print(array2[i] + " ");
}
}
}
4.数组元素的反转
//方式一
for(int i = 0;i < arr.length / 2;i++) {
String temp = arr[i];
arr[i] = arr[arr.length - i - 1];
arr[arr.length - i - 1] = temp;
}
//方式二
for(int i = 0, j = arr.length - 1;i < j;i++,j--) {
String temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
5.数组中指定元素的查找：搜索、检索
5.1 线性查找：
实现思路：通过遍历的方式，一个一个的数据进行比较、查找。
适用性：具有普遍实用性
String dest = "gg";//查找目标
boolean isFlag = true;
for(int i = 0;i < arr.length;i++) {
if(dest.equals(arr[i])) {
System.out.println("发现指定元素，坐标为：" + i);
isFlag = false;
break;
}
}
if(isFlag) {
System.out.println("抱歉，没发现目标！");
}
5.2 二分法查找：(熟悉)
实现思路：每次取中间值，折半的方法检索
适用性：前提：所要查找的数组必须有序
int[] arr2 = new int[] {-56,-24,-23,-15,27,66,88,99,103,127};
int dest1 = 88;
dest1 = 67;
boolean isFlag1 = true;
int head = 0;//初始的首索引
int end = arr2.length - 1;//初始的末索引
while(head <= end) {
int middle = (head + end) / 2;
if(dest1 == arr2[middle]) {
System.out.println("发现指定元素，坐标为：" + middle);
isFlag1 = false;
break;
}else if(dest1 < arr2[middle]) {
end = middle - 1;
}else {
head = middle + 1;
}
}
if(isFlag1) {
System.out.println("抱歉，没发现目标！");
}
6.数组的排序算法
理解：
1）衡量排序算法的优劣：
时间复杂度、空间复杂度、稳定性
2）排序的分类：内部排序 与 外部排序（需要借助于磁盘）
3）不同排序算法的时间复杂度
冒泡排序的实现：
int[] arr = new int[] {34,23,65,-34,-55,66,88,99,-21,12};
for(int i = 0;i < arr.length - 1;i++) {
for(int j = 0;j < arr.length - 1 - i;j++) {
if(arr[j] > arr[j+1]) {
int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
for(int i = 0;i < arr.length;i++) {
System.out.print(arr[i] + " ");
}
Arrays工具类的使用
1.理解：
1）java.util包下。
2）Arrays：提供了许多操作数组的方法。
2.使用：
//1. boolean equals(int[] a,int[] b) : 判断两个数组是否相等。
int[] arr1 = new int[] {1,2,3,4};
int[] arr2 = new int[] {1,3,2,4};
boolean isEquals = Arrays.equals(arr1, arr2);
System.out.println(isEquals);
//2. String toString(int[] a) : 输出数组信息。
System.out.println(Arrays.toString(arr1));
//3. void fill(int[] a,int val) : 将指定值填充到数组之中。
Arrays.fill(arr1, 10);
System.out.println(Arrays.toString(arr1));
//4. void sort(int[] a) : 对数组进行排序。
Arrays.sort(arr2);
System.out.println(Arrays.toString(arr2));
//5. int binarySearch(int[] a,int key) : 对排序后的数组进行二分法检索指定的值。
int[] arr3 = new int[] {-56,-24,-23,-15,27,66,88,99,103,127};
int index = Arrays.binarySearch(arr3, 88);
if(index >= 0) {
System.out.println("发现指定元素，坐标为：" + index);
}else {
System.out.println("抱歉，没发现目标！");
}
数组的常见异常
小知识：一旦程序出现异常，未处理时，就终止执行
1.数组角标越界异常：ArrayIndexOutOfBoundsException
//说明：只要角标不在范围内都算是越界，不管是超过，还是是负数
int[] arr = new int[] {1,4,534,63,5,2,3};
for(int i = 0;i <= arr.length;i++) {
System.out.println(arr[i]);
}
System.out.println(arr[8]);
System.out.println("hello");
2.空指针异常：NullPointerException
//情况一：
int[] arr1 = new int[] {1,2,3};
arr1 = null;
System.out.println(arr1[2]);
//情况二：
int[][] arr2 = new int[4][];
System.out.println(arr2[0]);
System.out.println(arr2[2][0]);
//情况：
String[] arr3 = new String[] {"aa","bb","cc"};
arr3[2] = null;
System.out.println(arr3[2].toString());
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
