Java 8 की Optional.ifPresent की कार्यात्मक शैली और यदि नहीं तो क्या है?

Question

जावा 8 में, मैं एक Optionalवस्तु के लिए कुछ करना चाहता हूं यदि वह मौजूद है, और दूसरी चीज है अगर वह मौजूद नहीं है।

if (opt.isPresent()) {
  System.out.println("found");
} else {
  System.out.println("Not found");
}

यह एक 'कार्यात्मक शैली' नहीं है, हालांकि।

Optionalएक ifPresent()विधि है, लेकिन मैं एक orElse()विधि को चेन करने में असमर्थ हूं ।

इस प्रकार, मैं नहीं लिख सकता:

opt.ifPresent( x -> System.out.println("found " + x))
   .orElse( System.out.println("NOT FOUND"));

@Assylias के जवाब में, मुझे नहीं लगता Optional.map()कि निम्नलिखित मामले के लिए काम करता है:

opt.map( o -> {
  System.out.println("while opt is present...");
  o.setProperty(xxx);
  dao.update(o);
  return null;
}).orElseGet( () -> {
  System.out.println("create new obj");
  dao.save(new obj);
  return null;
});

इस स्थिति में, जब optमैं उपस्थित होता हूं, मैं इसकी संपत्ति को अपडेट करता हूं और डेटाबेस में सहेजता हूं। जब यह उपलब्ध नहीं होता है, तो मैं एक नया बनाता हूं objऔर डेटाबेस में सहेजता हूं ।

दो लंबोदर में ध्यान दें मुझे वापस लौटना है null।

लेकिन जब optमौजूद होगा, तो दोनों लंबों को निष्पादित किया जाएगा। objअद्यतन किया जाएगा, और एक नई वस्तु डेटाबेस में सहेजी जाएगी। इसका कारण return nullपहले मेमने में है। और orElseGet()अंजाम देता रहेगा।

Comments

अपने पहले नमूने का उपयोग करें। यह सुंदर है ।

— सोतीरियोस डेलिमोलिस

मेरा सुझाव है कि आप एक एपीआई का उपयोग करते समय कुछ व्यवहार को मजबूर करना बंद करें जो उस व्यवहार के लिए डिज़ाइन नहीं किया गया है। आप कुछ छोटे शैली की टिप्पणियों के अलावा मेरे लिए ठीक उदाहरण देखते हैं, लेकिन उन पर विचार किया गया है।

— skiwi

@smallufo: (दोनों) के return null;साथ बदलें return o;। हालांकि, मुझे इस बात का अहसास है कि आप गलत जगह पर काम कर रहे हैं। आपको उस साइट पर काम करना चाहिए जो उस का उत्पादन करती है Optional। उस स्थान पर मध्यवर्ती के बिना वांछित संचालन करने का एक तरीका होना चाहिए Optional।

— होल्गर

जावा 9 आपकी समस्या का समाधान लागू करता है: iteratrlearning.com/java9/2016/09/05/java9-optional.html

— pisaruk

मुझे लगता है कि इसका कारण यह आसानी से नहीं हो सकता है। वैकल्पिक प्रवाह नियंत्रण नहीं करना चाहिए, बल्कि मूल्य परिवर्तन करना चाहिए। मुझे इसके ifPresentविपरीत पता है । अन्य सभी विधियाँ मूल्य को दर्शाती हैं न कि क्रियाओं को।

— एलिकएल्ज़िन-किलाका

Answer 1

मेरे लिए @ व्हाइट का जवाब ठीक है, पहले मुझे रननेबल का उपयोग करना पसंद नहीं था, लेकिन मुझे कोई विकल्प नहीं मिला, यहां एक और कार्यान्वयन मुझे अधिक पसंद आया

public class OptionalConsumer<T> {
    private Optional<T> optional;

    private OptionalConsumer(Optional<T> optional) {
        this.optional = optional;
    }

    public static <T> OptionalConsumer<T> of(Optional<T> optional) {
        return new OptionalConsumer<>(optional);
    }

    public OptionalConsumer<T> ifPresent(Consumer<T> c) {
        optional.ifPresent(c);
        return this;
    }

    public OptionalConsumer<T> ifNotPresent(Runnable r) {
        if (!optional.isPresent()) {
            r.run();
        }
        return this;
    }
}

फिर :

Optional<Any> o = Optional.of(...);
OptionalConsumer.of(o).ifPresent(s ->System.out.println("isPresent "+s))
            .ifNotPresent(() -> System.out.println("! isPresent"));

अपडेट 1:

विकास के पारंपरिक तरीके के लिए उपरोक्त समाधान जब आपके पास मूल्य है और इसे संसाधित करना चाहते हैं लेकिन क्या होगा अगर मैं कार्यक्षमता को परिभाषित करना चाहता हूं और निष्पादन तब होगा, वृद्धि के नीचे की जांच करें;

public class OptionalConsumer<T> implements Consumer<Optional<T>> {
private final Consumer<T> c;
private final Runnable r;

public OptionalConsumer(Consumer<T> c, Runnable r) {
    super();
    this.c = c;
    this.r = r;
}

public static <T> OptionalConsumer<T> of(Consumer<T> c, Runnable r) {
    return new OptionalConsumer(c, r);
}

@Override
public void accept(Optional<T> t) {
    if (t.isPresent()) {
        c.accept(t.get());
    }
    else {
        r.run();
    }
}

तो के रूप में इस्तेमाल किया जा सकता है:

    Consumer<Optional<Integer>> c=OptionalConsumer.of(System.out::println, ()->{System.out.println("Not fit");});
    IntStream.range(0, 100).boxed().map(i->Optional.of(i).filter(j->j%2==0)).forEach(c);

इस नए कोड में आपके पास 3 चीजें हैं:

1. ऑब्जेक्ट की मौजूदा आसान से पहले कार्यक्षमता को परिभाषित कर सकते हैं।
2. प्रत्येक वैकल्पिक के लिए ऑब्जेक्ट रिफ्रेंस नहीं बना रहा है, केवल एक, आपके पास इतनी कम मेमोरी है तो कम जीसी।
3. यह अन्य घटकों के साथ बेहतर उपयोग के लिए उपभोक्ता को लागू कर रहा है।

वैसे अब इसका नाम अधिक वर्णनात्मक है यह वास्तव में उपभोक्ता> है

Comments

Optional.ofNullable (o) का उपयोग Optional.of (o) के बजाय करना चाहिए

— ट्रैपर

यदि आप सुनिश्चित नहीं हैं कि यदि आप जिस मूल्य का उपयोग करने जा रहे हैं, वह अशक्त है या नहीं, तो आपको Nullable का उपयोग करने की आवश्यकता है और NPE का सामना करने की आवश्यकता नहीं है, और यदि आपको यकीन है कि यह अशक्त नहीं है या आपको इसकी परवाह नहीं है एनपीई।

— बसीम रेडा ज़ोहदी

मुझे लगता है कि वर्ग OptionalConsumer से बेहतर लगता है अगर / कोड में। धन्यवाद! :)

— witek1902

Answer 2

यदि आप जावा 9+ का उपयोग कर रहे हैं, तो आप ifPresentOrElse()विधि का उपयोग कर सकते हैं :

opt.ifPresentOrElse(
   value -> System.out.println("Found: " + value),
   () -> System.out.println("Not found")
);

Comments

अच्छा है क्योंकि यह लगभग रूप में साफ है जैसे कि स्काला में मैचिंग पैटर्न

— sscarduzio

दो लंबोदर की तरह वह बहुत बदसूरत है। मुझे लगता है कि अगर / इन मामलों के लिए और अधिक क्लीनर है।

— जॉन १६३16४

@ john16384 ठीक है, अगर आपको यह बदसूरत लगता है, तो मैं अपना जवाब (नहीं) हटाने जा रहा हूं।

— बृहस्पतिवार को

यह बहुत अच्छा है लेकिन सवाल विशेष रूप से JDK8 के लिए था क्योंकि ifresentOrElse उपलब्ध नहीं है।

— हरिन

Answer 3

जावा 9 पेश करता है

ifPresentOrElse यदि कोई मान मौजूद है, तो दिए गए क्रिया को मान के साथ करता है, अन्यथा दिए गए खाली-आधारित क्रिया को निष्पादित करता है।

Java 8 चीट शीट में उत्कृष्ट वैकल्पिक देखें ।

यह अधिकांश उपयोग के मामलों के लिए सभी उत्तर प्रदान करता है।

नीचे संक्षिप्त सारांश

ifPresent () - वैकल्पिक सेट होने पर कुछ करें

opt.ifPresent(x -> print(x)); 
opt.ifPresent(this::print);

फ़िल्टर () - अस्वीकार (फ़िल्टर आउट) कुछ वैकल्पिक मान।

opt.filter(x -> x.contains("ab")).ifPresent(this::print);

नक्शा () - यदि मौजूद हो तो मूल्य बदलें

opt.map(String::trim).filter(t -> t.length() > 1).ifPresent(this::print);

orElse () / orElseGet () - डिफ़ॉल्ट T के लिए खाली वैकल्पिक मोड़

int len = opt.map(String::length).orElse(-1);
int len = opt.
    map(String::length).
    orElseGet(() -> slowDefault());     //orElseGet(this::slowDefault)

orElseThrow () - खाली वैकल्पिक पर आलसी फेंक अपवाद

opt.
filter(s -> !s.isEmpty()).
map(s -> s.charAt(0)).
orElseThrow(IllegalArgumentException::new);

Comments

यह वास्तव में ओपी के सवाल का जवाब नहीं देता है। यह बहुत सारे सामान्य उपयोगों का उत्तर देता है, लेकिन ओपी ने जो नहीं पूछा।

— कप्तान मैन

@ कैपटमैन वास्तव में यह करता है; Opt.map ("पाया गया") .Else ("नहीं मिला") अभिव्यक्ति बिल भरता है।

— मैट

@Matt नहीं, ओपी विशेष रूप से अपने द्वारा किए गए कार्यों के लिए पूछ रहा है जब वैकल्पिक है / मौजूद नहीं है, जब यह है या नहीं तो एक मान वापस करने के लिए नहीं। ओपी भी सवाल में कुछ इसी तरह का उल्लेख करते हुए orlseGet का उपयोग करते हुए बताते हैं कि यह काम क्यों नहीं करेगा।

— कप्तान मैन

@ कैपटमैन मैं आपकी बात देखता हूं। मुझे लगता है कि वह इसे काम कर सकता है अगर वह इसमें से वापस नहीं आया है map, लेकिन यह एक कार्यात्मक समाधान के लिए पूछने के लिए थोड़ा अजीब है ताकि आप एक डीएओ को बुला सकें। मुझे लगता है कि इस map.orElseब्लॉक से अद्यतन / नई वस्तु को वापस करने के लिए और अधिक समझ में आता है और फिर आपको लौटी हुई वस्तु के साथ क्या करना है।

— मैट

मुझे लगता है कि mapधारा पर ही ध्यान केंद्रित है और "धारा में इस तत्व की स्थिति के आधार पर किसी अन्य वस्तु के लिए चीजें करना" के लिए इरादा नहीं है। यह जानकर अच्छा लगा कि ifPresentOrElseजावा 9. में जोड़ा गया है

— वेस्टर्नगंज

Answer 4

एक विकल्प है:

System.out.println(opt.map(o -> "Found")
                      .orElse("Not found"));

मुझे नहीं लगता कि यह पठनीयता में सुधार करता है।

या जैसा कि मार्को ने सुझाव दिया था, एक टर्नरी ऑपरेटर का उपयोग करें:

System.out.println(opt.isPresent() ? "Found" : "Not found");

Comments

धन्यवाद @assylias, लेकिन मुझे नहीं लगता कि Optional.map () मामले के लिए काम करता है (मेरा संदर्भ अद्यतन देखें)।

— छोटूफे

@smallufo आपको new Object();अपने पहले लैम्ब्डा में लौटने की आवश्यकता होगी लेकिन ईमानदार होना जो बहुत बदसूरत हो जाता है। मैं आपके अद्यतित उदाहरण के लिए if / if से चिपका रहूंगा।

— अस्वच्छता

सहमत हूँ, चाइनिंग के mapलिए बस वापस जाने के Optionalलिए कोड को समझना कठिन हो mapजाता है, जबकि इसे किसी चीज़ के लिए सचमुच माना जाता है।

— टिआना

Answer 5

एक अन्य समाधान उच्च-क्रम के कार्यों का उपयोग निम्नानुसार होगा

opt.<Runnable>map(value -> () -> System.out.println("Found " + value))
   .orElse(() -> System.out.println("Not Found"))
   .run();

Comments

मेरी नज़र में JDK 9. के बिना अब तक का सबसे अच्छा समाधान

— सेमीफोर

एक स्पष्टीकरण बहुत अच्छा होगा। मैं अपने आप से पूछ रहा हूं, आपको एक रनवेबल मैप (?) का उपयोग करने की आवश्यकता क्यों है और value -> () -> sysoइसका क्या मतलब है।

— मेंहली

इस समाधान के लिए धन्यवाद! मुझे लगता है कि रननेबल का उपयोग करने का कारण यह है कि मैप किसी भी मूल्य पर वापस नहीं आता है और रननेबल के साथ यह लैम्ब्डा लौटाता है और जैसे कि मैप का परिणाम लैम्ब्डा है हम इसे बाद में चलाते हैं। इसलिए यदि आपके पास रिटर्निंग वैल्यू है तो आप निम्नलिखित का उपयोग कर सकते हैं:String result = opt.map(value -> "withOptional").orElse("without optional");

— नैनोटेक्निक 18

Answer 6

यह बॉक्स से बाहर करने का एक शानदार तरीका नहीं है। यदि आप नियमित रूप से अपने क्लीनर सिंटैक्स का उपयोग करना चाहते हैं, तो आप मदद करने के लिए एक उपयोगिता वर्ग बना सकते हैं:

public class OptionalEx {
    private boolean isPresent;

    private OptionalEx(boolean isPresent) {
        this.isPresent = isPresent;
    }

    public void orElse(Runnable runner) {
        if (!isPresent) {
            runner.run();
        }
    }

    public static <T> OptionalEx ifPresent(Optional<T> opt, Consumer<? super T> consumer) {
        if (opt.isPresent()) {
            consumer.accept(opt.get());
            return new OptionalEx(true);
        }
        return new OptionalEx(false);
    }
}

तब आप सिंटैक्स प्राप्त करने के लिए कहीं और एक स्थैतिक आयात का उपयोग कर सकते हैं जो आपके पास है:

import static com.example.OptionalEx.ifPresent;

ifPresent(opt, x -> System.out.println("found " + x))
    .orElse(() -> System.out.println("NOT FOUND"));

Comments

धन्यवाद। यह समाधान सुंदर है। मुझे पता है कि शायद कोई अंतर्निहित समाधान नहीं है (जब तक कि जेडीके ऐसी विधि को शामिल नहीं करता है)। आप OptionalEx बहुत मददगार है। आपका धन्यावाद।

— स्मॉलफू

हां, मुझे परिणाम पसंद है, और शैली इसका समर्थन करती है। एसओ, मानक एपीआई में क्यों नहीं?

— 13

अच्छा उत्तर। हम भी ऐसा ही करते हैं। मैं मानता हूं कि यह एपीआई (या भाषा!) में होना चाहिए, लेकिन इसे अस्वीकार कर दिया गया है: bugs.openjdk.java.net/browse/JDK-8057557 ।

— गैरेट स्मिथ

अच्छा लगा। यह विचार के लिए JDK 8.1 का हिस्सा होना चाहिए।

— peter_pilgrim

Optional.ifPresentOrElse()JDK 9. में जोड़ा गया है

— स्टुअर्ट मार्क्स

Answer 7

यदि आप केवल जावा 8 या निम्न का उपयोग कर सकते हैं:

1) यदि आपके पास spring-dataअब तक का सबसे अच्छा तरीका नहीं है:

opt.<Runnable>map(param -> () -> System.out.println(param))
      .orElse(() -> System.out.println("no-param-specified"))
      .run();

अब मुझे पता है कि यह इतना पठनीय और किसी के लिए समझने में कठिन भी नहीं है, लेकिन मेरे लिए व्यक्तिगत रूप से ठीक लगता है और मुझे इस मामले में एक और अच्छा धाराप्रवाह रास्ता नहीं दिखता।

2) यदि आप पर्याप्त भाग्यशाली हैं और आप spring-dataसबसे अच्छा तरीका इस्तेमाल कर सकते हैं तो वैकल्पिक # ifPresentOrElse :

Optionals.ifPresentOrElse(opt, System.out::println,
      () -> System.out.println("no-param-specified"));

यदि आप जावा 9 का उपयोग कर सकते हैं, तो आपको निश्चित रूप से जाना चाहिए:

opt.ifPresentOrElse(System.out::println,
      () -> System.out.println("no-param-specified"));

Answer 8

जावा 8+ के लिए ऑब्जेक्ट-फ़ंक्शनल लाइब्रेरी, Vavr (जिसे पहले Javaslang के रूप में जाना जाता है) का उपयोग करके वर्णित व्यवहार को प्राप्त किया जा सकता है , जो कि ज्यादातर स्काला कंस्ट्रक्शंस को लागू करता है (एक तरह से अधिक स्पष्ट भाषा के रूप में जावेद पर निर्मित रिचर्स सिस्टम)। शुद्ध कार्यात्मक कोड लिखने के लिए अपने जावा प्रोजेक्ट्स को जोड़ना एक बहुत अच्छी लाइब्रेरी है।

Vavr Optionविकल्प प्रकार के साथ काम करने के लिए कार्य प्रदान करता है कि मोनाद प्रदान करता है:

• fold: दोनों मामलों पर विकल्प के मान को परिभाषित करने के लिए (परिभाषित / खाली)
• onEmpty: Runnableविकल्प खाली होने पर निष्पादित करने की अनुमति देता है
• peek: विकल्प के मूल्य (जब परिभाषित) का उपभोग करने की अनुमति देता है।
• और यह Serializableइसके विपरीत भी है Optionalजिसका अर्थ है कि आप इसे विधि तर्क और उदाहरण सदस्य के रूप में सुरक्षित रूप से उपयोग कर सकते हैं।

विकल्प जावा के वैकल्पिक "छद्म-मोनाद" के अंतर पर मठ के कानूनों का पालन करता है और एक समृद्ध एपीआई प्रदान करता है। और निश्चित रूप से आप इसे एक जावा के वैकल्पिक (और आसपास का दूसरा तरीका) से बना सकते हैं: Option.ofOptional(javaOptional)-Vrr इंटरऑपरेबिलिटी पर केंद्रित है।

उदाहरण के लिए जा रहे हैं:

// AWESOME Vavr functional collections (immutable for the gread good :)
// fully convertible to Java's counterparts.
final Map<String, String> map = Map("key1", "value1", "key2", "value2");

final Option<String> opt = map.get("nonExistentKey"); // you're safe of null refs!

final String result = opt.fold(
        () -> "Not found!!!",                // Option is None
        val -> "Found the value: " + val     // Option is Some(val)
);

आगे की पढाई

अशक्त संदर्भ, अरब डॉलर की गलती

एनबी यह केवल एक बहुत कम उदाहरण है कि ववर प्रदान करता है (पैटर्न मिलान, स्ट्रीम उर्फ ​​आलसी मूल्यांकन की गई सूचियां, मोनैडिक प्रकार, अपरिवर्तनीय संग्रह, ...)।

Answer 9

एक अन्य समाधान निम्नलिखित हो सकता है:

आप इसका उपयोग कैसे करते हैं:

    final Opt<String> opt = Opt.of("I'm a cool text");
    opt.ifPresent()
        .apply(s -> System.out.printf("Text is: %s\n", s))
        .elseApply(() -> System.out.println("no text available"));

या मामले में आप विपरीत उपयोग के मामले में सच है:

    final Opt<String> opt = Opt.of("This is the text");
    opt.ifNotPresent()
        .apply(() -> System.out.println("Not present"))
        .elseApply(t -> /*do something here*/);

यह सामग्री हैं:

1. थोड़ा संशोधित फ़ंक्शन इंटरफ़ेस, बस "और अधिक" विधि के लिए
2. वैकल्पिक वृद्धि
3. थोड़ा सा करंट :-)

"कॉस्मैटिकली" फंक्शन इंटरफ़ेस बढ़ाया।

@FunctionalInterface
public interface Fkt<T, R> extends Function<T, R> {

    default R elseApply(final T t) {
        return this.apply(t);
    }

}

और वृद्धि के लिए वैकल्पिक आवरण वर्ग:

public class Opt<T> {

    private final Optional<T> optional;

    private Opt(final Optional<T> theOptional) {
        this.optional = theOptional;
    }

    public static <T> Opt<T> of(final T value) {
        return new Opt<>(Optional.of(value));
    }

    public static <T> Opt<T> of(final Optional<T> optional) {
        return new Opt<>(optional);
    }

    public static <T> Opt<T> ofNullable(final T value) {
        return new Opt<>(Optional.ofNullable(value));
    }

    public static <T> Opt<T> empty() {
        return new Opt<>(Optional.empty());
    }

    private final BiFunction<Consumer<T>, Runnable, Void> ifPresent = (present, notPresent) -> {
        if (this.optional.isPresent()) {
            present.accept(this.optional.get());
        } else {
            notPresent.run();
        }
        return null;
    };

   private final BiFunction<Runnable, Consumer<T>, Void> ifNotPresent = (notPresent, present) -> {
        if (!this.optional.isPresent()) {
            notPresent.run();
        } else {
            present.accept(this.optional.get());
        }
        return null;
    };

    public Fkt<Consumer<T>, Fkt<Runnable, Void>> ifPresent() {
        return Opt.curry(this.ifPresent);
    }

    public Fkt<Runnable, Fkt<Consumer<T>, Void>> ifNotPresent() {
        return Opt.curry(this.ifNotPresent);
    }

    private static <X, Y, Z> Fkt<X, Fkt<Y, Z>> curry(final BiFunction<X, Y, Z> function) {
        return (final X x) -> (final Y y) -> function.apply(x, y);
    }
}

यह चाल करना चाहिए और बुनियादी आवश्यकताओं के रूप में काम कर सकता है कि ऐसी आवश्यकताओं से कैसे निपटें।

यहां मूल विचार निम्नलिखित है। एक गैर-कार्यात्मक शैली की प्रोग्रामिंग दुनिया में, आप शायद एक ऐसा तरीका लागू करेंगे जिसमें दो पैरामीटर हों, जहां पहला एक प्रकार का रन करने योग्य कोड हो, जिसे उस मूल्य पर उपलब्ध होने पर निष्पादित किया जाना चाहिए और दूसरा पैरामीटर रनने योग्य कोड है, जिसे उस स्थिति में चलाया जाना चाहिए मान उपलब्ध नहीं है। बेहतर पठनीयता के लिए, आप एक पैरामीटर के दो कार्यों में दो पैरामीटर के फंक्शन को विभाजित करने के लिए कर सकते हैं। यह वही है जो मैंने मूल रूप से यहां किया था।

संकेत: ऑप्ट अन्य उपयोग के मामले भी प्रदान करता है जहां आप कोड का एक टुकड़ा निष्पादित करना चाहते हैं, यदि मूल्य उपलब्ध नहीं है। यह Optional.filter.stuff के माध्यम से भी किया जा सकता है लेकिन मुझे यह अधिक पठनीय लगा।

उम्मीद है की वो मदद करदे!

अच्छी प्रोग्रामिंग :-)

Comments

क्या आप बता सकते हैं कि क्या काम नहीं कर रहा है? मैंने इसे फिर से परीक्षण किया और मेरे लिए यह काम कर रहा है?

— एलेसैंड्रो गिसा

क्षमा करें, लेकिन ckass Fkt को कहां परिभाषित किया गया है? अंतिम लेकिन कम से कम मेरे पास एक संकलित मुद्दा नहीं है: त्रुटि: (35, 17) जावा: चर वैकल्पिक को प्रारंभ नहीं किया जा सकता है

— एनरिको ज्यूरिन

Fkt को इंटरफ़ेस के रूप में ऊपर परिभाषित किया गया है। बस पूरा लेख पढ़ें :-)

— एलेसेंड्रो गियोसा

हाँ। मैंने EFunction इंटरफ़ेस को Fkt में नाम के रूप में बदल दिया। एक टाइपो था। समीक्षा के लिए धन्यवाद :-) इसके लिए खेद है।

— एलेसेंड्रो गिसा

मुझे नहीं लगता है कि इस तरह कोड लिखने के लिए अच्छा विचार है ... जब आप कर सकते हैं तो आपको jdk उपयोगिता का उपयोग करना चाहिए।

— ट्युलपैन ट्युलपैन

Answer 10

मामले में आप मूल्य संग्रहीत करना चाहते हैं:

Pair.of<List<>, List<>> output = opt.map(details -> Pair.of(details.a, details.b))).orElseGet(() -> Pair.of(Collections.emptyList(), Collections.emptyList()));

Answer 11

यह मानते हुए कि आपके पास एक सूची है और isPresent()समस्या (वैकल्पिक के साथ संबंधित) से बचने के लिए आप उपयोग .iterator().hasNext()कर सकते हैं कि क्या मौजूद नहीं है।