Java Programming

Java一维与二维数组的拷贝与排序

Posted by saltyfishyjk on 2022-02-15
Words 1.1k and Reading Time 5 Minutes
Viewed Times

Java一维与二维数组的拷贝与排序

Arrays.sort()

一维数组升序排序

e.g.(demo.java)

1
2
3
4
5
6
7
8
9
10
import java.util.Arrays;

public class demo {
    public static void main(String[] args){
        int[] arr = new int[]{1,5,98,6,78,65};
        Arrays.sort(arr);
        for(int i : arr){
            System.out.println(i);
        }
}

output:

1
2
3
4
5
6
1
5
6
65
78
98

二维数组按行升序排序

e.g.(demo.java)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import java.util.Arrays;

public class demo {
    public static void main(String[] args){
        int [][] arr = new int[][]{{1,20,3},{20,3,5},{9,0,8}};
        int n = arr.length;
        for(int i = 0;i < n;i++){
            Arrays.sort(arr[i]);
        }
        for(int i = 0;i < n;i++){
            for(int j : arr[i]){
                System.out.print(j + " ");
            }
            System.out.println();
        }
}

output:

1
2
3
1 3 20 
3 5 20 
0 8 9

二维数组按列升序排序

思路：将数组转置，每行调用Arrays.sort()，再转置回来

e.g.(demo.java)

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
import java.util.Arrays;

public class demo {
    public static int[][] arrTransfer(int[][] arr){ //借用线代思想，对矩阵转置
        int n = arr.length;
        int m = arr[0].length;
        int[][] ret = new int[m][n];
        for(int i = 0;i < n;i++){
            for(int j = 0;j < m;j++){
                ret[j][i] = arr[i][j];
            }
        }
        return ret;
    }
    public static void main(String[] args){
        int [][] arr = new int[][]{{1,20,3},{20,3,5},{9,0,8}};
        int n = arr.length;
        int m = arr[0].length;//该方法适用于矩阵类二维数组，不等长二维数组不适用
        int[][] tempArr = new int[m][n];
        tempArr = arrTransfer(arr);
        for(int i = 0;i < m;i++){
            Arrays.sort(tempArr[i]);
        }
        arr = arrTransfer(tempArr);
        for(int i = 0;i < n;i++){
            for(int j : arr[i]){
                System.out.print(j + " ");
            }
            System.out.println();
        }
}

output:

1
2
3
1 0 3 
9 3 5 
20 20 8

Java中的数组

Java中数组的基本性质

  1. 数组是使用统一名称引用的一组具有相同类型的数据
  2. Java中的数组属于引用类型（对象），类似C语言中的指针

一维数组的拷贝

e.g.(demo.java)

1
2
3
4
5
6
7
8
9
10
11
12
13
import java.util.Arrays;

public class demo {
    public static void main(String[] args){
        int[] arr1 = {10,2,5,4};
        int[] arr2 = arr1.clone(); //获得arr1的一份拷贝，arr2指向的内存空间不同于arr1
        int[] arr3 = arr1; //获得了arr1（引用）的拷贝，赋给arr3，二者同时指向一块内存空间，因此对arr3或arr1做的操作都会反映到同一块内存空间上
        Arrays.sort(arr1);
        System.out.println("arr1" + Arrays.toString(arr1));
        System.out.println("arr2" + Arrays.toString(arr2));
        System.out.println("arr3" + Arrays.toString(arr3));
    }
}

二维数组的拷贝

二维数组可以看作数组的数组，即，每一个元素都是一个一维数组，因此可以依照上述拷贝一维数组的思想拷贝二维数组

e.g.(demo.java)

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
import java.util.Arrays;

public class demo {
    public static void main(String[] args){
        int[][] arr1 = {{1,20,4},{23,92,24},{92,482,234}};
        int[][] arr2 = arr1.clone();
        int n = arr1.length;
        int m = arr1[0].length;
        int[][] arr3 = new int[n][m];
        for(int i = 0;i < n;i++){
            arr3[i] = arr1[i].clone();
        }
        for(int i = 0;i < n;i++){
            Arrays.sort(arr1[i]);
        }
        System.out.println("arr1" + Arrays.toString(arr1));
        System.out.println("arr2" + Arrays.toString(arr2));
        System.out.println("arr3" + Arrays.toString(arr3));
        for(int i = 0;i < n;i++){
            System.out.println("arr1" + Arrays.toString(arr1[i]));
        }
        for(int i = 0;i < n;i++){
            System.out.println("arr2" + Arrays.toString(arr2[i]));
        }
        for(int i = 0;i < n;i++){
            System.out.println("arr3" + Arrays.toString(arr3[i]));
        }
    }
}

output:

1
2
3
4
5
6
7
8
9
10
11
12
arr1[[I@4eec7777, [I@3b07d329, [I@41629346]
arr2[[I@4eec7777, [I@3b07d329, [I@41629346]
arr3[[I@214c265e, [I@448139f0, [I@7cca494b]
arr1[1, 4, 20]
arr1[23, 24, 92]
arr1[92, 234, 482]
arr2[1, 4, 20]
arr2[23, 24, 92]
arr2[92, 234, 482]
arr3[1, 20, 4]
arr3[23, 92, 24]
arr3[92, 482, 234]

从输出可以看出，arr2和arr1值相等，指向同一块内存空间；arr3复制arr1的数据到另一块内存空间，不受arr1引用的内存空间的数据的改变影响；同时可以看出，arr1是一个特殊的数组，每个元素是一个一维数组

关于浅拷贝与深拷贝

上述的拷贝仅仅局限于数组，事实上对象等也可以拷贝，此处涉及深浅拷贝的区别，读者可以参考以下两篇博客：

彻底讲明白浅拷贝与深拷贝

Java中浅拷贝和深拷贝的区别

一个例题

leetcode 1380. 矩阵中的幸运数

读者可以在此题中简单应用上述数组知识

This is copyright.

FEATURED TAGS
Java Programming
FRIENDS