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

public class ToListExample {
    public static void main(String[] args) {
        Stream<String> stream = Stream.of("apple", "banana", "orange");
        List<String> list = stream.collect(Collectors.toList());
        System.out.println(list); // [apple, banana, orange]
    }
}

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

public class ToSetExample {
    public static void main(String[] args) {
        Stream<String> stream = Stream.of("apple", "banana", "apple");
        Set<String> set = stream.collect(Collectors.toSet());
        System.out.println(set); // [apple, banana]
    }
}

public static <T, K, U> Collector<T, ?, Map<K, U>> toMap(  
    Function<? super T, ? extends K> keyMapper,  
    Function<? super T, ? extends U> valueMapper  
)

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

// Создаем Map: {имя -> длина строки}  
Map<String, Integer> nameToLength = names.stream()  
    .collect(Collectors.toMap(  
        name -> name,            // ключ – сама строка  
        name -> name.length()    // значение – длина строки  
    ));  

// Результат: {"Alice":5, "Bob":3, "Charlie":7}
Что произойдет, если ключи повторяются?
→ Будет выброшено IllegalStateException!

public static <T, K, U> Collector<T, ?, Map<K, U>> toMap(  
    Function<? super T, ? extends K> keyMapper,  
    Function<? super T, ? extends U> valueMapper,  
    BinaryOperator<U> mergeFunction  
)

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

Map<String, Integer> nameToLength = names.stream()  
    .collect(Collectors.toMap(  
        name -> name,  
        name -> name.length(),  
        (oldValue, newValue) -> oldValue  // при конфликте берем старое значение  
    ));  

// Результат: {"Alice":5, "Bob":3}

List<String> names = List.of("A", "B", "A", "C");  

Map<String, String> mergedLetters = names.stream()  
    .collect(Collectors.toMap(  
        letter -> letter,  
        letter -> letter,  
        (oldVal, newVal) -> oldVal + newVal  // "A" + "A" → "AA"  
    ));  

// Результат: {"A":"AA", "B":"B", "C":"C"}

record Product(String id, double price) {}  

List<Product> products = List.of(  
    new Product("A", 10.0),  
    new Product("B", 20.0),  
    new Product("A", 15.0)  
);  

Map<String, Double> totalPriceById = products.stream()  
    .collect(Collectors.toMap(  
        Product::id,  
        Product::price,  
        Double::sum  // 10.0 + 15.0 = 25.0  
    ));  

// Результат: {"A":25.0, "B":20.0}

public static <T, K, U, M extends Map<K, U>> Collector<T, ?, M> toMap(  
    Function<? super T, ? extends K> keyMapper,  
    Function<? super T, ? extends U> valueMapper,  
    BinaryOperator<U> mergeFunction,  
    Supplier<M> mapFactory  
)

Map<String, Integer> orderedMap = names.stream()  
    .collect(Collectors.toMap(  
        name -> name,  
        name -> name.length(),  
        (oldVal, newVal) -> oldVal,  
        LinkedHashMap::new  
    ));  

Map<String, Integer> sortedMap = names.stream()  
    .collect(Collectors.toMap(  
        name -> name,  
        name -> name.length(),  
        (oldVal, newVal) -> oldVal,  
        TreeMap::new  
    ));

Map<String, Integer> unmodifiableMap = names.stream()  
    .collect(Collectors.toUnmodifiableMap(  
        name -> name,  
        name -> name.length()  
    ));  

ConcurrentMap<String, Integer> concurrentMap = names.stream()  
    .collect(Collectors.toConcurrentMap(  
        name -> name,  
        name -> name.length()  
    ));