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

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(); // 换行
}

image-20231230181443257

增强型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(); // 换行
}

image-20231230181444815

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));
    }
}

image-20231227110933955

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]
  • 19
    点赞
  • 22
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值