Две коллекции: индекс вместо стрима в стриме

record Guest(String name, String card, int discount) {}   // имя, номер карты, скидка в %

List<Guest> guests() {
    return List.of(
            new Guest("Анна", "К-101", 10),
            new Guest("Борис", "К-102", 5),
            new Guest("Вера", "К-103", 10),
            new Guest("Глеб", "К-104", 5),
            new Guest("Дина", "К-105", 10),
            new Guest("Зоя", "К-106", 15));
}

List<Integer> discounts = orders.stream()
        .map(order -> guests.stream()                                   // для заказа — стрим по гостям
                .filter(guest -> guest.name().equals(order.guest()))   // гость этого заказа
                .findFirst()                                            // Optional<Guest>
                .map(guest -> order.total() * guest.discount() / 100)   // скидка в рублях
                .orElse(0))                                             // карты нет — скидки нет
        .toList();

[43, 15, 22, 41, 17, 65, 0, 89, 33, 0]

long comparisons = 0;   // сколько раз сравнили имена — только чтобы увидеть работу

int discountBySearch(Order order, List<Guest> guests) {
    return guests.stream()
            .filter(guest -> {
                comparisons++;
                return guest.name().equals(order.guest());
            })
            .findFirst()
            .map(guest -> order.total() * guest.discount() / 100)
            .orElse(0);
}

int daySearch = orders.stream()
        .mapToInt(order -> discountBySearch(order, guests))
        .sum();

скидок за день: 325 ₽, сравнений: 33

List<Guest> manyGuests = IntStream.rangeClosed(1, 1_000)
        .mapToObj(i -> new Guest("гость " + i, "К-" + i, 10))
        .toList();
List<Order> manyOrders = IntStream.rangeClosed(1, 10_000)
        .mapToObj(i -> new Order(i, "гость " + (i % 1_000 + 1), List.of(new Item("латте", 250, 1))))
        .toList();

comparisons = 0;
int monthSearch = manyOrders.stream()
        .mapToInt(order -> discountBySearch(order, manyGuests))
        .sum();

месяц перебором: скидок 250000 ₽, сравнений: 5005000

Map<String, Guest> cards = guests.stream()
        .collect(Collectors.toMap(Guest::name, Function.identity()));   // имя → сам гость

IO.println(cards.get("Вера"));
IO.println(cards.get("Егор"));

Guest[name=Вера, card=К-103, discount=10]
null

IO.println(cards.get("Егор").discount());

Exception in thread "main" java.lang.NullPointerException: Cannot invoke "Coffee$Guest.discount()" because the return value of "java.util.Map.get(Object)" is null

long lookups = 0;       // сколько раз обратились к индексу

int discountByIndex(Order order, Map<String, Guest> cards) {
    lookups++;
    return Optional.ofNullable(cards.get(order.guest()))   // гость или пустая коробка
            .map(guest -> order.total() * guest.discount() / 100)
            .orElse(0);
}

Map<String, Guest> manyCards = manyGuests.stream()
        .collect(Collectors.toMap(Guest::name, Function.identity()));
lookups = 0;
int monthIndex = manyOrders.stream()
        .mapToInt(order -> discountByIndex(order, manyCards))
        .sum();

месяц по индексу: скидок 250000 ₽, обращений к индексу: 10000

Map<String, Integer> percentByName = guests.stream()
        .collect(Collectors.toMap(Guest::name, Guest::discount));      // имя → процент
List<Integer> percents = orders.stream()
        .map(order -> percentByName.getOrDefault(order.guest(), 0))    // нет карты — 0 %
        .toList();

[10, 5, 10, 5, 10, 10, 0, 10, 5, 0]

Exception in thread "main" java.lang.IllegalStateException: Duplicate key Анна (attempted merging values Guest[name=Анна, card=К-101, discount=10] and Guest[name=Анна, card=К-107, discount=5])

List<String> noCard = orders.stream()
        .map(Order::guest)
        .filter(name -> !cards.containsKey(name))   // имени нет в индексе
        .distinct()
        .toList();

[Егор, Жанна]

java Coffee.java

// Coffee.java — учебный пример статьи 9 серии «Стримы по шагам».
// Запуск: java Coffee.java (нужен JDK 25)

import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

/** Позиция заказа: напиток или десерт, цена за штуку в рублях, сколько штук. */
record Item(String name, int price, int qty) {}

/** Заказ: номер за день, имя гостя, позиции. */
record Order(int number, String guest, List<Item> items) {

    /** Сумма заказа в рублях — стримом, как в статье 8. */
    int total() {
        return items.stream()
                .mapToInt(item -> item.price() * item.qty())
                .sum();
    }
}

/** Гость с картой лояльности: имя, номер карты, скидка в процентах. */
record Guest(String name, String card, int discount) {}

/** Заказы кофейни «Наковальня» за один день. */
List<Order> orders() {
    return List.of(
            new Order(1, "Анна", List.of(new Item("латте", 250, 1), new Item("круассан", 180, 1))),
            new Order(2, "Борис", List.of(new Item("эспрессо", 150, 2))),
            new Order(3, "Вера", List.of(new Item("капучино", 220, 1))),
            new Order(4, "Глеб", List.of(new Item("латте", 250, 2), new Item("чизкейк", 320, 1))),
            new Order(5, "Анна", List.of(new Item("американо", 170, 1))),
            new Order(6, "Дина", List.of(new Item("раф", 290, 1), new Item("круассан", 180, 2))),
            new Order(7, "Егор", List.of(new Item("эспрессо", 150, 1))),
            new Order(8, "Вера", List.of(new Item("латте", 250, 1), new Item("чизкейк", 320, 2))),
            new Order(9, "Борис", List.of(new Item("капучино", 220, 3))),
            new Order(10, "Жанна", List.of(new Item("какао", 200, 1))));
}

/** Гости с картой лояльности. У кого карты нет, того в списке нет. */
List<Guest> guests() {
    return List.of(
            new Guest("Анна", "К-101", 10),
            new Guest("Борис", "К-102", 5),
            new Guest("Вера", "К-103", 10),
            new Guest("Глеб", "К-104", 5),
            new Guest("Дина", "К-105", 10),
            new Guest("Зоя", "К-106", 15));
}

long comparisons = 0;   // сколько раз сравнили имена — только чтобы увидеть работу
long lookups = 0;       // сколько раз обратились к индексу

/** Скидка по заказу в рублях: перебором гостей — стрим в стриме. */
int discountBySearch(Order order, List<Guest> guests) {
    return guests.stream()
            .filter(guest -> {
                comparisons++;
                return guest.name().equals(order.guest());
            })
            .findFirst()
            .map(guest -> order.total() * guest.discount() / 100)
            .orElse(0);
}

/** Скидка по заказу в рублях: одним обращением к индексу. */
int discountByIndex(Order order, Map<String, Guest> cards) {
    lookups++;
    return Optional.ofNullable(cards.get(order.guest()))
            .map(guest -> order.total() * guest.discount() / 100)
            .orElse(0);
}

void main() {
    List<Order> orders = orders();
    List<Guest> guests = guests();

    // 1. Скидка по каждому заказу: для каждого заказа — стрим по гостям
    List<Integer> discounts = orders.stream()
            .map(order -> guests.stream()
                    .filter(guest -> guest.name().equals(order.guest()))
                    .findFirst()
                    .map(guest -> order.total() * guest.discount() / 100)
                    .orElse(0))
            .toList();
    IO.println(discounts);

    // 2. Сколько сравнений имён ушло на день
    int daySearch = orders.stream()
            .mapToInt(order -> discountBySearch(order, guests))
            .sum();
    IO.println("скидок за день: " + daySearch + " ₽, сравнений: " + comparisons);

    // 3. Месяц сети: 1 000 гостей с картой, 10 000 заказов
    List<Guest> manyGuests = IntStream.rangeClosed(1, 1_000)
            .mapToObj(i -> new Guest("гость " + i, "К-" + i, 10))
            .toList();
    List<Order> manyOrders = IntStream.rangeClosed(1, 10_000)
            .mapToObj(i -> new Order(i, "гость " + (i % 1_000 + 1), List.of(new Item("латте", 250, 1))))
            .toList();

    // 4. Месяц перебором
    comparisons = 0;
    int monthSearch = manyOrders.stream()
            .mapToInt(order -> discountBySearch(order, manyGuests))
            .sum();
    IO.println("месяц перебором: скидок " + monthSearch + " ₽, сравнений: " + comparisons);

    // 5. Индекс: имя → гость, один проход по гостям
    Map<String, Guest> cards = guests.stream()
            .collect(Collectors.toMap(Guest::name, Function.identity()));
    IO.println(cards.get("Вера"));
    IO.println(cards.get("Егор"));

    // 6. День по индексу — ответ тот же
    int dayIndex = orders.stream()
            .mapToInt(order -> discountByIndex(order, cards))
            .sum();
    IO.println("скидок за день: " + dayIndex + " ₽, обращений к индексу: " + lookups);

    // 7. Месяц по индексу
    Map<String, Guest> manyCards = manyGuests.stream()
            .collect(Collectors.toMap(Guest::name, Function.identity()));
    lookups = 0;
    int monthIndex = manyOrders.stream()
            .mapToInt(order -> discountByIndex(order, manyCards))
            .sum();
    IO.println("месяц по индексу: скидок " + monthIndex + " ₽, обращений к индексу: " + lookups);

    // 8. Нужен один процент — индекс «имя → скидка» и getOrDefault
    Map<String, Integer> percentByName = guests.stream()
            .collect(Collectors.toMap(Guest::name, Guest::discount));
    List<Integer> percents = orders.stream()
            .map(order -> percentByName.getOrDefault(order.guest(), 0))
            .toList();
    IO.println(percents);

    // 9. Гости без карты — кому её предложить
    List<String> noCard = orders.stream()
            .map(Order::guest)
            .filter(name -> !cards.containsKey(name))
            .distinct()
            .toList();
    IO.println(noCard);

    // Сделай руками — раскомментируй и запусти:
    // IO.println(cards.get("Егор").discount());   // NullPointerException
}