java compare排序怎么忽略为空 java comparator排序顺序

转载

mob6454cc620c34 2024-06-25 08:36:03

文章标签 Java 增强排序 List Test 文章分类 Java 后端开发

概述

常用到对Java对数组对象进行排序，今天来总结一下，Java对排序问题的处理。Java排序一般包括基础排序和Lambda Comparator增强排序。目的时为了凸显增强排序的优势。

准备

我们先定义一个简单的实体类：

public class Flux {
    private String name;
    private int age;

    public Flux(final String name, final int age) {
        this.name = name;
        this.age = age;
    }
}

基本排序

对集合排序时，为Comparator创建一个匿名内部类用来排序：

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

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

@Test
public void givenPreLambda_whenSortingEntitiesByName_thenCorrectlySorted() {
    List<Flux> fluxs= Lists.newArrayList(new Flux("a", 10), new Flux("b", 12));
    Collections.sort(fluxs, new Comparator<Flux>() {
        @Override
        public int compare(Fluxh1, Fluxh2) {
            return h1.getName().compareTo(h2.getName());
        }
    });
    Assert.assertThat(fluxs.get(0), equalTo(new Flux("c", 12)));
}

使用Lambda表达式的基本排序

Lambda表达式的描述，只使用简单实用的语义即可。

(final Fluxh1, final Fluxh2) -> h1.getName().compareTo(h2.getName());

类似地，测试方法：

@Test
public void whenSortingEntitiesByName_thenCorrectlySorted() {
    List<Flux> fluxs= Lists.newArrayList(new Flux("a", 10), new Flux("c", 12));

    fluxs.sort((Fluxh1, Fluxh2) -> h1.getName().compareTo(h2.getName()));
    Assert.assertThat(fluxs.get(0), equalTo(new Flux("c", 12)));
}

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

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

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

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

测试方法：

@Test
public void givenLambdaShortForm_whenSortingEntitiesByName_thenCorrectlySorted() {
    List<Flux> fluxs= Lists.newArrayList(new Flux("a", 10), new Flux("c", 12));
    fluxs.sort((h1, h2) -> h1.getName().compareTo(h2.getName()));
    Assert.assertThat(fluxs.get(0), equalTo(new Flux("c", 12)));
}

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

下面使用带有静态方法引用的Lambda表达式去进行排序。

首先，要定义compareByNameThenAge方法 ——这个方法拥有与Comparator对象里的compareTo方法完全相同：

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

现在，使用这个引用去调用fluxs.sort方法：

fluxs.sort(Flux::compareByNameThenAge);

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

@Test
public void givenMethodDefinition_whenSortingEntitiesByNameThenAge_thenCorrectlySorted() {
    List<Flux> fluxs = Lists.newArrayList(new Flux("a", 10), new Flux("c", 12));

    fluxs.sort(Flux::compareByNameThenAge);
    Assert.assertThat(fluxs.get(0), equalTo(new Flux("c", 12)));
}

提取Comparator进行排序

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

准备使用getName() getter方法去建造Lambda表达式并通过name对列表进行排序：

@Test
public void givenInstanceMethod_whenSortingByNameThenAge_thenCorrectlySorted() {
    List<Flux> fluxs = Lists.newArrayList(new Flux("a", 10), new Flux("c", 12));

    Collections.sort(fluxs, Comparator.comparing(Flux::getName));
    Assert.assertThat(fluxs.get(0), equalTo(new Flux("c", 12)));
}

反转排序

JDK 8提供了一个方法用来反转Comparator（reverse Comparator）——可以快速地反转排序结果：

@Test
public void whenSortingByNameReversed_thenCorrectlySorted() {
    List<Flux> fluxs = Lists.newArrayList(
      new Flux("a", 10), new Flux("c", 12));
    Comparator<Flux> comparator = (h1, h2) -> h1.getName().compareTo(h2.getName());

    fluxs.sort(comparator.reversed());
    Assert.assertThat(fluxs.get(0), equalTo(new Flux("a", 10)));
}

多条件排序

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

@Test
public void whenSortingEntitiesByNameThenAge_thenCorrectlySorted() {
    List<Flux> fluxs = Lists.newArrayList(
      new Flux("a", 12), new Flux("a", 10), new Flux("z", 12));

    fluxs.sort((lhs, rhs) -> {
        if (lhs.getName().equals(rhs.getName())) {
            return lhs.getAge() - rhs.getAge();
        } else {
            return lhs.getName().compareTo(rhs.getName());
        }
    });
    Assert.assertThat(fluxs.get(0), equalTo(new Flux("a", 10)));
}

多条件组合排序

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

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

@Test
public void compositionSortedByNameThenAge() {
    List<Flux> fluxs = Lists.newArrayList(
      new Flux("a", 12), new Flux("a", 10), new Flux("z", 12));

    fluxs.sort(Comparator.comparing(Flux::getName).thenComparing(Flux::getAge));
    Assert.assertThat(fluxs.get(0), equalTo(new Flux("a", 10)));
}