Java Academy · Aula

Mapeando para e de streams de objetos

mapToObj e mapToInt.

Mapeando para e de streams de objetos é uma aula grátis de Java Academy no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Java Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Java Academy inclui 4 aulas no total.

Dois mundos de fluxos

Java tem fluxos de objetos (Stream<T>) e fluxos de primitivas (IntStream e equivalentes). Os métodos de mapeamento permitem passar de um para o outro.

import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        System.out.println(IntStream.rangeClosed(1, 3).sum());
    }
}

mapToObj: de primitiva para objeto

mapToObj converte cada primitiva em um objeto, produzindo um Stream<T>.

import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        List<String> labels = IntStream.rangeClosed(1, 3)
            .mapToObj(n -> "item-" + n)
            .collect(Collectors.toList());
        System.out.println(labels);
    }
}

mapToInt: de objeto para primitiva

mapToInt extrai um int de cada objeto, produzindo um IntStream pronto para agregações numéricas.

import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> words = List.of("hi", "hello", "hey");
        int totalChars = words.stream()
            .mapToInt(String::length)
            .sum();
        System.out.println(totalChars);
    }
}

boxed: de primitiva para fluxo de empacotadores

boxed transforma um IntStream em um Stream<Integer>, necessário antes de coletar os elementos em uma List.

import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        List<Integer> list = IntStream.rangeClosed(1, 5)
            .boxed()
            .collect(Collectors.toList());
        System.out.println(list);
    }
}

mapToLong e mapToDouble

O mesmo padrão se aplica a outras primitivas: mapToLong e mapToDouble.

import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> prices = List.of("9.99", "19.50", "4.25");
        double total = prices.stream()
            .mapToDouble(Double::parseDouble)
            .sum();
        System.out.println(total);
    }
}

Por que mapToInt supera map

Usar map em um fluxo de objetos mantém os valores empacotados. mapToInt disponibiliza métodos numéricos como sum e average, evitando o empacotamento.

import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> nums = List.of(10, 20, 30);
        double avg = nums.stream()
            .mapToInt(Integer::intValue)
            .average()
            .getAsDouble();
        System.out.println(avg);
    }
}

Ida e volta: de objeto para Int e para objeto

Você pode percorrer as duas direções em um único fluxo: extraia os números, transforme-os e depois mapeie-os novamente para objetos.

import java.util.List;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        List<String> words = List.of("a", "bb", "ccc");
        List<String> report = words.stream()
            .mapToInt(String::length)
            .mapToObj(len -> "len=" + len)
            .collect(Collectors.toList());
        System.out.println(report);
    }
}

asLongStream e asDoubleStream

Dentro dos fluxos de primitivas, você pode ampliar os tipos: asLongStream e asDoubleStream evitam o empacotamento ao alterar a largura numérica.

import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        double avg = IntStream.of(1, 2, 3, 4)
            .asDoubleStream()
            .average()
            .getAsDouble();
        System.out.println(avg);
    }
}

Coletando resultados de primitivas

Para reunir primitivas em uma coleção, chame primeiro boxed e depois um coletor.

import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        Set<Integer> evens = IntStream.rangeClosed(1, 10)
            .filter(n -> n % 2 == 0)
            .boxed()
            .collect(Collectors.toSet());
        System.out.println(evens);
    }
}

flatMapToInt

flatMapToInt achata objetos em um único IntStream, sendo útil quando cada objeto produz vários números.

import java.util.List;
import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        List<int[]> rows = List.of(new int[]{1, 2}, new int[]{3, 4});
        int sum = rows.stream()
            .flatMapToInt(Arrays::stream)
            .sum();
        System.out.println(sum);
    }
}

Escolhendo o Mapper certo

Escolha de acordo com a direção:

De objeto para primitiva: mapToInt, mapToLong, mapToDouble.
De primitiva para objeto: mapToObj ou boxed.

import java.util.List;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        List<String> in = List.of("x", "yy");
        String out = in.stream()
            .mapToInt(String::length)
            .mapToObj(Integer::toString)
            .collect(Collectors.joining(","));
        System.out.println(out);
    }
}

Verificação rápida

Qual método transforma um IntStream em um Stream<Integer>?

Recapitulação

Você passou entre fluxos de objetos e de primitivas:

mapToInt/mapToLong/mapToDouble passam de objetos para primitivas.
mapToObj e boxed passam de primitivas para objetos.
flatMapToInt achata vários números em um único IntStream.
Passar para fluxos de primitivas permite usar agregações numéricas sem empacotamento.

Perguntas Frequentes

A aula “Mapeando para e de streams de objetos” é grátis?

Sim — o texto completo de “Mapeando para e de streams de objetos” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Java Academy, atualize para CoddyKit PRO. O curso de Java Academy inclui 4 aulas no total.

O que vou aprender em “Mapeando para e de streams de objetos”?

mapToObj e mapToInt. Você pratica Java Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Java Academy?

Nenhuma experiência prévia é necessária. Java Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.

Quanto tempo leva a aula “Mapeando para e de streams de objetos”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Java Academy?

Sim. Cada aula de Java Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Java Academy