Akışlarla çalışma, 3. bölüm

1. Kontrol

Veri akışlarını birbirine zincirlemeyi öğrenmekten çoktan sıkılmış olabileceğinizi düşünüyorum. Sonunda verilerle bir şeyler yapmak istiyorsunuz.

Sınıfın Stream, akış oluşturmayan, bunun yerine içlerinde ne tür veriler olduğunu kontrol eden üç standart yöntemi vardır. Bu yöntemler şunlardır: anyMatch(), allMatch()ve noneMatch().

boolean anyMatch(rule)yöntem

Bu yöntem, akışın, yönteme iletilen kuralı karşılayan en az bir öğeye sahip olup olmadığını kontrol eder. Böyle bir öğe varsa, yöntem trueaksi takdirde döndürür false.

örnekler

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

Son örnekte, önce yalnızca sıfırdan küçük olan öğeleri tutuyoruz ve ardından filtrelenmiş öğelerden herhangi birinin sıfırdan büyük olup olmadığını görmek için sonucu kontrol ediyoruz. Tabii ki, bu tür unsurlar artık yok.

boole allMatch(kural) yöntemi

Bu yöntem, akıştaki tüm öğelerin kuralla eşleşip eşleşmediğini kontrol eder (yüklem olarak da bilinir). Kural, yönteme bir argüman olarak iletilir:

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

Son örnekte, önce sadece sıfırdan küçük olan elemanların filtreden geçmesine izin veriyoruz ve ardından tutulan tüm elemanların sıfırdan küçük olup olmadığını kontrol ediyoruz. Kontrol olumlu sonuç verir.

boolean noneMatch(rule) yöntemi

Yöntem noneMatch(), akışın iletilen kuralla eşleşen hiçbir öğeye sahip olup olmadığını kontrol eder. Yöntemin tam tersi gibidir anyMatch().

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. Fayda sınıfları: Optionalsınıf

Bazen programcılar için referanslarla çalışmak çok sakıncalıdır null. Örneğin, iki diziyi karşılaştırdığınızı varsayalım. Her iki değişken de değilse null, o zaman basitçe arayabilirsiniz s1.equals(s2)ve her şey çalışacaktır. Ama eğer s1olabilirse null, o zaman a'dan kaçınmak için bu durumu işleyen bir kod yazmanız gerekir NullPointerException.

Bu yüzden programcılar fayda sınıfını buldular Optional<T>. Kodu kabaca şöyle görünür:

class Optional<Type>
{
   private final T 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;
   }
}

Bu sınıfın amacı basitçe bir T nesnesini (türü T olan bir nesneye referans) depolamaktır. Bir nesnenin içindeki nesne referansı Optional<T>olabilir null.

Bu sınıf, programcıların biraz daha güzel kod yazmasına izin verir. Hadi karşılaştıralım:

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

Bir nesne, referansları depolasalar bile, yöntem kullanılarak Optionalher zaman başka bir nesneyle karşılaştırılabilir .Optionalequalsnull

Basitçe söylemek gerekirse, sınıf, bir nesnenin bir değer depolaması durumunda Optional"güzel" kontroller ve "güzel" eylemler yazmanıza izin verir .nullOptionalnull

3. Öğeleri bulma

Sınıfa dönelim Stream. Sınıfın Stream, bir akıştaki öğeleri aramanıza izin veren 4 yöntemi daha vardır. Bu yöntemler findFirst(), findAny(), min()ve max().

Optional<T> findFirst()yöntem

Yöntem findFirst(), akıştaki ilk öğeyi döndürür. Tüm yaptığı bu.

Burada dikkat edilmesi gereken daha ilginç olan şey, yöntemin bir Tnesne değil, bir Optional<T>sarmalayıcı nesne döndürmesidir. Bu, yöntemin nullbir nesne bulamadıktan sonra asla geri dönmemesini sağlar.

Örnek:

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

Daha fazla açıklığa kavuşturmak için, son satırı birkaç satıra ayıralım:

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

Son get()yöntem, basitçe nesnenin içinde depolanan değeri alır Optional.

Optional<T> findAny()yöntem

Yöntem findAny(), akıştan herhangi bir öğeyi döndürür ve burada biter. Bu yönteme benzer findFirst(), ancak paralel işlemlerde kullanılan akışlar için harikadır.

Akışları paralel olarak işlerken, bir akışın bazı bölümlerinde zaten bulunmuş bir öğe olabilir, ancak bunun ilk olup olmadığı henüz net değil.

Birçok öğe tüm filtrelerle eşleşiyorsa ve programcının bunlardan tam olarak ilkini alması önemliyse, o zaman yöntem, findFirst()çağrılması gereken şeydir. Programcı gerçekte 0 veya 1 öğenin tüm filtrelerle eşleşeceğini biliyorsa, o zaman basitçe çağırmak yeterlidir findAny()- ve bu daha hızlı olacaktır.

Optional<T> min(Comparator<T>)yöntem

Yöntem , akıştaki tüm öğeleri karşılaştırmak için min()bir nesne kullanır ve minimum öğeyi döndürür. comparatorKarşılaştırma nesnesi tanımlamanın en uygun yolu lambda işlevi kullanmaktır.

En kısa diziyi aramaya örnek:

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>)yöntem

Yöntem , akıştaki tüm öğeleri karşılaştırmak için max()bir nesne kullanır ve maksimum öğeyi döndürür. comparatorKarşılaştırma nesnesi tanımlamanın en uygun yolu lambda işlevi kullanmaktır.

En uzun diziyi arama örneği:

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