{"id":31632,"date":"2023-08-17T12:53:52","date_gmt":"2023-01-27T12:24:20","guid":{"rendered":"https:\/\/www.silicloud.com\/zh\/blog\/java-%e7%9a%84-optional-%e7%b1%bb\/"},"modified":"2024-01-15T06:49:52","modified_gmt":"2024-01-14T22:49:52","slug":"java-%e7%9a%84-optional-%e7%b1%bb","status":"publish","type":"post","link":"https:\/\/www.silicloud.com\/zh\/blog\/java-%e7%9a%84-optional-%e7%b1%bb\/","title":{"rendered":"Java \u7684 Optional \u7c7b"},"content":{"rendered":"

\u4f7f\u7528\u793a\u4f8b<\/h1>\n
\r\nimport<\/span> java.util.Arrays<\/span>;<\/span>\r\nimport<\/span> java.util.List<\/span>;<\/span>\r\nimport<\/span> java.util.Optional<\/span>;<\/span>\r\n\r\npublic<\/span> class<\/span> StreamSample<\/span> {<\/span>\r\n    public<\/span> static<\/span> void<\/span> main<\/span>(<\/span>String<\/span>[]<\/span> args<\/span>)<\/span> {<\/span>\r\n        List<\/span><<\/span>Integer<\/span>><\/span> list<\/span> =<\/span> Arrays<\/span>.<\/span>asList<\/span>(<\/span>1<\/span>,<\/span> 2<\/span>,<\/span> 4<\/span>,<\/span> 10<\/span>,<\/span> 15<\/span>,<\/span> 20<\/span>);<\/span>\r\n        Optional<\/span><<\/span>Integer<\/span>><\/span> optional<\/span> =<\/span> list<\/span>.<\/span>stream<\/span>().<\/span>filter<\/span>(<\/span>x<\/span> -><\/span> x<\/span> ><\/span> 10<\/span>).<\/span>findAny<\/span>();<\/span>\r\n        optional<\/span>.<\/span>ifPresent<\/span>(<\/span>System<\/span>.<\/span>out<\/span>::<\/span>println<\/span>);<\/span> \/\/ => 15<\/span>\r\n        System<\/span>.<\/span>out<\/span>.<\/span>println<\/span>(<\/span>optional<\/span>.<\/span>isPresent<\/span>());<\/span> \/\/ => true<\/span>\r\n        System<\/span>.<\/span>out<\/span>.<\/span>println<\/span>(<\/span>optional<\/span>.<\/span>get<\/span>());<\/span>  \/\/ => 15<\/span>\r\n    }<\/span>\r\n}<\/span>\r\n\r\n<\/code><\/pre>\n
Java API\u4ee3\u7801\u7684\u516c\u5f0f<\/h1>\n
\/*\r\n * Copyright (c) 2012, 2017, Oracle and\/or its affiliates. All rights reserved.\r\n * ORACLE PROPRIETARY\/CONFIDENTIAL. Use is subject to license terms.\r\n *\r\n *\r\n *\r\n *\r\n *\r\n *\r\n *\r\n *\r\n *\r\n *\r\n *\r\n *\r\n *\r\n *\r\n *\r\n *\r\n *\r\n *\r\n *\r\n *\r\n *\/<\/span>\r\npackage<\/span> java.util<\/span>;<\/span>\r\n\r\nimport<\/span> java.util.function.Consumer<\/span>;<\/span>\r\nimport<\/span> java.util.function.Function<\/span>;<\/span>\r\nimport<\/span> java.util.function.Predicate<\/span>;<\/span>\r\nimport<\/span> java.util.function.Supplier<\/span>;<\/span>\r\nimport<\/span> java.util.stream.Stream<\/span>;<\/span>\r\n\r\n\/**\r\n * A container object which may or may not contain a non-{@code null} value.\r\n * If a value is present, {@code isPresent()} returns {@code true}. If no\r\n * value is present, the object is considered <i>empty<\/i> and\r\n * {@code isPresent()} returns {@code false}.\r\n *\r\n * <p>Additional methods that depend on the presence or absence of a contained\r\n * value are provided, such as {@link #orElse(Object) orElse()}\r\n * (returns a default value if no value is present) and\r\n * {@link #ifPresent(Consumer) ifPresent()} (performs an\r\n * action if a value is present).\r\n *\r\n * <p>This is a <a href=\"..\/lang\/doc-files\/ValueBased.html\">value-based<\/a>\r\n * class; use of identity-sensitive operations (including reference equality\r\n * ({@code ==}), identity hash code, or synchronization) on instances of\r\n * {@code Optional} may have unpredictable results and should be avoided.\r\n *\r\n * @apiNote\r\n * {@code Optional} is primarily intended for use as a method return type where\r\n * there is a clear need to represent \"no result,\" and where using {@code null}\r\n * is likely to cause errors. A variable whose type is {@code Optional} should\r\n * never itself be {@code null}; it should always point to an {@code Optional}\r\n * instance.\r\n *\r\n * @param <T> the type of value\r\n * @since 1.8\r\n *\/<\/span>\r\npublic<\/span> final<\/span> class<\/span> Optional<\/span><<\/span>T<\/span>><\/span> {<\/span>\r\n    \/**\r\n     * Common instance for {@code empty()}.\r\n     *\/<\/span>\r\n    private<\/span> static<\/span> final<\/span> Optional<\/span><?><\/span> EMPTY<\/span> =<\/span> new<\/span> Optional<\/span><>();<\/span>\r\n\r\n    \/**\r\n     * If non-null, the value; if null, indicates no value is present\r\n     *\/<\/span>\r\n    private<\/span> final<\/span> T<\/span> value<\/span>;<\/span>\r\n\r\n    \/**\r\n     * Constructs an empty instance.\r\n     *\r\n     * @implNote Generally only one empty instance, {@link Optional#EMPTY},\r\n     * should exist per VM.\r\n     *\/<\/span>\r\n    private<\/span> Optional<\/span>()<\/span> {<\/span>\r\n        this<\/span>.<\/span>value<\/span> =<\/span> null<\/span>;<\/span>\r\n    }<\/span>\r\n\r\n    \/**\r\n     * Returns an empty {@code Optional} instance.  No value is present for this\r\n     * {@code Optional}.\r\n     *\r\n     * @apiNote\r\n     * Though it may be tempting to do so, avoid testing if an object is empty\r\n     * by comparing with {@code ==} against instances returned by\r\n     * {@code Optional.empty()}.  There is no guarantee that it is a singleton.\r\n     * Instead, use {@link #isPresent()}.\r\n     *\r\n     * @param <T> The type of the non-existent value\r\n     * @return an empty {@code Optional}\r\n     *\/<\/span>\r\n    public<\/span> static<\/span><<\/span>T<\/span>><\/span> Optional<\/span><<\/span>T<\/span>><\/span> empty<\/span>()<\/span> {<\/span>\r\n        @SuppressWarnings<\/span>(<\/span>\"unchecked\"<\/span>)<\/span>\r\n        Optional<\/span><<\/span>T<\/span>><\/span> t<\/span> =<\/span> (<\/span>Optional<\/span><<\/span>T<\/span>>)<\/span> EMPTY<\/span>;<\/span>\r\n        return<\/span> t<\/span>;<\/span>\r\n    }<\/span>\r\n\r\n    \/**\r\n     * Constructs an instance with the described value.\r\n     *\r\n     * @param value the non-{@code null} value to describe\r\n     * @throws NullPointerException if value is {@code null}\r\n     *\/<\/span>\r\n    private<\/span> Optional<\/span>(<\/span>T<\/span> value<\/span>)<\/span> {<\/span>\r\n        this<\/span>.<\/span>value<\/span> =<\/span> Objects<\/span>.<\/span>requireNonNull<\/span>(<\/span>value<\/span>);<\/span>\r\n    }<\/span>\r\n\r\n    \/**\r\n     * Returns an {@code Optional} describing the given non-{@code null}\r\n     * value.\r\n     *\r\n     * @param value the value to describe, which must be non-{@code null}\r\n     * @param <T> the type of the value\r\n     * @return an {@code Optional} with the value present\r\n     * @throws NullPointerException if value is {@code null}\r\n     *\/<\/span>\r\n    public<\/span> static<\/span> <<\/span>T<\/span>><\/span> Optional<\/span><<\/span>T<\/span>><\/span> of<\/span>(<\/span>T<\/span> value<\/span>)<\/span> {<\/span>\r\n        return<\/span> new<\/span> Optional<\/span><>(<\/span>value<\/span>);<\/span>\r\n    }<\/span>\r\n\r\n    \/**\r\n     * Returns an {@code Optional} describing the given value, if\r\n     * non-{@code null}, otherwise returns an empty {@code Optional}.\r\n     *\r\n     * @param value the possibly-{@code null} value to describe\r\n     * @param <T> the type of the value\r\n     * @return an {@code Optional} with a present value if the specified value\r\n     *         is non-{@code null}, otherwise an empty {@code Optional}\r\n     *\/<\/span>\r\n    public<\/span> static<\/span> <<\/span>T<\/span>><\/span> Optional<\/span><<\/span>T<\/span>><\/span> ofNullable<\/span>(<\/span>T<\/span> value<\/span>)<\/span> {<\/span>\r\n        return<\/span> value<\/span> ==<\/span> null<\/span> ?<\/span> empty<\/span>()<\/span> :<\/span> of<\/span>(<\/span>value<\/span>);<\/span>\r\n    }<\/span>\r\n\r\n    \/**\r\n     * If a value is present, returns the value, otherwise throws\r\n     * {@code NoSuchElementException}.\r\n     *\r\n     * @apiNote\r\n     * The preferred alternative to this method is {@link #orElseThrow()}.\r\n     *\r\n     * @return the non-{@code null} value described by this {@code Optional}\r\n     * @throws NoSuchElementException if no value is present\r\n     *\/<\/span>\r\n    public<\/span> T<\/span> get<\/span>()<\/span> {<\/span>\r\n        if<\/span> (<\/span>value<\/span> ==<\/span> null<\/span>)<\/span> {<\/span>\r\n            throw<\/span> new<\/span> NoSuchElementException<\/span>(<\/span>\"No value present\"<\/span>);<\/span>\r\n        }<\/span>\r\n        return<\/span> value<\/span>;<\/span>\r\n    }<\/span>\r\n\r\n    \/**\r\n     * If a value is present, returns {@code true}, otherwise {@code false}.\r\n     *\r\n     * @return {@code true} if a value is present, otherwise {@code false}\r\n     *\/<\/span>\r\n    public<\/span> boolean<\/span> isPresent<\/span>()<\/span> {<\/span>\r\n        return<\/span> value<\/span> !=<\/span> null<\/span>;<\/span>\r\n    }<\/span>\r\n\r\n    \/**\r\n     * If a value is present, performs the given action with the value,\r\n     * otherwise does nothing.\r\n     *\r\n     * @param action the action to be performed, if a value is present\r\n     * @throws NullPointerException if value is present and the given action is\r\n     *         {@code null}\r\n     *\/<\/span>\r\n    public<\/span> void<\/span> ifPresent<\/span>(<\/span>Consumer<\/span><?<\/span> super<\/span> T<\/span>><\/span> action<\/span>)<\/span> {<\/span>\r\n        if<\/span> (<\/span>value<\/span> !=<\/span> null<\/span>)<\/span> {<\/span>\r\n            action<\/span>.<\/span>accept<\/span>(<\/span>value<\/span>);<\/span>\r\n        }<\/span>\r\n    }<\/span>\r\n\r\n    \/**\r\n     * If a value is present, performs the given action with the value,\r\n     * otherwise performs the given empty-based action.\r\n     *\r\n     * @param action the action to be performed, if a value is present\r\n     * @param emptyAction the empty-based action to be performed, if no value is\r\n     *        present\r\n     * @throws NullPointerException if a value is present and the given action\r\n     *         is {@code null}, or no value is present and the given empty-based\r\n     *         action is {@code null}.\r\n     * @since 9\r\n     *\/<\/span>\r\n    public<\/span> void<\/span> ifPresentOrElse<\/span>(<\/span>Consumer<\/span><?<\/span> super<\/span> T<\/span>><\/span> action<\/span>,<\/span> Runnable<\/span> emptyAction<\/span>)<\/span> {<\/span>\r\n        if<\/span> (<\/span>value<\/span> !=<\/span> null<\/span>)<\/span> {<\/span>\r\n            action<\/span>.<\/span>accept<\/span>(<\/span>value<\/span>);<\/span>\r\n        }<\/span> else<\/span> {<\/span>\r\n            emptyAction<\/span>.<\/span>run<\/span>();<\/span>\r\n        }<\/span>\r\n    }<\/span>\r\n\r\n    \/**\r\n     * If a value is present, and the value matches the given predicate,\r\n     * returns an {@code Optional} describing the value, otherwise returns an\r\n     * empty {@code Optional}.\r\n     *\r\n     * @param predicate the predicate to apply to a value, if present\r\n     * @return an {@code Optional} describing the value of this\r\n     *         {@code Optional}, if a value is present and the value matches the\r\n     *         given predicate, otherwise an empty {@code Optional}\r\n     * @throws NullPointerException if the predicate is {@code null}\r\n     *\/<\/span>\r\n    public<\/span> Optional<\/span><<\/span>T<\/span>><\/span> filter<\/span>(<\/span>Predicate<\/span><?<\/span> super<\/span> T<\/span>><\/span> predicate<\/span>)<\/span> {<\/span>\r\n        Objects<\/span>.<\/span>requireNonNull<\/span>(<\/span>predicate<\/span>);<\/span>\r\n        if<\/span> (!<\/span>isPresent<\/span>())<\/span> {<\/span>\r\n            return<\/span> this<\/span>;<\/span>\r\n        }<\/span> else<\/span> {<\/span>\r\n            return<\/span> predicate<\/span>.<\/span>test<\/span>(<\/span>value<\/span>)<\/span> ?<\/span> this<\/span> :<\/span> empty<\/span>();<\/span>\r\n        }<\/span>\r\n    }<\/span>\r\n\r\n    \/**\r\n     * If a value is present, returns an {@code Optional} describing (as if by\r\n     * {@link #ofNullable}) the result of applying the given mapping function to\r\n     * the value, otherwise returns an empty {@code Optional}.\r\n     *\r\n     * <p>If the mapping function returns a {@code null} result then this method\r\n     * returns an empty {@code Optional}.\r\n     *\r\n     * @apiNote\r\n     * This method supports post-processing on {@code Optional} values, without\r\n     * the need to explicitly check for a return status.  For example, the\r\n     * following code traverses a stream of URIs, selects one that has not\r\n     * yet been processed, and creates a path from that URI, returning\r\n     * an {@code Optional<Path>}:\r\n     *\r\n     * <pre>{@code\r\n     *     Optional<Path> p =\r\n     *         uris.stream().filter(uri -> !isProcessedYet(uri))\r\n     *                       .findFirst()\r\n     *                       .map(Paths::get);\r\n     * }<\/pre>\r\n     *\r\n     * Here, {@code findFirst} returns an {@code Optional<URI>}, and then\r\n     * {@code map} returns an {@code Optional<Path>} for the desired\r\n     * URI if one exists.\r\n     *\r\n     * @param mapper the mapping function to apply to a value, if present\r\n     * @param <U> The type of the value returned from the mapping function\r\n     * @return an {@code Optional} describing the result of applying a mapping\r\n     *         function to the value of this {@code Optional}, if a value is\r\n     *         present, otherwise an empty {@code Optional}\r\n     * @throws NullPointerException if the mapping function is {@code null}\r\n     *\/<\/span>\r\n    public<\/span> <<\/span>U<\/span>><\/span> Optional<\/span><<\/span>U<\/span>><\/span> map<\/span>(<\/span>Function<\/span><?<\/span> super<\/span> T<\/span>,<\/span> ?<\/span> extends<\/span> U<\/span>><\/span> mapper<\/span>)<\/span> {<\/span>\r\n        Objects<\/span>.<\/span>requireNonNull<\/span>(<\/span>mapper<\/span>);<\/span>\r\n        if<\/span> (!<\/span>isPresent<\/span>())<\/span> {<\/span>\r\n            return<\/span> empty<\/span>();<\/span>\r\n        }<\/span> else<\/span> {<\/span>\r\n            return<\/span> Optional<\/span>.<\/span>ofNullable<\/span>(<\/span>mapper<\/span>.<\/span>apply<\/span>(<\/span>value<\/span>));<\/span>\r\n        }<\/span>\r\n    }<\/span>\r\n\r\n    \/**\r\n     * If a value is present, returns the result of applying the given\r\n     * {@code Optional}-bearing mapping function to the value, otherwise returns\r\n     * an empty {@code Optional}.\r\n     *\r\n     * <p>This method is similar to {@link #map(Function)}, but the mapping\r\n     * function is one whose result is already an {@code Optional}, and if\r\n     * invoked, {@code flatMap} does not wrap it within an additional\r\n     * {@code Optional}.\r\n     *\r\n     * @param <U> The type of value of the {@code Optional} returned by the\r\n     *            mapping function\r\n     * @param mapper the mapping function to apply to a value, if present\r\n     * @return the result of applying an {@code Optional}-bearing mapping\r\n     *         function to the value of this {@code Optional}, if a value is\r\n     *         present, otherwise an empty {@code Optional}\r\n     * @throws NullPointerException if the mapping function is {@code null} or\r\n     *         returns a {@code null} result\r\n     *\/<\/span>\r\n    public<\/span> <<\/span>U<\/span>><\/span> Optional<\/span><<\/span>U<\/span>><\/span> flatMap<\/span>(<\/span>Function<\/span><?<\/span> super<\/span> T<\/span>,<\/span> ?<\/span> extends<\/span> Optional<\/span><?<\/span> extends<\/span> U<\/span>>><\/span> mapper<\/span>)<\/span> {<\/span>\r\n        Objects<\/span>.<\/span>requireNonNull<\/span>(<\/span>mapper<\/span>);<\/span>\r\n        if<\/span> (!<\/span>isPresent<\/span>())<\/span> {<\/span>\r\n            return<\/span> empty<\/span>();<\/span>\r\n        }<\/span> else<\/span> {<\/span>\r\n            @SuppressWarnings<\/span>(<\/span>\"unchecked\"<\/span>)<\/span>\r\n            Optional<\/span><<\/span>U<\/span>><\/span> r<\/span> =<\/span> (<\/span>Optional<\/span><<\/span>U<\/span>>)<\/span> mapper<\/span>.<\/span>apply<\/span>(<\/span>value<\/span>);<\/span>\r\n            return<\/span> Objects<\/span>.<\/span>requireNonNull<\/span>(<\/span>r<\/span>);<\/span>\r\n        }<\/span>\r\n    }<\/span>\r\n\r\n    \/**\r\n     * If a value is present, returns an {@code Optional} describing the value,\r\n     * otherwise returns an {@code Optional} produced by the supplying function.\r\n     *\r\n     * @param supplier the supplying function that produces an {@code Optional}\r\n     *        to be returned\r\n     * @return returns an {@code Optional} describing the value of this\r\n     *         {@code Optional}, if a value is present, otherwise an\r\n     *         {@code Optional} produced by the supplying function.\r\n     * @throws NullPointerException if the supplying function is {@code null} or\r\n     *         produces a {@code null} result\r\n     * @since 9\r\n     *\/<\/span>\r\n    public<\/span> Optional<\/span><<\/span>T<\/span>><\/span> or<\/span>(<\/span>Supplier<\/span><?<\/span> extends<\/span> Optional<\/span><?<\/span> extends<\/span> T<\/span>>><\/span> supplier<\/span>)<\/span> {<\/span>\r\n        Objects<\/span>.<\/span>requireNonNull<\/span>(<\/span>supplier<\/span>);<\/span>\r\n        if<\/span> (<\/span>isPresent<\/span>())<\/span> {<\/span>\r\n            return<\/span> this<\/span>;<\/span>\r\n        }<\/span> else<\/span> {<\/span>\r\n            @SuppressWarnings<\/span>(<\/span>\"unchecked\"<\/span>)<\/span>\r\n            Optional<\/span><<\/span>T<\/span>><\/span> r<\/span> =<\/span> (<\/span>Optional<\/span><<\/span>T<\/span>>)<\/span> supplier<\/span>.<\/span>get<\/span>();<\/span>\r\n            return<\/span> Objects<\/span>.<\/span>requireNonNull<\/span>(<\/span>r<\/span>);<\/span>\r\n        }<\/span>\r\n    }<\/span>\r\n\r\n    \/**\r\n     * If a value is present, returns a sequential {@link Stream} containing\r\n     * only that value, otherwise returns an empty {@code Stream}.\r\n     *\r\n     * @apiNote\r\n     * This method can be used to transform a {@code Stream} of optional\r\n     * elements to a {@code Stream} of present value elements:\r\n     * <pre>{@code\r\n     *     Stream<Optional<T>> os = ..\r\n     *     Stream<T> s = os.flatMap(Optional::stream)\r\n     * }<\/pre>\r\n     *\r\n     * @return the optional value as a {@code Stream}\r\n     * @since 9\r\n     *\/<\/span>\r\n    public<\/span> Stream<\/span><<\/span>T<\/span>><\/span> stream<\/span>()<\/span> {<\/span>\r\n        if<\/span> (!<\/span>isPresent<\/span>())<\/span> {<\/span>\r\n            return<\/span> Stream<\/span>.<\/span>empty<\/span>();<\/span>\r\n        }<\/span> else<\/span> {<\/span>\r\n            return<\/span> Stream<\/span>.<\/span>of<\/span>(<\/span>value<\/span>);<\/span>\r\n        }<\/span>\r\n    }<\/span>\r\n\r\n    \/**\r\n     * If a value is present, returns the value, otherwise returns\r\n     * {@code other}.\r\n     *\r\n     * @param other the value to be returned, if no value is present.\r\n     *        May be {@code null}.\r\n     * @return the value, if present, otherwise {@code other}\r\n     *\/<\/span>\r\n    public<\/span> T<\/span> orElse<\/span>(<\/span>T<\/span> other<\/span>)<\/span> {<\/span>\r\n        return<\/span> value<\/span> !=<\/span> null<\/span> ?<\/span> value<\/span> :<\/span> other<\/span>;<\/span>\r\n    }<\/span>\r\n\r\n    \/**\r\n     * If a value is present, returns the value, otherwise returns the result\r\n     * produced by the supplying function.\r\n     *\r\n     * @param supplier the supplying function that produces a value to be returned\r\n     * @return the value, if present, otherwise the result produced by the\r\n     *         supplying function\r\n     * @throws NullPointerException if no value is present and the supplying\r\n     *         function is {@code null}\r\n     *\/<\/span>\r\n    public<\/span> T<\/span> orElseGet<\/span>(<\/span>Supplier<\/span><?<\/span> extends<\/span> T<\/span>><\/span> supplier<\/span>)<\/span> {<\/span>\r\n        return<\/span> value<\/span> !=<\/span> null<\/span> ?<\/span> value<\/span> :<\/span> supplier<\/span>.<\/span>get<\/span>();<\/span>\r\n    }<\/span>\r\n\r\n    \/**\r\n     * If a value is present, returns the value, otherwise throws\r\n     * {@code NoSuchElementException}.\r\n     *\r\n     * @return the non-{@code null} value described by this {@code Optional}\r\n     * @throws NoSuchElementException if no value is present\r\n     * @since 10\r\n     *\/<\/span>\r\n    public<\/span> T<\/span> orElseThrow<\/span>()<\/span> {<\/span>\r\n        if<\/span> (<\/span>value<\/span> ==<\/span> null<\/span>)<\/span> {<\/span>\r\n            throw<\/span> new<\/span> NoSuchElementException<\/span>(<\/span>\"No value present\"<\/span>);<\/span>\r\n        }<\/span>\r\n        return<\/span> value<\/span>;<\/span>\r\n    }<\/span>\r\n\r\n    \/**\r\n     * If a value is present, returns the value, otherwise throws an exception\r\n     * produced by the exception supplying function.\r\n     *\r\n     * @apiNote\r\n     * A method reference to the exception constructor with an empty argument\r\n     * list can be used as the supplier. For example,\r\n     * {@code IllegalStateException::new}\r\n     *\r\n     * @param <X> Type of the exception to be thrown\r\n     * @param exceptionSupplier the supplying function that produces an\r\n     *        exception to be thrown\r\n     * @return the value, if present\r\n     * @throws X if no value is present\r\n     * @throws NullPointerException if no value is present and the exception\r\n     *          supplying function is {@code null}\r\n     *\/<\/span>\r\n    public<\/span> <<\/span>X<\/span> extends<\/span> Throwable<\/span>><\/span> T<\/span> orElseThrow<\/span>(<\/span>Supplier<\/span><?<\/span> extends<\/span> X<\/span>><\/span> exceptionSupplier<\/span>)<\/span> throws<\/span> X<\/span> {<\/span>\r\n        if<\/span> (<\/span>value<\/span> !=<\/span> null<\/span>)<\/span> {<\/span>\r\n            return<\/span> value<\/span>;<\/span>\r\n        }<\/span> else<\/span> {<\/span>\r\n            throw<\/span> exceptionSupplier<\/span>.<\/span>get<\/span>();<\/span>\r\n        }<\/span>\r\n    }<\/span>\r\n\r\n    \/**\r\n     * Indicates whether some other object is \"equal to\" this {@code Optional}.\r\n     * The other object is considered equal if:\r\n     * <ul>\r\n     * <li>it is also an {@code Optional} and;\r\n     * <li>both instances have no value present or;\r\n     * <li>the present values are \"equal to\" each other via {@code equals()}.\r\n     * <\/ul>\r\n     *\r\n     * @param obj an object to be tested for equality\r\n     * @return {@code true} if the other object is \"equal to\" this object\r\n     *         otherwise {@code false}\r\n     *\/<\/span>\r\n    @Override<\/span>\r\n    public<\/span> boolean<\/span> equals<\/span>(<\/span>Object<\/span> obj<\/span>)<\/span> {<\/span>\r\n        if<\/span> (<\/span>this<\/span> ==<\/span> obj<\/span>)<\/span> {<\/span>\r\n            return<\/span> true<\/span>;<\/span>\r\n        }<\/span>\r\n\r\n        if<\/span> (!(<\/span>obj<\/span> instanceof<\/span> Optional<\/span>))<\/span> {<\/span>\r\n            return<\/span> false<\/span>;<\/span>\r\n        }<\/span>\r\n\r\n        Optional<\/span><?><\/span> other<\/span> =<\/span> (<\/span>Optional<\/span><?>)<\/span> obj<\/span>;<\/span>\r\n        return<\/span> Objects<\/span>.<\/span>equals<\/span>(<\/span>value<\/span>,<\/span> other<\/span>.<\/span>value<\/span>);<\/span>\r\n    }<\/span>\r\n\r\n    \/**\r\n     * Returns the hash code of the value, if present, otherwise {@code 0}\r\n     * (zero) if no value is present.\r\n     *\r\n     * @return hash code value of the present value or {@code 0} if no value is\r\n     *         present\r\n     *\/<\/span>\r\n    @Override<\/span>\r\n    public<\/span> int<\/span> hashCode<\/span>()<\/span> {<\/span>\r\n        return<\/span> Objects<\/span>.<\/span>hashCode<\/span>(<\/span>value<\/span>);<\/span>\r\n    }<\/span>\r\n\r\n    \/**\r\n     * Returns a non-empty string representation of this {@code Optional}\r\n     * suitable for debugging.  The exact presentation format is unspecified and\r\n     * may vary between implementations and versions.\r\n     *\r\n     * @implSpec\r\n     * If a value is present the result must include its string representation\r\n     * in the result.  Empty and present {@code Optional}s must be unambiguously\r\n     * differentiable.\r\n     *\r\n     * @return the string representation of this instance\r\n     *\/<\/span>\r\n    @Override<\/span>\r\n    public<\/span> String<\/span> toString<\/span>()<\/span> {<\/span>\r\n        return<\/span> value<\/span> !=<\/span> null<\/span>\r\n            ?<\/span> String<\/span>.<\/span>format<\/span>(<\/span>\"Optional[%s]\"<\/span>,<\/span> value<\/span>)<\/span>\r\n            :<\/span> \"Optional.empty\"<\/span>;<\/span>\r\n    }<\/span>\r\n}<\/span>\r\n\r\n<\/code><\/pre>\n","protected":false},"excerpt":{"rendered":"
\u4f7f\u7528\u793a\u4f8b import java.util.Arrays; import java.util.List; im […]<\/p>\n","protected":false},"author":6,"featured_media":0,"comment_status":"closed","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[1],"tags":[],"class_list":["post-31632","post","type-post","status-publish","format-standard","hentry","category-uncategorized"],"yoast_head":"\nJava \u7684 Optional \u7c7b - Blog - Silicon Cloud<\/title>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/www.silicloud.com\/zh\/blog\/java-\u7684-optional-\u7c7b\/\" \/>\n<meta property=\"og:locale\" content=\"zh_CN\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Java \u7684 Optional \u7c7b\" \/>\n<meta property=\"og:description\" content=\"\u4f7f\u7528\u793a\u4f8b import java.util.Arrays; import java.util.List; im […]\" \/>\n<meta property=\"og:url\" content=\"https:\/\/www.silicloud.com\/zh\/blog\/java-\u7684-optional-\u7c7b\/\" \/>\n<meta property=\"og:site_name\" content=\"Blog - Silicon Cloud\" \/>\n<meta property=\"article:published_time\" content=\"2023-01-27T12:24:20+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2024-01-14T22:49:52+00:00\" \/>\n<meta name=\"author\" content=\"\u6587, \u7fd4\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"\u4f5c\u8005\" \/>\n\t<meta name=\"twitter:data1\" content=\"\u6587, \u7fd4\" \/>\n\t<meta name=\"twitter:label2\" content=\"\u9884\u8ba1\u9605\u8bfb\u65f6\u95f4\" \/>\n\t<meta name=\"twitter:data2\" content=\"11 \u5206\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\/\/schema.org\",\"@graph\":[{\"@type\":\"WebPage\",\"@id\":\"https:\/\/www.silicloud.com\/zh\/blog\/java-%e7%9a%84-optional-%e7%b1%bb\/\",\"url\":\"https:\/\/www.silicloud.com\/zh\/blog\/java-%e7%9a%84-optional-%e7%b1%bb\/\",\"name\":\"Java \u7684 Optional \u7c7b - Blog - Silicon Cloud\",\"isPartOf\":{\"@id\":\"https:\/\/www.silicloud.com\/zh\/blog\/#website\"},\"datePublished\":\"2023-01-27T12:24:20+00:00\",\"dateModified\":\"2024-01-14T22:49:52+00:00\",\"author\":{\"@id\":\"https:\/\/www.silicloud.com\/zh\/blog\/#\/schema\/person\/64d5cc7727fffbff2f9a2a8da1de3e5c\"},\"breadcrumb\":{\"@id\":\"https:\/\/www.silicloud.com\/zh\/blog\/java-%e7%9a%84-optional-%e7%b1%bb\/#breadcrumb\"},\"inLanguage\":\"zh-Hans\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/www.silicloud.com\/zh\/blog\/java-%e7%9a%84-optional-%e7%b1%bb\/\"]}]},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/www.silicloud.com\/zh\/blog\/java-%e7%9a%84-optional-%e7%b1%bb\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"\u9996\u9875\",\"item\":\"https:\/\/www.silicloud.com\/zh\/blog\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Java \u7684 Optional \u7c7b\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\/\/www.silicloud.com\/zh\/blog\/#website\",\"url\":\"https:\/\/www.silicloud.com\/zh\/blog\/\",\"name\":\"Blog - Silicon Cloud\",\"description\":\"\",\"inLanguage\":\"zh-Hans\"},{\"@type\":\"Person\",\"@id\":\"https:\/\/www.silicloud.com\/zh\/blog\/#\/schema\/person\/64d5cc7727fffbff2f9a2a8da1de3e5c\",\"name\":\"\u6587, \u7fd4\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"zh-Hans\",\"@id\":\"https:\/\/www.silicloud.com\/zh\/blog\/#\/schema\/person\/image\/\",\"url\":\"https:\/\/secure.gravatar.com\/avatar\/920c3d673e0bccacc98e5e6b7149bb3c22edd8d39cb753e5d7d7e471498118a1?s=96&d=mm&r=g\",\"contentUrl\":\"https:\/\/secure.gravatar.com\/avatar\/920c3d673e0bccacc98e5e6b7149bb3c22edd8d39cb753e5d7d7e471498118a1?s=96&d=mm&r=g\",\"caption\":\"\u6587, \u7fd4\"},\"url\":\"https:\/\/www.silicloud.com\/zh\/blog\/author\/wenxiang\/\"},{\"@type\":\"ImageObject\",\"inLanguage\":\"zh-Hans\",\"@id\":\"https:\/\/www.silicloud.com\/zh\/blog\/java-%e7%9a%84-optional-%e7%b1%bb\/#local-main-organization-logo\",\"url\":\"\",\"contentUrl\":\"\",\"caption\":\"Blog - Silicon Cloud\"}]}<\/script>\n<!-- \/ Yoast SEO Premium plugin. -->","yoast_head_json":{"title":"Java \u7684 Optional \u7c7b - Blog - Silicon Cloud","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/www.silicloud.com\/zh\/blog\/java-\u7684-optional-\u7c7b\/","og_locale":"zh_CN","og_type":"article","og_title":"Java \u7684 Optional \u7c7b","og_description":"\u4f7f\u7528\u793a\u4f8b import java.util.Arrays; import java.util.List; im […]","og_url":"https:\/\/www.silicloud.com\/zh\/blog\/java-\u7684-optional-\u7c7b\/","og_site_name":"Blog - Silicon Cloud","article_published_time":"2023-01-27T12:24:20+00:00","article_modified_time":"2024-01-14T22:49:52+00:00","author":"\u6587, \u7fd4","twitter_card":"summary_large_image","twitter_misc":{"\u4f5c\u8005":"\u6587, \u7fd4","\u9884\u8ba1\u9605\u8bfb\u65f6\u95f4":"11 \u5206"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"WebPage","@id":"https:\/\/www.silicloud.com\/zh\/blog\/java-%e7%9a%84-optional-%e7%b1%bb\/","url":"https:\/\/www.silicloud.com\/zh\/blog\/java-%e7%9a%84-optional-%e7%b1%bb\/","name":"Java \u7684 Optional \u7c7b - Blog - Silicon Cloud","isPartOf":{"@id":"https:\/\/www.silicloud.com\/zh\/blog\/#website"},"datePublished":"2023-01-27T12:24:20+00:00","dateModified":"2024-01-14T22:49:52+00:00","author":{"@id":"https:\/\/www.silicloud.com\/zh\/blog\/#\/schema\/person\/64d5cc7727fffbff2f9a2a8da1de3e5c"},"breadcrumb":{"@id":"https:\/\/www.silicloud.com\/zh\/blog\/java-%e7%9a%84-optional-%e7%b1%bb\/#breadcrumb"},"inLanguage":"zh-Hans","potentialAction":[{"@type":"ReadAction","target":["https:\/\/www.silicloud.com\/zh\/blog\/java-%e7%9a%84-optional-%e7%b1%bb\/"]}]},{"@type":"BreadcrumbList","@id":"https:\/\/www.silicloud.com\/zh\/blog\/java-%e7%9a%84-optional-%e7%b1%bb\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"\u9996\u9875","item":"https:\/\/www.silicloud.com\/zh\/blog\/"},{"@type":"ListItem","position":2,"name":"Java \u7684 Optional \u7c7b"}]},{"@type":"WebSite","@id":"https:\/\/www.silicloud.com\/zh\/blog\/#website","url":"https:\/\/www.silicloud.com\/zh\/blog\/","name":"Blog - Silicon Cloud","description":"","inLanguage":"zh-Hans"},{"@type":"Person","@id":"https:\/\/www.silicloud.com\/zh\/blog\/#\/schema\/person\/64d5cc7727fffbff2f9a2a8da1de3e5c","name":"\u6587, \u7fd4","image":{"@type":"ImageObject","inLanguage":"zh-Hans","@id":"https:\/\/www.silicloud.com\/zh\/blog\/#\/schema\/person\/image\/","url":"https:\/\/secure.gravatar.com\/avatar\/920c3d673e0bccacc98e5e6b7149bb3c22edd8d39cb753e5d7d7e471498118a1?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/920c3d673e0bccacc98e5e6b7149bb3c22edd8d39cb753e5d7d7e471498118a1?s=96&d=mm&r=g","caption":"\u6587, \u7fd4"},"url":"https:\/\/www.silicloud.com\/zh\/blog\/author\/wenxiang\/"},{"@type":"ImageObject","inLanguage":"zh-Hans","@id":"https:\/\/www.silicloud.com\/zh\/blog\/java-%e7%9a%84-optional-%e7%b1%bb\/#local-main-organization-logo","url":"","contentUrl":"","caption":"Blog - Silicon Cloud"}]}},"_links":{"self":[{"href":"https:\/\/www.silicloud.com\/zh\/blog\/wp-json\/wp\/v2\/posts\/31632","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.silicloud.com\/zh\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.silicloud.com\/zh\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.silicloud.com\/zh\/blog\/wp-json\/wp\/v2\/users\/6"}],"replies":[{"embeddable":true,"href":"https:\/\/www.silicloud.com\/zh\/blog\/wp-json\/wp\/v2\/comments?post=31632"}],"version-history":[{"count":2,"href":"https:\/\/www.silicloud.com\/zh\/blog\/wp-json\/wp\/v2\/posts\/31632\/revisions"}],"predecessor-version":[{"id":57108,"href":"https:\/\/www.silicloud.com\/zh\/blog\/wp-json\/wp\/v2\/posts\/31632\/revisions\/57108"}],"wp:attachment":[{"href":"https:\/\/www.silicloud.com\/zh\/blog\/wp-json\/wp\/v2\/media?parent=31632"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.silicloud.com\/zh\/blog\/wp-json\/wp\/v2\/categories?post=31632"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.silicloud.com\/zh\/blog\/wp-json\/wp\/v2\/tags?post=31632"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}