Làm cách nào để tổng hợp danh sách các số nguyên với các luồng java?

Tôi muốn tổng hợp một danh sách các số nguyên. Nó hoạt động như sau, nhưng cú pháp không cảm thấy đúng. Mã có thể được tối ưu hóa?

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

Điều này sẽ hoạt động, nhưng i -> iđang thực hiện một số unboxing tự động, đó là lý do tại sao nó "cảm thấy" lạ. Một trong những điều sau đây sẽ hoạt động và giải thích rõ hơn những gì trình biên dịch đang làm dưới mui xe với cú pháp ban đầu của bạn:

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

Tôi đề nghị thêm 2 lựa chọn:

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

Cái thứ hai sử dụng Collectors.summingInt()collector, cũng có một summingLong()collector mà bạn sẽ sử dụng mapToLong.

Và một tùy chọn thứ ba: Java 8 giới thiệu một bộ LongAddertích lũy rất hiệu quả được thiết kế để tăng tốc tổng hợp trong các luồng song song và môi trường đa luồng. Đây là một ví dụ sử dụng:

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

Từ các tài liệu

Các hoạt động rút gọn Hoạt động rút gọn (còn gọi là nếp gấp) lấy một chuỗi các phần tử đầu vào và kết hợp chúng thành một kết quả tóm tắt duy nhất bằng cách áp dụng lặp lại một hoạt động kết hợp, chẳng hạn như tìm tổng hoặc tối đa của một tập hợp số hoặc tích lũy các phần tử vào một danh sách. Các lớp luồng có nhiều dạng hoạt động giảm chung, được gọi là less () và coll (), cũng như nhiều dạng rút gọn chuyên biệt như sum (), max () hoặc Count ().

Tất nhiên, các hoạt động như vậy có thể được thực hiện dễ dàng như các vòng lặp tuần tự đơn giản, như trong:

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

Tuy nhiên, có những lý do chính đáng để thích một hoạt động giảm hơn tích lũy đột biến như ở trên. Không chỉ là giảm "trừu tượng" hơn - nó hoạt động trên toàn bộ luồng chứ không phải là các phần tử riêng lẻ - nhưng hoạt động giảm được xây dựng đúng cách vốn đã song song, miễn là (các) hàm được sử dụng để xử lý các phần tử là liên kết và không quốc tịch Ví dụ: được cung cấp một dòng số mà chúng tôi muốn tìm tổng, chúng tôi có thể viết:

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

hoặc là:

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

Các hoạt động giảm này có thể chạy an toàn song song với hầu như không sửa đổi:

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

Vì vậy, đối với bản đồ bạn sẽ sử dụng:

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

Hoặc là:

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

Bạn có thể sử dụng phương thức rút gọn:

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

hoặc là

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

Bạn có thể sử dụng reduce()để tổng hợp một danh sách các số nguyên.

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

Bạn có thể sử dụng phương pháp thu thập để thêm danh sách các số nguyên.

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

Đây sẽ là cách ngắn nhất để tổng hợp intmảng loại (cho longmảng LongStream, cho doublemảng DoubleStreamvà vv). Không phải tất cả các kiểu số nguyên hoặc dấu phẩy động đều có cách Streamthực hiện.

IntStream.of(integers).sum();

Có thể điều này sẽ giúp những người có đối tượng trong danh sách.

Nếu bạn có một danh sách các đối tượng và muốn tổng hợp các trường cụ thể của đối tượng này, hãy sử dụng bên dưới.

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

Tôi đã tuyên bố một danh sách các số nguyên.

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

Bạn có thể thử sử dụng những cách khác nhau dưới đây.

Sử dụng mapToInt

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

Sử dụng summarizingInt

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

Sử dụng 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);

Hầu hết các khía cạnh được bảo hiểm. Nhưng có thể có một yêu cầu để tìm tổng hợp các loại dữ liệu khác ngoài Integer, Long (đã có hỗ trợ luồng chuyên biệt). Ví dụ: stram với BigInteger Đối với loại như vậy, chúng ta có thể sử dụng giảm hoạt động như

list.stream (). giảm ((bigInteger1, bigInteger2) -> bigInteger1.add (bigInteger2))