Cad is Optional ann agus conas a chabhraíonn sé le null?

Question

Accepted Answer

**`Optional`** (Java 8+) is contiméir atá in ann nó nach bhfuil in ann luach a bhualadh — bealach soiléir chun "b'fhéidir go bhfuil luach in easnamh" a ionadaíocht in ionad `null` a thabhairt ar ais. Cabhraíonn sé an drochbunachar `NullPointerException` (NPE) a sheachaint trí chumraí ar ghlaochaithe a mheas an cás folamh. ## An fhadhb: null agus NPEs ```java // ❌ returning null — callers may forget to check → NullPointerException public User findUser(String id) { return userMap.get(id); // returns null if not found } User u = findUser("x"); u.getName(); // 💥 NPE if u was null — and nothing forced you to check ``` Is furasta null-luachanna a thugtar ar ais a dhiúltú, agus an NPE ina dhiaidh sin — "earráid an bhillúin dollar" — ceann de na meanbhuganna Java is coitianta. ## An réiteach: Optional a thabhairt ar ais ```java // ✅ the return type ITSELF signals "might be absent" — callers must handle it public Optional findUser(String id) { return Optional.ofNullable(userMap.get(id)); } ``` Anois déanann an síniú an neamhláithreachd soiléir agus bhrúnn an API spreacharnaithe ag an tiomsaitheoir ar ghlaochaithe déileáil a dhéanamh ar an gcás folamh. ## Optionals a chruthú ```java Optional a = Optional.of("hi"); // value present (throws if you pass null) Optional b = Optional.empty(); // explicitly absent Optional c = Optional.ofNullable(x); // present if x != null, else empty ``` ## Optionals a úsáid go sábháilte ```java Optional 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"); ``` Ligint na modhanna feidhmiúla (`map`, `filter`, `orElse`, `ifPresent`) duit luachanna a chlaochlú agus a bhaint go sábháilte, ag slabhraíonn gan imscrúduithe null foluaineach. ## Anti-patterns a sheachaint ```java // ❌ 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 ``` ## Cén fáth a bhfuil sé tábhachtach Is uirlis Java `Optional` an fhadhb fholuain **bugs bhaineann le null** a threisiú tríd an neamhláithreachd a dhéanamh soiléir sa chóras cineál — ag socrú NPEs tostach i gcás láimhsithe. Is í a príomhúsáid **cineál toraidh** a bheith aici do na modhanna nár fhéad luach a tháirgeadh, áit ar dhéanann sé an cás folamh a dhoiciméadú agus a fhórsáil a mheas, agus a chuid modhanna feidhmiúla (`map`, `orElse`, `ifPresent`) a chumasaítear slabhraíonn geal, neodrúisithe null. An tuiscint ar an chaoi ar chóir a úsáid go ceart — agus na anti-patterns (glaoch `get()` go cúramach, a úsáid do na páirc/pharaiméadair, `null` a thabhairt ar ais) — ag socrú i gcóras níos láidre, féin-dhéanta cód le níos lú NPEs, ar an chúis go bhfuil sé araon uirlis dea-chleachtais agus ábhar agallamh coitianta i Java nua-aimseartha.