Arbeta med strömmar, del 3

1. Kontroll

Jag tror att du kanske redan är uttråkad av att lära dig hur man länkar samman dataströmmar. Du vill äntligen göra något med datan.

Klassen Streamhar tre standardmetoder som inte konstruerar strömmar, utan istället kontrollerar vilken typ av data som finns i dem. Dessa metoder är: anyMatch(), allMatch(), och noneMatch().

boolean anyMatch(rule)metod

Denna metod kontrollerar om strömmen har minst ett element som uppfyller regeln som skickas till metoden. Om det finns ett sådant element returnerar metoden , trueannars false.

Exempel

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 sista exemplet behåller vi först bara de element som är mindre än noll, och sedan kontrollerar vi resultatet för att se om något av de filtrerade elementen är större än noll. Sådana element finns naturligtvis inte längre.

boolesk allMatch(rule) metod

Denna metod kontrollerar om alla element i strömmen matchar regeln (även känt som ett predikat). Regeln skickas som ett argument till 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 sista exemplet tillåter vi först bara element som är mindre än noll att passera genom filtret, och sedan kontrollerar vi om alla kvarhållna element är mindre än noll. Kontrollen ger ett positivt resultat.

boolean noneMatch(rule)-metod

Metoden noneMatch()kontrollerar om strömmen inte har några element som matchar den godkända regeln. Det är som motsatsen till 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. Verktygsklasser: Optionalklass

Ibland är det väldigt obekvämt för programmerare att arbeta med nullreferenser. Anta till exempel att du jämför två strängar. Om båda variablerna inte är null, kan du helt enkelt ringa s1.equals(s2), och allt kommer att fungera. Men om det s1skulle kunna vara nullså måste du skriva kod som hanterar denna situation för att undvika en NullPointerException.

Det var därför programmerare kom med verktygsklassen Optional<T>. Dess kod ser ungefär ut så här:

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

Syftet med denna klass är helt enkelt att lagra ett T-objekt (en referens till ett objekt vars typ är T). Objektreferensen inuti ett Optional<T>objekt kan vara null.

Den här klassen låter programmerare skriva lite snyggare kod. Låt oss jämföra:

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

Ett Optionalobjekt kan alltid jämföras med ett annat Optionalobjekt med equalsmetoden, även om de lagrar nullreferenser.

Enkelt sagt Optionallåter klassen dig skriva "vackera" kontroller för nulloch "vackra" åtgärder i händelse av att ett Optionalobjekt lagrar ett nullvärde.

3. Hitta element

Låt oss återgå till Streamklassen. Klassen Streamhar ytterligare fyra metoder som låter dig söka efter element i en ström. Dessa metoder är findFirst(), findAny(), min(), och max().

Optional<T> findFirst()metod

Metoden findFirst()returnerar helt enkelt det första elementet i strömmen. Det är allt det gör.

Det mer intressanta att notera här är att metoden inte returnerar ett Tobjekt, utan snarare ett Optional<T>omslagsobjekt. Detta säkerställer att metoden aldrig kommer tillbaka nullefter att ha misslyckats med att hitta ett objekt.

Exempel:

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

För att förtydliga, låt oss dela upp den sista raden i flera rader:

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 sista get()metoden är att helt enkelt hämta värdet som är lagrat inuti Optionalobjektet.

Optional<T> findAny()metod

Metoden findAny()returnerar alla element från strömmen och slutar där. Denna metod liknar findFirst(), men den är utmärkt för strömmar som används i parallella operationer.

När man bearbetar strömmar parallellt kan det vara att ett element redan har hittats i någon del av en ström, men det är ännu inte klart om det är det första eller inte.

Om många element har matchat alla filter, och det är viktigt för programmeraren att få exakt det första av dem, så findFirst()är metoden det som ska kallas. Om programmeraren vet att i verkligheten 0 eller 1 element kommer att matcha alla filter, räcker det att helt enkelt ringa — findAny()och det kommer att gå snabbare.

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

Metoden min()använder ett comparatorobjekt för att jämföra alla element i strömmen och returnerar minimielementet. Det bekvämaste sättet att definiera ett komparatorobjekt är med en lambdafunktion.

Exempel på sökning efter den kortaste strängen:

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

Metoden max()använder ett comparatorobjekt för att jämföra alla element i strömmen och returnerar det maximala elementet. Det bekvämaste sättet att definiera ett komparatorobjekt är med en lambdafunktion.

Exempel på sökning efter den längsta strängen:

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