Java Academy · Lezione

toMap, joining e summarizing

Converta gli stream in mappe, concateni le stringhe con joining e calcoli statistiche con summarizingInt.

toMap, joining e summarizing è 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.

Nozioni di base su Collectors.toMap

Collectors.toMap(keyMapper, valueMapper) converte uno stream in una Map. Ogni elemento fornisce una coppia chiave-valore.

import java.util.*;
import java.util.stream.*;

record Country(String code, String name) {}
List<Country> countries = List.of(
    new Country("US","United States"),
    new Country("DE","Germany"),
    new Country("JP","Japan")
);

Map<String, String> codeToName =
    countries.stream().collect(
        Collectors.toMap(Country::code, Country::name)
    );
System.out.println(codeToName.get("DE")); // Germany

Gestione delle chiavi duplicate

toMap genera IllegalStateException in presenza di chiavi duplicate. Fornisca una funzione di merge come terzo argomento per risolvere i conflitti:

List<String> words = List.of("apple","ant","banana","bat","cherry");

Map<Character, String> firstByLetter =
    words.stream().collect(
        Collectors.toMap(
            w -> w.charAt(0),
            w -> w,
            (existing, replacement) -> existing // keep first
        )
    );
System.out.println(firstByLetter); // {a=apple, b=banana, c=cherry}

toMap con trasformazione dei valori

Il value mapper può essere una funzione qualsiasi: trasformi l'elemento prima di memorizzarlo:

record User(String login, String email) {}
List<User> users = List.of(
    new User("alice","alice@example.com"),
    new User("bob","bob@example.com")
);

Map<String, String> loginToEmail =
    users.stream().collect(
        Collectors.toMap(User::login, u -> u.email().toUpperCase())
    );
System.out.println(loginToEmail.get("alice")); // ALICE@EXAMPLE.COM

toUnmodifiableMap

Utilizzi Collectors.toUnmodifiableMap() per produrre una map immutabile: è equivalente ad avvolgere il risultato con Collections.unmodifiableMap(), ma più pulito:

Map<String, Integer> wordLengths =
    Stream.of("Java","Stream","API")
          .collect(Collectors.toUnmodifiableMap(w -> w, String::length));
// wordLengths.put("test",4); // throws UnsupportedOperationException

Collectors.joining

Collectors.joining() concatena gli elementi stringa. Accetta facoltativamente un delimitatore, un prefisso e un suffisso:

List<String> names = List.of("Alice","Bob","Carol");

System.out.println(names.stream().collect(Collectors.joining()));
// AliceBobCarol

System.out.println(names.stream().collect(Collectors.joining(", ")));
// Alice, Bob, Carol

System.out.println(names.stream().collect(Collectors.joining(", ", "[", "]")));
// [Alice, Bob, Carol]

joining per l'output CSV

Crei righe CSV o clausole SQL IN con joining:

List<Integer> ids = List.of(1,2,3,4,5);

String inClause = ids.stream()
    .map(Object::toString)
    .collect(Collectors.joining(",", "(", ")"));
System.out.println("WHERE id IN " + inClause);
// WHERE id IN (1,2,3,4,5)

summarizingInt / Long / Double

Collectors.summarizingInt() calcola tutte le statistiche in un'unica passata e restituisce un IntSummaryStatistics:

record Product(String name, int price) {}
List<Product> products = List.of(
    new Product("A",100), new Product("B",200), new Product("C",150)
);

IntSummaryStatistics stats =
    products.stream().collect(Collectors.summarizingInt(Product::price));

System.out.println("Count: " + stats.getCount());   // 3
System.out.println("Sum: "   + stats.getSum());     // 450
System.out.println("Min: "   + stats.getMin());     // 100
System.out.println("Max: "   + stats.getMax());     // 200
System.out.println("Avg: "   + stats.getAverage()); // 150.0

summingInt e averagingInt

Per i casi più semplici in cui serve una sola statistica:

int total = products.stream().collect(Collectors.summingInt(Product::price));
System.out.println("Total: " + total); // 450

double avg = products.stream().collect(Collectors.averagingInt(Product::price));
System.out.println("Average: " + avg); // 150.0

groupingBy con summarizingInt

Combini summarizing per ogni gruppo:

record Sale(String region, int amount) {}
List<Sale> sales = List.of(
    new Sale("North",100), new Sale("South",200),
    new Sale("North",150), new Sale("South",300)
);

Map<String, IntSummaryStatistics> statsByRegion =
    sales.stream().collect(
        Collectors.groupingBy(Sale::region,
            Collectors.summarizingInt(Sale::amount))
    );
statsByRegion.forEach((r,s) ->
    System.out.printf("%s: sum=%d avg=%.1f%n", r, s.getSum(), s.getAverage()));

Raccolta in LinkedHashMap

Per impostazione predefinita, toMap produce una HashMap, che non mantiene un ordine. Utilizzi l'overload a 4 argomenti per specificare una LinkedHashMap e preservare l'ordine di inserimento:

Map<String, Integer> ordered =
    Stream.of("banana","apple","cherry")
          .collect(Collectors.toMap(
              w -> w,
              String::length,
              (a,b) -> a,
              LinkedHashMap::new
          ));
System.out.println(ordered.keySet()); // [banana, apple, cherry]

Pratica: parser di configurazione

Analizzi le righe nel formato key=value e le inserisca in una map con toMap:

List<String> lines = List.of("host=localhost","port=5432","db=myapp");

Map<String, String> config =
    lines.stream()
         .map(l -> l.split("=", 2))
         .collect(Collectors.toMap(a -> a[0], a -> a[1]));

System.out.println(config.get("port")); // 5432

Verifica rapida

Utilizza Collectors.toMap(k, v) su uno stream che contiene due elementi con la stessa chiave. Che cosa succede?

Riepilogo: toMap, joining, summarizing

Punti chiave:

toMap(keyMapper, valueMapper): genera un'eccezione per le chiavi duplicate se non viene fornita una funzione di merge
joining(delimiter, prefix, suffix): concatena le stringhe in modo elegante
summarizingInt fornisce conteggio, somma, minimo, massimo e media in un'unica passata
Utilizzi summingInt/averagingInt quando serve una sola statistica
Utilizzi toMap a 4 argomenti con LinkedHashMap::new per ottenere risultati ordinati

Domande Frequenti

La lezione «toMap, joining e summarizing» è gratuita?

Sì — il testo completo di «toMap, joining e summarizing» è 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 «toMap, joining e summarizing»?

Converta gli stream in mappe, concateni le stringhe con joining e calcoli statistiche con summarizingInt. 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 «toMap, joining e summarizing»?

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

groupingBy: classificare gli elementi
partitioningBy e counting
toMap, joining e summarizing
Creazione di un Collector personalizzato

← Torna a Java Academy