Optional<T> (Java 8+) అనేది ఒక విలువను కలిగి ఉండవచ్చు లేదా కలిగి ఉండకపోవచ్చు ఒక కంటైనర — null ను తిరిగి ఇవ్వడానికి బదులుగా "విలువ లేకపోవచ్చు" ను సూచించడానికి స్పష్టమైన మార్గం. ఇది కాలర్లను ఖాళీ సందర్భాన్ని పరిగణించడానికి బలవంతం చేయడం ద్వారా భయంకరమైన NullPointerException (NPE) ను నిరోధించడానికి సహాయం చేస్తుంది.
User {
userMap.get(id);
}
findUser();
u.getName();
NULL రిటర్న్లు సులభంగా విస్మరించబడతాయి, మరియు ఫలితంగా NPE — "బిలియన్ డాలర్ల తప్పు" — Java లో అత్యంత సాధారణ బగ్లలో ఒకటి.
// ✅ the return type ITSELF signals "might be absent" — callers must handle it
public Optional<User> findUser(String id) {
return Optional.ofNullable(userMap.get(id));
}
ఇప్పుడు సంతకం లేకపోవటాన్ని స్పష్టంగా చేస్తుంది మరియు కంపైలర్చే ప్రోత్సహించిన API కాలర్లను ఖాళీ సందర్భాన్ని నిర్వహించమని నిర్ధారిస్తుంది.
Optional<String> a = Optional.of("hi"); // value present (throws if you pass null)
Optional<String> b = Optional.empty(); // explicitly absent
Optional<String> c = Optional.ofNullable(x); // present if x != null, else empty
Optional<User> user = findUser("123");
// provide a fallback
User u = user.orElse(defaultUser);
User u2 = user.orElseGet(() -> createDefault()); // lazy fallback
User u3 = user.orElseThrow(() -> new NotFoundException());
// run code only if present
user.ifPresent(u -> System.out.println(u.getName()));
// transform without unwrapping (chainable, null-safe)
String name = user.map(User::getName).orElse("Unknown");
String city = user.map(User::getAddress).map(Address::getCity).orElse("N/A");
కార్యకరమైన పద్ధతులు (map, filter, orElse, ifPresent) విలువలను సురక్షితంగా పరిణామం చేయడానికి మరియు సంగ్రహించడానికి మీకు అనుమతిస్తాయి, చిన్న null తనిఖీలు లేకుండా శృంఖలాబద్ధంగా.
// ❌ defeats the purpose — get() throws if empty, like dereferencing null
if (user.isPresent()) {
User u = user.get(); // verbose AND risky if you forget isPresent()
}
// ✅ use orElse/map/ifPresent instead
// ❌ don't use Optional for fields or method parameters — it's designed for RETURN types
// ❌ never return null from a method that returns Optional
Optional అనేది null-సంబంధిత బగ్ సమస్యను పరిష్కరించడానికి Java యొక్క సాధనం, ఇది టైప్ సిస్టమ్లో లేకపోవటాన్ని స్పష్టంగా చేయడం ద్వారా — నిశ్శబ్ద NPEలను నిర్వహించిన సందర్భంగా మారుస్తుంది.
ఇది ఒక విలువను ఉత్పత్తి చేయకపోవచ్చు ఆ పద్ధతుల కోసం రిటర్న్ టైప్ గా అందించడం దీని ప్రధాన ఉద్దేశ్యం, ఇక్కడ ఇది లేకపోవటాన్ని విస్మరించి చేస్తుంది, మరియు దీని కార్యకరమైన పద్ధతులు (map, orElse, ifPresent) శుద్ధ, null-సురక్షితమైన శృంఖలాబద్ధతను ప్రారంభించాయి.
దీన్ని సరిగ్గా ఎలా ఉపయోగించాలో అర్థం చేసుకోవడం — మరియు యాంటీ-ప్యాటర్నలు (అసాధారణంగా get() ను పిలిచే, ఫీల్డ్ల / పారామితుల కోసం ఉపయోగించుకోవడం, null ను తిరిగి ఇవ్వడం) — మరింత దృఢమైన, స్వయం-డాక్యుమెంటెడ్ కోడ్కు తక్కువ NPEలతో దారితీస్తుంది, అందుకే ఇది ఉత్తమ-అభ్యాస సాధనం మరియు ఆధునిక Java లో సాధారణ ఇంటర్వ్యూ టాపిక్.