文章目录
1、一维数组
1.1 数组概念
数组指的是一种容器，可以同来存储同种数据类型的多个值。但是数组容器在存储数据的时候，需要结合隐式转换考虑。
比如：定义了一个int类型的数组。那么boolean。double类型的数据是不能存到这个数组中的，但是byte类型，short类型，int类型的数据是可以存到这个数组里面的。
建议：容器的类，和存储的数据类型保持一致。
举例：
- 整数1 2 3 4 56 就可以使用int类型的数组来存储。
- 小数1.1 1.2 1.3 1.4 就可以使用double类型的数组来存储。
- 字符串"aaa" “bbb” “ccc” 就可以使用String类型的数组来存储。
1.2 数组的声明
格式一（推荐）：
数据类型 [] 数组名
int [] array;
格式二：
数据类型 数组名 []
int array [];
- 数据类型：限定了数组以后能存什么类型的数据。
- 方括号：表示现在定义的是一个数组。
- 数组名：就是一个名字而已，方便以后使用。
1.3 数组的静态初始化
完整格式：
数据类型[] 数组名 = new 数据类型[]{元素1，元素2，元素3，元素4...};
int[] arr = new int[]{11,22,33};
double[] arr = new double[]{1.1,1.2,1.3};
- 数据类型：限定了数组以后能存什么类型的数据。
- 方括号：表示现在定义的是一个数组。
- 数组名：其实就是名字而已，方便以后使用，在起名字的时候遵循小驼峰命名法。
- new：就是给数组在内存中开辟了一个空间。
- 数据类型：限定了数组以后能存什么类型的数据，前面和后面的数据类型一定要保持一致。
- 方括号：表示现在定义的是一个数组。
- 大括号：表示数组里面的元素。元素也就是存入到数组中的数据。
- 数组一旦创建之后，长度不能发生变化。
简化格式:
数据类型[] 数组名 = {元素1，元素2，元素3，元素4...};
int[] array = {1,2,3,4,5};
double[] array = {1.1,1.2,1.3};
1.4 数组的动态初始化
不明确具体的数据，推荐使用动态初始化，默认初始值，后序再由代码设置实际的值。
格式：
数据类型[] 数组名 = new 数据类型[数组的长度];
//1.定义一个数组，存3个人的年龄，年龄未知
int[] agesArr = new int[3];
//2.定义一个数组，存班级10名学生的考试成绩，考试成绩暂时未知，考完才知道。
int[] scoresArr = new int[10];
数组的默认初始化值：
- 整数类型：0
- 小数类型：0.0
- 布尔类型：false
- 字符类型：‘\u0000’
- 引用类型：null
1.5 地址值
int[] arr = {1,2,3,4,5};
System.out.println(arr);//[I@6d03e736
double[] arr2 = {1.1,2.2,3.3};
System.out.println(arr2);//[D@568db2f2
打印数组的时候，实际出现的是数组的地址值。数组的地址值表示数组在内存中的位置。
以[I@6d03e736为例：
- [ ：表示现在打印的是一个数组。
- I：表示现在打印的数组是int类型的。
- @：仅仅是一个间隔符号而已。
- 6d03e736：就是数组在内存中真正的地址值。（十六进制的）
但是，我们习惯性会把[I@6d03e736这个整体称之为数组的地址值。地址值对于我们来说，作用不大，简单了解。
1.6 数组元素访问
格式：
数组名[索引];
-
获取数组中对应索引上的值
-
修改数组中对应索引上的值，一旦修改之后，原来的值就会被覆盖了。
代码示例：
public class ArrDemo2 {
/*
数组中元素访问的格式：
数组名[索引];
作用：
1.获取指定索引上对应的元素
2.修改指定索引上对应的元素
*/
public static void main(String[] args) {
int[] arr = {1,2,3,4,5};
//需求1：获取arr数组中，3索引上的值
int number = arr[3];
System.out.println(number);
System.out.println(arr[3]);
//需求2：将arr数组中，3索引上的值修改为10
arr[3] = 10;
System.out.println("修改之后为:" + arr[3]);
}
}
1.7 索引
数组索引也叫角标、下标，就是数组容器中每一个小格子对应的编号。索引的特点：
- 索引一定是从0开始的。
- 连续不间断。
- 逐个+1增长。
1.8 数组的遍历
遍历：就是把数组里面所有的内容一个一个全部取出来。
数组的长度：数组名.length;
通用代码：
for(int i = 0; i < arr.length; i++){
//在循环的过程中，i依次表示数组中的每一个索引
sout(arr[i]);//就可以把数组里面的每一个元素都获取出来，并打印在控制台上了。
}
1.9 数组两种初始化方式的区别
静态初始化：int[] arr = {1,2,3,4,5};
动态初始化：int[] arr = new int[3];
静态初始化：手动指定数组的元素，系统会根据元素的个数，计算出数组的长度。
动态初始化：手动指定数组长度，由系统给出默认初始化值。
使用场景：只明确元素个数，但是不明确具体的数据，推荐使用动态初始化。已经明确了要操作的所有数据，推荐使用静态初始化。
举例：
-
使用数组来存储键盘录入的5个整数。
int[] arr = new int[5]; -
将全班的学生成绩存入数组中，已知学生成绩为：66,77,88,99,100
int[] arr = new int[5]; arr[0] = 66; arr[1] = 77;虽然可以实现，但是太麻烦了，建议使用静态初始化：int[] arr = {66,77,88,99,100};
2、二维数组
2.1 二维数组的声明
数据类型[][] 数组名;
int[][] array;
这只是声明了一个数组变量，而没有分配内存空间或初始化数组。在使用数组之前，需要使用 new 关键字为数组分配内存，并指定数组的行数和列数（即初始化），如：
int[][] array;
array = new int[3][4];
2.2 二维数组的静态初始化
完整格式：
数据类型[][] 数组名 = new 数据类型[][]{{元素1，元素2},{元素1，元素2}}
int[][] arr = new int[][]{{1, 2, 3}, {4, 5, 6, 7, 8}};
简化格式：
数据类型[][] 数组名 = {{元素1，元素2},{元素1，元素2}}
int[][] arr = {{1, 2, 3},{4, 5, 6, 7, 8}};
2.3 二维数组的动态初始化
不明确具体的数据，推荐使用动态初始化，默认初始值，后序再由代码设置实际的值。
格式：
数据类型[][] 数组名 = new 数据类型[m][n]
int[][] arr = new int[3][3];
m为二维数组中一维数组的数量，n表示每个一维数组的长度。
特殊情况：省略第二维大小
int[][] array = new int[3][];
array[0] = new int[2];
array[1] = new int[3];
array[2] = new int[4];
在这个例子中，array 是一个包含3行的二维数组，但每一行的列数不同。通过在第二维中使用不同的 new int[] 语句，为每一行分配了不同长度的数组。
2.4 二维数组的遍历
嵌套的for循环：
int[][] array = {
{1, 2, 3},
{4, 5, 6},
{7, 8, 9}
};
for (int i = 0; i < array.length; i++) {
for (int j = 0; j < array[i].length; j++) {
int element = array[i][j];
// 对数组中的元素进行操作
System.out.print(element + " ");
}
System.out.println(); // 换行
}
增强型for循环：
int[][] array = {
{1, 2, 3},
{4, 5, 6},
{7, 8, 9}
};
for (int[] row : array) {
for (int element : row) {
// 对数组中的元素进行操作
System.out.print(element + " ");
}
System.out.println(); // 换行
}
3、操作数组的工具类Arrays
3.1 基本使用
- tostring：将数组变成字符串
- binarySearch：二分查找发查找元素
- copyOf：拷贝数组
- copyOfRange：拷贝数组(指定范围)
- fill：填充数组，会覆盖原来的元素
- sort：排序，默认情况下，给基本数据类型进行升序排列，底层使用的是快速排序
public class ArraysDemo01 {
public static void main(String[] args) {
//tostring: 将数组变成字符串
System.out.println("-----------------toString--------------------------");
int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
System.out.println(Arrays.toString(arr));
/**
* binarySearch:二分查找发查找元素
* 细节1：二分查找的前提：数组中的元素必须是有序，且数组元素必须时升序
* 细节2：如果查找的元素时存在的，返回的是真实的索引，如果查找的元素不存在，返回的是 （ -插入点-1 ），插入点是指当前的元素应该在数组中的什么位置
*/
System.out.println("-----------------binarySearch--------------------------");
System.out.println(Arrays.binarySearch(arr, 10));//9
System.out.println(Arrays.binarySearch(arr, 2));//1
System.out.println(Arrays.binarySearch(arr, 20));//-11
/**
* copyOf:拷贝数组
* 参数一：老数组
* 参数二：新数组的长度
* 返回值：新数组
*
* 如果新数组小于老数组的长度，会部分拷贝
* 如果新数组等于老数组的长度，会完全拷贝
* 如果新数组大于老数组的长度，会补上默认初始值
*/
System.out.println("-----------------copyOf--------------------------");
int[] newArr1 = Arrays.copyOf(arr, arr.length);
System.out.println(Arrays.toString(newArr1));
//copyOfRange：拷贝数组(指定范围)
//细节：包头不包尾，包左不包右
System.out.println("-----------------copyOfRange--------------------------");
int[] newArr2 = Arrays.copyOfRange(arr, 0, 9);//拷贝了索引为0~8的数据
System.out.println(Arrays.toString(newArr2));
//fill：填充数组，会覆盖原来的元素
System.out.println("-----------------fill--------------------------");
Arrays.fill(arr, 20);
System.out.println(Arrays.toString(arr));
//sort：排序，默认情况下，给基本数据类型进行升序排列，底层使用的是快速排序
System.out.println("-----------------sort--------------------------");
int[] arr2 = {10, 2, 5, 1, 4, 3, 6, 7, 8, 9};
Arrays.sort(arr2);
System.out.println(Arrays.toString(arr2));
}
}
3.2 重写排序方法
public static void sort(要排序的数组，排序规则) 按照指定的规则排序
- 只能给引用数据类型的数组进行排序
- 如果数组是基本数据类型，需要变成对应的包装类
底层原理：
- 利用插入排序 + 二分查找的方式进行排序的。
- 默认把0索引的数据当做是有序的序列，1索引到最后认为是无序的序列。
- 遍历无序的序列得到里面的每一个元素，假设当前遍历得到的元素是A元素
- 把A往有序序列中进行插入，在插入的时候，是利用二分查找确定A元素的插入点。
- 拿着A元素，跟插入点的元素进行比较，比较的规则就是compare方法的方法体
- 如果方法的返回值是负数，拿着A继续跟前面的数据进行比较
- 如果方法的返回值是正数，拿着A继续跟后面的数据进行比较
- 如果方法的返回值是0，也拿着A跟后面的数据进行比较
- 直到能确定A的最终位置为止。
compare方法的形式参数：
-
参数一 o1: 表示在无序序列中，遍历得到的每一个元素
-
参数二 o2: 有序序列中的元素
-
返回值：
-
负数:表示当前要插入的元素是小的，放在前面
-
正数:表示当前要插入的元素是大的，放在后面
-
0: 表示当前要插入的元素跟现在的元素比是一样的们也会放在后面
-
简单理解
return o1 - o2; //升序排序
return o2 - o1; //降序排序
-
代码示例：
public class ArraysDemo02 {
public static void main(String[] args) {
Integer[] arr3 = {10, 2, 5, 1, 4, 3, 6, 7, 8, 9};
Arrays.sort(arr3, new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
System.out.println("=============");
System.out.println("o1:" + o1);
System.out.println("o2:" + o2);
System.out.println(o1 - o2);
//return o1 - o2; //升序排序
return o2 - o1; //降序排序
}
});
System.out.println(Arrays.toString(arr3));
}
}
输出
=============
o1:2
o2:10
-8
=============
o1:5
o2:2
3
=============
o1:5
o2:2
3
=============
o1:5
o2:10
-5
=============
o1:1
o2:5
-4
=============
o1:1
o2:2
-1
=============
o1:4
o2:2
2
=============
o1:4
o2:5
-1
=============
o1:3
o2:4
-1
=============
o1:3
o2:1
2
=============
o1:3
o2:2
1
=============
o1:6
o2:3
3
=============
o1:6
o2:5
1
=============
o1:6
o2:10
-4
=============
o1:7
o2:4
3
=============
o1:7
o2:6
1
=============
o1:7
o2:10
-3
=============
o1:8
o2:4
4
=============
o1:8
o2:6
2
=============
o1:8
o2:7
1
=============
o1:8
o2:10
-2
=============
o1:9
o2:5
4
=============
o1:9
o2:7
2
=============
o1:9
o2:8
1
=============
o1:9
o2:10
-1
[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
856
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
