Arbejde med vandløb, del 3

1. Kontrol

Jeg tror, ​​du måske allerede er træt af at lære at kæde datastrømme sammen. Du vil endelig gøre noget med dataene.

Klassen Streamhar tre standardmetoder, der ikke konstruerer strømme, men i stedet tjekker, hvilken slags data der er i dem. Disse metoder er: anyMatch(), allMatch(), og noneMatch().

boolean anyMatch(rule)metode

Denne metode kontrollerer, om strømmen har mindst ét ​​element, der opfylder reglen, der sendes til metoden. Hvis der er et sådant element, returnerer metoden trueellers false.

Eksempler

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

I det sidste eksempel beholder vi først kun de elementer, der er mindre end nul, og derefter tjekker vi resultatet for at se, om nogen af ​​de filtrerede elementer er større end nul. Naturligvis er sådanne elementer der ikke længere.

boolesk allMatch(rule) metode

Denne metode kontrollerer, om alle elementer i strømmen matcher reglen (også kendt som et prædikat). Reglen overføres som et argument til metoden:

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

I det sidste eksempel tillader vi først kun elementer, der er mindre end nul, at passere gennem filteret, og derefter tjekker vi, om alle de tilbageholdte elementer er mindre end nul. Checken giver et positivt resultat.

boolesk noneMatch(rule) metode

Metoden noneMatch()kontrollerer, om strømmen ikke har nogen elementer, der matcher den beståede regel. Det er ligesom det modsatte af anyMatch()metoden.

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

Nogle gange er det meget ubelejligt for programmører at arbejde med nullreferencer. Antag for eksempel, at du sammenligner to strenge. Hvis begge variabler ikke er null, så kan du blot kalde s1.equals(s2), og alt vil fungere. Men hvis s1det kunne være null, så skal du skrive kode, der håndterer denne situation for at undgå en NullPointerException.

Det er derfor, programmører kom op med hjælpeklassen Optional<T>. Dens kode ser nogenlunde sådan ud:

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

Formålet med denne klasse er simpelthen at gemme et T-objekt (en reference til et objekt, hvis type er T). Objektreferencen inde i et Optional<T>objekt kan være null.

Denne klasse lader programmører skrive lidt smukkere kode. Lad os sammenligne:

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

Et Optionalobjekt kan altid sammenlignes med et andet Optionalobjekt ved hjælp af equalsmetoden, selvom de gemmer nullreferencer.

Blot sagt, Optionalklassen lader dig skrive "smukke" checks for nullog "smukke" handlinger i tilfælde af, at et Optionalobjekt gemmer en nullværdi.

3. At finde elementer

Lad os vende tilbage til Streamklassen. Klassen Streamhar yderligere 4 metoder, der lader dig søge efter elementer i en strøm. Disse metoder er findFirst(), findAny(), min(), og max().

Optional<T> findFirst()metode

Metoden findFirst()returnerer simpelthen det første element i strømmen. Det er alt, det gør.

Den mere interessante ting at bemærke her er, at metoden ikke returnerer et Tobjekt, men snarere et Optional<T>indpakningsobjekt. Dette sikrer, at metoden aldrig vender tilbage, nullefter at det ikke lykkedes at finde et objekt.

Eksempel:

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

For mere præcisering, lad os opdele den sidste linje i flere linjer:

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

Den sidste get()metode er simpelthen at hente værdien gemt inde i objektet Optional.

Optional<T> findAny()metode

Metoden findAny()returnerer ethvert element fra strømmen og slutter der. Denne metode ligner findFirst(), men den er fantastisk til vandløb, der bruges i parallelle operationer.

Når man behandler strømme parallelt, kan det være, at et element allerede er fundet i en del af en strøm, men det er endnu ikke klart, om det er det første eller ej.

Hvis mange elementer har matchet alle filtrene, og det er vigtigt for programmøren at få præcis det første af dem, så findFirst()er metoden det, man skal kalde. Hvis programmøren ved, at 0 eller 1 element i virkeligheden vil matche alle filtrene, så er det nok bare at ringe findAny()- og det vil være hurtigere.

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

Metoden min()bruger et comparatorobjekt til at sammenligne alle elementer i strømmen og returnerer minimumselementet. Den mest bekvemme måde at definere et komparatorobjekt på er med en lambda-funktion.

Eksempel på søgning efter den korteste streng:

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

Metoden max()bruger et comparatorobjekt til at sammenligne alle elementer i strømmen og returnerer det maksimale element. Den mest bekvemme måde at definere et komparatorobjekt på er med en lambda-funktion.

Eksempel på søgning efter den længste streng:

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