Java 源码解析

Objects

public final class Objects {    // 构造方法私有, 并且使用final修饰符修饰该类不能被继承    private Objects() {        throw new AssertionError("No java.util.Objects instances for you!");    }    // 比较a跟b    public static boolean equals(Object a, Object b) {        return (a == b) || (a != null && a.equals(b));    }   // 深度比较a跟b, a跟b可以为数组    public static boolean deepEquals(Object a, Object b) {        if (a == b)            return true;        else if (a == null || b == null)            return false;        else            return Arrays.deepEquals0(a, b);    }    // 获取 o 的 hash 码    public static int hashCode(Object o) {        return o != null ? o.hashCode() : 0;    }   // 按照输入的顺序, 生成 hash 码    public static int hash(Object... values) {        return Arrays.hashCode(values);    }    // 把 o 转成 String    public static String toString(Object o) {        return String.valueOf(o);    }    // 把 o 转成 String, 如果 o 为 null, 使用 nullDefault 默认值    public static String toString(Object o, String nullDefault) {        return (o != null) ? o.toString() : nullDefault;    }    // 比较 a 跟 b, 如果不相等, 使用 c 规则再进行对比    public static <T> int compare(T a, T b, Comparator<? super T> c) {        return (a == b) ? 0 :  c.compare(a, b);    }    // 请求参数不能为 null, 如果为 null 抛出空指针    public static <T> T requireNonNull(T obj) {        if (obj == null)            throw new NullPointerException();        return obj;    }    // 请求参数不能为 null, 如果为 null 使用 message 信息抛出空指针    public static <T> T requireNonNull(T obj, String message) {        if (obj == null)            throw new NullPointerException(message);        return obj;    }    // 判断 obj 是否为 null, 这个方法为 java.util.function.Predicate 而存在    // 过滤器 Objects::isNull    public static boolean isNull(Object obj) {        return obj == null;    }    // 判断 obj 是否不为 null, 这个方法为 java.util.function.Predicate 而存在    // 过滤器 Objects::nonNull    public static boolean nonNull(Object obj) {        return obj != null;    }    // 请求参数不能为 null, 如果为 null 使用 messageSupplier 信息抛出空指针    public static <T> T requireNonNull(T obj, Supplier<String> messageSupplier) {        if (obj == null)            throw new NullPointerException(messageSupplier.get());        return obj;    }}

Supplier

@FunctionalInterfacepublic interface Supplier<T> {    // 获取结果    T get();}

Predicate

@FunctionalInterfacepublic interface Predicate<T> {    // 输入一个参数    boolean test(T t);    // 把这个 Predicate 的规则跟 other 里面的规则组合起来    default Predicate<T> and(Predicate<? super T> other) {        Objects.requireNonNull(other);        return (t) -> test(t) && other.test(t);    }    // 获取一个与这个 Predicate 的规则相反的 Predicate    default Predicate<T> negate() {        return (t) -> !test(t);    }    // 返回一个满足这个 Predicate 的规则或者满足 other 规则, 返回 true 的 Predicate    default Predicate<T> or(Predicate<? super T> other) {        Objects.requireNonNull(other);        return (t) -> test(t) || other.test(t);    }    // 当 targetRef 为 null, 返回一个判断是否为 null 的 Predicate, 如果 Predicate 不为空, 返回一个对比 targetRef 的 Predicate    static <T> Predicate<T> isEqual(Object targetRef) {        return (null == targetRef)                ? Objects::isNull                : object -> targetRef.equals(object);    }}

Function

主要作用是用来转换类型, Function<T, R> T 为输入的类型, R 为输出的类型.

@FunctionalInterfacepublic interface Function<T, R> {    // 输入一个 T 类型, 输出一个 R 类型    R apply(T t);    // 把 Function<T, R> 转换成 Function<V, R>    default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {        Objects.requireNonNull(before);        return (V v) -> apply(before.apply(v));    }    // 把 Function<T, R> 转成 Function<T, V>    default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {        Objects.requireNonNull(after);        return (T t) -> after.apply(apply(t));    }    // 获取一个 Function<Object, Object>, Function 输入什么, 就会输出什么    static <T> Function<T, T> identity() {        return t -> t;    }}

Consumer

@FunctionalInterfacepublic interface Consumer<T> {    // 执行输入的参数    void accept(T t);    // 首先执行本接口的 accept, 再执行 after 的 accept    default Consumer<T> andThen(Consumer<? super T> after) {        Objects.requireNonNull(after);        return (T t) -> { accept(t); after.accept(t); };    }}

Comparator

@FunctionalInterfacepublic interface Comparator<T> {    // 如果第一个参数小于, 等于, 或者大于第二个参数, 分别对应一个负数, 0, 正数    int compare(T o1, T o2);    // obj 与该对象对比    boolean equals(Object obj);    // 反转排序规则, 例如 compare(o1, o2) 为 1, reversed().compare(o1, o2) 为 -1    default Comparator<T> reversed() {        return Collections.reverseOrder(this);    }    // 第二规则, 当 comare 为 0 时, 根据 other 规则再进行对比.     // 例如: Comparator<String> cmp = Comparator.comparingInt(String::length).thenComparing(String.CASE_INSENSITIVE_ORDER);    default Comparator<T> thenComparing(Comparator<? super T> other) {        Objects.requireNonNull(other);        return (Comparator<T> & Serializable) (c1, c2) -> {            int res = compare(c1, c2);            return (res != 0) ? res : other.compare(c1, c2);        };    }    //     default <U> Comparator<T> thenComparing(            Function<? super T, ? extends U> keyExtractor,            Comparator<? super U> keyComparator)    {        return thenComparing(comparing(keyExtractor, keyComparator));    }    //     default <U extends Comparable<? super U>> Comparator<T> thenComparing(            Function<? super T, ? extends U> keyExtractor)    {        return thenComparing(comparing(keyExtractor));    }    //     default Comparator<T> thenComparingInt(ToIntFunction<? super T> keyExtractor) {        return thenComparing(comparingInt(keyExtractor));    }    //     default Comparator<T> thenComparingLong(ToLongFunction<? super T> keyExtractor) {        return thenComparing(comparingLong(keyExtractor));    }    //     default Comparator<T> thenComparingDouble(ToDoubleFunction<? super T> keyExtractor) {        return thenComparing(comparingDouble(keyExtractor));    }    //     public static <T extends Comparable<? super T>> Comparator<T> reverseOrder() {        return Collections.reverseOrder();    }    /**     * Returns a comparator that compares {@link Comparable} objects in natural     * order.     *     * <p>The returned comparator is serializable and throws {@link     * NullPointerException} when comparing {@code null}.     *     * @param  <T> the {@link Comparable} type of element to be compared     * @return a comparator that imposes the <i>natural ordering</i> on {@code     *         Comparable} objects.     * @see Comparable     * @since 1.8     */    @SuppressWarnings("unchecked")    public static <T extends Comparable<? super T>> Comparator<T> naturalOrder() {        return (Comparator<T>) Comparators.NaturalOrderComparator.INSTANCE;    }    /**     * Returns a null-friendly comparator that considers {@code null} to be     * less than non-null. When both are {@code null}, they are considered     * equal. If both are non-null, the specified {@code Comparator} is used     * to determine the order. If the specified comparator is {@code null},     * then the returned comparator considers all non-null values to be equal.     *     * <p>The returned comparator is serializable if the specified comparator     * is serializable.     *     * @param  <T> the type of the elements to be compared     * @param  comparator a {@code Comparator} for comparing non-null values     * @return a comparator that considers {@code null} to be less than     *         non-null, and compares non-null objects with the supplied     *         {@code Comparator}.     * @since 1.8     */    public static <T> Comparator<T> nullsFirst(Comparator<? super T> comparator) {        return new Comparators.NullComparator<>(true, comparator);    }    /**     * Returns a null-friendly comparator that considers {@code null} to be     * greater than non-null. When both are {@code null}, they are considered     * equal. If both are non-null, the specified {@code Comparator} is used     * to determine the order. If the specified comparator is {@code null},     * then the returned comparator considers all non-null values to be equal.     *     * <p>The returned comparator is serializable if the specified comparator     * is serializable.     *     * @param  <T> the type of the elements to be compared     * @param  comparator a {@code Comparator} for comparing non-null values     * @return a comparator that considers {@code null} to be greater than     *         non-null, and compares non-null objects with the supplied     *         {@code Comparator}.     * @since 1.8     */    public static <T> Comparator<T> nullsLast(Comparator<? super T> comparator) {        return new Comparators.NullComparator<>(false, comparator);    }    /**     * Accepts a function that extracts a sort key from a type {@code T}, and     * returns a {@code Comparator<T>} that compares by that sort key using     * the specified {@link Comparator}.      *     * <p>The returned comparator is serializable if the specified function     * and comparator are both serializable.     *     * @apiNote     * For example, to obtain a {@code Comparator} that compares {@code     * Person} objects by their last name ignoring case differences,     *     * <pre>{@code     *     Comparator<Person> cmp = Comparator.comparing(     *             Person::getLastName,     *             String.CASE_INSENSITIVE_ORDER);     * }</pre>     *     * @param  <T> the type of element to be compared     * @param  <U> the type of the sort key     * @param  keyExtractor the function used to extract the sort key     * @param  keyComparator the {@code Comparator} used to compare the sort key     * @return a comparator that compares by an extracted key using the     *         specified {@code Comparator}     * @throws NullPointerException if either argument is null     * @since 1.8     */    public static <T, U> Comparator<T> comparing(            Function<? super T, ? extends U> keyExtractor,            Comparator<? super U> keyComparator)    {        Objects.requireNonNull(keyExtractor);        Objects.requireNonNull(keyComparator);        return (Comparator<T> & Serializable)            (c1, c2) -> keyComparator.compare(keyExtractor.apply(c1),                                              keyExtractor.apply(c2));    }    /**     * Accepts a function that extracts a {@link java.lang.Comparable     * Comparable} sort key from a type {@code T}, and returns a {@code     * Comparator<T>} that compares by that sort key.     *     * <p>The returned comparator is serializable if the specified function     * is also serializable.     *     * @apiNote     * For example, to obtain a {@code Comparator} that compares {@code     * Person} objects by their last name,     *     * <pre>{@code     *     Comparator<Person> byLastName = Comparator.comparing(Person::getLastName);     * }</pre>     *     * @param  <T> the type of element to be compared     * @param  <U> the type of the {@code Comparable} sort key     * @param  keyExtractor the function used to extract the {@link     *         Comparable} sort key     * @return a comparator that compares by an extracted key     * @throws NullPointerException if the argument is null     * @since 1.8     */    public static <T, U extends Comparable<? super U>> Comparator<T> comparing(            Function<? super T, ? extends U> keyExtractor)    {        Objects.requireNonNull(keyExtractor);        return (Comparator<T> & Serializable)            (c1, c2) -> keyExtractor.apply(c1).compareTo(keyExtractor.apply(c2));    }    /**     * Accepts a function that extracts an {@code int} sort key from a type     * {@code T}, and returns a {@code Comparator<T>} that compares by that     * sort key.     *     * <p>The returned comparator is serializable if the specified function     * is also serializable.     *     * @param  <T> the type of element to be compared     * @param  keyExtractor the function used to extract the integer sort key     * @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> comparingInt(ToIntFunction<? super T> keyExtractor) {        Objects.requireNonNull(keyExtractor);        return (Comparator<T> & Serializable)            (c1, c2) -> Integer.compare(keyExtractor.applyAsInt(c1), keyExtractor.applyAsInt(c2));    }    /**     * Accepts a function that extracts a {@code long} sort key from a type     * {@code T}, and returns a {@code Comparator<T>} that compares by that     * sort key.     *     * <p>The returned comparator is serializable if the specified function is     * also serializable.     *     * @param  <T> the type of element to be compared     * @param  keyExtractor the function used to extract the long sort key     * @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> comparingLong(ToLongFunction<? super T> keyExtractor) {        Objects.requireNonNull(keyExtractor);        return (Comparator<T> & Serializable)            (c1, c2) -> Long.compare(keyExtractor.applyAsLong(c1), keyExtractor.applyAsLong(c2));    }    /**     * Accepts a function that extracts a {@code double} sort key from a type     * {@code T}, and returns a {@code Comparator<T>} that compares by that     * sort key.     *     * <p>The returned comparator is serializable if the specified function     * is also serializable.     *     * @param  <T> the type of element to be compared     * @param  keyExtractor the function used to extract the double sort key     * @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> comparingDouble(ToDoubleFunction<? super T> keyExtractor) {        Objects.requireNonNull(keyExtractor);        return (Comparator<T> & Serializable)            (c1, c2) -> Double.compare(keyExtractor.applyAsDouble(c1), keyExtractor.applyAsDouble(c2));    }}

Optional

public final class Optional<T> {    // 共用的空对象, 使用 empty() 调用    private static final Optional<?> EMPTY = new Optional<>();     // 如果有值就是这个值, 如果为 null 表名当前没有值    private final T value;    // 初始化一个空的值    private Optional() {        this.value = null;    }    // 返回一个空的实例    public static<T> Optional<T> empty() {        @SuppressWarnings("unchecked")        Optional<T> t = (Optional<T>) EMPTY;        return t;    }     // 以参数值构造一个实例, 如果参数为 null, 抛出 NullPointerException 异常    private Optional(T value) {        this.value = Objects.requireNonNull(value);    }    // 返回一个实例, 如果参数为 null, 抛出 NullPointerException 异常    public static <T> Optional<T> of(T value) {        return new Optional<>(value);    }    /**     * Returns an {@code Optional} describing the specified value, if non-null,     * otherwise returns an empty {@code Optional}.     *     * @param <T> the class of the value     * @param value the possibly-null value to describe     * @return an {@code Optional} with a present value if the specified value     * is non-null, otherwise an empty {@code Optional}     */     // 返回一个 value 描述, 如果 value 为 nul, 返回一个空对象    public static <T> Optional<T> ofNullable(T value) {        return value == null ? empty() : of(value);    }     // 如果 value 不为 null, 返回 value, 如果为 null, 抛出 NoSuchElementException 异常    public T get() {        if (value == null) {            throw new NoSuchElementException("No value present");        }        return value;    }     // 如果value 不为 null, 返回 true, 否则 返回 false    public boolean isPresent() {        return value != null;    }     // 如果 value 不为 null, 使用 consumer 做一些操作    public void ifPresent(Consumer<? super T> consumer) {        if (value != null)            consumer.accept(value);    }     // 如果 value 为 null, 返回当前对象, 如果不为 null, 判断是否满足 predicate 的条件    public Optional<T> filter(Predicate<? super T> predicate) {        Objects.requireNonNull(predicate);        if (!isPresent())            return this;        else            return predicate.test(value) ? this : empty();    }    /**     * If a value is present, apply the provided mapping function to it,     * and if the result is non-null, return an {@code Optional} describing the     * result.  Otherwise return an empty {@code Optional}.     *     * @apiNote This method supports post-processing on optional values, without     * the need to explicitly check for a return status.  For example, the     * following code traverses a stream of file names, selects one that has     * not yet been processed, and then opens that file, returning an     * {@code Optional<FileInputStream>}:     *     * <pre>{@code     *     Optional<FileInputStream> fis =     *         names.stream().filter(name -> !isProcessedYet(name))     *                       .findFirst()     *                       .map(name -> new FileInputStream(name));     * }</pre>     *     * Here, {@code findFirst} returns an {@code Optional<String>}, and then     * {@code map} returns an {@code Optional<FileInputStream>} for the desired     * file if one exists.     *     * @param <U> The type of the result of the mapping function     * @param mapper a mapping function to apply to the value, if present     * @return an {@code Optional} describing the result of applying a mapping     * function to the value of this {@code Optional}, if a value is present,     * otherwise an empty {@code Optional}     * @throws NullPointerException if the mapping function is null     */    public<U> Optional<U> map(Function<? super T, ? extends U> mapper) {        Objects.requireNonNull(mapper);        if (!isPresent())            return empty();        else {            return Optional.ofNullable(mapper.apply(value));        }    }    /**     * If a value is present, apply the provided {@code Optional}-bearing     * mapping function to it, return that result, otherwise return an empty     * {@code Optional}.  This method is similar to {@link #map(Function)},     * but the provided mapper is one whose result is already an {@code Optional},     * and if invoked, {@code flatMap} does not wrap it with an additional     * {@code Optional}.     *     * @param <U> The type parameter to the {@code Optional} returned by     * @param mapper a mapping function to apply to the value, if present     *           the mapping function     * @return the result of applying an {@code Optional}-bearing mapping     * function to the value of this {@code Optional}, if a value is present,     * otherwise an empty {@code Optional}     * @throws NullPointerException if the mapping function is null or returns     * a null result     */    public<U> Optional<U> flatMap(Function<? super T, Optional<U>> mapper) {        Objects.requireNonNull(mapper);        if (!isPresent())            return empty();        else {            return Objects.requireNonNull(mapper.apply(value));        }    }    /**     * Return the value if present, otherwise return {@code other}.     *     * @param other the value to be returned if there is no value present, may     * be null     * @return the value, if present, otherwise {@code other}     */    public T orElse(T other) {        return value != null ? value : other;    }    /**     * Return the value if present, otherwise invoke {@code other} and return     * the result of that invocation.     *     * @param other a {@code Supplier} whose result is returned if no value     * is present     * @return the value if present otherwise the result of {@code other.get()}     * @throws NullPointerException if value is not present and {@code other} is     * null     */    public T orElseGet(Supplier<? extends T> other) {        return value != null ? value : other.get();    }    /**     * Return the contained value, if present, otherwise throw an exception     * to be created by the provided supplier.     *     * @apiNote A method reference to the exception constructor with an empty     * argument list can be used as the supplier. For example,     * {@code IllegalStateException::new}     *     * @param <X> Type of the exception to be thrown     * @param exceptionSupplier The supplier which will return the exception to     * be thrown     * @return the present value     * @throws X if there is no value present     * @throws NullPointerException if no value is present and     * {@code exceptionSupplier} is null     */    public <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier) throws X {        if (value != null) {            return value;        } else {            throw exceptionSupplier.get();        }    }    /**     * Indicates whether some other object is "equal to" this Optional. The     * other object is considered equal if:     * <ul>     * <li>it is also an {@code Optional} and;     * <li>both instances have no value present or;     * <li>the present values are "equal to" each other via {@code equals()}.     * </ul>     *     * @param obj an object to be tested for equality     * @return {code true} if the other object is "equal to" this object     * otherwise {@code false}     */    @Override    public boolean equals(Object obj) {        if (this == obj) {            return true;        }        if (!(obj instanceof Optional)) {            return false;        }        Optional<?> other = (Optional<?>) obj;        return Objects.equals(value, other.value);    }    /**     * Returns the hash code value of the present value, if any, or 0 (zero) if     * no value is present.     *     * @return hash code value of the present value or 0 if no value is present     */    @Override    public int hashCode() {        return Objects.hashCode(value);    }    /**     * Returns a non-empty string representation of this Optional suitable for     * debugging. The exact presentation format is unspecified and may vary     * between implementations and versions.     *     * @implSpec If a value is present the result must include its string     * representation in the result. Empty and present Optionals must be     * unambiguously differentiable.     *     * @return the string representation of this instance     */    @Override    public String toString() {        return value != null            ? String.format("Optional[%s]", value)            : "Optional.empty";    }}