java.util.Comparator#thenComparing ( )源码实例Demo

下面列出了java.util.Comparator#thenComparing ( ) 实例代码,或者点击链接到github查看源代码,也可以在右侧发表评论。

源代码1 项目: openAGV   文件: CompositeOrderComparator.java
@Inject
public CompositeOrderComparator(DefaultDispatcherConfiguration configuration,
                                Map<String, Comparator<TransportOrder>> availableComparators) {
  // At the end, if all other comparators failed to see a difference, compare by age.
  // As the age of two distinct transport orders may still be the same, finally compare by name.
  // Add configured comparators before these two.
  Comparator<TransportOrder> composite
      = new TransportOrderComparatorByAge().thenComparing(new TransportOrderComparatorByName());

  for (String priorityKey : Lists.reverse(configuration.orderPriorities())) {
    Comparator<TransportOrder> configuredComparator = availableComparators.get(priorityKey);
    checkArgument(configuredComparator != null, "Unknown order priority key: %s", priorityKey);
    composite = configuredComparator.thenComparing(composite);
  }
  this.compositeComparator = composite;
}
 
@Inject
public CompositeOrderCandidateComparator(
    DefaultDispatcherConfiguration configuration,
    Map<String, Comparator<AssignmentCandidate>> availableComparators) {
  // At the end, if all other comparators failed to see a difference, compare by age.
  // As the age of two distinct transport orders may still be the same, finally compare by name.
  // Add configured comparators before these two.
  Comparator<AssignmentCandidate> composite
      = new CandidateComparatorByOrderAge().thenComparing(new CandidateComparatorByOrderName());

  for (String priorityKey : Lists.reverse(configuration.orderCandidatePriorities())) {
    Comparator<AssignmentCandidate> configuredComparator = availableComparators.get(priorityKey);
    checkArgument(configuredComparator != null,
                  "Unknown order candidate priority key: %s",
                  priorityKey);
    composite = configuredComparator.thenComparing(composite);
  }
  this.compositeComparator = composite;
}
 
源代码3 项目: openAGV   文件: CompositeVehicleComparator.java
@Inject
public CompositeVehicleComparator(DefaultDispatcherConfiguration configuration,
                                  Map<String, Comparator<Vehicle>> availableComparators) {
  // At the end, if all other comparators failed to see a difference, compare by energy level.
  // As the energy level of two distinct vehicles may still be the same, finally compare by name.
  // Add configured comparators before these two.
  Comparator<Vehicle> composite
      = new VehicleComparatorByEnergyLevel().thenComparing(new VehicleComparatorByName());

  for (String priorityKey : Lists.reverse(configuration.vehiclePriorities())) {
    Comparator<Vehicle> configuredComparator = availableComparators.get(priorityKey);
    checkArgument(configuredComparator != null, "Unknown vehicle priority key: %s", priorityKey);
    composite = configuredComparator.thenComparing(composite);
  }
  this.compositeComparator = composite;
}
 
@Override
public int compare(final String o1, final String o2) {
    final Matcher matcherOne = VERSION_FORMAT_REGEX.matcher(o1);
    final Matcher matcherTwo = VERSION_FORMAT_REGEX.matcher(o2);

    // Fall back to simple string comparision if either of the versions cannot be parsed
    if (!matcherOne.matches() || !matcherTwo.matches()) {
        return o1.compareTo(o2);
    }

    Comparator<Matcher> comparator = Comparator.comparing(m -> m.group("group"), Comparator.nullsFirst(Comparator.naturalOrder()));
    comparator = comparator.thenComparingInt(m -> Integer.parseInt(m.group("major")));
    comparator = comparator.thenComparing(m -> m.group("minor"), Comparator.nullsLast(Comparator.naturalOrder()));

    return comparator.compare(matcherOne, matcherTwo);
}
 
源代码5 项目: openjdk-jdk8u   文件: EntryComparators.java
public void testKVComparators() {
    // Comparator<People> cmp = Comparator.naturalOrder(); // Should fail to compiler as People is not comparable
    // We can use simple comparator, but those have been tested above.
    // Thus choose to do compose for some level of interation.
    Comparator<People> cmp1 = Comparator.comparing(People::getFirstName);
    Comparator<People> cmp2 = Comparator.comparing(People::getLastName);
    Comparator<People> cmp = cmp1.thenComparing(cmp2);

    assertPairComparison(people[0], people[0], people[1], people[1],
                     Map.Entry.<People, People>comparingByKey(cmp),
                     Map.Entry.<People, People>comparingByValue(cmp));

}
 
源代码6 项目: openjdk-8-source   文件: BasicTest.java
public void testComposeComparator() {
    // Longer string in front
    Comparator<String> first = (s1, s2) -> s2.length() - s1.length();
    Comparator<String> second = Comparator.naturalOrder();
    Comparator<String> composed = first.thenComparing(second);

    assertTrue(composed.compare("abcdefg", "abcdef") < 0);
    assertTrue(composed.compare("abcdef", "abcdefg") > 0);
    assertTrue(composed.compare("abcdef", "abcdef") == 0);
    assertTrue(composed.compare("abcdef", "ghijkl") < 0);
    assertTrue(composed.compare("ghijkl", "abcdefg") > 0);
}
 
源代码7 项目: openjdk-jdk8u-backup   文件: EntryComparators.java
public void testKVComparators() {
    // Comparator<People> cmp = Comparator.naturalOrder(); // Should fail to compiler as People is not comparable
    // We can use simple comparator, but those have been tested above.
    // Thus choose to do compose for some level of interation.
    Comparator<People> cmp1 = Comparator.comparing(People::getFirstName);
    Comparator<People> cmp2 = Comparator.comparing(People::getLastName);
    Comparator<People> cmp = cmp1.thenComparing(cmp2);

    assertPairComparison(people[0], people[0], people[1], people[1],
                     Map.Entry.<People, People>comparingByKey(cmp),
                     Map.Entry.<People, People>comparingByValue(cmp));

}
 
源代码8 项目: jdk8u-dev-jdk   文件: BasicTest.java
public void testNullsLast() {
    Comparator<String> strcmp = Comparator.nullsLast(Comparator.naturalOrder());
    Comparator<People> cmp = Comparator.comparing(People::getLastName, strcmp)
                                       .thenComparing(People::getFirstName, strcmp);
    // Mary.null vs Mary.Cook - solve by last name
    assertComparison(cmp, people[5], people[6]);
    // John.null vs Mary.null - solve by first name
    assertComparison(cmp, people[7], people[6]);

    // More than one thenComparing
    strcmp = Comparator.nullsLast(Comparator.comparingInt(String::length)
                                            .thenComparing(String.CASE_INSENSITIVE_ORDER));
    assertComparison(strcmp, "abc", null);
    assertComparison(strcmp, "ab", "abc");
    assertComparison(strcmp, "abc", "def");

    // Ensure reverse still handle null properly
    Comparator<String> strcmp2 = strcmp.reversed().thenComparing(Comparator.naturalOrder());
    assertComparison(strcmp2, null, "abc");
    assertComparison(strcmp2, "abc", "ab");
    assertComparison(strcmp2, "def", "abc");
    assertComparison(strcmp2, "ABC", "abc");

    // Considering non-null values to be equal
    Comparator<String> blind = Comparator.nullsLast(null);
    assertComparison(blind, "abc", null);
    assertEquals(0, blind.compare("abc", "def"));
    // reverse still consider non-null values to be equal
    strcmp = blind.reversed();
    assertComparison(strcmp, null, "abc");
    assertEquals(0, strcmp.compare("abc", "def"));
    // chain with another comparator to compare non-nulls
    strcmp = blind.thenComparing(Comparator.naturalOrder());
    assertComparison(strcmp, "abc", null);
    assertComparison(strcmp, "abc", "def");
}
 
源代码9 项目: jdk8u-jdk   文件: BasicTest.java
public void testNullsLast() {
    Comparator<String> strcmp = Comparator.nullsLast(Comparator.naturalOrder());
    Comparator<People> cmp = Comparator.comparing(People::getLastName, strcmp)
                                       .thenComparing(People::getFirstName, strcmp);
    // Mary.null vs Mary.Cook - solve by last name
    assertComparison(cmp, people[5], people[6]);
    // John.null vs Mary.null - solve by first name
    assertComparison(cmp, people[7], people[6]);

    // More than one thenComparing
    strcmp = Comparator.nullsLast(Comparator.comparingInt(String::length)
                                            .thenComparing(String.CASE_INSENSITIVE_ORDER));
    assertComparison(strcmp, "abc", null);
    assertComparison(strcmp, "ab", "abc");
    assertComparison(strcmp, "abc", "def");

    // Ensure reverse still handle null properly
    Comparator<String> strcmp2 = strcmp.reversed().thenComparing(Comparator.naturalOrder());
    assertComparison(strcmp2, null, "abc");
    assertComparison(strcmp2, "abc", "ab");
    assertComparison(strcmp2, "def", "abc");
    assertComparison(strcmp2, "ABC", "abc");

    // Considering non-null values to be equal
    Comparator<String> blind = Comparator.nullsLast(null);
    assertComparison(blind, "abc", null);
    assertEquals(0, blind.compare("abc", "def"));
    // reverse still consider non-null values to be equal
    strcmp = blind.reversed();
    assertComparison(strcmp, null, "abc");
    assertEquals(0, strcmp.compare("abc", "def"));
    // chain with another comparator to compare non-nulls
    strcmp = blind.thenComparing(Comparator.naturalOrder());
    assertComparison(strcmp, "abc", null);
    assertComparison(strcmp, "abc", "def");
}
 
源代码10 项目: openjdk-jdk8u   文件: BasicTest.java
public void testNullsFirst() {
    Comparator<String> strcmp = Comparator.nullsFirst(Comparator.naturalOrder());
    Comparator<People> cmp = Comparator.comparing(People::getLastName, strcmp)
                                       .thenComparing(People::getFirstName, strcmp);
    // Mary.null vs Mary.Cook - solve by last name
    assertComparison(cmp, people[6], people[5]);
    // John.null vs Mary.null - solve by first name
    assertComparison(cmp, people[7], people[6]);

    // More than one thenComparing
    strcmp = Comparator.nullsFirst(Comparator.comparingInt(String::length)
                                             .thenComparing(String.CASE_INSENSITIVE_ORDER));
    assertComparison(strcmp, null, "abc");
    assertComparison(strcmp, "ab", "abc");
    assertComparison(strcmp, "abc", "def");
    assertEquals(0, strcmp.compare("abc", "ABC"));

    // Ensure reverse still handle null properly
    Comparator<String> strcmp2 = strcmp.reversed().thenComparing(Comparator.naturalOrder());
    assertComparison(strcmp2, "abc", null);
    assertComparison(strcmp2, "abc", "ab");
    assertComparison(strcmp2, "def", "abc");
    assertComparison(strcmp2, "ABC", "abc");

    // Considering non-null values to be equal
    Comparator<String> blind = Comparator.nullsFirst(null);
    assertComparison(blind, null, "abc");
    assertEquals(0, blind.compare("abc", "def"));
    // reverse still consider non-null values to be equal
    strcmp = blind.reversed();
    assertComparison(strcmp, "abc", null);
    assertEquals(0, strcmp.compare("abc", "def"));
    // chain with another comparator to compare non-nulls
    strcmp = blind.thenComparing(Comparator.naturalOrder());
    assertComparison(strcmp, null, "abc");
    assertComparison(strcmp, "abc", "def");
}
 
源代码11 项目: dragonwell8_jdk   文件: BasicTest.java
public void testComposeComparator() {
    // Longer string in front
    Comparator<String> first = (s1, s2) -> s2.length() - s1.length();
    Comparator<String> second = Comparator.naturalOrder();
    Comparator<String> composed = first.thenComparing(second);

    assertTrue(composed.compare("abcdefg", "abcdef") < 0);
    assertTrue(composed.compare("abcdef", "abcdefg") > 0);
    assertTrue(composed.compare("abcdef", "abcdef") == 0);
    assertTrue(composed.compare("abcdef", "ghijkl") < 0);
    assertTrue(composed.compare("ghijkl", "abcdefg") > 0);
}
 
源代码12 项目: openjdk-jdk9   文件: EntryComparators.java
public void testKVComparators() {
    // Comparator<People> cmp = Comparator.naturalOrder(); // Should fail to compiler as People is not comparable
    // We can use simple comparator, but those have been tested above.
    // Thus choose to do compose for some level of interation.
    Comparator<People> cmp1 = Comparator.comparing(People::getFirstName);
    Comparator<People> cmp2 = Comparator.comparing(People::getLastName);
    Comparator<People> cmp = cmp1.thenComparing(cmp2);

    assertPairComparison(people[0], people[0], people[1], people[1],
                     Map.Entry.<People, People>comparingByKey(cmp),
                     Map.Entry.<People, People>comparingByValue(cmp));

}
 
源代码13 项目: openjdk-jdk8u-backup   文件: BasicTest.java
public void testComposeComparator() {
    // Longer string in front
    Comparator<String> first = (s1, s2) -> s2.length() - s1.length();
    Comparator<String> second = Comparator.naturalOrder();
    Comparator<String> composed = first.thenComparing(second);

    assertTrue(composed.compare("abcdefg", "abcdef") < 0);
    assertTrue(composed.compare("abcdef", "abcdefg") > 0);
    assertTrue(composed.compare("abcdef", "abcdef") == 0);
    assertTrue(composed.compare("abcdef", "ghijkl") < 0);
    assertTrue(composed.compare("ghijkl", "abcdefg") > 0);
}
 
源代码14 项目: hottub   文件: BasicTest.java
public void testComposeComparator() {
    // Longer string in front
    Comparator<String> first = (s1, s2) -> s2.length() - s1.length();
    Comparator<String> second = Comparator.naturalOrder();
    Comparator<String> composed = first.thenComparing(second);

    assertTrue(composed.compare("abcdefg", "abcdef") < 0);
    assertTrue(composed.compare("abcdef", "abcdefg") > 0);
    assertTrue(composed.compare("abcdef", "abcdef") == 0);
    assertTrue(composed.compare("abcdef", "ghijkl") < 0);
    assertTrue(composed.compare("ghijkl", "abcdefg") > 0);
}
 
源代码15 项目: jdk8u60   文件: BasicTest.java
public void testComposeComparator() {
    // Longer string in front
    Comparator<String> first = (s1, s2) -> s2.length() - s1.length();
    Comparator<String> second = Comparator.naturalOrder();
    Comparator<String> composed = first.thenComparing(second);

    assertTrue(composed.compare("abcdefg", "abcdef") < 0);
    assertTrue(composed.compare("abcdef", "abcdefg") > 0);
    assertTrue(composed.compare("abcdef", "abcdef") == 0);
    assertTrue(composed.compare("abcdef", "ghijkl") < 0);
    assertTrue(composed.compare("ghijkl", "abcdefg") > 0);
}
 
源代码16 项目: jdk8u_jdk   文件: BasicTest.java
public void testNullsFirst() {
    Comparator<String> strcmp = Comparator.nullsFirst(Comparator.naturalOrder());
    Comparator<People> cmp = Comparator.comparing(People::getLastName, strcmp)
                                       .thenComparing(People::getFirstName, strcmp);
    // Mary.null vs Mary.Cook - solve by last name
    assertComparison(cmp, people[6], people[5]);
    // John.null vs Mary.null - solve by first name
    assertComparison(cmp, people[7], people[6]);

    // More than one thenComparing
    strcmp = Comparator.nullsFirst(Comparator.comparingInt(String::length)
                                             .thenComparing(String.CASE_INSENSITIVE_ORDER));
    assertComparison(strcmp, null, "abc");
    assertComparison(strcmp, "ab", "abc");
    assertComparison(strcmp, "abc", "def");
    assertEquals(0, strcmp.compare("abc", "ABC"));

    // Ensure reverse still handle null properly
    Comparator<String> strcmp2 = strcmp.reversed().thenComparing(Comparator.naturalOrder());
    assertComparison(strcmp2, "abc", null);
    assertComparison(strcmp2, "abc", "ab");
    assertComparison(strcmp2, "def", "abc");
    assertComparison(strcmp2, "ABC", "abc");

    // Considering non-null values to be equal
    Comparator<String> blind = Comparator.nullsFirst(null);
    assertComparison(blind, null, "abc");
    assertEquals(0, blind.compare("abc", "def"));
    // reverse still consider non-null values to be equal
    strcmp = blind.reversed();
    assertComparison(strcmp, "abc", null);
    assertEquals(0, strcmp.compare("abc", "def"));
    // chain with another comparator to compare non-nulls
    strcmp = blind.thenComparing(Comparator.naturalOrder());
    assertComparison(strcmp, null, "abc");
    assertComparison(strcmp, "abc", "def");
}
 
源代码17 项目: openjdk-8-source   文件: EntryComparators.java
public void testKVComparators() {
    // Comparator<People> cmp = Comparator.naturalOrder(); // Should fail to compiler as People is not comparable
    // We can use simple comparator, but those have been tested above.
    // Thus choose to do compose for some level of interation.
    Comparator<People> cmp1 = Comparator.comparing(People::getFirstName);
    Comparator<People> cmp2 = Comparator.comparing(People::getLastName);
    Comparator<People> cmp = cmp1.thenComparing(cmp2);

    assertPairComparison(people[0], people[0], people[1], people[1],
                     Map.Entry.<People, People>comparingByKey(cmp),
                     Map.Entry.<People, People>comparingByValue(cmp));

}
 
源代码18 项目: openjdk-jdk8u-backup   文件: EntryComparators.java
private <K, V> void assertPairComparison(K k1, V v1, K k2, V v2,
                                    Comparator<Map.Entry<K, V>> ck,
                                    Comparator<Map.Entry<K, V>> cv) {
    final Map.Entry<K, V> p11 = new AbstractMap.SimpleImmutableEntry<>(k1, v1);
    final Map.Entry<K, V> p12 = new AbstractMap.SimpleImmutableEntry<>(k1, v2);
    final Map.Entry<K, V> p21 = new AbstractMap.SimpleImmutableEntry<>(k2, v1);
    final Map.Entry<K, V> p22 = new AbstractMap.SimpleImmutableEntry<>(k2, v2);

    assertTrue(ck.compare(p11, p11) == 0);
    assertTrue(ck.compare(p12, p11) == 0);
    assertTrue(ck.compare(p11, p12) == 0);
    assertTrue(ck.compare(p12, p22) < 0);
    assertTrue(ck.compare(p12, p21) < 0);
    assertTrue(ck.compare(p21, p11) > 0);
    assertTrue(ck.compare(p21, p12) > 0);

    assertTrue(cv.compare(p11, p11) == 0);
    assertTrue(cv.compare(p12, p11) > 0);
    assertTrue(cv.compare(p11, p12) < 0);
    assertTrue(cv.compare(p12, p22) == 0);
    assertTrue(cv.compare(p12, p21) > 0);
    assertTrue(cv.compare(p21, p11) == 0);
    assertTrue(cv.compare(p21, p12) < 0);

    Comparator<Map.Entry<K, V>> cmp = ck.thenComparing(cv);
    assertTrue(cmp.compare(p11, p11) == 0);
    assertTrue(cmp.compare(p12, p11) > 0);
    assertTrue(cmp.compare(p11, p12) < 0);
    assertTrue(cmp.compare(p12, p22) < 0);
    assertTrue(cmp.compare(p12, p21) < 0);
    assertTrue(cmp.compare(p21, p11) > 0);
    assertTrue(cmp.compare(p21, p12) > 0);

    cmp = cv.thenComparing(ck);
    assertTrue(cmp.compare(p11, p11) == 0);
    assertTrue(cmp.compare(p12, p11) > 0);
    assertTrue(cmp.compare(p11, p12) < 0);
    assertTrue(cmp.compare(p12, p22) < 0);
    assertTrue(cmp.compare(p12, p21) > 0);
    assertTrue(cmp.compare(p21, p11) > 0);
    assertTrue(cmp.compare(p21, p12) < 0);
}
 
源代码19 项目: hottub   文件: EntryComparators.java
private <K, V> void assertPairComparison(K k1, V v1, K k2, V v2,
                                    Comparator<Map.Entry<K, V>> ck,
                                    Comparator<Map.Entry<K, V>> cv) {
    final Map.Entry<K, V> p11 = new AbstractMap.SimpleImmutableEntry<>(k1, v1);
    final Map.Entry<K, V> p12 = new AbstractMap.SimpleImmutableEntry<>(k1, v2);
    final Map.Entry<K, V> p21 = new AbstractMap.SimpleImmutableEntry<>(k2, v1);
    final Map.Entry<K, V> p22 = new AbstractMap.SimpleImmutableEntry<>(k2, v2);

    assertTrue(ck.compare(p11, p11) == 0);
    assertTrue(ck.compare(p12, p11) == 0);
    assertTrue(ck.compare(p11, p12) == 0);
    assertTrue(ck.compare(p12, p22) < 0);
    assertTrue(ck.compare(p12, p21) < 0);
    assertTrue(ck.compare(p21, p11) > 0);
    assertTrue(ck.compare(p21, p12) > 0);

    assertTrue(cv.compare(p11, p11) == 0);
    assertTrue(cv.compare(p12, p11) > 0);
    assertTrue(cv.compare(p11, p12) < 0);
    assertTrue(cv.compare(p12, p22) == 0);
    assertTrue(cv.compare(p12, p21) > 0);
    assertTrue(cv.compare(p21, p11) == 0);
    assertTrue(cv.compare(p21, p12) < 0);

    Comparator<Map.Entry<K, V>> cmp = ck.thenComparing(cv);
    assertTrue(cmp.compare(p11, p11) == 0);
    assertTrue(cmp.compare(p12, p11) > 0);
    assertTrue(cmp.compare(p11, p12) < 0);
    assertTrue(cmp.compare(p12, p22) < 0);
    assertTrue(cmp.compare(p12, p21) < 0);
    assertTrue(cmp.compare(p21, p11) > 0);
    assertTrue(cmp.compare(p21, p12) > 0);

    cmp = cv.thenComparing(ck);
    assertTrue(cmp.compare(p11, p11) == 0);
    assertTrue(cmp.compare(p12, p11) > 0);
    assertTrue(cmp.compare(p11, p12) < 0);
    assertTrue(cmp.compare(p12, p22) < 0);
    assertTrue(cmp.compare(p12, p21) > 0);
    assertTrue(cmp.compare(p21, p11) > 0);
    assertTrue(cmp.compare(p21, p12) < 0);
}
 
源代码20 项目: jdk8u60   文件: EntryComparators.java
private <K, V> void assertPairComparison(K k1, V v1, K k2, V v2,
                                    Comparator<Map.Entry<K, V>> ck,
                                    Comparator<Map.Entry<K, V>> cv) {
    final Map.Entry<K, V> p11 = new AbstractMap.SimpleImmutableEntry<>(k1, v1);
    final Map.Entry<K, V> p12 = new AbstractMap.SimpleImmutableEntry<>(k1, v2);
    final Map.Entry<K, V> p21 = new AbstractMap.SimpleImmutableEntry<>(k2, v1);
    final Map.Entry<K, V> p22 = new AbstractMap.SimpleImmutableEntry<>(k2, v2);

    assertTrue(ck.compare(p11, p11) == 0);
    assertTrue(ck.compare(p12, p11) == 0);
    assertTrue(ck.compare(p11, p12) == 0);
    assertTrue(ck.compare(p12, p22) < 0);
    assertTrue(ck.compare(p12, p21) < 0);
    assertTrue(ck.compare(p21, p11) > 0);
    assertTrue(ck.compare(p21, p12) > 0);

    assertTrue(cv.compare(p11, p11) == 0);
    assertTrue(cv.compare(p12, p11) > 0);
    assertTrue(cv.compare(p11, p12) < 0);
    assertTrue(cv.compare(p12, p22) == 0);
    assertTrue(cv.compare(p12, p21) > 0);
    assertTrue(cv.compare(p21, p11) == 0);
    assertTrue(cv.compare(p21, p12) < 0);

    Comparator<Map.Entry<K, V>> cmp = ck.thenComparing(cv);
    assertTrue(cmp.compare(p11, p11) == 0);
    assertTrue(cmp.compare(p12, p11) > 0);
    assertTrue(cmp.compare(p11, p12) < 0);
    assertTrue(cmp.compare(p12, p22) < 0);
    assertTrue(cmp.compare(p12, p21) < 0);
    assertTrue(cmp.compare(p21, p11) > 0);
    assertTrue(cmp.compare(p21, p12) > 0);

    cmp = cv.thenComparing(ck);
    assertTrue(cmp.compare(p11, p11) == 0);
    assertTrue(cmp.compare(p12, p11) > 0);
    assertTrue(cmp.compare(p11, p12) < 0);
    assertTrue(cmp.compare(p12, p22) < 0);
    assertTrue(cmp.compare(p12, p21) > 0);
    assertTrue(cmp.compare(p21, p11) > 0);
    assertTrue(cmp.compare(p21, p12) < 0);
}