jdk-sandbox: comparison jdk/src/share/classes/java/util/Comparator.java

equal deleted inserted replaced

-:f96e3aef2081
+:0f98f8e3bdcb
 * 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.comparing(String::length)
+*     Comparator<String> cmp = Comparator.comparingInt(String::length)
 *             .thenComparing(String.CASE_INSENSITIVE_ORDER);
 * }</pre>
 *
 * @param  other the other comparator to be used when this comparator
 *         compares two objects that are equal.
 /**
 * Returns a lexicographic-order comparator with a function that
 * 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) {
+default Comparator<T> thenComparingInt(ToIntFunction<? super T> keyExtractor) {
-return thenComparing(comparing(keyExtractor));
+return thenComparing(comparingInt(keyExtractor));
 }
 /**
 * Returns a lexicographic-order comparator with a function that
 * 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) {
+default Comparator<T> thenComparingLong(ToLongFunction<? super T> keyExtractor) {
-return thenComparing(comparing(keyExtractor));
+return thenComparing(comparingLong(keyExtractor));
 }
 /**
 * Returns a lexicographic-order comparator with a function that
 * 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) {
+default Comparator<T> thenComparingDouble(ToDoubleFunction<? super T> keyExtractor) {
-return thenComparing(comparing(keyExtractor));
+return thenComparing(comparingDouble(keyExtractor));
 }
 /**
 * Returns a comparator that imposes the reverse of the <em>natural
 * ordering</em>.
 * @return a comparator that compares by an extracted key
 * @see #comparing(Function)
 * @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));
 }
 * @return a comparator that compares by an extracted key
 * @see #comparing(Function)
 * @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));
 }
 * @return a comparator that compares by an extracted key
 * @see #comparing(Function)
 * @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));
 }
 }

changeset 19605	0f98f8e3bdcb
parent 19208	1e3d351eba80
child 19867	9918d2d14f78