Stream.min: примеры (JAVA)

Короткие примеры использования

Пример 1: минимальное целое в IntStream

int[] arr = {5, 2, 9};
OptionalInt min = IntStream.of(arr).min();
// извлечение безопасно через orElse
int value = min.orElse(Integer.MIN_VALUE);

min = OptionalInt[2]
value = 2

Пример 2: Stream<String> по лексикографическому порядку

Stream s = Stream.of("beta", "alpha", "gamma");
Optional r = s.min(Comparator.naturalOrder());
String out = r.orElse("empty");

r = Optional[alpha]
out = "alpha"

Пример 3: Stream объектов с кастомным сравнителем

record Person(String name, int age) {}
Stream<Person> people = Stream.of(new Person("A", 30), new Person("B", 25));
Optional<Person> youngest = people.min(Comparator.comparingInt(Person::age));

youngest = Optional[Person{name=B, age=25}]

Пример 4: пустой поток

Optional<String> empty = Stream.empty().min(Comparator.naturalOrder());
boolean present = empty.isPresent();

empty = Optional.empty
present = false

Похожие функции в Java

• Collections.min(Collection, Comparator) - поиск минимума в уже материализованной коллекции. Предпочтительнее при необходимости повторных запросов к коллекции или когда поток не нужен.
• Stream.collect(Collectors.minBy(comparator)) - возвращает Optional как результат коллекции. Удобно при комбинировании с другими коллекторными операциями.
• stream.sorted(comparator).findFirst() - эквивалент в терминах результата, но менее эффективен, так как сортировка дороже редукции.
• reduce с бинарной операцией - можно реализовать минимизацию вручную, но сложнее и обычно менее читаемо.

Краткая рекомендация: для поиска минимума в потоке использовать именно min (или примитивную перегрузку). Для уже имеющейся коллекции можно выбрать Collections.min. Для сложных конвейеров с комбинацией агрегаций удобен Collectors.minBy.

Альтернативы в других языках

• PHP: min() для массива или набора аргументов. Пример:

  $a = [3,1,4];
  echo min($a);

  1

  PHP сразу возвращает значение, Optional отсутствует.
• JavaScript: Math.min(...arr) или arr.reduce((a,b)=>Math.min(a,b)). Пример:

  const arr = [3,1,4];
  console.log(Math.min(...arr));

  1

  При пустом массиве Math.min() вернёт Infinity.
• Python: встроенная min(iterable, key=... , default=...). Пример:

  min([3,1,4])

  1

  Python поддерживает аргумент default для пустых и ключевую функцию.
• SQL: агрегат MIN(column) для вычисления минимума в наборе строк. Возвращает NULL для пустого набора.
• C#: LINQ Enumerable.Min() и перегрузки. Пример:

  new[]{3,1,4}.Min();

  1

  Для пустых последовательностей будет исключение без предварительной проверки.
• Kotlin: minOrNull(), minByOrNull(). Пример:

  listOf(3,1,4).minOrNull()

  1

  Возвращает null для пустых коллекций.
• Go: нет встроенного для слайсов - обычный цикл. Пример:

  arr := []int{3,1,4}
  min := arr[0]
  for _, v := range arr { if v < min { min = v } }

  min = 1

  Является явным и эффективным, но требует инициализации и обработки пустого среза.
• Lua: math.min принимает аргументы, для массивов нужен цикл.

Отличия от Java: в большинстве языков отсутствует концепция Optional, в некоторых предусмотрены параметры по умолчанию для пустых коллекций (например, Python). Java-разделение на ссылочные и примитивные потоки с соответствующими Optional-типами уникально.

Типичные ошибки и примеры

1) Неправильная перегрузка у Stream<T> - попытка вызвать stream.min() без Comparator для ссылочных потоков. Это приведёт к ошибке компиляции.

Stream<String> s = Stream.of("a","b");
// s.min(); // Ошибка компиляции: метод min(Comparator) отсутствует

2) NullPointerException при передаче null в качестве компаратора.

Stream.of("a").min(null);

Exception in thread "main" java.lang.NullPointerException
    at java.base/java.util.Objects.requireNonNull(Objects.java:233)
    at java.base/java.util.stream.ReferencePipeline.min(ReferencePipeline.java:...)

3) NoSuchElementException при вызове get() на пустом Optional.

Optional<Integer> empty = Stream.<Integer>empty().min(Comparator.naturalOrder());
int v = empty.get();

Exception in thread "main" java.util.NoSuchElementException: No value present
    at java.base/java.util.Optional.get(Optional.java:...)

4) Неконсистентный компаратор (нарушение транзитивности) может привести к непредсказуемому результату или ошибкам при параллельной обработке. Пример логической ошибки - компаратор, использующий изменяемое внешнее состояние.

Изменения и примечания по версиям

Метод Stream.min присутствует с Java 8 и в явном виде с тех пор не менял сигнатуру. Основные изменения в экосистеме, влияющие на использование:

• Добавление Optional и примитивных OptionalInt/ OptionalLong/ OptionalDouble в Java 8 - поведение минимального поиска связано с ними.
• С появлением Stream.ofNullable (Java 9) упрощается работа с единственными значениями, которые могут быть null, но это не меняет поведение min.
• Никаких существенных изменений в реализации min в последних версиях Java не происходило; рекомендации по использованию компараторов и обработке пустых Optional остались прежними.

Расширенные и нестандартные примеры

Пример 1: минимум по нескольким полям с разными приоритетами (требует компараторов с несколькими шагами)

record Item(String id, int weight, int price) {}
List<Item> items = List.of(new Item("a", 10, 100), new Item("b", 10, 90), new Item("c", 8, 200));
Optional<Item> best = items.stream().min(
    Comparator.comparingInt(Item::weight)
              .thenComparingInt(Item::price).reversed()
);
// Здесь сначала минимальный вес, при равенстве - больший price (reversed после thenComparing)

best = Optional[Item{id=c, weight=8, price=200}]

Пример 2: обработка null-значений с Comparator.nullsFirst

Stream<String> s = Stream.of(null, "b", "a");
Optional<String> min = s.min(Comparator.nullsFirst(Comparator.naturalOrder()));
String out = min.orElse("none");

min = Optional.empty? actually Optional[null] (Optional не хранит null; nullsFirst с потоком содержащим null приведёт к NPE при создании потока из null; корректнее использовать Stream.ofNullable)
out = "none" или при корректном источнике min = null

Примечание: поток не должен содержать явные null-элементы - лучше строить поток через Stream.ofNullable и фильтровать.

Пример 3: использование Collectors.minBy внутри группировки

Map<String, Optional<Item>> byGroup = items.stream()
    .collect(Collectors.groupingBy(i -> i.id.substring(0,1),
        Collectors.minBy(Comparator.comparingInt(Item::price))));

byGroup = {"a"=Optional[Item{id=a,...}], "b"=Optional[Item{id=b,...}], ...}

Пример 4: параллельный поток и детерминированность

List<Integer> nums = ThreadLocalRandom.current().ints(1000, 0, 10000).boxed().collect(Collectors.toList());
int minSeq = nums.stream().min(Comparator.naturalOrder()).orElseThrow();
int minPar = nums.parallelStream().min(Comparator.naturalOrder()).orElseThrow();

minSeq == minPar (при корректном и детерминированном компараторе значение совпадает)

Пример 5: поиск минимального по абсолютной величине и возврат оригинального элемента

List<Integer> vals = List.of(-10, 3, -2, 2);
Optional<Integer> minAbs = vals.stream().min(Comparator.comparingInt(Math::abs));
int result = minAbs.orElse(0);

minAbs = Optional[2] или Optional[-2] в зависимости от порядка сравнения при одинаковом абсолютном значении (Comparator не различает знаки)

Пример 6: минимизация BigDecimal с учетом точности

List<BigDecimal> bd = List.of(new BigDecimal("1.00"), new BigDecimal("1.0"), new BigDecimal("0.99"));
Optional<BigDecimal> m = bd.stream().min(Comparator.naturalOrder());

m = Optional[0.99]

Пример 7: безопасное извлечение из Optional с исключением

String min = Stream.<String>empty()
    .min(Comparator.naturalOrder())
    .orElseThrow(() -> new IllegalStateException("Нет элементов"));

Exception: IllegalStateException: Нет элементов

Пояснения: в расширенных сценариях учитывать следующее - избегать состояния внутри компаратора, использовать стабильные и транзитивные правила сравнения, на пустые потоки реагировать через orElse, orElseGet или orElseThrow, а для групповых операций применять Collectors.minBy.