用Java8来排排序

1、定义简单实体类

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Human {

    private String name;
    private int age;

}

2、不使用Lambda表达式的基本排序

在Java 8之前，对集合进行排序要为Comparator创建一个匿名内部类用来排序：

new Comparator<Human>() {
    @Override
    public int compare(Human h1, Human h2) {
        return h1.getName().compareTo(h2.getName());
    }
}

简单地用它来对Human实体列表进行排序：

public void sortDemoA() {
    List<Human> humanList = Lists.newArrayList();
    humanList.add(new Human("human1", 60));
    humanList.add(new Human("human2", 50));
    humanList.add(new Human("human3", 40));
    humanList.add(new Human("human4", 30));
    humanList.add(new Human("human5", 20));
    humanList.add(new Human("human6", 10));

    // 打乱集合顺序
    Collections.shuffle(humanList);

    System.out.println("打乱集合后，排序前：");
    humanList.forEach(human -> System.out.println(human.getName() + " -> " + human.getAge()));

    Collections.sort(humanList, new Comparator<Human>() {
        @Override
        public int compare(Human h1, Human h2) {
            return h1.getName().compareTo(h2.getName()); // 根据name排序
        }
    });

    System.out.println("打乱集合后，排序后：");
    humanList.forEach(human -> System.out.println(human.getName() + " -> " + human.getAge()));
}

以上代码输出：

打乱集合后，排序前：
human1 -> 60
human6 -> 10
human2 -> 50
human4 -> 30
human5 -> 20
human3 -> 40
打乱集合后，排序后：
human1 -> 60
human2 -> 50
human3 -> 40
human4 -> 30
human5 -> 20
human6 -> 10

将根据name排序改为根据age排序，在compare方法中改为：

1	return h1.getAge() - h2.getAge(); // 根据age排序

输出：

打乱集合后，排序前：
human3 -> 40
human4 -> 30
human2 -> 50
human1 -> 60
human6 -> 10
human5 -> 20
打乱集合后，排序后：
human6 -> 10
human5 -> 20
human4 -> 30
human3 -> 40
human2 -> 50
human1 -> 60

3、使用Lambda表达式的基本排序

根据Lambda表达式的介绍，我们现在可以不使用匿名内部类，只使用简单实用的语义就可以得到相同的结果。

1	(Human h1, Human h2) -> h1.getName().compareTo(h2.getName());

代码：

public void sortDemoA() {
    List<Human> humanList = Lists.newArrayList();
    humanList.add(new Human("human1", 60));
    humanList.add(new Human("human2", 50));
    humanList.add(new Human("human3", 40));
    humanList.add(new Human("human4", 30));
    humanList.add(new Human("human5", 20));
    humanList.add(new Human("human6", 10));

    // 打乱集合顺序
    Collections.shuffle(humanList);

    System.out.println("打乱集合后，排序前：");
    humanList.forEach(human -> System.out.println(human.getName() + " -> " + human.getAge()));

    // Change
    humanList.sort((Human h1, Human h2) -> h1.getName().compareTo(h2.getName()));

    System.out.println("打乱集合后，排序后：");
    humanList.forEach(human -> System.out.println(human.getName() + " -> " + human.getAge()));
}

注意：我们同样使用新的sort API，这个API在Java 8里被添加到java.util.List ——而不是旧的Collections.sort API。

4、没有类型定义（ Type Definitions）的基本排序

我们通过不指定类型定义来进一步简化表达式 ————编译器自己可以进行类型判断：

1	(h1, h2) -> h1.getName().compareTo(h2.getName())

代码：

public void sortDemoA() {
    List<Human> humanList = Lists.newArrayList();
    humanList.add(new Human("human1", 60));
    humanList.add(new Human("human2", 50));
    humanList.add(new Human("human3", 40));
    humanList.add(new Human("human4", 30));
    humanList.add(new Human("human5", 20));
    humanList.add(new Human("human6", 10));

    // 打乱集合顺序
    Collections.shuffle(humanList);

    System.out.println("打乱集合后，排序前：");
    humanList.forEach(human -> System.out.println(human.getName() + " -> " + human.getAge()));

    // Change
    humanList.sort((Human h1, Human h2) -> h1.getName().compareTo(h2.getName()));

    System.out.println("打乱集合后，排序后：");
    humanList.forEach(human -> System.out.println(human.getName() + " -> " + human.getAge()));
}

5、使用静态方法的引用来排序

下面我们将要使用带有静态方法引用的Lambda表达式去进行排序。
首先，我们要定义compareByNameThenAge方法 ——这个方法拥有与Comparator对象里的compareTo方法完全相同的签名：

在Human类中加入：

public static int compareByNameThenAge(Human lhs, Human rhs) {
    if (lhs.name.equals(rhs.name)) {
        return lhs.age - rhs.age;
    } else {
        return lhs.name.compareTo(rhs.name);
    }
}

使用：

1	humanList.sort(Human::compareByNameThenAge);

最终结果是一个使用静态方法作为Comparator的有效的排序集合：

public void sortDemoA() {
    List<Human> humanList = Lists.newArrayList();
    humanList.add(new Human("human1", 60));
    humanList.add(new Human("human2", 50));
    humanList.add(new Human("human3", 40));
    humanList.add(new Human("human4", 30));
    humanList.add(new Human("human5", 20));
    humanList.add(new Human("human6", 10));

    // 打乱集合顺序
    Collections.shuffle(humanList);

    System.out.println("打乱集合后，排序前：");
    humanList.forEach(human -> System.out.println(human.getName() + " -> " + human.getAge()));

    humanList.sort(Human::compareByNameThenAge);

    System.out.println("打乱集合后，排序后：");
    humanList.forEach(human -> System.out.println(human.getName() + " -> " + human.getAge()));
}

6、提取Comparator进行排序

我们可以通过使用实例方法的引用和Comparator.comparing方法来避免定义比较逻辑——它会提取和创建一个基于那个函数的Comparable。
这个方法值得记住：

public void sortDemoA() {
    List<Human> humanList = Lists.newArrayList();
    humanList.add(new Human("human1", 60));
    humanList.add(new Human("human2", 50));
    humanList.add(new Human("human3", 40));
    humanList.add(new Human("human4", 30));
    humanList.add(new Human("human5", 20));
    humanList.add(new Human("human6", 10));

    // 打乱集合顺序
    Collections.shuffle(humanList);

    System.out.println("打乱集合后，排序前：");
    humanList.forEach(human -> System.out.println(human.getName() + " -> " + human.getAge()));

    humanList.sort(Comparator.comparing(Human::getName)); //根据name排序
    // humanList.sort(Comparator.comparing(Human::getAge)); //根据age排序

    System.out.println("打乱集合后，排序后：");
    humanList.forEach(human -> System.out.println(human.getName() + " -> " + human.getAge()));
}

7、反转排序

JDK 8同样提供了一个有用的方法用来反转Comparator（reverse Comparator）——我们可以快速地利用它来反转我们的排序：

1	humanList.sort(comparator.reversed());

8、多条件排序

比较操作的Lambda表达式不一定都是这么简单的——我们同样可以编写更复杂的表达式，比如先根据name后根据age来对实体进行排序：

humanList.sort((lhs, rhs) -> {
    if (lhs.getName().equals(rhs.getName())) {
        return lhs.getAge() - rhs.getAge();
    } else {
        return lhs.getName().compareTo(rhs.getName());
    }
});

9、多条件组合排序

同样的比较逻辑——先根据name进行排序其次是age，同样可以通过Comparator新的组合支持来实现。

从JDK 8开始，我们现在可以把多个Comparator链在一起（chain together）去建造更复杂的比较逻辑：

1	humanList.sort(Comparator.comparing(Human::getName).thenComparing(Human::getAge));

Tips

1、流操作

还可以引入jdk8中的流来操作集合：

1
2
3

humanList.stream()
    .sorted(Comparator.comparing(Human::getName).thenComparing(Human::getAge))
    .collect(Collectors.toList());

但是要注意，流操作中不改变原来的集合，即上述代码没有改变humanList中元素的顺序，应该要用一个新的list来接收流的返回值：

public void sortDemoA() {
    List<Human> humanList = Lists.newArrayList();
    humanList.add(new Human("human1", 60));
    humanList.add(new Human("human2", 50));
    humanList.add(new Human("human3", 40));
    humanList.add(new Human("human3", 30));
    humanList.add(new Human("human5", 20));
    humanList.add(new Human("human6", 10));

    // 打乱集合顺序
    Collections.shuffle(humanList);

    System.out.println("打乱集合后，排序前：");
    humanList.forEach(human -> System.out.println(human.getName() + " -> " + human.getAge()));

    List<Human> sortedList = humanList.stream()
        .sorted(Comparator.comparing(Human::getName).thenComparing(Human::getAge))
        .collect(Collectors.toList());

    System.out.println("打乱集合后，排序后：");
    sortedList.forEach(human -> System.out.println(human.getName() + " -> " + human.getAge()));
}

2、实体类中hashCode和equals的处理

(参考自阿里Java开发手册)
1）只要重写 equals，就必须重写 hashCode。
2）因为 Set 存储的是不重复的对象，依据 hashCode 和 equals 进行判断，所以 Set 存储的对象必须重写这两个方法。
3）如果自定义对象作为 Map 的键，那么必须重写 hashCode 和 equals。
说明：String 重写了 hashCode 和 equals 方法，所以我们可以非常愉快地使用 String 对象作为 key 来使用。

[1]英文原文：Basic Sort without Lambdas
[2]Baeldung上的“Java ——回归基础”系列
[3]Java8学习资料

用Java8来排排序

用Java8来排排序

1、定义简单实体类

2、不使用Lambda表达式的基本排序

3、使用Lambda表达式的基本排序

4、没有类型定义（ Type Definitions）的基本排序

5、使用静态方法的引用来排序

6、提取Comparator进行排序

7、反转排序

8、多条件排序

9、多条件组合排序

Tips

1、流操作

2、实体类中hashCode和equals的处理

Read More