Java में null जांचना कैसे बंद करें और पागल न हों

null का अभिशाप: हम बार-बार एक ही चीज़ क्यों लिखते हैं?

यदि आप एक सप्ताह से अधिक समय से Java में लिख रहे हैं, तो आपने निश्चित रूप से NullPointerException का सामना किया होगा। और, सबसे अधिक संभावना है, आपकी पहली प्रतिक्रिया थी: "हाँ, बस जाँच करने की ज़रूरत है!"। इस तरह कोड के किलोमीटर लंबे टुकड़े जन्म लेते हैं:

if (user != null) {\n    if (user.getAddress() != null) {\n        String city = user.getAddress().getCity();\n        if (city != null) {\n            System.out.println(city.toUpperCase());\n        }\n    }\n}\n

यह कोड काम करता है। लेकिन यह बदसूरत है। यह तर्क को पढ़ने को यातना और रखरखाव को दुःस्वप्न में बदल देता है। Stack Overflow पर प्रश्न "How do I avoid checking for nulls in Java?" ने संयोग से हजारों बार नहीं देखा गया। हर Java डेवलपर देर-सबेर यह सवाल पूछता है।

अच्छी खबर: null जांच से बचना न केवल संभव है, बल्कि आवश्यक भी है। Java JavaScript नहीं है, और हमारे पास "सुरक्षात्मक" निर्माणों के बिना स्वच्छ, सुरक्षित कोड लिखने के लिए उपकरण हैं। आइए उन सभी पर चर्चा करें - बुनियादी सेट से लेकर उन्नत तकनीकों तक।

1. Optional<T> — आपका मुख्य सहयोगी

Java 8 से शुरू करके, हमारे पास Optional है। यह एक कंटेनर है जो एक मान रख सकता है या खाली हो सकता है। यह सचमुच null जांच से बचने और कोड को अधिक घोषणात्मक बनाने के लिए बनाया गया है।

यह कैसे काम करता है?

विधि से null लौटाने के बजाय, Optional लौटाएँ। और जाँच के बजाय - विधियों की श्रृंखला का उपयोग करें।

// बुरा\npublic String getCity(User user) {\n    if (user == null) return "Unknown";\n    Address address = user.getAddress();\n    if (address == null) return "Unknown";\n    return address.getCity();\n}\n\n// अच्छा\npublic Optional<String> getCity(User user) {\n    return Optional.ofNullable(user)\n            .map(User::getAddress)\n            .map(Address::getCity);\n}\n\n// उपयोग\nString city = getCity(someUser).orElse("Unknown");\n

ध्यान दें: एक भी if नहीं है। map केवल तभी काम करता है जब मान null न हो। यदि किसी भी चरण में null आता है - श्रृंखला टूट जाती है, और आपको Optional.empty() मिलता है।

Optional के लोकप्रिय तरीके

\n
• orElse(T other) — मान या वैकल्पिक विकल्प लौटाएँ
\n
• orElseGet(Supplier<? extends T> other) — आलसी संस्करण, केवल ज़रूरत पड़ने पर गणना करता है
\n
• orElseThrow(Supplier<? extends X> exceptionSupplier) — अपना अपवाद फेंकें
\n
• ifPresent(Consumer<? super T> consumer) — यदि मान मौजूद है तो कार्रवाई करें
\n
• filter(Predicate<? super T> predicate) — शर्त के अनुसार फ़िल्टर करें
\n

// फ़िल्टर के साथ उदाहरण\nOptional<String> name = Optional.of("Java");\nname.filter(n -> n.startsWith("J"))\n    .ifPresent(System.out::println); // "Java" प्रिंट करेगा\n

महत्वपूर्ण: Optional लौटाए गए मानों के लिए है, क्लास फ़ील्ड या विधि पैरामीटर के लिए नहीं। इसका दुरुपयोग न करें।

2. Objects.requireNonNull() — स्पष्ट अनुबंधों के लिए उपयोगिता

कभी-कभी null एक त्रुटि है, और इसे जितनी जल्दी हो सके पता लगाने की आवश्यकता है। मैन्युअल रूप से जाँच लिखने के बजाय, java.util.Objects.requireNonNull() का उपयोग करें।

public class UserService {\n    private final UserRepository repository;\n\n    public UserService(UserRepository repository) {\n        this.repository = Objects.requireNonNull(repository, \n            "UserRepository must not be null");\n    }\n\n    public User findById(Long id) {\n        Objects.requireNonNull(id, "ID must not be null");\n        return repository.findById(id);\n    }\n}\n

यह दृष्टिकोण कहलाता है