0Pricing
Java Academy · Lezione

Conversione da e verso stream di oggetti

mapToObj e mapToInt

Conversione da e verso stream di oggetti è una lezione Java Academy gratuita su CoddyKit. Questa è la lezione 3 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Java Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Java Academy include 4 lezioni in totale.

Due mondi di stream

Java dispone di stream di oggetti (Stream<T>) e stream primitivi (IntStream e simili). I metodi di mapping consentono di passare dall'uno all'altro.

import java.util.stream.IntStream;

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

mapToObj: da primitivo a oggetto

mapToObj converte ogni primitivo in un oggetto, producendo uno 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: da oggetto a primitivo

mapToInt estrae un int da ogni oggetto, producendo un IntStream pronto per le aggregazioni numeriche.

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: da primitivo a stream di wrapper

boxed trasforma un IntStream in uno Stream<Integer>, necessario prima di raccogliere i risultati in 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 e mapToDouble

Lo stesso schema si applica agli altri primitivi: 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);
    }
}

Perché mapToInt è meglio di map

Usare map su uno stream di oggetti mantiene gli elementi sottoposti a boxing. mapToInt abilita metodi numerici come sum e average, evitando al contempo il 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);
    }
}

Percorso completo: da oggetto a int e di nuovo a oggetto

Può spostarsi in entrambe le direzioni all'interno di un'unica pipeline: estragga i numeri, li trasformi e poi li riconverta in oggetti.

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

All'interno degli stream primitivi può ampliare i tipi: asLongStream e asDoubleStream evitano il boxing mentre modificano l'ampiezza numerica.

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

Raccogliere risultati primitivi

Per raccogliere i primitivi in una collezione, chiami prima boxed e poi 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 appiattisce gli oggetti in un singolo IntStream, utile quando ogni oggetto produce più numeri.

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

Scegliere il mapper corretto

Scelga in base alla direzione:

  • Da oggetto a primitivo: mapToInt, mapToLong, mapToDouble.
  • Da primitivo a oggetto: 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);
    }
}

Verifica rapida

Quale metodo trasforma un IntStream in uno Stream<Integer>?

Riepilogo

È passato dagli stream di oggetti a quelli primitivi e viceversa:

  • mapToInt/mapToLong/mapToDouble passano da oggetti a primitivi.
  • mapToObj e boxed passano da primitivi a oggetti.
  • flatMapToInt appiattisce molti numeri in un unico IntStream.
  • Il passaggio agli stream primitivi abilita le aggregazioni numeriche senza boxing.

Domande Frequenti

La lezione «Conversione da e verso stream di oggetti» è gratuita?

Sì — il testo completo di «Conversione da e verso stream di oggetti» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Java Academy, passa a CoddyKit PRO. Il corso Java Academy include 4 lezioni in totale.

Cosa imparerò in «Conversione da e verso stream di oggetti»?

mapToObj e mapToInt Eserciti Java Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Java Academy?

Non è richiesta alcuna esperienza precedente. Java Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 4.

Quanto tempo richiede la lezione «Conversione da e verso stream di oggetti»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Java Academy?

Sì. Ogni lezione Java Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. IntStream e LongStream
  2. Operazioni di intervallo e aggregazione
  3. Conversione da e verso stream di oggetti
  4. Generazione di stream primitivi
← Torna a Java Academy