Bagaimana cara menjumlahkan daftar bilangan bulat dengan aliran java?

Saya ingin menjumlahkan daftar bilangan bulat. Ini berfungsi sebagai berikut, tetapi sintaksnya terasa tidak benar. Bisakah kode dioptimalkan?

Map<String, Integer> integers;
integers.values().stream().mapToInt(i -> i).sum();

Ini akan bekerja, tetapi i -> imelakukan beberapa unboxing otomatis yang mengapa "terasa" aneh. Salah satu dari yang berikut ini akan berfungsi dan lebih baik menjelaskan apa yang dilakukan kompiler di bawah tenda dengan sintaks asli Anda:

integers.values().stream().mapToInt(i -> i.intValue()).sum();
integers.values().stream().mapToInt(Integer::intValue).sum();

Saya menyarankan 2 opsi lagi:

integers.values().stream().mapToInt(Integer::intValue).sum();
integers.values().stream().collect(Collectors.summingInt(Integer::intValue));

Yang kedua menggunakan Collectors.summingInt()kolektor, ada juga summingLong()kolektor yang akan Anda gunakan mapToLong.

Dan opsi ketiga: Java 8 memperkenalkan LongAdderakumulator yang sangat efektif yang dirancang untuk mempercepat peringkasan dalam aliran paralel dan lingkungan multi-utas. Di sini, inilah contoh penggunaannya:

LongAdder a = new LongAdder();
map.values().parallelStream().forEach(a::add);
sum = a.intValue();

Dari dokumen

Operasi reduksi Operasi reduksi (juga disebut lipatan) mengambil urutan elemen input dan menggabungkannya ke dalam hasil ringkasan tunggal dengan aplikasi berulang dari operasi kombinasi, seperti menemukan jumlah atau maksimum satu set angka, atau mengumpulkan elemen ke dalam sebuah daftar. Kelas aliran memiliki beberapa bentuk operasi pengurangan umum, yang disebut mengurangi () dan mengumpulkan (), serta beberapa bentuk pengurangan khusus seperti jumlah (), maks (), atau hitung ().

Tentu saja, operasi tersebut dapat dengan mudah diimplementasikan sebagai loop berurutan sederhana, seperti pada:

int sum = 0;
for (int x : numbers) {
   sum += x;
}

Namun, ada alasan bagus untuk lebih memilih operasi pengurangan daripada akumulasi mutatif seperti di atas. Tidak hanya pengurangan "lebih abstrak" - ini beroperasi pada aliran secara keseluruhan daripada elemen individual - tetapi operasi pengurangan yang dibangun dengan benar secara inheren dapat diparalelkan, selama fungsi yang digunakan untuk memproses elemen-elemen tersebut asosiatif. dan tanpa kewarganegaraan. Sebagai contoh, diberi aliran angka yang ingin kita temukan jumlahnya, kita dapat menulis:

int sum = numbers.stream().reduce(0, (x,y) -> x+y);

atau:

int sum = numbers.stream().reduce(0, Integer::sum);

Operasi pengurangan ini dapat berjalan dengan aman secara paralel dengan hampir tidak ada modifikasi:

int sum = numbers.parallelStream().reduce(0, Integer::sum);

Jadi, untuk peta Anda akan menggunakan:

integers.values().stream().mapToInt(i -> i).reduce(0, (x,y) -> x+y);

Atau:

integers.values().stream().reduce(0, Integer::sum);

Anda dapat menggunakan metode pengurangan:

long sum = result.stream().map(e -> e.getCreditAmount()).reduce(0L, (x, y) -> x + y);

atau

long sum = result.stream().map(e -> e.getCreditAmount()).reduce(0L, Integer::sum);

Anda dapat menggunakan reduce()untuk menjumlahkan daftar bilangan bulat.

int sum = integers.values().stream().reduce(0, Integer::sum);

Anda dapat menggunakan metode kumpulkan untuk menambahkan daftar bilangan bulat.

List<Integer> list = Arrays.asList(2, 4, 5, 6);
int sum = list.stream().collect(Collectors.summingInt(Integer::intValue));

Ini akan menjadi cara terpendek untuk meringkas intjenis array (untuk longarray LongStream, untuk doublearray DoubleStreamdan sebagainya). Namun tidak semua tipe integer primitif atau floating point Streamdiimplementasikan.

IntStream.of(integers).sum();

Semoga ini membantu mereka yang memiliki objek dalam daftar.

Jika Anda memiliki daftar objek dan ingin menjumlahkan bidang tertentu dari objek ini gunakan di bawah ini.

List<ResultSom> somList = MyUtil.getResultSom();
BigDecimal result= somList.stream().map(ResultSom::getNetto).reduce(
                                             BigDecimal.ZERO, BigDecimal::add);

Saya telah mendeklarasikan daftar Integer.

ArrayList<Integer> numberList = new ArrayList<Integer>(Arrays.asList(1, 2, 3, 4, 5));

Anda dapat mencoba menggunakan berbagai cara di bawah ini.

Menggunakan mapToInt

int sum = numberList.stream().mapToInt(Integer::intValue).sum();

Menggunakan summarizingInt

int sum = numberList.stream().collect(Collectors.summarizingInt(Integer::intValue)).getSum();

Menggunakan reduce

int sum = numberList.stream().reduce(Integer::sum).get().intValue();

class Pojo{
    int num;

    public Pojo(int num) {
        super();
        this.num = num;
    }

    public int getNum() {
        return num;
    }

    public void setNum(int num) {
        this.num = num;
    }
}

List<Pojo> list = new ArrayList<Pojo>();
            list.add(new Pojo(1));
            list.add(new Pojo(5));
            list.add(new Pojo(3));
            list.add(new Pojo(4));
            list.add(new Pojo(5));

            int totalSum = list.stream().mapToInt(pojo -> pojo.getNum()).sum();
            System.out.println(totalSum);

Sebagian besar aspek tercakup. Tetapi mungkin ada persyaratan untuk menemukan agregasi tipe data lain selain dari Integer, Long (yang sudah disediakan dukungan aliran khusus). Untuk mis. Stram dengan BigInteger Untuk tipe seperti itu kita dapat menggunakan seperti mengurangi operasi

list.stream (). kurangi ((bigInteger1, bigInteger2) -> bigInteger1.add (bigInteger2))