二维数组多次排序或嵌套list多次排序-Toy模板网

这篇具有很好参考价值的文章主要介绍了二维数组多次排序或嵌套list多次排序。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

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

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

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

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

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

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

方法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());
}

但是提交的结果然后是耗时耗空间。
既然数组能用流处理，那是不是可以全部用流的形式过滤和排序呢
方法3：文章来源地址https://www.toymoban.com/news/detail-726752.html

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