Werken met streams, deel 3

1. Controleren

Ik denk dat je het misschien al beu bent om te leren hoe je datastromen aan elkaar kunt koppelen. Je wilt eindelijk iets met de data doen.

De Streamklasse heeft drie standaardmethoden die geen streams construeren, maar in plaats daarvan controleren wat voor soort gegevens erin staan. Deze methoden zijn: anyMatch(), allMatch(), en noneMatch().

boolean anyMatch(rule)methode

Deze methode controleert of de stream minstens één element heeft dat voldoet aan de regel die aan de methode wordt doorgegeven. Als er zo'n element is, retourneert de methode true, anders false.

Voorbeelden

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

In het laatste voorbeeld behouden we eerst alleen de elementen die kleiner zijn dan nul, en vervolgens controleren we het resultaat om te zien of een van de gefilterde elementen groter is dan nul. Dergelijke elementen zijn er natuurlijk niet meer.

booleaanse methode allMatch(regel).

Deze methode controleert of alle elementen in de stream overeenkomen met de regel (ook wel predikaat genoemd). De regel wordt als argument doorgegeven aan de methode:

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

In het laatste voorbeeld laten we eerst alleen elementen die kleiner zijn dan nul door het filter, en dan controleren we of alle behouden elementen kleiner zijn dan nul. De controle levert een positief resultaat op.

booleaanse methode noneMatch(regel).

De noneMatch()methode controleert of de stream geen elementen bevat die overeenkomen met de doorgegeven regel. Het is als het tegenovergestelde van de anyMatch()methode.

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. Nutsklassen: Optionalklasse

Soms is het voor programmeurs erg onhandig om met nullreferenties te werken. Stel dat u twee tekenreeksen vergelijkt. Als beide variabelen dat niet zijn null, dan kun je gewoon bellen s1.equals(s2)en alles zal werken. Maar als s1het zou kunnen null, dan moet je code schrijven die deze situatie afhandelt om een NullPointerException​​.

Daarom bedachten programmeurs de Optional<T>utility-klasse. De code ziet er ongeveer zo uit:

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

Het doel van deze klasse is simpelweg om een ​​T-object op te slaan (een verwijzing naar een object waarvan het type T is). De objectreferentie binnen een Optional<T>object kan null.

Met deze klasse kunnen programmeurs iets mooiere code schrijven. Laten we vergelijken:

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

Het ene Optionalobject kan altijd worden vergeleken met een ander Optionalobject met behulp van de equalsmethode, zelfs als ze nullreferenties opslaan.

Simpel gezegd, de Optionalklasse laat je "mooie" controles schrijven voor nullen "mooie" acties in het geval dat een Optionalobject een nullwaarde opslaat.

3. Elementen zoeken

Laten we teruggaan naar de Streamklas. De Streamklasse heeft nog 4 methoden waarmee u naar elementen in een stroom kunt zoeken. Deze methoden zijn findFirst(), findAny(), min(), en max().

Optional<T> findFirst()methode

De findFirst()methode retourneert eenvoudigweg het eerste element in de stream. Dat is alles wat het doet.

Het interessantere om hier op te merken is dat de methode geen Tobject retourneert, maar eerder een Optional<T>wrapper-object. Dit zorgt ervoor dat de methode nooit terugkeert nullnadat een object niet is gevonden.

Voorbeeld:

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

Laten we voor meer duidelijkheid de laatste regel opsplitsen in verschillende regels:

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

De laatste get()methode is simpelweg het ophalen van de waarde die in het Optionalobject is opgeslagen.

Optional<T> findAny()methode

De findAny()methode retourneert elk element uit de stream en eindigt daar. Deze methode is vergelijkbaar met findFirst(), maar is geweldig voor streams die worden gebruikt in parallelle bewerkingen.

Wanneer streams parallel worden verwerkt, kan het zijn dat er al een element is gevonden in een deel van een stream, maar het is nog niet duidelijk of dit het eerste is of niet.

Als veel elementen overeenkomen met alle filters, en het is belangrijk voor de programmeur om precies de eerste te krijgen, dan findFirst()moet de methode worden genoemd. Als de programmeur weet dat in werkelijkheid 0 of 1 element overeenkomt met alle filters, volstaat het om gewoon te bellen findAny()- en dit zal sneller zijn.

Optional<T> min(Comparator<T>)methode

De min()methode gebruikt een comparatorobject om alle elementen in de stroom te vergelijken en retourneert het minimale element. De handigste manier om een ​​comparatorobject te definiëren is met een lambda-functie.

Voorbeeld van zoeken naar de kortste string:

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

De max()methode gebruikt een comparatorobject om alle elementen in de stroom te vergelijken en retourneert het maximale element. De handigste manier om een ​​comparatorobject te definiëren is met een lambda-functie.

Voorbeeld van zoeken naar de langste string:

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