Travailler avec les threads, partie 3

1. Vérification

Je pense que vous vous ennuyez peut-être déjà à apprendre à enchaîner des flux de données. Vous voulez enfin faire quelque chose avec les données.

La Streamclasse a trois méthodes standard qui ne construisent pas de flux, mais vérifient à la place le type de données qu'ils contiennent. Ces méthodes sont : anyMatch(), allMatch(), et noneMatch().

boolean anyMatch(rule)méthode

Cette méthode vérifie si le flux contient au moins un élément qui satisfait la règle transmise à la méthode. S'il existe un tel élément, la méthode retourne true, sinon false.

Exemples

Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5);
boolean result = stream.anyMatch(x -> x > 0);

true

Stream<Integer> stream = Stream.of(1, -2, 3, -4, 5);
boolean result = stream.anyMatch(x -> x > 0);

true

Stream<Integer> stream = Stream.of(1, -2, 3, -4, 5);
boolean result = stream.filter(x -> x < 0).anyMatch(x -> x > 0);

false

Dans le dernier exemple, nous ne retenons d'abord que les éléments inférieurs à zéro, puis nous vérifions le résultat pour voir si l'un des éléments filtrés est supérieur à zéro. Bien sûr, de tels éléments ne sont plus là.

méthode booléenne allMatch(rule)

Cette méthode vérifie si tous les éléments du flux correspondent à la règle (également appelée prédicat). La règle est passée en argument à la méthode :

Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5);
boolean result = stream.allMatch(x -> x > 0);

true

Stream<Integer> stream = Stream.of(1, -2, 3, -4, 5);
boolean result = stream.allMatch(x -> x > 0);

false

Stream<Integer> stream = Stream.of(1, -2, 3, -4, 5);
boolean result = stream.filter(x -> x < 0).allMatch(x -> x < 0);

true

Dans le dernier exemple, nous n'autorisons d'abord que les éléments inférieurs à zéro à passer à travers le filtre, puis nous vérifions si tous les éléments retenus sont inférieurs à zéro. Le contrôle donne un résultat positif.

méthode booléenne noneMatch(rule)

La noneMatch()méthode vérifie si le flux ne contient aucun élément correspondant à la règle transmise. C'est comme le contraire de la anyMatch()méthode.

Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5);
boolean result = stream.noneMatch(x -> x > 0);

false

Stream<Integer> stream = Stream.of(1, -2, 3, -4, 5);
boolean result = stream.noneMatch(x -> x > 0);

false

Stream<Integer> stream = Stream.of(1, -2, 3, -4, 5);
boolean result = stream.filter(x -> x < 0).noneMatch(x -> x > 0);

true

2. Classes utilitaires : Optionalclasse

Parfois, il est très gênant pour les programmeurs de travailler avec nulldes références. Par exemple, supposons que vous compariez deux chaînes. Si les deux variables ne sont pas null, vous pouvez simplement appeler s1.equals(s2), et tout fonctionnera. Mais si s1c'est possible null, alors vous devez écrire du code qui gère cette situation afin d'éviter un NullPointerException.

C'est pourquoi les programmeurs ont créé la Optional<T>classe utilitaire. Son code ressemble à peu près à ceci :

class Optional<Type>
{
   private final Type value;
   private Optional() { this.value = null;}
   private Optional(value) { this.value = value;}
   public static <Type> Optional<Type> of(Type value)
   {
      return new Optional<Type>(value);
   }

   public boolean isPresent()
   {
      return value != null;
   }

   public boolean isEmpty()
   {
      return value == null;
   }

   public Type get()
   {
      if (value == null)
      {
         throw new NoSuchElementException();
      }
      return value;
   }

   public Type orElse(Type other)
   {
      return value != null ? value : other;
   }

   public Type orElseThrow()
   {
      if (value == null)
      {
         throw new NoSuchElementException();
      }
      return value;
   }
}

Le but de cette classe est simplement de stocker un objet T (une référence à un objet dont le type est T). La référence d'objet à l'intérieur d'un Optional<T>objet peut être null.

Cette classe permet aux programmeurs d'écrire un code légèrement plus joli. Comparons:

public void printString(String s)
{
   Optional<String> str = Optional.ofNullable(s);
   System.out.println(str.orElse(""));
}

public void printString(String s)
{
   String str = s != null ? s : "";
   System.out.println(str)
}

Un Optionalobjet peut toujours être comparé à un autre Optionalobjet à l'aide de la equalsméthode, même s'ils stockent nulldes références.

En termes simples, la Optionalclasse vous permet d'écrire de "belles" vérifications nullet de "belles" actions dans le cas où un Optionalobjet stocke une nullvaleur.

3. Trouver des éléments

Revenons à la Streamclasse. La Streamclasse a 4 méthodes supplémentaires qui vous permettent de rechercher des éléments dans un flux. Ces méthodes sont findFirst(), findAny(), min()et max().

Optional<T> findFirst()méthode

La findFirst()méthode renvoie simplement le premier élément du flux. C'est tout ce qu'il fait.

La chose la plus intéressante à noter ici est que la méthode ne renvoie pas un Tobjet, mais plutôt un Optional<T>objet wrapper. Cela garantit que la méthode ne reviendra jamais nullaprès avoir échoué à trouver un objet.

Exemple:

ArrayList<String> list = new ArrayList<String>();
Collections.addAll(list, "Hello", "how's", "life?");
String str = list.stream().findFirst().get(); // Hello

Pour plus de clarté, divisons la dernière ligne en plusieurs lignes :

ArrayList<String> list = new ArrayList<String>();
Collections.addAll(list, "Hello", "how's", "life?");

Stream<String> stream = list.stream();
Optional<String> result = stream.findFirst();
String str = result.get(); // Hello

La dernière get()méthode consiste simplement à récupérer la valeur stockée à l'intérieur de l' Optionalobjet.

Optional<T> findAny()méthode

La findAny()méthode renvoie n'importe quel élément du flux et s'arrête là. Cette méthode est similaire à findFirst(), mais elle est idéale pour les flux utilisés dans des opérations parallèles.

Lors du traitement de flux en parallèle, il se peut qu'un élément ait déjà été trouvé dans une partie d'un flux, mais il n'est pas encore clair s'il s'agit du premier ou non.

Si de nombreux éléments correspondent à tous les filtres et qu'il est important pour le programmeur d'obtenir exactement le premier d'entre eux, la findFirst()méthode est ce qu'il convient d'appeler. Si le programmeur sait qu'en réalité 0 ou 1 élément correspondra à tous les filtres, il suffit alors d'appeler simplement findAny()- et ce sera plus rapide.

Optional<T> min(Comparator<T>)méthode

La min()méthode utilise un comparatorobjet pour comparer tous les éléments du flux et renvoie l'élément minimum. Le moyen le plus pratique de définir un objet comparateur consiste à utiliser une fonction lambda.

Exemple de recherche de la chaîne la plus courte :

ArrayList<String> list = new ArrayList<String>();
Collections.addAll(list, "Hello", "how's", "life?");
String min = list.stream().min( (s1, s2)-> s1.length()-s2.length() ).get();

Optional<T> max(Comparator<T>)méthode

La max()méthode utilise un comparatorobjet pour comparer tous les éléments du flux et renvoie l'élément maximum. Le moyen le plus pratique de définir un objet comparateur consiste à utiliser une fonction lambda.

Exemple de recherche de la chaîne la plus longue :

ArrayList<String> list = new ArrayList<String>();
Collections.addAll(list, "Hello", "how's", "life?");
String max = list.stream().max( (s1, s2)-> s1.length()-s2.length() ).get();