Mercurial > hg > openjdk > lambda > jdk
changeset 9552:99012c58e718
Comparator comparing API renaming
| author | henryjen |
|---|---|
| date | Wed, 21 Aug 2013 20:41:35 -0700 |
| parents | 190f250c7163 |
| children | 7bb72727c1ad |
| files | src/share/classes/java/util/Comparator.java test/java/util/Comparator/BasicTest.java test/java/util/List/ExtensionsTest.java test/java/util/List/SortAndReplaceAllTest.java test/java/util/Map/EntryComparators.java test/java/util/function/BinaryOperator/BasicTest.java test/java/util/stream/Stream/StringBuilderStreamTest.java |
| diffstat | 7 files changed, 53 insertions(+), 55 deletions(-) [+] |
line wrap: on
line diff
--- a/src/share/classes/java/util/Comparator.java Wed Aug 21 15:52:32 2013 -0700 +++ b/src/share/classes/java/util/Comparator.java Wed Aug 21 20:41:35 2013 -0700 @@ -199,7 +199,7 @@ * composed using following code, * * <pre>{@code - * Comparator<String> cmp = Comparator.comparing(String::length) + * Comparator<String> cmp = Comparator.comparingInt(String::length) * .thenComparing(String.CASE_INSENSITIVE_ORDER); * }</pre> * @@ -270,18 +270,18 @@ * extracts a {@code int} sort key. * * @implSpec This default implementation behaves as if {@code - * thenComparing(comparing(keyExtractor))}. + * thenComparing(comparingInt(keyExtractor))}. * * @param keyExtractor the function used to extract the integer sort key * @return a lexicographic-order comparator composed of this and then the * {@code int} sort key * @throws NullPointerException if the argument is null. - * @see #comparing(ToIntFunction) + * @see #comparingInt(ToIntFunction) * @see #thenComparing(Comparator) * @since 1.8 */ - default Comparator<T> thenComparing(ToIntFunction<? super T> keyExtractor) { - return thenComparing(comparing(keyExtractor)); + default Comparator<T> thenComparingInt(ToIntFunction<? super T> keyExtractor) { + return thenComparing(comparingInt(keyExtractor)); } /** @@ -289,18 +289,18 @@ * extracts a {@code long} sort key. * * @implSpec This default implementation behaves as if {@code - * thenComparing(comparing(keyExtractor))}. + * thenComparing(comparingLong(keyExtractor))}. * * @param keyExtractor the function used to extract the long sort key * @return a lexicographic-order comparator composed of this and then the * {@code long} sort key * @throws NullPointerException if the argument is null. - * @see #comparing(ToLongFunction) + * @see #comparingLong(ToLongFunction) * @see #thenComparing(Comparator) * @since 1.8 */ - default Comparator<T> thenComparing(ToLongFunction<? super T> keyExtractor) { - return thenComparing(comparing(keyExtractor)); + default Comparator<T> thenComparingLong(ToLongFunction<? super T> keyExtractor) { + return thenComparing(comparingLong(keyExtractor)); } /** @@ -308,18 +308,18 @@ * extracts a {@code double} sort key. * * @implSpec This default implementation behaves as if {@code - * thenComparing(comparing(keyExtractor))}. + * thenComparing(comparingDouble(keyExtractor))}. * * @param keyExtractor the function used to extract the double sort key * @return a lexicographic-order comparator composed of this and then the * {@code double} sort key * @throws NullPointerException if the argument is null. - * @see #comparing(ToDoubleFunction) + * @see #comparingDouble(ToDoubleFunction) * @see #thenComparing(Comparator) * @since 1.8 */ - default Comparator<T> thenComparing(ToDoubleFunction<? super T> keyExtractor) { - return thenComparing(comparing(keyExtractor)); + default Comparator<T> thenComparingDouble(ToDoubleFunction<? super T> keyExtractor) { + return thenComparing(comparingDouble(keyExtractor)); } /** @@ -484,7 +484,7 @@ * @throws NullPointerException if the argument is null * @since 1.8 */ - public static <T> Comparator<T> comparing(ToIntFunction<? super T> keyExtractor) { + 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)); @@ -505,7 +505,7 @@ * @throws NullPointerException if the argument is null * @since 1.8 */ - public static <T> Comparator<T> comparing(ToLongFunction<? super T> keyExtractor) { + 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)); @@ -526,7 +526,7 @@ * @throws NullPointerException if the argument is null * @since 1.8 */ - public static<T> Comparator<T> comparing(ToDoubleFunction<? super T> keyExtractor) { + 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));
--- a/test/java/util/Comparator/BasicTest.java Wed Aug 21 15:52:32 2013 -0700 +++ b/test/java/util/Comparator/BasicTest.java Wed Aug 21 20:41:35 2013 -0700 @@ -90,7 +90,7 @@ Thing[] things = new Thing[intValues.length]; for (int i=0; i<intValues.length; i++) things[i] = new Thing(intValues[i], 0L, 0.0, null); - Comparator<Thing> comp = Comparator.comparing(new ToIntFunction<Thing>() { + Comparator<Thing> comp = Comparator.comparingInt(new ToIntFunction<Thing>() { @Override public int applyAsInt(Thing thing) { return thing.getIntField(); @@ -104,7 +104,7 @@ Thing[] things = new Thing[longValues.length]; for (int i=0; i<longValues.length; i++) things[i] = new Thing(0, longValues[i], 0.0, null); - Comparator<Thing> comp = Comparator.comparing(new ToLongFunction<Thing>() { + Comparator<Thing> comp = Comparator.comparingLong(new ToLongFunction<Thing>() { @Override public long applyAsLong(Thing thing) { return thing.getLongField(); @@ -118,7 +118,7 @@ Thing[] things = new Thing[doubleValues.length]; for (int i=0; i<doubleValues.length; i++) things[i] = new Thing(0, 0L, doubleValues[i], null); - Comparator<Thing> comp = Comparator.comparing(new ToDoubleFunction<Thing>() { + Comparator<Thing> comp = Comparator.comparingDouble(new ToDoubleFunction<Thing>() { @Override public double applyAsDouble(Thing thing) { return thing.getDoubleField(); @@ -222,14 +222,14 @@ assertComparison(cmp.thenComparing(People::getLastName), people[0], people[1]); assertComparison(cmp.thenComparing(People::getLastName), people[4], people[0]); // thenComparing(ToIntFunction) - assertComparison(cmp.thenComparing(People::getAge), people[0], people[1]); - assertComparison(cmp.thenComparing(People::getAge), people[1], people[5]); + assertComparison(cmp.thenComparingInt(People::getAge), people[0], people[1]); + assertComparison(cmp.thenComparingInt(People::getAge), people[1], people[5]); // thenComparing(ToLongFunction) - assertComparison(cmp.thenComparing(People::getAgeAsLong), people[0], people[1]); - assertComparison(cmp.thenComparing(People::getAgeAsLong), people[1], people[5]); + assertComparison(cmp.thenComparingLong(People::getAgeAsLong), people[0], people[1]); + assertComparison(cmp.thenComparingLong(People::getAgeAsLong), people[1], people[5]); // thenComparing(ToDoubleFunction) - assertComparison(cmp.thenComparing(People::getAgeAsDouble), people[0], people[1]); - assertComparison(cmp.thenComparing(People::getAgeAsDouble), people[1], people[5]); + assertComparison(cmp.thenComparingDouble(People::getAgeAsDouble), people[0], people[1]); + assertComparison(cmp.thenComparingDouble(People::getAgeAsDouble), people[1], people[5]); } @@ -243,7 +243,7 @@ assertComparison(cmp, people[7], people[6]); // More than one thenComparing - strcmp = Comparator.nullsFirst(Comparator.comparing(String::length) + strcmp = Comparator.nullsFirst(Comparator.comparingInt(String::length) .thenComparing(String.CASE_INSENSITIVE_ORDER)); assertComparison(strcmp, null, "abc"); assertComparison(strcmp, "ab", "abc"); @@ -281,7 +281,7 @@ assertComparison(cmp, people[7], people[6]); // More than one thenComparing - strcmp = Comparator.nullsLast(Comparator.comparing(String::length) + strcmp = Comparator.nullsLast(Comparator.comparingInt(String::length) .thenComparing(String.CASE_INSENSITIVE_ORDER)); assertComparison(strcmp, "abc", null); assertComparison(strcmp, "ab", "abc"); @@ -341,7 +341,7 @@ } catch (NullPointerException npe) {} try { - Comparator<People> cmp = Comparator.comparing((Function<People, String>) null, Comparator.<String>naturalOrder()); + Comparator<People> cmp = Comparator.comparing(null, Comparator.<String>naturalOrder()); fail("comparing(null, cmp) should throw NPE"); } catch (NullPointerException npe) {} try { @@ -350,19 +350,19 @@ } catch (NullPointerException npe) {} try { - Comparator<People> cmp = Comparator.comparing((Function<People, String>) null); + Comparator<People> cmp = Comparator.comparing(null); fail("comparing(null) should throw NPE"); } catch (NullPointerException npe) {} try { - Comparator<People> cmp = Comparator.comparing((ToIntFunction<People>) null); + Comparator<People> cmp = Comparator.comparingInt(null); fail("comparing(null) should throw NPE"); } catch (NullPointerException npe) {} try { - Comparator<People> cmp = Comparator.comparing((ToLongFunction<People>) null); + Comparator<People> cmp = Comparator.comparingLong(null); fail("comparing(null) should throw NPE"); } catch (NullPointerException npe) {} try { - Comparator<People> cmp = Comparator.comparing((ToDoubleFunction<People>) null); + Comparator<People> cmp = Comparator.comparingDouble(null); fail("comparing(null) should throw NPE"); } catch (NullPointerException npe) {} }
--- a/test/java/util/List/ExtensionsTest.java Wed Aug 21 15:52:32 2013 -0700 +++ b/test/java/util/List/ExtensionsTest.java Wed Aug 21 20:41:35 2013 -0700 @@ -125,8 +125,8 @@ public void testSort() throws Exception{ Comparator[] cs = { Comparator.<Integer>naturalOrder(), Comparator.<Integer>reverseOrder(), - Comparator.comparing(LambdaUtilities.highestPosValueIntFunction() ), - Comparator.comparing(LambdaUtilities.lowestPosValueIntFunction() ), + Comparator.comparingInt(LambdaUtilities.highestPosValueIntFunction() ), + Comparator.comparingInt(LambdaUtilities.lowestPosValueIntFunction() ), }; Iterator<Comparator> csit = Arrays.stream(cs).iterator();
--- a/test/java/util/List/SortAndReplaceAllTest.java Wed Aug 21 15:52:32 2013 -0700 +++ b/test/java/util/List/SortAndReplaceAllTest.java Wed Aug 21 20:41:35 2013 -0700 @@ -139,8 +139,8 @@ final Function<Integer, String> i2s = i -> String.valueOf(i); Comparator[] cs = { Comparator.<Integer>naturalOrder(), Comparator.<Integer>reverseOrder(), - Comparator.comparing(LambdaUtilities.highestPosValueIntFunction()), - Comparator.comparing(LambdaUtilities.lowestPosValueIntFunction()), + Comparator.comparingInt(LambdaUtilities.highestPosValueIntFunction()), + Comparator.comparingInt(LambdaUtilities.lowestPosValueIntFunction()), Comparator.comparing(i2s, Comparator.<String>naturalOrder()), Comparator.comparing(i2s, Comparator.<String>reverseOrder()), };
--- a/test/java/util/Map/EntryComparators.java Wed Aug 21 15:52:32 2013 -0700 +++ b/test/java/util/Map/EntryComparators.java Wed Aug 21 20:41:35 2013 -0700 @@ -115,8 +115,8 @@ // 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((Function<People, String>) People::getFirstName); - Comparator<People> cmp2 = Comparator.comparing((Function<People, String>) People::getLastName); + 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],
--- a/test/java/util/function/BinaryOperator/BasicTest.java Wed Aug 21 15:52:32 2013 -0700 +++ b/test/java/util/function/BinaryOperator/BasicTest.java Wed Aug 21 20:41:35 2013 -0700 @@ -67,26 +67,26 @@ }; public void testMaxBy() { - Comparator<People> cmp = Comparator.comparing((Function<People, String>) People::getFirstName); + Comparator<People> cmp = Comparator.comparing(People::getFirstName); // lesser assertSame(maxBy(cmp).apply(people[0], people[1]), people[1]); // euqal - cmp = Comparator.comparing((Function<People, String>) People::getLastName); + cmp = Comparator.comparing(People::getLastName); assertSame(maxBy(cmp).apply(people[0], people[1]), people[0]); // greater - cmp = Comparator.comparing((ToIntFunction<People>) People::getAge); + cmp = Comparator.comparingInt(People::getAge); assertSame(maxBy(cmp).apply(people[0], people[1]), people[0]); } - public void testLesserOf() { - Comparator<People> cmp = Comparator.comparing((Function<People, String>) People::getFirstName); + public void testMinBy() { + Comparator<People> cmp = Comparator.comparing(People::getFirstName); // lesser assertSame(minBy(cmp).apply(people[0], people[1]), people[0]); // euqal - cmp = Comparator.comparing((Function<People, String>) People::getLastName); + cmp = Comparator.comparing(People::getLastName); assertSame(minBy(cmp).apply(people[0], people[1]), people[0]); // greater - cmp = Comparator.comparing((ToIntFunction<People>) People::getAge); + cmp = Comparator.comparingInt(People::getAge); assertSame(minBy(cmp).apply(people[0], people[1]), people[1]); }
--- a/test/java/util/stream/Stream/StringBuilderStreamTest.java Wed Aug 21 15:52:32 2013 -0700 +++ b/test/java/util/stream/Stream/StringBuilderStreamTest.java Wed Aug 21 20:41:35 2013 -0700 @@ -47,16 +47,14 @@ public class StringBuilderStreamTest<T extends Collection<StringBuilder>> extends GenericStreamTest<StringBuilder, Collection<StringBuilder>> { - public StringBuilderStreamTest(Class clazz, + public StringBuilderStreamTest(Class clazz, ParallelType parallelType, int initSize) { - super(clazz, parallelType, Comparator.comparing((Function<StringBuilder, - String>)StringBuilder::toString), initSize); + super(clazz, parallelType, Comparator.comparing(StringBuilder::toString), initSize); } - public StringBuilderStreamTest(Class clazz, + public StringBuilderStreamTest(Class clazz, ParallelType parallelType) { - super(clazz, parallelType, Comparator.comparing((Function<StringBuilder, - String>)StringBuilder::toString)); + super(clazz, parallelType, Comparator.comparing(StringBuilder::toString)); } @Factory @@ -93,7 +91,7 @@ streamFor(col).sorted().findFirst(); System.out.println(col.size()); } - + @Override protected Object[] predicateAndDesc(int size){ LambdaUtilities.CharType charType = Arrays.stream(LambdaUtilities.CharType.values()).findAny().get(); @@ -117,7 +115,7 @@ {(BinaryOperator<StringBuilder>)StringBuilder::append, "StringBuilder::append", false}, {LambdaUtilities.maxGenericBinaryOperator(naturalOrderComparator), "(t1, t2) -> t1 < t2 ? t2 : t1", true}, {LambdaUtilities.minGenericBinaryOperator(naturalOrderComparator), " (t1, t2) -> t1 < t2 ? t1 : t2", true}, - }; + }; } //Function<U, ? extends Comparable>, descrption for Function<? extends Comparable> @@ -127,14 +125,14 @@ {(Function<StringBuilder, String>)StringBuilder::toString, "StringBuilder::toString"}, }; } - + @Override protected Collection<StringBuilder> generate(int size) { Collection<StringBuilder> col = createEmptyCollection(); IntStream.range(0, size).mapToObj(i -> new StringBuilder().append(i) ).forEach(sb -> col.add(sb)); return col; } - + @Override protected StringBuilder[] bases(int size){ return new StringBuilder[]{new StringBuilder(), new StringBuilder(rand.nextInt(size)), new StringBuilder(size)};