标签：方法 instance ogr err array 能力 null local 直接
comparator 是javase中的接口，位于java.util包下，该接口抽象度极高，有必要掌握该接口的使用comparator是用来排序，但我想说排序是comparator能实现的功能之一，他不仅限于排序
Comparator接口代表一个比较器，比较器具有可比性！平时我们大多数都是使用改接口（Comparator）实现对集合，排序。这是
因为JAVASE数组工具类和集合工具类中提供的sort方法sort就是使用Comparator接口来处理排序的,但是Comparator接口并不只是
用来排序的，下面是JAVASE一些使用到Comparator接口的地方：
Arrays.sort(T[],Comparator<? super T> c);
Collections.sort(List<T> list,Comparator<? super T> c);
什么场景需要做比较，那么什么场景就是Comparator接口的用武之地，我总结的两个场景：
在List或数组中的对象如果没有实现Comparable接口时，那么就需要调用者为需要排序的数组或List设置一个Compartor，Compartor的compare方法用来告诉代码应该怎么去比较两个实例，然后根据比较结果进行排序。
public class SortTest {
@Data
@AllArgsConstructor
@ToString
class Dog{ //内部类
public int age;
public String name;
public String num;
}
List<Dog> list= new ArrayList<Dog>(){
{
add(new Dog(5, "DogA","001"));
add(new Dog(5, "DogB","002"));
add(new Dog(5, "DogC","003"));
add(new Dog(9, "DogA","004"));
add(new Dog(35, "DogF","005"));
add(new Dog(74, "Dogg","006"));
}
};
}
/**
*单一条件排序
*/
@Test
public void test1(){
//按照年龄排序
Collections.sort(list, new Comparator<Dog>() {
//实现compare(T o1, To2) 方法，返回正数，零，负数各代表大于，等于小于
@Override
public int compare(Dog o1, Dog o2) {
//return o2.age - o1.age; //排序规则----升序
return String.valueOf(o1.getAge()).compareTo(String.valueOf(o2.getAge())); //compareTo（）传String
}
});
System.out.println("给狗狗按照年龄倒序："+list);
}
@Test
public void test2(){
//按照名字排序
Collator comparator = Collator.getInstance(Locale.CANADA);
Collections.sort(list, new Comparator<Dog>() {
@Override
public int compare(Dog o1, Dog o2) {
// return o1.name.compareTo(o2.name);
return comparator.compare(o1.getName(),o2.getName());
}
});
System.out.println("给狗狗按名字字母顺序排序："+list);
}
/**
*使用Lambda表达式优化比较器代码(单一条件排序)
*/
@Test
public void test3() {
//对学生集合按年龄进行排序
Collections.sort(list,(s1, s2) -> (s1.getAge() - s2.getAge()) );
}
/**
*多条件排序
*/
@Test
public void test4() {
Collections.sort(list,new Comparator<Dog>() {
@Override
public int compare(Dog s1, Dog s2) {
int flag;
// 首选按年龄升序排序
flag = s1.getAge()-s2.getAge();
if(flag==0){
// 如果年龄按编号降序排序
flag = s2.getNum().compareTo(s1.getNum());
}
return flag;
}
});
list.forEach(System.out::println);
}
/**
*多条件排序 ----使用lambda表达式优化
*/
@Test
public void test5() {
Collections.sort(list,(s1,s2)->{
int flag;
// 首选按年龄升序排序
flag = s1.getAge()-s2.getAge();
// 方案一、判断是否为空 --- 为空执行lambda表达式，返回一个对象
flag = Optional.ofNullable(flag == 0 ? null: flag).orElseGet(() -> s2.getNum().compareTo(s1.getNum()));
//方案二、
if(flag==0){
// 如果年龄按编号降序排序
flag =s2.getNum().compareTo(s1.getNum());
}
//最终返回
return flag;
});
list.forEach(System.out::println);
}
/**
*自定义条件排序
*/
//定义排序规则 通过asList()方法将数组转为list集合
String[] order = {"语文","数学","英语","物理","化学","生物","政治","历史","地理","总分"};
final List<String> definedOrder = Arrays.asList(order);
//需要排序的数据
List<String> listClass = new ArrayList<String>(){
{
add("总分");
add("英语");
add("政治");
add("总分");
add("数学");
}
};
//自定义条件排序方案一
@Test
public void test6(){
Collections.sort(listClass,new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
//int indexOf(String str) ：返回第一次出现的指定子字符串在此字符串中的索引。
int io1 = definedOrder .indexOf(o1);
int io2 = definedOrder .indexOf(o2);
return io1-io2;
}
});
for(String s:listClass){
System.out.print(s+" ");
}
//打印结果：数学 英语 政治 总分 总分
}
//自定义条件排序方案二 使用Lambda表达式优化比较器代码
@Test
public void test7(){
Collections.sort(listClass,(s1,s2)->definedOrder.indexOf(s1) - definedOrder.indexOf(s2));
listClass.forEach(System.out::print);
}
使用Comparator和for循环处理列表，来进行分类；通过调用者实现Comparator接口的比较逻辑，来告诉程序应该怎么比较，通过比较之后得结果来进行分组。
-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
下面例子中分别按照狗狗的颜色和体重级别两个维度来进行分组，因此分组的核心逻辑其实就是比较逻辑。相面我抽了一个工具方法：dividerList,第一个参数为需要处理的数据源，第二参数是分组时的比较逻辑。
@Data
@AllArgsConstructor
@ToString
class Apple {
public String color;
public int weight;
}
List<Apple> list = new ArrayList<Apple>(){
{
add(new Apple("红", 205));
add(new Apple("红", 131));
add(new Apple("绿", 248));
add(new Apple("绿", 22));
add(new Apple("黄", 119));
add(new Apple("黄", 224));
add(new Apple("白", 2024));
}
};
/**
* 是否为同一组的判断标准 参数一：需要处理的数据源 datas，参数二分组时的比较逻辑c
*/
public static <T> List<List<T>> divider(Collection<T> datas, Comparator<? super T> c) {
List<List<T>> result = new ArrayList<List<T>>();
for (T t : datas) {
boolean isSameGroup = false;
for (int j = 0; j < result.size(); j++) {
if (c.compare(t, result.get(j).get(0)) == 0) {
isSameGroup = true;
result.get(j).add(t);
break;
}
}
if (!isSameGroup) {
// 创建
List<T> innerList = new ArrayList<T>();
result.add(innerList);
innerList.add(t);
}
}
return result;
}
@Test
public void test1(){
List<List<Apple>> byColors = divider(list, new Comparator<Apple>() {
//按照颜色基本进行分组
@Override
public int compare(Apple o1, Apple o2) {
// 按颜色分组
return o1.color.compareTo(o2.color);
}
});
System.out.println("按颜色分组" + byColors);
}
/**
*使用lambda优化（按照颜色分组）
*/
@Test
public void test1_1() {
//按照颜色重量级分组
divider_Lambda(list, (o1, o2) -> o1.color.compareTo(o2.color)).forEach(System.out::println);
}
@Test
public void test2(){
//按照重量级进行分组
List<List<Apple>> byWeight = divider(list, new Comparator<Apple>() {
@Override
public int compare(Apple o1, Apple o2) {
// 按重量级
return (o1.getWeight() / 100 == o2.getWeight() / 100) ? 0 : 1;
}
});
byWeight.forEach(x-> System.out.println("按照总量分组："+x));
//System.out.println("按重量级分组" + byWeight);
}
/**
*使用lambda优化（按照重量级进行分组）
*/
@Test
public void test2_1() {
//按照颜色分组
divider_Lambda(list, (o1, o2) -> (o1.getWeight() / 100 == o2.getWeight() / 100) ? 0 : 1).forEach(System.out::println);
}
package com.zy.pagehelper.model;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.math.BigDecimal;
@Data
@NoArgsConstructor
@Builder
public class Persons implements Comparable {
private String name;
private BigDecimal age;
private Integer height;
private Student student;
public Persons(String name, BigDecimal age, Integer height) {
this.name = name;
this.age = age;
this.height = height;
this.student = new Student(0);
}
public Persons(String name, BigDecimal age, Integer height, Student student) {
this.name = name;
this.age = age;
this.height = height;
this.student = student;
}
@Override
public int compareTo(Object o) {
Persons p1 = (Persons) o;
if (this.age.equals(p1.age)) {
return p1.height - this.height;
}
return this.age.compareTo(p1.age);
}
}
package com.zy.pagehelper.model;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.Comparator;
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Student implements Comparator {
private int age;
@Override
public int compare(Object o1, Object o2) {
Student p1 = (Student) o1;
Student p2 = (Student) o2;
int result = Integer.compare(p1.age, p2.age);
result = result == 0 ? ((p1.age > p2.age) ? 1 : -1) : result;
return result;
}
}
Persons persons = new Persons();
List<Persons> personList = new ArrayList<Persons>() {
{
add(new Persons("a", new BigDecimal(12), 170));
add(new Persons("b", new BigDecimal(24), 175, new Student(27)));
add(new Persons("c", new BigDecimal(12), 177));
add(new Persons("a", new BigDecimal(12), 177));
add(new Persons("b", new BigDecimal(54), 174, new Student(19)));
}
};
naturalOrder - 自然比较，根据实体类定义的Comparable进行比较！
示例代码：
@Test
public void testNaturalOrder(){
// naturalOrder 自然比较，根据实体类定义的Comparable
System.out.println("naturalOrder : ");
personList.sort(Comparator.naturalOrder());
personList.forEach(System.out::println);
}
comparing、comparingLong、comparingInt、comparingDouble - 常用比较方法，可以指定参数类型
comparing方法参数是一个函数式接口keyExtractor，意识即为指定排序对象中的排序键，这里注意排序键这里标注了Comparable接口
comparing方法
/**
* Accepts a function that extracts a {@link java.lang.Comparable
* Comparable} sort key from a type {@code T}, and returns a {@code
* Comparator<T>} that compares by that sort key.
*
* <p>The returned comparator is serializable if the specified function
* is also serializable.
*
* @apiNote
* For example, to obtain a {@code Comparator} that compares {@code
* Person} objects by their last name,
*
* <pre>{@code
* Comparator<Person> byLastName = Comparator.comparing(Person::getLastName);
* }</pre>
*/
public static <T, U extends Comparable<? super U>> Comparator<T> comparing(
Function<? super T, ? extends U> keyExtractor)
{
Objects.requireNonNull(keyExtractor);
return (Comparator<T> & Serializable)
(c1, c2) -> keyExtractor.apply(c1).compareTo(keyExtractor.apply(c2));
}
comparing方法参数是一个函数式接口keyExtractor，意识即为指定排序对象中的排序键，这里注意排序键这里标注了Comparable接口。
同时我们也可以看到有重载的comparing方法：
/**
* Accepts a function that extracts a sort key from a type {@code T}, and
* returns a {@code Comparator<T>} that compares by that sort key using
* the specified {@link Comparator}.
*
* <p>The returned comparator is serializable if the specified function
* and comparator are both serializable.
*
* @apiNote
* For example, to obtain a {@code Comparator} that compares {@code
* Person} objects by their last name ignoring case differences,
*
* <pre>{@code
* Comparator<Person> cmp = Comparator.comparing(
* Person::getLastName,
* String.CASE_INSENSITIVE_ORDER);
* }</pre>
*/
public static <T, U> Comparator<T> comparing(
Function<? super T, ? extends U> keyExtractor,
Comparator<? super U> keyComparator)
{
Objects.requireNonNull(keyExtractor);
Objects.requireNonNull(keyComparator);
return (Comparator<T> & Serializable)
(c1, c2) -> keyComparator.compare(keyExtractor.apply(c1),
keyExtractor.apply(c2));
}
第二个参数也很好理解，提取完sort key之后，要定义关于这个key的Comparator，在注释中的例子也比较好理解。 这里有个小tips：在String类中，提供了一个实现Comparator接口的常量来标识不对语言敏感的字典序排序器。
/**
* A Comparator that orders {@code String} objects as by
* {@code compareToIgnoreCase}. This comparator is serializable.
* <p>
* Note that this Comparator does <em>not</em> take locale into account,
* and will result in an unsatisfactory ordering for certain locales.
* The java.text package provides <em>Collators</em> to allow
* locale-sensitive ordering.
*
* @see java.text.Collator#compare(String, String)
* @since 1.2
*/
public static final Comparator<String> CASE_INSENSITIVE_ORDER
= new CaseInsensitiveComparator();
private static class CaseInsensitiveComparator
implements Comparator<String>, java.io.Serializable {
// use serialVersionUID from JDK 1.2.2 for interoperability
private static final long serialVersionUID = 8575799808933029326L;
public int compare(String s1, String s2) {
int n1 = s1.length();
int n2 = s2.length();
int min = Math.min(n1, n2);
for (int i = 0; i < min; i++) {
char c1 = s1.charAt(i);
char c2 = s2.charAt(i);
if (c1 != c2) {
c1 = Character.toUpperCase(c1);
c2 = Character.toUpperCase(c2);
if (c1 != c2) {
c1 = Character.toLowerCase(c1);
c2 = Character.toLowerCase(c2);
if (c1 != c2) {
// No overflow because of numeric promotion
return c1 - c2;
}
}
}
}
return n1 - n2;
}
/** Replaces the de-serialized object. */
private Object readResolve() { return CASE_INSENSITIVE_ORDER; }
}
// 这里其实可以看到compareToIgnoreCase也是调用了这个实例的compare方法
public int compareToIgnoreCase(String str) {
return CASE_INSENSITIVE_ORDER.compare(this, str);
}
在Comparator接口中，也直接提供了具体类型的三个comparing方法：
public static <T> Comparator<T> comparingInt(ToIntFunction<? super T> keyExtractor) {
Objects.requireNonNull(keyExtractor);
return (Comparator<T> & Serializable)
(c1, c2) -> Integer.compare(keyExtractor.applyAsInt(c1), keyExtractor.applyAsInt(c2));
}
public static <T> Comparator<T> comparingLong(ToLongFunction<? super T> keyExtractor) {
Objects.requireNonNull(keyExtractor);
return (Comparator<T> & Serializable)
(c1, c2) -> Long.compare(keyExtractor.applyAsLong(c1), keyExtractor.applyAsLong(c2));
}
public static<T> Comparator<T> comparingDouble(ToDoubleFunction<? super T> keyExtractor) {
Objects.requireNonNull(keyExtractor);
return (Comparator<T> & Serializable)
(c1, c2) -> Double.compare(keyExtractor.applyAsDouble(c1), keyExtractor.applyAsDouble(c2));
}
测试示例代码：
@Test
public void testComparing(){
//comparing、comparingLong、comparingInt、comparingDouble - 常用比较方法，可以指定参数类型
// comparing 1.0 比较集合中对象的年龄，取最大值
Optional<Persons> optional = personList.stream().max(Comparator.comparing(Persons::getAge));
System.out.println("comparing 1.0 : get max age " + optional.get().toString() + "\n");
// comparing 2.1
optional = personList.stream().max(Comparator.comparing(Persons::getName, Comparator.reverseOrder()));
System.out.println("comparing 2.1 : get min name " + optional.get().toString() + "\n");
// comparing 2.2
optional = personList.stream().max(Comparator.comparing(Persons::getName, String::compareTo));
System.out.println("comparing 2.2 : get max name " + optional.get().toString() + "\n");
// comparing 2.3 该方法多了一个参数 keyComparator ，keyComparator 是创建一个自定义的比较器。示例种：通过cmmpare()方法进行学生年龄比较，
optional = personList.stream().max(Comparator.comparing(Persons::getStudent, (o1, o2) -> new Student().compare(o1, o2)));
System.out.println("comparing 2.3 : get max student.age " + optional.get().toString() + "\n");
}
/*
打印结果
comparing 1.0 : get max age Persons(name=b, age=54, height=174, student=Student(age=19))
comparing 2.1 : get min name Persons(name=a, age=12, height=170, student=Student(age=0))
comparing 2.2 : get max name Persons(name=c, age=12, height=177, student=Student(age=0))
comparing 2.3 : get max student.age Persons(name=b, age=24, height=175, student=Student(age=27))
*/
// 升序 comparing方法的具体实现一comparingInt
System.out.println("升序 : ");
personList.sort(Comparator.comparingInt(Persons::getHeight));
personList.forEach(System.out::println);
// 降序 comparing方法的具体实现二comparingInt
System.out.println("降序 : ");
personList.sort(Comparator.comparingInt(Persons::getHeight).reversed());
personList.forEach(System.out::println);
/**
* Returns a lexicographic-order comparator with another comparator.
* If this {@code Comparator} considers two elements equal, i.e.
* {@code compare(a, b) == 0}, {@code other} is used to determine the order.
*
* <p>The returned comparator is serializable if the specified comparator
* is also serializable.
*
* @apiNote
* For example, to sort a collection of {@code String} based on the length
* and then case-insensitive natural ordering, the comparator can be
* composed using following code,
*
* <pre>{@code
* Comparator<String> cmp = Comparator.comparingInt(String::length)
* .thenComparing(String.CASE_INSENSITIVE_ORDER);
* }</pre>
*/
default Comparator<T> thenComparing(Comparator<? super T> other) {
Objects.requireNonNull(other);
return (Comparator<T> & Serializable) (c1, c2) -> {
int res = compare(c1, c2);
return (res != 0) ? res : other.compare(c1, c2);
};
}
从方法名称上知道这是当比较相同时的使用的一个排序规则，这里需要注意看具体实现是会先调用比较器实例中的compare方法来进行比较一轮，当结果等于0的时候才会调用other这个比较器规则进行比较。比如下面的一个DOME：
List<String> strings = Arrays.asList("def", "abc", "hel", "world");
strings.sort(Comparator.comparingInt(String::length).reversed() //（1）
.thenComparing(String::compareToIgnoreCase) // （2）
.thenComparing(Comparator.reverseOrder()) // （3）这个比较器不会被应用 因为比较器（2）已经把结果比较出来了，并且没有相等的结果，这里不会再应用（3）比较器
);
System.out.println(strings); // 输出[world, abc, def, hel]
当然因为有了 comparing方法的支持，所以也就有了下面两个thenComparing的重载方法
default <U extends Comparable<? super U>> Comparator<T> thenComparing(
Function<? super T, ? extends U> keyExtractor)
{
return thenComparing(comparing(keyExtractor));
}
default <U> Comparator<T> thenComparing(
Function<? super T, ? extends U> keyExtractor,
Comparator<? super U> keyComparator)
{
return thenComparing(comparing(keyExtractor, keyComparator));
}
测试示例代码：
@Test
public void test2(){
//根据第一个属性进行排序，如果相同则以此根据下一个thenComparing（）中的属性进行排序
// thenComparing 1.0
System.out.println("thenComparing 1.0 : ");
personList.sort(Comparator.comparing(Persons::getAge));
personList.forEach(System.out::println);
// thenComparing 1.1
System.out.println("thenComparing 1.1 : ");
personList.sort(Comparator.comparing(Persons::getAge).thenComparing(Persons::getHeight));
personList.forEach(System.out::println);
// thenComparing 2.0
System.out.println("thenComparing 2.0 : ");
personList.sort(Comparator.comparing(Persons::getAge).thenComparing(Persons::getHeight).thenComparing(Persons::getName));
personList.forEach(System.out::println);
}
Comparator接口中有两个对null友好的比较器方法：
/**
* Returns a null-friendly comparator that considers {@code null} to be
* less than non-null. When both are {@code null}, they are considered
* equal. If both are non-null, the specified {@code Comparator} is used
* to determine the order. If the specified comparator is {@code null},
* then the returned comparator considers all non-null values to be equal.
*
* <p>The returned comparator is serializable if the specified comparator
* is serializable.
*
* @param <T> the type of the elements to be compared
* @param comparator a {@code Comparator} for comparing non-null values
* @return a comparator that considers {@code null} to be less than
* non-null, and compares non-null objects with the supplied
* {@code Comparator}.
* @since 1.8
*/
public static <T> Comparator<T> nullsFirst(Comparator<? super T> comparator) {
return new Comparators.NullComparator<>(true, comparator);
}
// null比非null元素都大的
public static <T> Comparator<T> nullsLast(Comparator<? super T> comparator) {
return new Comparators.NullComparator<>(false, comparator);
}
这里是通过Comparators这个工厂类提供的NullComparator比较器实现的，看到注释有一条需要注意是如果不指定comparator参数，即传入null，那么所有的非null参数都会被视为相等。
当集合中存在null元素时，可以使用针对null友好的比较器，null元素排在集合的最前面/最后面
测试示例代码
@Test
public void testNulls() {
// nullsLast
System.out.println("nullsLast : ");
personList.sort(Comparator.nullsLast(Comparator.comparing(Persons::getName)));
personList.forEach(System.out::println);
// nullsFirst
System.out.println("nullsFirst : ");
personList.sort(Comparator.nullsFirst(Comparator.comparing(Persons::getName)));
personList.forEach(System.out::println);
}
这两个接口首先要做一个简单区别。
* Lists (and arrays) of objects that implement this interface can be sorted
* automatically by {@link Collections#sort(List) Collections.sort} (and
* {@link Arrays#sort(Object[]) Arrays.sort}). Objects that implement this
* interface can be used as keys in a {@linkplain SortedMap sorted map} or as
* elements in a {@linkplain SortedSet sorted set}, without the need to
* specify a {@linkplain Comparator comparator}.<p>
可以看到注释中说明了实现了该接口的对象，在数组中可以使用Collections.sort或者Arrays.sort方法实现排序，或者实现了该接口的对象可以作为sortedMap或者SortedSet的key。这里也提到我们不用制定一个排序或者作为key的Comparator接口。
public interface Comparable<T> {
/**
* 省略部分注释
* <p>The implementor must ensure <tt>sgn(x.compareTo(y)) ==
* -sgn(y.compareTo(x))</tt> for all <tt>x</tt> and <tt>y</tt>. (This
* implies that <tt>x.compareTo(y)</tt> must throw an exception iff
* <tt>y.compareTo(x)</tt> throws an exception.)
*/
public int compareTo(T o);
}
在compareTo方法上的注释中提到，必须确保 x.compareTo(y)和y.compareTo(x)的结果是一致的，并且这也意味着当x.compartTo(y)抛出一个异常，那么y.compareTo(x)也应该去抛出一个异常，那么这里就思考到了一个关于null的设计：null.compareTo(obj)我们肯定知道会有NPE，那么你在实现compareTo方法的时候，如果obj.compareTo(null)这里也应该去抛出NPE。
这里就不去写具体的demo去演示了，这里理解为一个对象实现了Comparable接口，那么这个对象就是可比较的，并且在排序等场景下调用实现接口中的compareTo方法。
Comparator接口要理解为比较器，实现其接口的类其实是比较器的一种实现，相当于一个比较的函数定义。来看下他的注释：
* A comparison function, which imposes a <i>total ordering</i> on some
* collection of objects. Comparators can be passed to a sort method (such
* as {@link Collections#sort(List,Comparator) Collections.sort} or {@link
* Arrays#sort(Object[],Comparator) Arrays.sort}) to allow precise control
* over the sort order. Comparators can also be used to control the order of
* certain data structures (such as {@link SortedSet sorted sets} or {@link
* SortedMap sorted maps}), or to provide an ordering for collections of
* objects that don‘t have a {@link Comparable natural ordering}.<p>
这里我们看到Arrays、Collections也提供了重载的sort方法，支持传入一个集合/数组和Comparator接口的实例。当然当前列表/数组中的对象不一定是实现了Comparable接口。
类实现了comparable接口之后，可以直接调用排序方法；而当使用comparator时，不需要类实现，具体使用时（也就是调用某些方法时）的需要类和该comparator绑定起来来实现。comparable实现内部排序，Comparator是外部排序。
标签：方法 instance ogr err array 能力 null local 直接
原文地址：https://www.cnblogs.com/MrYuChen-Blog/p/14012428.html
