11-数组操作

Posted 年小猫

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了11-数组操作相关的知识,希望对你有一定的参考价值。

遍历数组
数组最常见的一个操作就是遍历。数组的每个元素都可以通过索引来访问,因此,使用标准的for循环可以完成一个数组的遍历。
        int[] ns = { 1, 4, 9, 16, 25 };
        for (int i=0; i<ns.length; i++) {
            int n = ns[i];
            System.out.println(n);
        }

为了实现for循环遍历,初始条件为i=0,因为索引总是从0开始,继续循环的条件为i<ns.length,因为当i=ns.length时,i 已经超出了索引范围(索引范围是0 ~ ns.length-1)。
除了标准for循环外,还可以用for each循环,直接迭代数组的每个元素:
public class Main {
    public static void main(String[] args) {
        int[] ns = { 1, 4, 9, 16, 25 };
        for (int n : ns) {
            System.out.println(n);
        }
    }
}

注意:for each循环更加简洁,但在for each循环中,变量n直接拿到ns数组的元素,而不是索引,因此,到底用哪一种for循环,取决于实际需要
在打印的数组的元素内容时,使用for each循环会比标准for更加简洁,但Java标准库提供了Arrays.toString(),可以快速打印数组内容。
import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] ns = { 1, 1, 2, 3, 5, 8 };
        System.out.println(Arrays.toString(ns));
    }
}


数组排序
对数组进行排序是程序中非常基本的需求。常用的排序算法有冒泡排序、插入排序和快速排序等
//冒泡排序
import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] ns = { 28, 12, 89, 73, 65, 18, 96, 50, 8, 36 };
        // 排序前:
        System.out.println(Arrays.toString(ns));
        
        for (int i = 0; i < ns.length - 1; i++) {
            for (int j = 0; j < ns.length - i - 1; j++) {
                if (ns[j] > ns[j+1]) {
                    // 交换ns[j]和ns[j+1]:
                    int tmp = ns[j];
                    ns[j] = ns[j+1];
                    ns[j+1] = tmp;
                }
            }
        }
        // 排序后:
        System.out.println(Arrays.toString(ns));
    }
}

注意:交换两个变量的值必须借助一个临时变量。
冒泡排序的特点是,每一轮循环后,最大的一个数被交换到末尾,因此,下一轮循环就可以“刨除”最后的数,每一轮循环都比上一轮循环的结束位置靠前一位。

Java的标准库已经内置了排序功能,只需调用JDK提供的Arrays.sort()就可以排序
Arrays.sort()的用法很多。https://blog.csdn.net/qq_33098049/article/details/81588804
import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] ns = { 28, 12, 89, 73, 65, 18, 96, 50, 8, 36 };
        Arrays.sort(ns);
        System.out.println(Arrays.toString(ns));
    }
}

注意:对数组排序实际上修改了数组本身。例如,排序前的数组是
int[] ns = { 9, 3, 6, 5 };

在内存中,这个整型数组表示如下:
      ┌───┬───┬───┬───┐
ns───>│ 9365 │
      └───┴───┴───┴───┘
调用Arrays.sort(ns);后,这个整型数组在内存中变为:
      ┌───┬───┬───┬───┐
ns───>│ 3569 │
      └───┴───┴───┴───┘
即变量ns指向的数组内容已经被改变

对一个字符串数组进行排序,由于字符串不可变,情况与整数型排序不同。例如:
String[] ns = { "banana", "apple", "pear" };

排序前,这个数组在内存中表示如下:
                   ┌──────────────────────────────────┐
               ┌───┼──────────────────────┐           │
               │   │                      ▼           ▼
         ┌───┬─┴─┬─┴─┬───┬────────┬───┬───────┬───┬──────┬───┐
ns ─────>│???│???│???│   │"banana"│   │"apple"│   │"pear"│   │
         └─┬─┴───┴───┴───┴────────┴───┴───────┴───┴──────┴───┘
           │                 ▲
           └─────────────────┘
调用Arrays.sort(ns);排序后,这个数组在内存中表示如下:
                   ┌──────────────────────────────────┐
               ┌───┼──────────┐                       │
               │   │          ▼                       ▼
         ┌───┬─┴─┬─┴─┬───┬────────┬───┬───────┬───┬──────┬───┐
ns ─────>│???│???│???│   │"banana"│   │"apple"│   │"pear"│   │
         └─┬─┴───┴───┴───┴────────┴───┴───────┴───┴──────┴───┘
           │                              ▲
           └──────────────────────────────┘
原来的3个字符串在内存中均没有任何变化,但是ns数组的每个元素指向变化了。


多维数组
二维数组就是以一维数组为元素的数组:
public class Main {
    public static void main(String[] args) {
        int[][] ns = {
            { 1, 2, 3, 4 },
            { 5, 6, 7, 8 },
            { 9, 10, 11, 12 }
        };
        System.out.println(ns.length); // 3
    }
}

因为ns包含3个数组,因此,ns.length 为3。实际上ns在内存中的结构如下:
                    ┌───┬───┬───┬───┐
         ┌───┐  ┌──>│ 1234 │
ns ─────>│???│──┘   └───┴───┴───┴───┘
         ├───┤      ┌───┬───┬───┬───┐
         │???│─────>│ 5678 │
         ├───┤      └───┴───┴───┴───┘
         │???│──┐   ┌───┬───┬───┬───┐
         └───┘  └──>│ 9101112 │
                    └───┴───┴───┴───┘


这时如果定义一个普通数组arr0,然后把ns[0]赋值给它
public class Main {
    public static void main(String[] args) {
        int[][] ns = {
            { 1, 2, 3, 4 },
            { 5, 6, 7, 8 },
            { 9, 10, 11, 12 }
        };
        int[] arr0 = ns[0];
        System.out.println(arr0.length); // 4
    }
}

实际上arr0就获取了ns数组的第0个元素。因为ns数组的每个元素也是一个数组,因此,arr0指向的数组就是{ 1, 2, 3, 4 }。在内存中,结构如下:
            arr0 ─────┐
                      ▼
                    ┌───┬───┬───┬───┐
         ┌───┐  ┌──>│ 1234 │
ns ─────>│???│──┘   └───┴───┴───┴───┘
         ├───┤      ┌───┬───┬───┬───┐
         │???│─────>│ 5678 │
         ├───┤      └───┴───┴───┴───┘
         │???│──┐   ┌───┬───┬───┬───┐
         └───┘  └──>│ 9101112 │
                    └───┴───┴───┴───┘


访问二维数组的某个元素需要使用array[row][col],例如
System.out.println(ns[1][2]); // 7

二维数组的每个数组元素的长度并不要求相同,例如,可以这么定义ns数组
int[][] ns = {
    { 1, 2, 3, 4 },
    { 5, 6 },
    { 7, 8, 9 }
};

这个二维数组在内存中的结构如下:
                    ┌───┬───┬───┬───┐
         ┌───┐  ┌──>│ 1234 │
ns ─────>│???│──┘   └───┴───┴───┴───┘
         ├───┤      ┌───┬───┐
         │???│─────>│ 56 │
         ├───┤      └───┴───┘
         │???│──┐   ┌───┬───┬───┐
         └───┘  └──>│ 789 │
                    └───┴───┴───┘

要打印一个二维数组,可以使用两层嵌套的for循环,或者使用Java标准库的Arrays.deepToString():
for (int[] arr : ns) {
    for (int n : arr) {
        System.out.print(n);
        System.out.print(, );
    }
    System.out.println();
}
//或者
System.out.println(Arrays.deepToString(ns));


三维数组就是以二维数组为元素的数组:
int[][][] ns = {
    {
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9}
    },
    {
        {10, 11},
        {12, 13}
    },
    {
        {14, 15, 16},
        {17, 18}
    }
};
//以3个二位数组构成的三维数组

它在内存中的结构如下:
                              ┌───┬───┬───┐
                   ┌───┐  ┌──>│ 123 │
               ┌──>│???│──┘   └───┴───┴───┘
               │   ├───┤      ┌───┬───┬───┐
               │   │???│─────>│ 456 │
               │   ├───┤      └───┴───┴───┘
               │   │???│──┐   ┌───┬───┬───┐
        ┌───┐  │   └───┘  └──>│ 789 │
ns ────>│???│──┘              └───┴───┴───┘
        ├───┤      ┌───┐      ┌───┬───┐
        │???│─────>│???│─────>│1011 │
        ├───┤      ├───┤      └───┴───┘
        │???│──┐   │???│──┐   ┌───┬───┐
        └───┘  │   └───┘  └──>│1213 │
               │              └───┴───┘
               │   ┌───┐      ┌───┬───┬───┐
               └──>│???│─────>│141516 │
                   ├───┤      └───┴───┴───┘
                   │???│──┐   ┌───┬───┐
                   └───┘  └──>│1718 │
                              └───┴───┘

如果要访问三维数组的某个元素,例如,ns[2][0][1],只需要顺着定位找到对应的最终元素15即可。
注意:理论上,我们可以定义任意的N维数组。但在实际应用中,除了二维数组在某些时候还能用得上,更高维度的数组很少使用。

 

以上是关于11-数组操作的主要内容,如果未能解决你的问题,请参考以下文章

为什么我不能在此片段中生成唯一对象数组?

Android:片段内的按钮操作

VSCode自定义代码片段—— 数组的响应式方法

VSCode自定义代码片段10—— 数组的响应式方法

数组和适配器不能调用虚空片段

如何在kotlin的片段内显示网格视图?