import java.util.*;

public class Task200326 {
    public static void main(String[] args) {
        List<Integer> list1 = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8));
        List<Integer> list2 = new LinkedList<>(Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8));
        
        long count1 = list1.parallelStream()
            .map(x -> {
                try { Thread.sleep(10); } catch (InterruptedException e) {}
                return x * 2;
            })
            .count();
            
        long count2 = list2.parallelStream()
            .map(x -> {
                try { Thread.sleep(10); } catch (InterruptedException e) {}
                return x * 2;
            })
            .count();
            
        System.out.println(count1 == count2);
        System.out.println(list1.parallelStream().isParallel());
        System.out.println(list2.parallelStream().isParallel());
    }
}

public class Book {
    private final String title;
    private final String author;
    private final int year;
    private final List<String> genres;
    private final int complexity;  // «сложность» проверки, влияет на время фильтрации
    
    public Book(String title, String author, int year, 
                List<String> genres, int complexity) {
        this.title = title;
        this.author = author;
        this.year = year;
        this.genres = genres;
        this.complexity = complexity;
    }
    
    // геттеры...
    
    public boolean isExpensiveFantasyCheck() {
        // Имитация дорогой операции: чем выше complexity, тем дольше
        try {
            Thread.sleep(complexity);  // миллисекунды
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        return genres.contains("Фантастика");
    }
}

public class ParallelStreamBenchmark {
    
    public static List<String> findFantasyTitlesSequential(List<Book> books) {
        return books.stream()
            .filter(Book::isExpensiveFantasyCheck)
            .map(Book::getTitle)
            .collect(Collectors.toList());
    }
    
    public static List<String> findFantasyTitlesParallel(List<Book> books) {
        return books.parallelStream()
            .filter(Book::isExpensiveFantasyCheck)
            .map(Book::getTitle)
            .collect(Collectors.toList());
    }
    
    public static long measure(Runnable task) {
        long start = System.nanoTime();
        task.run();
        long end = System.nanoTime();
        return (end - start) / 1_000_000;  // миллисекунды
    }
}

List<Book> tinyLibrary = IntStream.range(0, 10)
    .mapToObj(i -> new Book("Книга " + i, "Автор " + i, 
        2000 + i, Arrays.asList(i % 2 == 0 ? "Фантастика" : "Роман"), 0))
    .collect(Collectors.toList());

long seqTime = measure(() -> findFantasyTitlesSequential(tinyLibrary));
long parTime = measure(() -> findFantasyTitlesParallel(tinyLibrary));

System.out.println("10 элементов, лёгкая операция:");
System.out.println("  Последовательно: " + seqTime + " мс");
System.out.println("  Параллельно: " + parTime + " мс");
System.out.println("  Накладка: " + (parTime - seqTime) + " мс");

List<Book> mediumLibrary = IntStream.range(0, 10_000)
    .mapToObj(i -> new Book("Книга " + i, "Автор " + i,
        2000 + i % 100, 
        Arrays.asList(i % 3 == 0 ? "Фантастика" : "Роман"), 0))
    .collect(Collectors.toList());

// те же измерения

List<Book> largeLibrary = IntStream.range(0, 100_000)
    .mapToObj(i -> new Book("Книга " + i, "Автор " + i,
        2000 + i % 100,
        Arrays.asList(i % 3 == 0 ? "Фантастика" : "Роман"), 1))
    .collect(Collectors.toList());

// те же измерения

List<Book> arrayList = new ArrayList<>(largeLibrary);
List<Book> linkedList = new LinkedList<>(largeLibrary);

// ArrayList — хорошее разбиение
long arrayListParallel = measure(() -> 
    arrayList.parallelStream().filter(...).collect(...));

// LinkedList — плохое разбиение
long linkedListParallel = measure(() ->
    linkedList.parallelStream().filter(...).collect(...));

System.out.println("ArrayList parallel: " + arrayListParallel + " мс");
System.out.println("LinkedList parallel: " + linkedListParallel + " мс");

public Map<String, Double> analyzeGenreComplexityParallel() {
    return books.parallelStream()
        .collect(Collectors.groupingByConcurrent(
            book -> book.getGenres().get(0),  // основной жанр
            Collectors.averagingInt(Book::getComplexity)
        ));
}

import java.util.*;

public class Task230326 {
    public static void main(String[] args) {
        TreeSet<String> set = new TreeSet<>();
        set.add("apple");
        set.add("banana");
        System.out.println(set.contains(null));
    }
}

import java.util.*;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.stream.*;

public class LambdaCaptureExample {
    
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
        
        //Ошибка: переменная не effectively final
        int count = 0;
        // names.forEach(name -> count++); // Compilation error!
        
        //Ошибка: передача изменяемой переменной
        int threshold = 5;
        // threshold = 10;
        // names.stream().filter(name -> name.length() > threshold); // Ошибка! threshold изменился
        
        //Решение 1: AtomicInteger для счетчика
        AtomicInteger counter = new AtomicInteger(0);
        names.forEach(name -> {
            if (name.length() > 3) {
                counter.incrementAndGet(); // Безопасно
            }
        });
        System.out.println("Count > 3: " + counter.get());
        
        //Решение 2: Использование Stream API вместо накопления
        long streamCount = names.stream()
            .filter(name -> name.length() > 3)
            .count(); // Никаких захваченных переменных
        System.out.println("Stream count: " + streamCount);
        
        //Решение 3: Массив как контейнер
        int[] arrayCount = {0};
        names.forEach(name -> {
            if (name.length() > 3) {
                arrayCount[0]++; // Работает, но менее элегантно
            }
        });
        System.out.println("Array count: " + arrayCount[0]);
                
        //Антипаттерн: сложный захват
        for (int i = 0; i < 3; i++) {
            // i меняется, нельзя использовать в лямбде
            // new Thread(() -> System.out.println(i)).start(); // Ошибка!
            
            //Правильно: копия значения
            int index = i;
            new Thread(() -> System.out.println("Index: " + index)).start();
        }
        
        // Пример с effectively final
        String prefix = "User: "; // effectively final
        names.stream()
            .map(name -> prefix + name) // Работает
            .forEach(System.out::println);
        
        // prefix = "Person: "; // Раскомментируй — ошибка!
    }
}

import java.util.function.Consumer;

public class Task240326 {
    public static void main(String[] args) {
        int[] counter = {0};
        
        Consumer<String> processor = s -> {
            counter[0]++;
            System.out.print(s + counter[0] + " ");
        };
        
        for (int i = 0; i < 3; i++) {
            processor.accept("A");
        }
        
        System.out.println(counter[0]);
    }
}