Evitando con garbo NullPointerException in Java

Question

Considera questa riga:

if (object.getAttribute("someAttr").equals("true")) { // ....

Ovviamente questa riga è un potenziale bug, l'attributo potrebbe esserlo null e otterremo un NullPointerException.Quindi dobbiamo rifattorizzarlo su una delle due scelte:

Prima opzione:

if ("true".equals(object.getAttribute("someAttr"))) { // ....

Seconda opzione:

String attr = object.getAttribute("someAttr");
if (attr != null) {
    if (attr.equals("true")) { // ....

La prima opzione è scomoda da leggere ma più concisa, mentre la seconda è chiara negli intenti, ma prolissa.

Quale opzione preferisci in termini di leggibilità?

Answer 1

Ho sempre usato

if ("true".equals(object.getAttribute("someAttr"))) { // ....

perché anche se è un po 'più difficile da leggere è molto meno prolisso e penso che sia abbastanza leggibile così ci si abitua molto facilmente

Answer 2

Nella seconda opzione, è possibile usufruire di cortocircuito &&:

String attr = object.getAttribute("someAttr");
if (attr != null && attr.equals("true")) { // ....

Answer 3

Ci sono alcune situazioni in cui l'approccio conciso sembra sbagliato all'inizio ma efficace diventa idiomatico.Questo è uno di loro;l'altro è qualcosa del tipo:

String line;
while ((line = bufferedReader.readLine()) != null) {
  // Use line
}

Effetti collaterali in una condizione?Impensabile!Tranne che è fondamentalmente più carino delle alternative, quando riconosci il modello particolare.

Questo modello è simile: è così comune in Java che mi aspetterei che qualsiasi sviluppatore ragionevolmente esperto lo riconoscesse.Il risultato è piacevolmente conciso.(In modo divertente, a volte vedo codice C# che utilizza lo stesso linguaggio, inutilmente: l'operatore di uguaglianza funziona bene con le stringhe in C#.)

Linea di fondo:utilizzare la prima versione e acquisire familiarità con essa.

Answer 4

Mi piace l'opzione 1 e direi che è abbastanza leggibile.

L'opzione 3 btw sarebbe quella di introdurre un metodo getAttribute che assume un valore predefinito come parametro.

Answer 5

aspirano sempre per il codice più breve, dato che entrambi sono funzionalmente equivalenti. Soprattutto in caso come questo, dove la leggibilità non è sacrificato.

Answer 6

Util.isEmpty(string) - torna string == null || string.trim().isEmpty() restituisce Util.notNull(string) "" se string == null, stringa altrimenti. ritorna Util.isNotEmpty(string)! Util.isEmpty(string)

E abbiamo una convenzione che per le stringhe, Util.isEmpty(string) significa semanticamente vera e Util.isNotEmpty(string) significa semanticamente falso.

Answer 7

E 'una domanda molto buona. Io di solito uso il non aggraziata:

if (object.getAttribute("someAttr") != null && object.getAttribute("someAttr").equals("true")) { // ....

(e io non lo uso più)

Answer 8

Ho un'altra risposta;

List<Map<String, Object>> group = jjDatabase.separateRow(db.Select("SELECT * FROM access_user_group  WHERE user_id=1 ;"));

Non c'è "group_c80" come colonna 'access_user_group' nel mio database, in modo a get (0) .get ( "group_c80") Null Pointer accordi di eccezione. Ma ho gestito attraverso codice qui sotto:

for (int j = 1; j < 100; j++) {
                    String rulId="0";//defult value,to privent null pointer exeption in group_c
                    try {
                        rulId = group.get(0).get("group_c" + j)).toString();
                    } catch (Exception ex) {
                        ServerLog.Print( "Handeled error in database for " + "group_c" + (j < 10 ? "0" + j : j) +"This error handeled and mot efect in program");
                        rulId = "0";
                    }}

Answer 9

Ecco il mio approccio, ha bisogno di una classe PropertyUtil però, ma il suo unico scritto una volta:

/**
 * Generic method to encapsulate type casting and preventing nullPointers.
 * 
 * @param <T>          The Type expected from the result value.
 * @param o            The object to cast.
 * @param typedDefault The default value, should be of Type T.
 * 
 * @return Type casted o, of default.
 */
public static <T> T getOrDefault (Object o, T typedDefault) {
    if (null == o) {
        return typedDefault;
    }
    return (T) o;
}

Il codice client può fare questo:

PropertyUtil.getOrDefault(obj.getAttribute("someAttr"), "").equals("true");

o, per una lista:

PropertyUtil.getOrDefault(
    genericObjectMap.get(MY_LIST_KEY), Collections.EMPTY_LIST
).contains(element);

O per un consumatore di lista, che sarebbe rifiutare Oggetto:

consumeOnlyList(
    PropertyUtil.getOrDefault(
        enericObjectMap.get(MY_LIST_KEY), Collections.EMPTY_LIST
    )
)

Il predefinito potrebbe essere un impl del modello dell'oggetto nullo https://en.wikipedia.org/wiki / Null_Object_pattern