java array 排序-hive array 排序

了解如何使用 Comparators、Comparables 和新的 lambda 表达式对 JavaSet、List 和 Map 的原始类型和自定义对象进行排序。 我们还将学习升序和降序排序方法。

//Sorting an arrayArrays.sort( arrayOfItems );
Arrays.sort( arrayOfItems, Collections.reverseOrder() );
Arrays.sort(arrayOfItems, 2, 6);
Arrays.parallelSort(arrayOfItems);//Sorting a ListCollections.sort(numbersList);
Collections.sort(numbersList, Collections.reverseOrder());//Sorting a SetSet to List -> Sort -> List to Set
Collections.sort(numbersList);//Sorting a MapTreeMaptreeMap = new TreeMap<>(map);
unsortedeMap.entrySet()
    .stream()
    .sorted(Map.Entry.comparingByValue())
    .forEachOrdered(x -> sortedMap.put(x.getKey(), x.getValue()));//Java 8 LambdaComparatornameSorter = (a, b) -> a.getName().compareToIgnoreCase(b.getName());
Collections.sort(list, nameSorter);
Collections.sort(list, Comparator.comparing(Employee::getName));//Group By SortingCollections.sort(list, Comparator
                        .comparing(Employee::getName)
                        .thenComparing(Employee::getDob));复制代码

1. 对对象列表进行排序

为了对对象列表进行排序，我们有两种流行的方法，即 Comparator 和 Comparator 接口。 在下面的示例中，我们将以不同的方式对 Employee 对象的集合进行排序。

public class Employee implements Comparable{private Long id;private String name;private LocalDate dob;
}复制代码

1.1. 可比界面

[Comparable]() 接口支持实现它的类的自然排序。 这使得该类与它的其他实例具有可比性。

实现 Comparable 接口的类必须覆盖 compareTo() 方法，它指定了同一类的两个实例之间的比较逻辑。

ArrayListlist = new ArrayList<>();//add employees..Collections.sort(list);复制代码

要对列表进行反向排序java array 排序，最好的方法是使用 *Comparator.reversed()* API 来进行反向排序。

ArrayListlist = new ArrayList<>();//add employees..Collections.sort(list, Comparator.reversed());复制代码

1.2. 比较器接口

当不寻求自然排序时，我们可以在 Comparator 接口的帮助下应用自定义排序行为。

比较器无需修改类的源代码。 我们可以在一个单独的类中创建比较逻辑，该类实现 Comparator 接口并覆盖其 compare() 方法。

在排序过程中，我们将此比较器的一个实例与自定义对象列表一起传递给 sort() 方法。

例如，我们想按照名字对员工进行排序，而自然排序已经通过 id 字段实现了。 因此，为了对名称字段进行排序，我们必须使用比较器接口编写自定义排序逻辑。

import java.util.Comparator;public class NameSorter implements Comparator;
{@Overridepublic int compare(Employee e1, Employee e2){return e1.getName().compareToIgnoreCase( e2.getName() );
    }
}复制代码

请注意，在给定的示例中，NameSorter 用作 *sort()* 方法中的第二个参数。

ArrayListlist = new ArrayList<>();//add employees to listCollections.sort(list, new NameSorter());复制代码

要进行反向排序java array 排序，我们只需要在比较器实例上调用 *reversed()* 方法。

ArrayListlist = new ArrayList<>();//add employees to listCollections.sort(list, new NameSorter().reversed());复制代码

1.3. 使用 Lambda 表达式排序

Lambda 表达式有助于动态编写 Comparator 实现。 我们不需要创建一个单独的类来提供一次性比较逻辑。

ComparatornameSorter = (a, b) -> a.getName().compareToIgnoreCase(b.getName());
Collections.sort(list, nameSorter);复制代码

1.4. 按组排序

要对不同字段的对象集合应用 SQL 风格的排序**（按排序分组**），我们可以在链中使用多个比较器。 可以使用 *Comparator.comparing() 和 Comparator.thenComparing()* 方法创建此类比较器链。

例如，我们可以按姓名然后按年龄对员工列表进行排序。

ArrayListlist = new ArrayList<>();//add employees to listCollections.sort(list, Comparator
                        .comparing(Employee::getName)
                        .thenComparing(Employee::getDob));复制代码

2.对数组进行排序

使用 java.util.Arrays.sort() 方法以各种方式对给定数组进行排序。  *sort()* 是一个重载方法，它接受各种类型作为方法参数。

此方法实现双轴快速排序算法，在所有数据集上提供 O(n log(n)) 性能，通常比传统（单轴）快速排序实现更快。

2.1. 升序排序

一个 Java 程序，它使用 *Arrays.sort()* 方法按升序对整数数组进行排序。

//Unsorted arrayInteger[] numbers = new Integer[] { 15, 11, ... };//Sort the arrayArrays.sort(numbers);复制代码

2.2. 降序

Java 提供了 Collections.reverseOrder() 比较器来反转一行中的默认排序行为。 我们可以使用此比较器按降序对数组进行排序。

请注意，数组中的所有元素必须通过指定的比较器相互比较。

//Unsorted arrayInteger[] numbers = new Integer[] { 15, 11, ... };//Sort the array in reverse orderArrays.sort(numbers, Collections.reverseOrder());复制代码

2.3. 数组范围排序

Arrays.sort() 方法是一个重载方法，需要两个额外的参数，即：fromIndex（含）和 toIndex（不含）。

当提供上述参数时，数组将在提供的范围内排序，从位置 fromIndex 到位置 toIndex。

下面是一个从元素 9 到 18 对数组进行排序的示例，即 {9, 55, 47, 18} 将被排序，其余元素将不会被触及。

//Unsorted arrayInteger[] numbers = new Integer[] { 15, 11, 9, 55, 47, 18, 1123, 520, 366, 420 };//Sort the arrayArrays.sort(numbers, 2, 6);//Print array to confirmSystem.out.println(Arrays.toString(numbers));复制代码

程序输出。

[15, 11, 9, 18, 47, 55, 1123, 520, 366, 420]复制代码

2.4. 平行排序

Java 8 引入了许多用于并行处理数据集和数据流的新 API。 这些 API 之一是 Arrays.parallelSort()。

parallelSort() 方法将数组分成多个子数组，每个子数组在不同的线程中使用 Arrays.sort() 进行排序。 最后，将所有排序好的子数组合并为一个排序数组。

parallelSort() 和 sort()，这两个 API 的输出最终会是一样的。 这只是利用 Java 的并发性的问题。

//Parallel sort complete arrayArrays.parallelSort(numbers);//Parallel sort array rangeArrays.parallelSort(numbers, 2, 6);//Parallel sort array in reverse orderArrays.parallelSort(numbers, Collections.reverseOrder());复制代码

3. 对集合进行排序

Java 中不直接支持对 Set 进行排序。 要对集合进行排序，请按照下列步骤操作。

将集合转换为列表。 使用 Collections.sort() API 对列表进行排序。 将列表转换回集合。

//Unsorted setHashSetnumbersSet = new LinkedHashSet<>(); //with Set itemsListnumbersList = new ArrayList(numbersSet) ;        //set -> list//Sort the listCollections.sort(numbersList);//sorted setnumbersSet = new LinkedHashSet<>(numbersList);          //list -> set复制代码

4.对地图进行排序

Map 是键值对的集合。 因此，从逻辑上讲，我们可以通过键或值两种方式对地图进行排序。

4.1. 按键排序

按键排序的最佳和最有效的方法是将所有映射条目添加到 TreeMap 对象。  TreeMap ，始终按排序顺序存储键。

HashMapmap = new HashMap<>();   //Unsorted MapTreeMaptreeMap = new TreeMap<>(map);   //Sorted by map keys复制代码

4.2. 按值排序

在Java 8中，Map.Entry类有一个静态方法**comparingByValue()**帮助我们对Map的值进行排序。

comparingByValue() 方法返回一个比较器，该比较器按自然顺序比较 Map.Entry 的值。

HashMapunSortedMap = new HashMap<>(); //Unsorted Map//LinkedHashMap preserve the ordering of elements in which they are insertedLinkedHashMapsortedMap = new LinkedHashMap<>();
unSortedMap.entrySet()
    .stream()
    .sorted(Map.Entry.comparingByValue())
    .forEachOrdered(x -> sortedMap.put(x.getKey(), x.getValue()));复制代码

5.5. 概括

在上面给出的示例中，我们学习了对数组、列表、映射和集合进行排序。

我们看到了初始化和使用 Comparator 接口的不同方式，包括 lambda 表达式。 我们还学习了如何有效地使用比较器接口。

快乐学习！  ！