Trabalhando com threads, parte 3

1. Verificando

Acho que você já deve estar entediado em aprender como encadear fluxos de dados. Você quer finalmente fazer algo com os dados.

A Streamclasse tem três métodos padrão que não constroem fluxos, mas verificam que tipo de dados estão neles. Esses métodos são: anyMatch(), allMatch(), e noneMatch().

boolean anyMatch(rule)método

Este método verifica se o stream possui pelo menos um elemento que satisfaça a regra que é passada para o método. Se houver tal elemento, o método retorna true, caso contrário false.

Exemplos

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

No último exemplo, primeiro retemos apenas os elementos menores que zero e, em seguida, verificamos o resultado para ver se algum dos elementos filtrados é maior que zero. Claro, esses elementos não estão mais lá.

Método booleano allMatch(rule)

Esse método verifica se todos os elementos no fluxo correspondem à regra (também conhecida como predicado). A regra é passada como um argumento para o método:

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

No último exemplo, primeiro permitimos que apenas elementos menores que zero passem pelo filtro e, em seguida, verificamos se todos os elementos retidos são menores que zero. A verificação produz um resultado positivo.

método booleano noneMatch(rule)

O noneMatch()método verifica se o fluxo não possui elementos que correspondam à regra aprovada. É como o oposto do anyMatch()método.

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 utilitárias: Optionalclasse

Às vezes é muito inconveniente para os programadores trabalhar com nullreferências. Por exemplo, suponha que você esteja comparando duas strings. Se ambas as variáveis ​​não forem null, você pode simplesmente chamar s1.equals(s2), e tudo funcionará. Mas se s1puder ser null, então você tem que escrever um código que lide com esta situação para evitar um erro NullPointerException.

É por isso que os programadores criaram a Optional<T>classe utilitária. Seu código é mais ou menos assim:

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;
   }
}

O propósito desta classe é simplesmente armazenar um objeto T (uma referência a um objeto cujo tipo é T). A referência de objeto dentro de um Optional<T>objeto pode ser null.

Essa classe permite que os programadores escrevam um código um pouco mais bonito. Vamos comparar:

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)
}

Um Optionalobjeto sempre pode ser comparado a outro Optionalobjeto usando o equalsmétodo, mesmo que armazenem nullreferências.

Simplificando, a Optionalclasse permite que você escreva verificações "bonitas" nulle ações "bonitas" no caso de um Optionalobjeto armazenar um nullvalor.

3. Encontrar elementos

Vamos voltar para a Streamaula. A Streamclasse tem mais 4 métodos que permitem pesquisar elementos em um fluxo. Esses métodos são findFirst(), findAny(), min()e max().

Optional<T> findFirst()método

O findFirst()método simplesmente retorna o primeiro elemento no fluxo. Isso é tudo que ele faz.

A coisa mais interessante a notar aqui é que o método não retorna um Tobjeto, mas sim um Optional<T>objeto wrapper. Isso garante que o método nunca retornará nullapós falhar em localizar um objeto.

Exemplo:

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

Para maior esclarecimento, vamos quebrar a última linha em várias linhas:

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

O último get()método é simplesmente recuperar o valor armazenado dentro do Optionalobjeto.

Optional<T> findAny()método

O findAny()método retorna qualquer elemento do stream e termina ali. Esse método é semelhante ao findFirst(), mas é ótimo para fluxos usados ​​em operações paralelas.

Ao processar fluxos em paralelo, pode ser que um elemento já tenha sido encontrado em alguma parte de um fluxo, mas ainda não está claro se é o primeiro ou não.

Se muitos elementos corresponderem a todos os filtros e for importante para o programador obter exatamente o primeiro deles, o findFirst()método é o que deve ser chamado. Se o programador souber que, na realidade, 0 ou 1 elemento corresponderá a todos os filtros, basta simplesmente chamar findAny()- e isso será mais rápido.

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

O min()método usa um comparatorobjeto para comparar todos os elementos no fluxo e retorna o elemento mínimo. A maneira mais conveniente de definir um objeto comparador é com uma função lambda.

Exemplo de busca pela string mais curta:

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étodo

O max()método usa um comparatorobjeto para comparar todos os elementos no fluxo e retorna o elemento máximo. A maneira mais conveniente de definir um objeto comparador é com uma função lambda.

Exemplo de busca pela string mais longa:

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();