二维数组多次排序 或 嵌套list多次排序

可以排序int[ ][ ]的顺序，也可以排序List> 顺序

为便于理解，以力扣原题为例：1333.餐厅过滤器

原题中给了一个双重数组，并要求返回一个List。

方法1：
会用流的，通常用于会反应把双重数组转成List>去处理这个双重数组，于是解题思路如下：

public static List<Integer> filterRestaurants2(int[][] restaurants, int veganFriendly, int maxPrice, int maxDistance) {
	//构造嵌套List
    List<List<Integer>> lists = new ArrayList<>();
    for(int[] arr : restaurants){
        if((veganFriendly == 1 && arr[2] != 1) || maxPrice < arr[3] || maxDistance < arr[4]){
            continue;
        }

        lists.add(Arrays.stream(arr).boxed().collect(Collectors.toList()));
    }
    
    if (lists.size() == 0) {
        return new ArrayList<>();
    }

	//嵌套List排序
    lists.sort((a,b) ->{
        int rating = b.get(1).compareTo(a.get(1));
        if (rating != 0) {
            return rating;
        }
        return b.get(0).compareTo(a.get(0));
    });

    return lists.stream().map(o->o.get(0)).collect(Collectors.toList());
}
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

可是该方式耗空间较大，于是又会想，能不能从直接用数组的方式，不另外构造新对象。

方法2：

public static List<Integer> filterRestaurants3(int[][] restaurants, int veganFriendly, int maxPrice, int maxDistance) {

    for(int[] arr : restaurants){
        if((veganFriendly == 1 && arr[2] != 1) || maxPrice < arr[3] || maxDistance < arr[4]){
            arr[0] = 0;
        }
    }

	//双重数组排序
    Arrays.sort(restaurants, (o1, o2) -> {
        int compare = Integer.compare(o2[1], o1[1]);
        if (compare != 0){
            return compare;
        }
        return Integer.compare(o2[0], o1[0]);
    });

    return Arrays.stream(restaurants).map((int[] o)->o[0]).filter(o->o!=0).collect(Collectors.toList());
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

但是提交的结果然后是耗时耗空间。
既然数组能用流处理，那是不是可以全部用流的形式过滤和排序呢
方法3：

public static List<Integer> filterRestaurants(int[][] restaurants, int veganFriendly, int maxPrice, int maxDistance) {
    return Arrays.stream(restaurants)
    .filter(r -> (veganFriendly != 1 || r[2] == 1) && r[3] <= maxPrice && r[4] <= maxDistance)
    //双重数组排序
    .sorted((a1, a2) -> a1[1] == a2[1] ? a2[0] - a1[0] : a2[1] - a1[1])
    .map(a -> a[0])
    .collect(Collectors.toList());
}
1
2
3
4
5
6
7
8