public class ExtremumFinder {
    public static MinMax findMinMax(int[] arr) {
        int min = arr[0], max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] < min) min = arr[i];
            if (arr[i] > max) max = arr[i];
        }
        return new MinMax(min, max);
    }
}

Оптимизация: обработка элементов парами уменьшает количество сравнений с 2n до 3n/2. Вместо сравнения каждого элемента с обоими экстремумами, сначала сравниваем пару элементов между собой, затем меньший — с минимумом, больший — с максимумом.

public long sum(int[] arr) {
    long total = 0;  // long для избежания переполнения
    for (int value : arr) {
        total += value;
    }
    return total;
}

public long countPositive(int[] arr) {
    long count = 0;
    for (int value : arr) {
        if (value > 0) count++;
    }
    return count;
}

public static int[] findTwoOldest(int[] years) {
    if (years.length < 2) throw new IllegalArgumentException();
    
    // Инициализируем упорядоченно
    int oldest = Math.min(years[0], years[1]);
    int secondOldest = Math.max(years[0], years[1]);
    
    for (int i = 2; i < years.length; i++) {
        if (years[i] < oldest) {
            secondOldest = oldest;
            oldest = years[i];
        } else if (years[i] < secondOldest) {
            secondOldest = years[i];
        }
    }
    return new int[]{oldest, secondOldest};
}

Особенность: алгоритм корректно обрабатывает дубликаты и все возможные порядки следования элементов. Сложность — O(n) с ровно n-1 сравнениями в худшем случае.

public class Statistics {
    public static Stats compute(int[] data) {
        double mean = 0, m2 = 0; // m2 - сумма квадратов отклонений
        int n = 0;
        
        for (int x : data) {
            n++;
            double delta = x - mean;
            mean += delta / n;
            m2 += delta * (x - mean);
        }
        
        double variance = (n > 1) ? m2 / (n - 1) : 0;
        return new Stats(mean, variance);
    }
}

Алгоритм обновляет среднее и накопленную сумму квадратов отклонений инкрементально. Это критически важно для потоковых данных, где хранение всех значений невозможно.

public static String mostFrequentAuthor(String[] authors) {
    Map<String, Integer> freq = new HashMap<>();
    String mostFreq = null;
    int maxCount = 0;
    
    for (String author : authors) {
        int count = freq.getOrDefault(author, 0) + 1;
        freq.put(author, count);
        
        if (count > maxCount) {
            maxCount = count;
            mostFreq = author;
        }
    }
    return mostFreq;
}

public static String majorityElement(String[] arr) {
    String candidate = null;
    int count = 0;
    
    for (String s : arr) {
        if (count == 0) {
            candidate = s;
            count = 1;
        } else if (s.equals(candidate)) {
            count++;
        } else {
            count--;
        }
    }
    
    // Второй проход для проверки (тоже O(n))
    return candidate; // если гарантировано наличие большинства
}

public class CombinedStats {
    int min, max, count;
    long sum;
    
    public void process(int value) {
        if (value < min) min = value;
        if (value > max) max = value;
        sum += value;
        count++;
    }
    
    public double average() {
        return (double) sum / count;
    }
}
Такой подход особенно ценен при обработке потоковых данных, где невозможно хранить историю.

import java.util.List;

public class Task150126 {
    public static void main(String[] args) {
        List<String> data = List.of("A", "B", "C");

        long count = data.stream()
            .peek(s -> System.out.print(s))
            .map(s -> s + s)
            .count();

        System.out.print(count);
    }
}

import java.util.List;

public class Task160126 {
    public static void main(String[] args) {
        List<String> data = List.of("apple", "banana");

        boolean result = data.stream()
            .filter(s -> s.length() > 10)
            .allMatch(s -> {
                System.out.print("check ");
                return s.startsWith("a");
            });

        System.out.print(result);
    }
}

// Демонстрация разницы в поиске
public class SearchComparison {
    // Линейный поиск в неотсортированном массиве
    public static int linearSearch(int[] array, int target) {
        for (int i = 0; i < array.length; i++) {
            if (array[i] == target) return i;
        }
        return -1;
    }
    
    // Бинарный поиск в отсортированном массиве
    public static int binarySearch(int[] sortedArray, int target) {
        int left = 0, right = sortedArray.length - 1;
        while (left <= right) {
            int mid = left + (right - left) / 2;
            if (sortedArray[mid] == target) return mid;
            if (sortedArray[mid] < target) left = mid + 1;
            else right = mid - 1;
        }
        return -1;
    }
}

// Сложный компаратор для неустойчивой сортировки
Comparator<Book> complexComparator = Comparator
    .comparing(Book::getAuthor)
    .thenComparing(Book::getYear);
books.sort(complexComparator); // Работает, но если сортировка неустойчива,
                               // порядок внутри автора может нарушиться

// Сначала сортируем по вторичному ключу
books.sort(Comparator.comparing(Book::getYear));

// Затем сортируем по основному ключу
books.sort(Comparator.comparing(Book::getAuthor));

// После второй сортировки порядок годов сохранится для каждого автора
// благодаря устойчивости