Menjumlahkan Angka dengan Aliran Java

1. Perkenalan

Dalam tutorial singkat ini, kami akan menunjukkan berbagai cara menghitung jumlah bilangan bulat, menggunakan Stream API .

Demi kesederhanaan, kami akan menggunakan bilangan bulat dalam contoh kami. Namun, kita juga bisa menerapkan metode yang sama untuk long dan double.

2. Menggunakan Stream.reduce ()

Stream.reduce () adalah operasi terminal yang melakukan pengurangan elemen aliran .

Ini menerapkan operator biner (akumulator) ke setiap elemen dalam aliran, di mana operan pertama adalah nilai kembalian dari aplikasi sebelumnya, dan yang kedua adalah elemen aliran saat ini.

Dalam metode pertama menggunakan metode reduce () , fungsi akumulator adalah ekspresi lambda yang menambahkan dua nilai Integer dan mengembalikan nilai Integer :

List integers = Arrays.asList(1, 2, 3, 4, 5); Integer sum = integers.stream() .reduce(0, (a, b) -> a + b);

Dengan cara yang sama, kita bisa menggunakan metode Java yang sudah ada :

List integers = Arrays.asList(1, 2, 3, 4, 5); Integer sum = integers.stream() .reduce(0, Integer::sum);

Atau kami dapat menentukan dan menggunakan metode kustom kami:

public class ArithmeticUtils { public static int add(int a, int b) { return a + b; } } 

Kemudian, kita bisa meneruskan fungsi ini sebagai parameter ke metode reduce () :

List integers = Arrays.asList(1, 2, 3, 4, 5); Integer sum = integers.stream() .reduce(0, ArithmeticUtils::add); 

3. Menggunakan Stream.collect ()

Metode kedua untuk menghitung jumlah daftar bilangan bulat adalah dengan menggunakan operasi terminal collect () :

List integers = Arrays.asList(1, 2, 3, 4, 5); Integer sum = integers.stream() .collect(Collectors.summingInt(Integer::intValue));

Demikian pula, kelas Collectors menyediakan metode summingLong () dan summingDouble () untuk menghitung jumlah masing-masing long dan doubles.

4. Menggunakan IntStream.sum ()

Stream API memberi kita operasi perantara mapToInt () , yang mengonversi aliran kita menjadi objek IntStream .

Metode ini mengambil mapper sebagai parameter yang digunakan untuk melakukan konversi, kemudian kita dapat memanggil metode sum () untuk menghitung jumlah elemen aliran.

Mari kita lihat contoh singkat bagaimana kita dapat menggunakannya:

List integers = Arrays.asList(1, 2, 3, 4, 5); Integer sum = integers.stream() .mapToInt(Integer::intValue) .sum();

Dengan cara yang sama, kita bisa menggunakan metode mapToLong () dan mapToDouble () untuk menghitung jumlah panjang dan ganda masing-masing.

5. Menggunakan Stream # sum dengan Map

Untuk menghitung jumlah nilai dari Peta struktur data, pertama kita membuat aliran dari nilai-nilai itu Peta , maka kita menerapkan salah satu metode yang kita gunakan sebelumnya.

Misalnya, dengan menggunakan IntStream.sum () :

Integer sum = map.values() .stream() .mapToInt(Integer::valueOf) .sum();

6. Menggunakan Stream # sum dengan Objek

Mari kita bayangkan bahwa kita memiliki daftar objek dan ingin menghitung jumlah semua nilai dari bidang tertentu dari objek ini.

Sebagai contoh:

public class Item { private int id; private Integer price; public Item(int id, Integer price) { this.id = id; this.price = price; } // Standard getters and setters } 

Selanjutnya, mari kita bayangkan bahwa kita ingin menghitung harga total semua item dari daftar berikut:

Item item1 = new Item(1, 10); Item item2 = new Item(2, 15); Item item3 = new Item(3, 25); Item item4 = new Item(4, 40); List items = Arrays.asList(item1, item2, item3, item4);

Dalam hal ini, untuk menghitung penjumlahan menggunakan metode yang ditunjukkan pada contoh sebelumnya, kita perlu memanggil peta () metode untuk mengubah aliran kami ke dalam aliran bilangan bulat .

Hasilnya, kita bisa menggunakan Stream.reduce (), Stream.collect (), dan IntStream.sum () untuk menghitung jumlahnya:

Integer sum = items.stream() .map(x -> x.getPrice()) .reduce(0, ArithmeticUtils::add); 
Integer sum = items.stream() .map(x -> x.getPrice()) .reduce(0, Integer::sum);
Integer sum = items.stream() .map(item -> item.getPrice()) .reduce(0, (a, b) -> a + b);
Integer sum = items.stream() .map(x -> x.getPrice()) .collect(Collectors.summingInt(Integer::intValue));
items.stream() .mapToInt(x -> x.getPrice()) .sum();

7. Menggunakan Stream # sum dengan String

Misalkan kita memiliki objek String yang berisi beberapa bilangan bulat.

Untuk menghitung jumlah bilangan bulat ini, pertama-tama, kita perlu mengubah String itu menjadi Array , lalu kita perlu menyaring elemen non-integer , dan terakhir, mengubah elemen yang tersisa dari array itu menjadi angka.

Mari kita lihat semua langkah ini beraksi:

String string = "Item1 10 Item2 25 Item3 30 Item4 45"; Integer sum = Arrays.stream(string.split(" ")) .filter((s) -> s.matches("\\d+")) .mapToInt(Integer::valueOf) .sum();

8. Kesimpulan

Dalam tutorial ini, kami melihat beberapa metode tentang cara menghitung jumlah daftar bilangan bulat dengan menggunakan Stream API. Selain itu, kami menggunakan metode ini untuk menghitung jumlah nilai bidang tertentu dari daftar objek, jumlah nilai peta, serta angka dalam objek String tertentu .

Seperti biasa, kode lengkap tersedia di GitHub.