Como somar uma lista de números inteiros com fluxos java?

Eu quero somar uma lista de números inteiros. Funciona da seguinte maneira, mas a sintaxe não parece correta. O código pode ser otimizado?

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

Isso funcionará, mas o i -> iestá fazendo algum desembalagem automática e é por isso que "parece" estranho. Qualquer um dos seguintes procedimentos funcionará e melhor explicará o que o compilador está fazendo sob o capô com sua sintaxe original:

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

Sugiro mais 2 opções:

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

O segundo usa Collectors.summingInt()coletor, há também um summingLong()coletor com o qual você usaria mapToLong.

E uma terceira opção: o Java 8 apresenta um LongAdderacumulador muito eficaz, projetado para acelerar o resumo em fluxos paralelos e ambientes multiencadeados. Aqui, aqui está um exemplo de uso:

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

Dos documentos

Operações de redução Uma operação de redução (também chamada de dobra) pega uma sequência de elementos de entrada e os combina em um único resultado resumido pela aplicação repetida de uma operação combinada, como encontrar a soma ou o máximo de um conjunto de números ou acumular elementos em uma lista. As classes de fluxos possuem várias formas de operações gerais de redução, chamadas reduzir () e coletar (), bem como várias formas especializadas de redução, como sum (), max () ou count ().

Obviamente, essas operações podem ser prontamente implementadas como loops sequenciais simples, como em:

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

No entanto, existem boas razões para preferir uma operação de redução a uma acumulação mutativa, como a acima. Não é apenas uma redução "mais abstrata" - ela opera no fluxo como um todo, em vez de elementos individuais - mas uma operação de redução adequadamente construída é inerentemente paralelelizável, desde que as funções usadas para processar os elementos sejam associativas e apátrida. Por exemplo, dado um fluxo de números para o qual queremos encontrar a soma, podemos escrever:

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

ou:

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

Essas operações de redução podem ser executadas com segurança em paralelo com quase nenhuma modificação:

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

Então, para um mapa você usaria:

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

Ou:

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

Você pode usar o método de redução:

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

ou

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

Você pode usar reduce()para somar uma lista de números inteiros.

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

Você pode usar o método collect para adicionar uma lista de números inteiros.

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

Essa seria a maneira mais curta de resumir o inttipo de matriz (para longmatriz LongStream, doublematriz DoubleStreame assim por diante). StreamPorém, nem todos os tipos de números inteiros primitivos ou de ponto flutuante têm a implementação.

IntStream.of(integers).sum();

Que isso ajude aqueles que têm objetos na lista.

Se você possui uma lista de objetos e deseja somar campos específicos desse objeto, use o abaixo.

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

Eu declarei uma lista de números inteiros.

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

Você pode tentar usar estas maneiras diferentes abaixo.

Usando mapToInt

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

Usando summarizingInt

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

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

A maioria dos aspectos é coberta. Mas pode haver um requisito para encontrar a agregação de outros tipos de dados além de Inteiro, Longo (para o qual já existe suporte especializado a fluxos). Por exemplo, stram com BigInteger Para esse tipo, podemos usar operações de redução como

Você pode usar o seguinte comando: list.stream ().