Menguasai Aliran Java: Panduan Lengkap untuk Pembangun

Java Stream, yang diperkenalkan dalam Java 8, adalah salah satu tambahan yang paling berkuasa kepada bahasa tersebut. Ia mendayakan operasi gaya fungsian pada koleksi dan jujukan, mengubah cara kami mendekati pemprosesan data dalam Java. Strim memudahkan tugas seperti menapis, memetakan dan mengumpul data sambil turut menyokong operasi selari untuk peningkatan prestasi. Dalam siaran ini, kami akan meneroka asas Strim, membincangkan jenis operasi yang mereka sokong dan memberikan contoh untuk membantu anda memanfaatkan sepenuhnya ciri penting ini.

Jadual Kandungan

1.  What is Streams and why we need it?
2.  Types of Streams: Intermediate vs. Terminal
3.  Creating Streams in Java
4.  Intermediate Stream Operations
5.  Terminal Stream Operations
6.  Using Streams with Lambdas
7.  Conclusion

Apakah itu Strim dan mengapa kita memerlukannya?

Strim dalam Java menyediakan cara yang berkuasa untuk memproses koleksi data. Ia membenarkan kami melaksanakan operasi berfungsi pada elemen koleksi, seperti penapisan dan transformasi, tanpa mengubah data asas. Strim membantu pembangun menumpukan pada perkara yang ingin mereka capai, bukannya cara mencapainya, memberikan abstraksi peringkat lebih tinggi untuk pemprosesan data.

Strim diperkenalkan dalam Java 8 bersama ekspresi lambda dan antara muka berfungsi, direka untuk menjadikan Java lebih ekspresif dan mengurangkan kod boilerplate. Dengan menggabungkan strim, Java mula menerima paradigma pengaturcaraan berfungsi, membolehkan kod yang lebih bersih dan ringkas.

Faedah Utama Strim

• Pemprosesan Data Pengisytiharan: Terangkan operasi yang ingin anda lakukan, bukannya mengurus gelung dan keadaan secara manual.
• Ketidakbolehubahan dan Ketiadaan Negara: Operasi aliran tidak mengubah suai struktur data sumber.
• Pemprosesan Selari: Sokongan untuk strim selari, membolehkan operasi diedarkan merentas berbilang rangkaian dengan mudah.

Jenis Aliran: Perantaraan lwn Terminal

Strim dikelaskan kepada dua jenis utama:

• Operasi Perantaraan: Operasi ini mengubah strim, mengembalikan strim lain sebagai hasilnya. Mereka malas—bermakna mereka tidak dilaksanakan sehingga operasi terminal dipanggil.
• Operasi Terminal: Operasi ini mencetuskan pemprosesan data strim dan mengembalikan hasil bukan strim (cth., koleksi, nilai tunggal atau boolean). Setelah operasi terminal dilaksanakan, strim itu dianggap telah digunakan dan tidak boleh digunakan semula.

Contoh:

List<String> names = List.of("Alice", "Bob", "Charlie", "David");

// Intermediate (lazy) operations: filter and map
Stream<String> stream = names.stream()
                             .filter(name -> name.startsWith("A"))
                             .map(String::toUpperCase);

// Terminal operation: collect
List<String> filteredNames = stream.collect(Collectors.toList());
System.out.println(filteredNames); // Output: [ALICE]

Dalam contoh ini, penapis dan peta ialah operasi perantaraan yang tidak akan dilaksanakan sehingga kutipan operasi terminal dipanggil.

Mencipta Strim dalam Java

Java menyediakan beberapa cara untuk mencipta strim, menjadikannya mudah untuk mula memproses data.

• Dari Koleksi

Cara paling biasa untuk membuat strim ialah daripada koleksi seperti Senarai, Set dan Peta.

1.  What is Streams and why we need it?
2.  Types of Streams: Intermediate vs. Terminal
3.  Creating Streams in Java
4.  Intermediate Stream Operations
5.  Terminal Stream Operations
6.  Using Streams with Lambdas
7.  Conclusion

• Daripada Tatasusunan

List<String> names = List.of("Alice", "Bob", "Charlie", "David");

// Intermediate (lazy) operations: filter and map
Stream<String> stream = names.stream()
                             .filter(name -> name.startsWith("A"))
                             .map(String::toUpperCase);

// Terminal operation: collect
List<String> filteredNames = stream.collect(Collectors.toList());
System.out.println(filteredNames); // Output: [ALICE]

• Menggunakan Stream.of

List<String> names = List.of("Alice", "Bob", "Charlie");
Stream<String> nameStream = names.stream();

• Strim Tak Terhingga (Strim Dijana)

Java membenarkan mencipta strim tak terhingga menggunakan Stream.generate dan Stream.iterate.

String[] namesArray = {"Alice", "Bob", "Charlie"};
Stream<String> nameStream = Arrays.stream(namesArray);

Operasi Aliran Perantaraan

Operasi perantaraan mengembalikan aliran baharu dan malas. Ini bermakna ia dilaksanakan hanya apabila operasi terminal dipanggil.

• penapis(Predikat)

Menapis elemen berdasarkan keadaan.

Stream<String> stream = Stream.of("Alice", "Bob", "Charlie");

• peta(Fungsi)

Mengubah elemen daripada satu jenis kepada jenis yang lain.

Stream<Double> randomNumbers = Stream.generate(Math::random).limit(5);
Stream<Integer> counting = Stream.iterate(0, n -> n + 1).limit(5);

• diisih(Pembanding)

Isih unsur dalam susunan semula jadi atau berdasarkan pembanding.

List<Integer> numbers = List.of(1, 2, 3, 4, 5);
List<Integer> evenNumbers = numbers.stream()
                                   .filter(n -> n % 2 == 0)
                                   .collect(Collectors.toList());

• lihat(Pengguna)

Melakukan tindakan pada setiap elemen, selalunya berguna untuk nyahpepijat.

List<String> names = List.of("Alice", "Bob");
List<Integer> nameLengths = names.stream()
                                 .map(String::length)
                                 .collect(Collectors.toList());

Operasi Aliran Terminal

Operasi terminal dilaksanakan terakhir, mencetuskan pemprosesan data sebenar dan mengembalikan hasil akhir.

• untukSetiap(Pengguna)

Melaksanakan tindakan untuk setiap elemen dalam strim.

List<String> names = List.of("Bob", "Alice", "Charlie");
List<String> sortedNames = names.stream()
                                .sorted()
                                .collect(Collectors.toList());

• kumpul(Pengumpul)

Mengumpul elemen strim ke dalam koleksi, senarai, set atau struktur data lain.

List<String> names = List.of("Alice", "Bob");
names.stream()
     .peek(name -> System.out.println("Processing " + name))
     .collect(Collectors.toList());

• kira()

Mengira bilangan elemen dalam strim.

List<String> names = List.of("Alice", "Bob");
names.stream().forEach(System.out::println);

• anyMatch(Predicate), allMatch(Predicate), noneMatch(Predicate)

Menyemak sama ada ada, semua atau tiada unsur sepadan dengan syarat yang diberikan.

List<String> names = List.of("Alice", "Bob");
Set<String> nameSet = names.stream().collect(Collectors.toSet());

• findFirst() dan findAny()

Mengembalikan Pilihan yang menerangkan unsur pertama atau mana-mana strim.

List<String> names = List.of("Alice", "Bob");
long count = names.stream().count();

Menggunakan Strim dengan Lambdas

Strim dan ekspresi lambda berjalan seiring. Oleh kerana strim adalah berdasarkan antara muka berfungsi, ia berfungsi dengan lancar dengan lambdas, membolehkan pemprosesan data yang ekspresif dan ringkas.

Sebagai contoh, menapis senarai nama untuk mencari nama bermula dengan "A" dan kemudian menukarnya kepada huruf besar:

List<String> names = List.of("Alice", "Bob", "Charlie");
boolean hasAlice = names.stream().anyMatch(name -> name.equals("Alice"));

Dalam contoh ini:

• penapis menggunakan nama lambda -> name.startsWith("A") untuk menapis nama.
• peta mengambil String rujukan kaedah::toUpperCase untuk menukar nama kepada huruf besar.

Kesimpulan

Java Streams membawa keupayaan pengaturcaraan berfungsi ke Java, membolehkan manipulasi data yang ekspresif dan ringkas. Dengan memahami perbezaan antara operasi perantaraan dan terminal serta cara mencipta dan menggunakan strim dengan berkesan, anda boleh meningkatkan kebolehbacaan dan kebolehselenggaraan kod anda dengan ketara. Sepadukan strim dan lambda dalam aliran kerja anda untuk menulis aplikasi Java yang lebih bersih dan cekap.

Selamat penstriman!

Atas ialah kandungan terperinci Menguasai Aliran Java: Panduan Lengkap untuk Pembangun. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!