Pause café #163. Quelle est la différence entre un lambda et une référence de méthode. 5 façons de concaténer une chaîne Null en Java

Quelle est la différence entre un lambda et une référence de méthode

Source : Reddit IntelliJ IDEA suggère de remplacer les expressions lambda par des références de méthode. Quelle est la différence entre eux? Il s'avère qu'il existe une différence subtile entre les expressions lambda et les références de méthode. Par exemple, comparez : myInstance::getStuff et () ->myInstance.getStuff() . En général, les deux options sont équivalentes. Mais si myInstance est nulle et que le lambda produit un pointeur nul lors de l'évaluation du lambda, alors une référence de méthode sera générée immédiatement lors de la tentative d'accès à la référence. Et quoi? En général, cela est important si le code évaluant l'expression lambda se trouve dans un try-catch avec un pointeur nul. Par exemple, j'ai une fonction couldBeNull(Supplier<T> function) qui fait quelque chose comme ceci :

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

Si l’appel de couldBeNull(() -> myNullVariable.getStuff()) fonctionnait sans lever d’exception, alors « l’équivalent » : couldBeNull(myNullVariable::getStuff) lancerait une NullPointerException immédiatement lorsque la fonction est appelée. C'est la différence. Note. Selon Stackoverflow, si vous remplacez le lambda par une référence de méthode, le bytecode de la classe sera plus compact, ce qui signifie que la classe se chargera plus rapidement dans la JVM. Cependant, pour obtenir un tel gain, des milliers de lambdas non optimisés sont nécessaires. Cependant, dans un projet de grande envergure, un tel nombre peut être facilement accumulé. Sinon, le choix entre un lambda et une référence de méthode est une question de goût et de lisibilité du code. Par exemple, si un lambda comporte plusieurs lignes, la lisibilité est réduite et le code ne bénéficiera que si le lambda est placé dans une méthode distincte et qu'une référence à celui-ci est utilisée.

5 façons de concaténer une chaîne Null en Java

Source : Gitconnected Après avoir lu cet article, vous découvrirez d'autres façons de travailler avec des chaînes en Java. Java propose de nombreuses façons de concaténer des chaînes, mais parfois, lorsque nous ne prêtons pas attention aux chaînes nulles, nous pouvons nous retrouver avec null, ce qui n'est évidemment pas ce que nous souhaitons. Utilisez donc mes méthodes recommandées pour éviter les valeurs nulles lors de la concaténation de String.

Analyse du problème

Si nous voulons concaténer des tableaux de chaînes, nous pouvons simplement utiliser l’opérateur +. Cependant, nous pouvons rencontrer des valeurs nulles en faisant cela .

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

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

La combinaison de tous ces éléments nous amène à ce résultat : Bien que nous ayons trouvé le problème, la valeur null résultante est également concaténée sous forme de chaîne, ce qui n'est clairement pas ce que nous espérions. Et même si nous travaillons sur Java 8 ou supérieur, en utilisant la méthode statique String.join() pour joindre des chaînes, nous nous retrouverons toujours avec des valeurs nulles .

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

Le résultat est le même: Alors comment résoudre ce problème ? Il existe plusieurs solutions. Pour faciliter la démonstration du code ultérieurement, nous extrayons une méthode qui peut transmettre une chaîne et renvoyer une chaîne non nulle.

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

1. String.concat()

String.concat() est une méthode fournie avec la classe String . C’est très pratique pour la concaténation de chaînes.

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

Étant donné que la méthode nullToString() est appelée, il n'y a pas de valeurs nulles en conséquence .

2.StringBuilder

La classe StringBuilder fournit de nombreuses méthodes utiles et pratiques pour construire des chaînes. La plus couramment utilisée d'entre elles est la méthode append() , qui utilise append() pour concaténer des chaînes et est combinée avec la méthode nullToString() pour éviter les valeurs nulles .

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

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

En conséquence, vous pouvez obtenir le résultat suivant :

3. Classe StringJoiner (Java 8+)

La classe StringJoiner fournit une fonction plus puissante pour joindre des chaînes. Il peut non seulement spécifier le délimiteur lors de la concaténation, mais également spécifier le préfixe et le suffixe. Lors de la concaténation de chaînes, nous pouvons utiliser sa méthode add() . La méthode nullToString() sera également utilisée ici pour éviter les valeurs nulles .

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

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

4. Streams.filter (Java 8+)

L'API Stream est une puissante classe d'opérations de flux introduite dans Java 8 qui peut effectuer des opérations standard de filtrage, de correspondance, de traversée, de regroupement, de statistiques et d'autres opérations.

• Le filtre de fonctionnement du filtre peut recevoir une fonction Prédicat .
• L'interface de la fonction Predicate est la même que celle de l' interface Function introduite précédemment.
• Il s'agit d'une interface fonctionnelle.
• Il peut prendre un paramètre générique <T> et la valeur de retour est de type booléen.
• Le prédicat est souvent utilisé pour filtrer les données .

Nous pouvons donc définir un prédicat pour vérifier la chaîne nulle et le transmettre à la méthode filter() à partir de l'API Stream. De plus, vous pouvez utiliser la méthode Collectors.joining() pour joindre les chaînes non nulles restantes.

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

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

5. Utilisez l'opérateur +

L’utilisation de l’ opérateur + peut également résoudre le problème, mais elle n’est pas recommandée. Nous savons que String est un objet immuable. L'utilisation du signe + crée souvent un objet chaîne, et chaque fois qu'une nouvelle chaîne est créée en mémoire, la consommation de performances liée à l'utilisation du signe + pour concaténer des chaînes est donc très élevée.

Conclusion

Cet article présente plusieurs méthodes de concaténation de chaînes et de gestion des valeurs NULL, dans lesquelles différentes méthodes peuvent convenir à différents scénarios. L'analyse montre que les performances de StringBuilder sont les meilleures. Mais en conditions réelles, il faut combiner certains scénarios puis choisir la méthode avec le moins de perte de performances.