Java数组：一维数组、二维数组、Arrays

文章目录

- 1、一维数组
- - 1.1 数组概念
  - 1.2 数组的声明
  - 1.3 数组的静态初始化
  - 1.4 数组的动态初始化
  - 1.5 地址值
  - 1.6 数组元素访问
  - 1.7 索引
  - 1.8 数组的遍历
  - 1.9 数组两种初始化方式的区别
- 2、二维数组
- - 2.1 二维数组的声明
  - 2.2 二维数组的静态初始化
  - 2.3 二维数组的动态初始化
  - 2.4 二维数组的遍历
- 3、操作数组的工具类Arrays
- - 3.1 基本使用
  - 3.2 重写排序方法

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]