Java Academy · Lección

Mapeo hacia y desde streams de objetos

mapToObj y mapToInt

Mapeo hacia y desde streams de objetos es una lección gratuita de Java Academy en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Java Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Java Academy incluye 4 lecciones en total.

Dos mundos de streams

Java tiene streams de objetos (Stream<T>) y streams primitivos (IntStream y otros). Los métodos de mapeo permiten pasar de unos a otros.

import java.util.stream.IntStream;

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

mapToObj: de primitivo a objeto

mapToObj convierte cada primitivo en un objeto y produce un 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 a primitivo

mapToInt extrae un int de cada objeto y produce un IntStream listo para realizar agregaciones 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 primitivos a un stream de envoltorios

boxed convierte un IntStream en un Stream<Integer>, necesario antes de recopilar los elementos en una 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 y mapToDouble

El mismo patrón se aplica a otros primitivos: mapToLong y 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 qué mapToInt supera a map

Usar map sobre un stream de objetos hace que siga siendo boxed. mapToInt habilita métodos numéricos como sum y average y, al mismo tiempo, evita el boxing.

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

Recorrido de ida y vuelta: de objeto a Int y de nuevo a objeto

Puede moverse en ambas direcciones dentro de una misma canalización: extraiga los números, transfórmelos y vuelva a convertirlos en 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 y asDoubleStream

Dentro de los streams primitivos puede ampliar los tipos: asLongStream y asDoubleStream evitan el boxing al cambiar el tamaño numérico.

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

Recopilación de resultados primitivos

Para reunir primitivos en una colección, llame primero a boxed y después a un collector.

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 aplana objetos en un único IntStream, lo que resulta útil cuando cada objeto produce varios 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);
    }
}

Elección del mapeador adecuado

Elija según la dirección:

De objeto a primitivo: mapToInt, mapToLong y mapToDouble.
De primitivo a objeto: mapToObj o 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);
    }
}

Comprobación rápida

¿Qué método convierte un IntStream en un Stream<Integer>?

Resumen

Pasó de streams de objetos a streams primitivos y viceversa:

mapToInt/mapToLong/mapToDouble convierten de objeto a primitivo.
mapToObj y boxed convierten de primitivo a objeto.
flatMapToInt aplana muchos números en un único IntStream.
Pasar a streams primitivos habilita agregados numéricos sin boxing.

Preguntas frecuentes

¿La lección «Mapeo hacia y desde streams de objetos» es gratis?

Sí — el texto completo de «Mapeo hacia y desde streams de objetos» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Java Academy, actualiza a CoddyKit PRO. El curso de Java Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Mapeo hacia y desde streams de objetos»?

mapToObj y mapToInt Practicas Java Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Java Academy?

No se requiere experiencia previa. Java Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.

¿Cuánto tiempo toma la lección «Mapeo hacia y desde streams de objetos»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Java Academy?

Sí. Cada lección de Java Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

IntStream y LongStream
Operaciones de rango y agregación
Mapeo hacia y desde streams de objetos
Generación de streams de tipos primitivos

← Volver a Java Academy