Bekerja dengan aliran, bahagian 3

1. Menyemak

Saya rasa anda mungkin sudah bosan dengan mempelajari cara merantai strim data. Anda akhirnya mahu melakukan sesuatu dengan data.

Kelas Streammempunyai tiga kaedah standard yang tidak membina aliran, sebaliknya semak jenis data yang ada di dalamnya. Kaedah ini ialah: anyMatch(), allMatch(), dan noneMatch().

boolean anyMatch(rule)kaedah

Kaedah ini menyemak sama ada aliran mempunyai sekurang-kurangnya satu elemen yang memenuhi peraturan yang dihantar kepada kaedah tersebut. Jika terdapat elemen sedemikian, kaedah kembali true, sebaliknya false.

Contoh

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

Dalam contoh terakhir, kami mula-mula mengekalkan hanya unsur yang kurang daripada sifar, dan kemudian kami menyemak hasilnya untuk melihat sama ada mana-mana unsur yang ditapis lebih besar daripada sifar. Sudah tentu unsur-unsur sebegini sudah tiada lagi.

kaedah boolean allMatch(rule).

Kaedah ini menyemak sama ada semua elemen dalam strim sepadan dengan peraturan (juga dikenali sebagai predikat). Peraturan diluluskan sebagai hujah kepada kaedah:

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

Dalam contoh terakhir, kami mula-mula membenarkan hanya elemen yang kurang daripada sifar untuk melalui penapis, dan kemudian kami menyemak sama ada semua elemen yang dikekalkan adalah kurang daripada sifar. Cek itu menghasilkan keputusan yang positif.

kaedah boolean noneMatch(rule).

Kaedah noneMatch()menyemak sama ada strim tiada unsur yang sepadan dengan peraturan yang diluluskan. Ia seperti bertentangan dengan anyMatch()kaedah.

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. Kelas utiliti: Optionalkelas

Kadang-kadang sangat menyusahkan pengaturcara untuk bekerja dengan nullrujukan. Sebagai contoh, katakan anda membandingkan dua rentetan. Jika kedua-dua pembolehubah bukan null, maka anda boleh panggil s1.equals(s2), dan semuanya akan berfungsi. Tetapi jika s1boleh null, maka anda perlu menulis kod yang mengendalikan situasi ini untuk mengelakkan NullPointerException.

Itulah sebabnya pengaturcara datang dengan Optional<T>kelas utiliti. Kodnya kelihatan lebih kurang seperti ini:

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

Tujuan kelas ini hanyalah untuk menyimpan objek T (rujukan kepada objek yang jenisnya ialah T). Rujukan objek di dalam Optional<T>objek boleh null.

Kelas ini membolehkan pengaturcara menulis kod yang lebih cantik sedikit. Mari bandingkan:

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

Satu Optionalobjek sentiasa boleh dibandingkan dengan Optionalobjek lain menggunakan equalskaedah, walaupun ia menyimpan nullrujukan.

Ringkasnya, Optionalkelas membolehkan anda menulis semakan "cantik" nulldan tindakan "cantik" sekiranya Optionalobjek menyimpan nullnilai.

3. Mencari elemen

Jom balik kelas Stream. Kelas Streammempunyai 4 lagi kaedah yang membolehkan anda mencari elemen dalam strim. Kaedah ini ialah findFirst(), findAny(), min()dan max().

Optional<T> findFirst()kaedah

Kaedah ini findFirst()hanya mengembalikan elemen pertama dalam aliran. Itu sahaja yang dilakukannya.

Perkara yang lebih menarik untuk diperhatikan di sini ialah kaedah itu tidak mengembalikan objek T, sebaliknya Optional<T>objek pembalut. Ini memastikan bahawa kaedah tidak akan kembali nullselepas gagal mencari objek.

Contoh:

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

Untuk lebih jelas, mari kita pecahkan baris terakhir kepada beberapa baris:

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

Kaedah terakhir get()adalah hanya mengambil nilai yang disimpan di dalam Optionalobjek.

Optional<T> findAny()kaedah

Kaedah ini findAny()mengembalikan sebarang elemen dari aliran dan berakhir di sana. Kaedah ini serupa dengan findFirst(), tetapi ia bagus untuk aliran yang digunakan dalam operasi selari.

Apabila memproses strim secara selari, ia mungkin elemen telah ditemui di beberapa bahagian strim, tetapi masih belum jelas sama ada ia adalah yang pertama atau tidak.

Jika banyak elemen telah dipadankan dengan semua penapis, dan penting bagi pengaturcara untuk mendapatkan yang pertama dengan tepat, maka kaedahnya findFirst()adalah apa yang sepatutnya dipanggil. Jika pengaturcara tahu bahawa pada hakikatnya 0 atau 1 elemen akan sepadan dengan semua penapis, maka sudah cukup untuk memanggil sahaja findAny()— dan ini akan menjadi lebih pantas.

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

Kaedah min()menggunakan comparatorobjek untuk membandingkan semua elemen dalam aliran dan mengembalikan elemen minimum. Cara paling mudah untuk menentukan objek pembanding ialah dengan fungsi lambda.

Contoh mencari rentetan terpendek:

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

Kaedah max()menggunakan comparatorobjek untuk membandingkan semua elemen dalam aliran dan mengembalikan elemen maksimum. Cara paling mudah untuk menentukan objek pembanding ialah dengan fungsi lambda.

Contoh mencari rentetan terpanjang:

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