【Java】数组

本文介绍Java数组的创建、遍历、复制，Arrays类的几种常用方法，以及优化后的冒泡排序。

数组概述

1. 长度确定
2. 元素类型必须相同
3. 可以存储基本数据类型和引用数据类型
4. 数组变量属于引用类型

---

创建数组和初始化

int[] arr1 = null;  // 声明数组
arr1 = new int[4];  // 给数组分配空间
int arr2[] = new int[4];
int[] arr3 = new int[] {1, 2, 3, 4};

String mat1[][] = {{"Hello", "Flink", "Hadoop"}, {"Spark", "Flume"}};
double[] mat2[] = new double[4][];
char mat3[][] = new char[4][4];
1
2
3
4
5
6
7
8

---

数组遍历和复制

1. 下标遍历与增强for循环

String mat[][] = {{"Hello", "Flink", "Hadoop"}, {"Spark", "Flume"}};

for (int i = 0; i < mat.length; i++) {
    for (int j = 0; j < mat[i].length; j++) {
        System.out.printf(mat[i][j] + ' ');
    }
    System.out.println();
}

System.out.println("--------------------------------");

for (String[] words : mat) {
    for (String word : words) {
        System.out.printf(word + ' ');
    }
    System.out.println();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

2. 复制

System.arraycopy(object src, int srcpos, object dest, int destpos, int length)
String mat[][] = {{"Hello", "Flink", "Hadoop"}, {"Spark", "Flume"}};
String matCopy[][] = new String[2][];
System.arraycopy(mat, 0, matCopy, 0, 2);
System.out.println(matCopy.toString());
System.out.println(Arrays.toString(matCopy));
System.out.println(Arrays.toString(matCopy[0]));
System.out.println(Arrays.toString(matCopy[1]));
// ---------------------------------------------
[[Ljava.lang.String;@14ae5a5
[[Ljava.lang.String;@7f31245a, [Ljava.lang.String;@6d6f6e28]
[Hello, Flink, Hadoop]
[Spark, Flume]
1
2
3
4
5
6
7
8
9
10
11
12
13

---

Java.util.Arrays类

Arrays.toString()

打印数组元素的值，若数组元素还是引用类型，则打印的仍然是引用的值
Arrays.toString()方法是Arrays类的静态方法

public static String toString(Object[] a) {
    if (a == null)
        return "null";

    int iMax = a.length - 1;
    if (iMax == -1)
        return "[]";

    StringBuilder b = new StringBuilder();
    b.append('[');
    for (int i = 0; ; i++) {
        b.append(String.valueOf(a[i]));
        if (i == iMax)
            return b.append(']').toString();
        b.append(", ");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

Arrays.sort()

1. 默认排序方式

int arr[] = {1, 9, 8, 2, 3, 7, 6, 5, 4};
Arrays.sort(arr);
System.out.println(Arrays.toString(arr));
1
2
3

2. 自定义排序规则 (Comparable接口)

public class Person implements Comparable{
    private String name;
    private int age;
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public int compareTo(Object o) {
        Person person = (Person) o;
        if (this.age < person.age) {
            return 1;
        }
        if (this.age > person.age) {
            return -1;
        }
        return 0;
    }
}
Person p1 = new Person("Amy", 24);
Person p2 = new Person("Tom", 22);
Person p3 = new Person("Anna", 23);
Person[] people = {p1, p2, p3};
Arrays.sort(people);
System.out.println(Arrays.toString(people));
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

Arrays.fill()

左闭右开

int arr[] = new int[] {1, 2, 3, 4, 5};
Arrays.fill(arr, 2, 4, 6);
System.out.println(Arrays.toString(arr));
1
2
3

---

用数组存储表格数据

Object[] p1 = {1001, "Amy", 21, 'F'};
Object[] p2 = {1002, "Tom", 22, 'M'};
Object[] p3 = {1003, "John", 23, 'M'};
Object[][] emps = new Object[3][];
emps[0] = p1;
emps[1] = p2;
emps[2] = p3;
for (Object[] person : emps) {
    System.out.println(Arrays.toString(person));
}
1
2
3
4
5
6
7
8
9
10

---

冒泡排序(优化)

• 若不用static关键字，则需要创建一个BubbleSort对象，再调用bubbleSort方法
• 为什么外层是n-1次循环？因为一次循环排好一个数，n-1次循环排好n-1个数，最后一个数则自然排好。
• 为什么内层是n-1-i次循环？n个数比较n-1次。
• 当内部没有发生比较时，说明已经排序好了。

public class BubbleSort {
    public static void main(String[] args) {
        int[] arr = {3, 1, 6, 2, 9, 0, 7, 4, 5, 8};
        bubbleSort(arr);
        System.out.println(Arrays.toString(arr));
    }
    public static void bubbleSort(int[] arr) {
        int n = arr.length;
        for (int i = 0; i < n - 1; i++) {
            boolean flag = true;
            for (int j = 0; j < n - i - 1; j++) {
                if (arr[j] > arr[j + 1]) {
                    swap(arr, j, j + 1);
                    flag = false;
                }
            }
            if (flag) break;
        }
    }
    public static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

二分法

Arrays.binarySearch(arr, target)

• 找到，返回正数，索引从零开始；
• 没找到，返回负数，索引从负一开始。