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));

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

import java.util.*;

public class Task190126 {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(5, 2, 9, 1, 5, 6);
        Comparator<Integer> comparator = (a, b) -> {
            if (a % 2 == b % 2) return 0;
            return a % 2 == 0 ? -1 : 1;
        };
        Collections.sort(list, comparator);
        System.out.println(list);
    }
}