Pausa caffè #163. Qual è la differenza tra un lambda e un riferimento al metodo. 5 modi per concatenare stringhe null in Java

Qual è la differenza tra un lambda e un riferimento al metodo

Fonte: Reddit IntelliJ IDEA suggerisce di sostituire le espressioni lambda con riferimenti a metodi. Qual'è la differenza tra loro? Si scopre che esiste una sottile differenza tra le espressioni lambda e i riferimenti ai metodi. Ad esempio, confronta: myInstance::getStuff e () ->myInstance.getStuff() . In generale, entrambe le opzioni sono equivalenti tra loro. Ma se myInstance è null e lambda produce un puntatore null durante la valutazione di lambda, verrà generato immediatamente un riferimento al metodo quando si tenta di accedere al riferimento. E cosa? In generale, questo è importante se il codice che valuta l'espressione lambda è all'interno di un try-catch con puntatore null. Ad esempio, ho una funzione mightBeNull(Supplier<T> function) che fa qualcosa del genere:

try {
    doStuff(function.get().getSomeMore().getSomeMore());
} catch (NullPointerException e) {
    doOtherStuff();
}

Se la chiamata mightBeNull(() -> myNullVariable.getStuff()) funzionasse senza generare un'eccezione, allora l'"equivalente": mightBeNull(myNullVariable::getStuff) lancerà una NullPointerException immediatamente quando viene chiamata la funzione. Questa è la differenza. Nota. Secondo Stackoverflow, se sostituisci lambda con un riferimento al metodo, il bytecode della classe sarà più compatto, il che significa che la classe verrà caricata più velocemente nella JVM. Tuttavia, per ottenere un tale guadagno, sono necessarie migliaia di lambda non ottimizzate. Tuttavia, in un progetto di grandi dimensioni, tale numero può essere facilmente accumulato. Altrimenti la scelta tra lambda e riferimento al metodo è una questione di gusti e di leggibilità del codice. Ad esempio, se una lambda ha più righe, la leggibilità viene ridotta e il codice trarrà vantaggio solo se la lambda viene inserita in un metodo separato e viene utilizzato un riferimento ad essa.

5 modi per concatenare stringhe null in Java

Fonte: Gitconnected Dopo aver letto questo post, imparerai altri modi per lavorare con le stringhe in Java. Java offre molti modi per concatenare le stringhe, ma a volte, quando non prestiamo attenzione alle stringhe nulle, possiamo ritrovarci con null, che ovviamente non è ciò che vogliamo. Quindi usa i miei metodi consigliati per evitare valori nulli durante la concatenazione di String.

Analisi del problema

Se vogliamo concatenare array di stringhe, possiamo semplicemente usare l'operatore +. Tuttavia, potremmo riscontrare valori nulli durante questa operazione .

String[] values = {"https", "://", "gist.", "github", ".com", null};
String result = "";

for (String value : values) {
    result = result + value;
}

La combinazione di tutti questi elementi ci porta a questo risultato: Sebbene abbiamo riscontrato il problema, anche il valore nullo risultante viene concatenato come stringa, il che chiaramente non è ciò che speravamo. E anche se stiamo lavorando su Java 8 o versioni successive, utilizzando il metodo statico String.join() per unire le stringhe, ci ritroveremo comunque con valori nulli .

String[] values = {"https", "://", "gist.", "github", ".com", null};
String result = String.join("", values);

Il risultato è lo stesso: Allora come risolvere questo problema? Esistono diverse soluzioni. Per rendere più semplice la dimostrazione successiva del codice, estraiamo un metodo che può passare una stringa e restituire una stringa non nulla.

public String nullToString(String value) {
    return value == null ? "" : value;
}

1. String.concat()

String.concat() è un metodo fornito con la classe String . È molto conveniente per la concatenazione di stringhe.

for (String value : values) {
    result = result.concat(getNonNullString(value));
}

Poiché viene chiamato il metodo nullToString() , non ci sono valori nulli come risultato .

2.StringBuilder

La classe StringBuilder fornisce molti metodi utili e convenienti per costruire stringhe. Il più comunemente usato tra questi è il metodo append() , che utilizza append() per concatenare le stringhe ed è combinato con il metodo nullToString() per evitare valori null .

String[] values = {"https", "://", "gist.", "github", ".com", null};
StringBuilder result = new StringBuilder();

for (String value : values) {
    result = result.append(nullToString(value));
}

Di conseguenza, puoi ottenere il seguente risultato:

3. Classe StringJoiner (Java 8+)

La classe StringJoiner fornisce una funzione più potente per unire le stringhe. Non solo può specificare il delimitatore durante la concatenazione, ma anche specificare il prefisso e il suffisso. Quando concatenamo le stringhe, possiamo usare il suo metodo add() . Anche qui verrà utilizzato il metodo nullToString() per evitare valori nulli .

String[] values = {"https", "://", "gist.", "github", ".com", null};
StringJoiner result = new StringJoiner("");

for (String value : values) {
    result = result.add(nullToString(value));
}

4. Streams.filtro (Java 8+)

L'API Stream è una potente classe di operazioni di flusso introdotta in Java 8 che può eseguire operazioni di filtraggio, corrispondenza, attraversamento, raggruppamento, statistiche e altre operazioni standard.

• Il filtro operativo del filtro può ricevere una funzione Predicato .
• L'interfaccia della funzione Predicate è la stessa dell'interfaccia Function introdotta in precedenza.
• Questa è un'interfaccia funzionale.
• Può accettare un parametro generico <T> e il valore restituito è di tipo booleano.
• Il predicato viene spesso utilizzato per filtrare i dati .

Quindi possiamo definire un predicato per verificare la stringa nulla e passarlo al metodo filter() dall'API Stream. Inoltre, puoi utilizzare il metodo Collectors.joining() per unire le restanti stringhe non nulle.

String[] values = {"https", "://", "gist.", "github", ".com", null};

String result = Arrays.stream(values)
    .filter(Objects::nonNull)
    .collect(Collectors.joining());

5. Utilizzare l'operatore +

Anche l'uso dell'operatore + può risolvere il problema, ma non è consigliabile. Sappiamo che String è un oggetto immutabile. L'uso del segno + spesso crea un oggetto stringa e ogni volta viene creata una nuova stringa in memoria, quindi il consumo di prestazioni derivante dall'uso del segno + per concatenare le stringhe è molto elevato.

Conclusione

Questo articolo presenta diversi metodi per concatenare stringhe e gestire valori NULL, in cui metodi diversi potrebbero essere adatti a scenari diversi. L'analisi mostra che le prestazioni di StringBuilder sono le migliori. Ma in condizioni reali è necessario combinare determinati scenari e quindi scegliere il metodo con la minore perdita di prestazioni.