public class ComparatorComparing {
    
    static class Person {
        String name;
        int age;
        LocalDate birthDate;
        
        Person(String name, int age) {
            this.name = name;
            this.age = age;
        }
        
        @Override
        public String toString() {
            return name + "(" + age + ")";
        }
    }
    
    // Класс без Comparable
    static class ExternalId {
        String prefix;
        int number;
        
        ExternalId(String prefix, int number) {
            this.prefix = prefix;
            this.number = number;
        }
        
        @Override
        public String toString() {
            return prefix + "-" + number;
        }
    }
    
    public static void main(String[] args) {
        List<Person> people = Arrays.asList(
            new Person("Alice", 30),
            new Person("Bob", 25),
            new Person("Charlie", 35)
        );
        
        //Работает: String реализует Comparable
        people.sort(Comparator.comparing(p -> p.name));
        System.out.println("Sorted by name: " + people);
        
        //Работает: int примитив через comparingInt
        people.sort(Comparator.comparingInt(p -> p.age));
        System.out.println("Sorted by age: " + people);
        
        //Ошибка: ExternalId не реализует Comparable
        List<ExternalId> ids = Arrays.asList(
            new ExternalId("A", 10),
            new ExternalId("B", 5),
            new ExternalId("A", 20)
        );
        
        // ids.sort(Comparator.comparing(id -> id)); // не скомпилируется!
        
        //Решение 1: явный компаратор для ключа
        ids.sort(Comparator.comparing(
            (ExternalId id) -> id.prefix,
            Comparator.naturalOrder() // для строк
        ));
        System.out.println("Sorted by prefix: " + ids);
        
        //Решение 2: составной компаратор через thenComparing
        ids.sort(Comparator
            .comparing((ExternalId id) -> id.prefix)
            .thenComparingInt(id -> id.number));
        System.out.println("Sorted by prefix then number: " + ids);
        
        //Решение 3: собственный компаратор для ключа
        Comparator<ExternalId> byNumberDesc = Comparator.comparing(
            (ExternalId id) -> id.number,
            (n1, n2) -> n2 - n1 // обратный порядок
        );
        ids.sort(byNumberDesc);
        System.out.println("Sorted by number desc: " + ids);
    }
}

import java.util.*;

public class Task270526 {
    public static void main(String[] args) {
        List<Person> people = Arrays.asList(
            new Person("Alice", 25),
            new Person("Bob", 30),
            new Person("Charlie", 20)
        );
        
        Comparator<Person> comparator = Comparator.comparing(p -> p.age);
        people.sort(comparator);
        System.out.println(people);
    }
    
    static class Person {
        String name;
        int age;
        
        Person(String name, int age) {
            this.name = name;
            this.age = age;
        }
        
        @Override
        public String toString() {
            return name + ":" + age;
        }
    }
}

<<dependency>
    <groupId>ch.qos.logback</groupId>
    <artifactId>logback-classic</artifactId>
    <version>1.4.14</version>
</dependency>
<<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-api</artifactId>
    <version>2.0.9</version>
</dependency>

<?xml version="1.0" encoding="UTF-8"?>
<<configuration>

    <!-- Переменная для профиля -->
    <springProperty scope="context" name="PROFILE" source="spring.profiles.active" defaultValue="default"/>
    <!-- Для не-Spring проекта используйте системное свойство -->
    <property name="PROFILE" value="${PROFILE:-default}"/>

    <!-- Консоль: INFO и выше -->
    <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
        </encoder>
        <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
            <level>INFO</level>
        </filter>
    </appender>

    <!-- Файл ошибок: ERROR и выше -->
    <appender name="ERROR_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <file>logs/errors.log</file>
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <fileNamePattern>logs/errors.%d{yyyy-MM-dd}.%i.log</fileNamePattern>
            <maxHistory>30</maxHistory>
            <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                <maxFileSize>10MB</maxFileSize>
            </timeBasedFileNamingAndTriggeringPolicy>
        </rollingPolicy>
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n%ex</pattern>
        </encoder>
        <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
            <level>ERROR</level>
        </filter>
    </appender>

    <!-- Файл отладки: DEBUG и выше, только при профиле dev -->
    <appender name="DEBUG_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <file>logs/debug.log</file>
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <fileNamePattern>logs/debug.%d{yyyy-MM-dd}.log</fileNamePattern>
            <maxHistory>7</maxHistory>
        </rollingPolicy>
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} [%X{operation}] - %msg%n</pattern>
        </encoder>
    </appender>

    <!-- Корневой логгер -->
    <root level="INFO">
        <appender-ref ref="CONSOLE"/>
        <appender-ref ref="ERROR_FILE"/>
    </root>

    <!-- Логгер приложения -->
    <logger name="library" level="INFO">
        <!-- DEBUG-файл подключается условно -->
    </logger>

    <!-- Условное включение DEBUG-файла через профиль -->
    <if condition='property("PROFILE").contains("dev")'>
        <then>
            <root level="DEBUG">
                <appender-ref ref="CONSOLE"/>
                <appender-ref ref="ERROR_FILE"/>
                <appender-ref ref="DEBUG_FILE"/>
            </root>
            <logger name="library" level="DEBUG"/>
        </then>
    </if>

</configuration>

<<dependency>
    <groupId>org.codehaus.janino</groupId>
    <artifactId>janino</artifactId>
    <version>3.1.11</version>
</dependency>

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.slf4j.MDC;
import org.slf4j.Marker;
import org.slf4j.MarkerFactory;

public class Library {
    private static final Logger log = LoggerFactory.getLogger(Library.class);
    private static final Marker SECURITY = MarkerFactory.getMarker("SECURITY");
    
    private final List<<Book> books = new ArrayList<>();
    
    // ...
}

public void addBook(Book book) {
    MDC.put("operation", "addBook");
    MDC.put("bookId", book.getId());
    
    try {
        Objects.requireNonNull(book, "Книга не может быть null");
        
        if (findById(book.getId()).isPresent()) {
            log.warn("Попытка добавить дубликат книги: id={}", book.getId());
            throw new DuplicateBookException(book.getId());
        }
        
        books.add(book);
        log.info("Книга добавлена: {} автор={} год={}", 
            book.getTitle(), book.getAuthor(), book.getYear());
            
    } finally {
        MDC.clear();
    }
}

public void removeBook(String bookId) {
    MDC.put("operation", "removeBook");
    MDC.put("bookId", bookId);
    
    try {
        Book removed = findById(bookId)
            .orElseThrow(() -> new BookNotFoundException(bookId));
        
        books.remove(removed);
        log.warn("Книга удалена: {} (автор={})", 
            removed.getTitle(), removed.getAuthor());
            
    } finally {
        MDC.clear();
    }
}

private List<<Book> parseBooks(String json) {
    try {
        return objectMapper.readValue(json, new TypeReference<List<<Book>>() {});
    } catch (JsonProcessingException e) {
        MDC.put("operation", "parseJson");
        log.error("Ошибка парсинга JSON: длина={}, причина={}", 
            json.length(), e.getOriginalMessage(), e);
        throw new LibraryException("Невалидный JSON", e);
    } finally {
        MDC.clear();
    }
}

public class MdcOperation implements AutoCloseable {
    private final String operation;
    
    public MdcOperation(String operation, String userId) {
        this.operation = operation;
        MDC.put("operation", operation);
        MDC.put("userId", userId);
        MDC.put("timestamp", Instant.now().toString());
    }
    
    @Override
    public void close() {
        MDC.remove("operation");
        MDC.remove("userId");
        MDC.remove("timestamp");
    }
}

public void processBatch(List<<Book> newBooks, String userId) {
    try (MdcOperation op = new MdcOperation("batchImport", userId)) {
        log.info("Начало пакетного импорта: {} книг", newBooks.size());
        
        for (Book book : newBooks) {
            try {
                addBook(book);
            } catch (DuplicateBookException e) {
                log.warn("Пропущен дубликат в пакете: {}", book.getId());
            }
        }
        
        log.info("Завершён пакетный импорт: добавлено {} из {}", 
            newBooks.size(), newBooks.size());
    }
}

public void clearAllBooks(String userId, String reason) {
    try (MdcOperation op = new MdcOperation("clearAll", userId)) {
        int count = books.size();
        
        log.info(SECURITY, "Запрос на удаление всех книг: причина='{}', пользователь={}", 
            reason, userId);
        
        if (count == 0) {
            log.warn("Попытка очистить пустую библиотеку");
            return;
        }
        
        // Дополнительное подтверждение для критической операции
        log.warn(SECURITY, "ВНИМАНИЕ: Удаление {} книг. Требуется подтверждение.", count);
        
        books.clear();
        
        log.error(SECURITY, "Библиотека полностью очищена: {} книг удалено пользователем {}", 
            count, userId);
    }
}

<<appender name="SECURITY_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
    <file>logs/security.log</file>
    <encoder>
        <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [SECURITY] %X{userId} %X{operation} - %msg%n</pattern>
    </encoder>
    <filter class="ch.qos.logback.core.filter.EvaluatorFilter">
        <evaluator class="ch.qos.logback.classic.boo.JaninoEventEvaluator">
            <expression>return marker != null &amp;&amp; marker.contains("SECURITY");</expression>
        </evaluator>
        <OnMatch>ACCEPT</OnMatch>
        <OnMismatch>DENY</OnMismatch>
    </filter>
</appender>

<<root level="INFO">
    <appender-ref ref="CONSOLE"/>
    <appender-ref ref="ERROR_FILE"/>
    <appender-ref ref="SECURITY_FILE"/>
</root>

// Опасно: пароль попадёт в лог
log.info("Авторизация: user={}, password={}", username, password);

public class User {
    private String login;
    private String passwordHash;  // храним хэш, не пароль
    private String plainPassword;  // только при создании, не логируем
    
    @Override
    public String toString() {
        return "User[login=" + login + ", password=***]";
    }
}

public String toLogString() {
    return "User[login=" + login + ", roles=" + roles + "]";
}

import ch.qos.logback.classic.spi.ILoggingEvent;
import ch.qos.logback.core.filter.Filter;
import ch.qos.logback.core.spi.FilterReply;

public class PasswordMaskingFilter extends Filter<<ILoggingEvent> {
    private static final Pattern PASSWORD_PATTERN = 
        Pattern.compile("(?i)(password|passwd|pwd)\\s*=\\s*[^\\s,}]+");
    
    @Override
    public FilterReply decide(ILoggingEvent event) {
        String message = event.getFormattedMessage();
        if (PASSWORD_PATTERN.matcher(message).find()) {
            // Можно: заменить, отклонить, или передать с предупреждением
            return FilterReply.DENY;  // Полностью блокируем сообщение с паролем
        }
        return FilterReply.NEUTRAL;
    }
}

<<appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
    <filter class="library.logging.PasswordMaskingFilter"/>
    <!-- ... -->
</appender>

public void authenticate(String login, char[] password) {
    // password — массив символов, не строка
    log.info("Попытка авторизации: login={}", login);
    
    boolean success = checkPassword(login, password);
    
    if (success) {
        log.info("Успешная авторизация: login={}", login);
    } else {
        log.warn("Неудачная авторизация: login={}", login);
    }
    
    // Очистка массива
    Arrays.fill(password, '\0');
}

public void addBookWithMetrics(Book book) {
    long start = System.currentTimeMillis();
    // ... операция ...
    long duration = System.currentTimeMillis() - start;
    log.info("Метрика: operation=addBook, durationMs={}", duration);
}

<<appender name="AUDIT" class="ch.qos.logback.core.FileAppender">
    <file>logs/audit.log</file>
    <append>true</append>
    <encoder>
        <pattern>%d{ISO8601} %X{userId} %X{operation} %msg%n</pattern>
    </encoder>
</appender>

import java.util.Arrays;
import java.util.List;

public class Task280526 {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(-5, -3, -1);
        int max = numbers.stream().reduce(0, Integer::max);
        System.out.println(max);
    }
}

public class NumberPolymorphism {
    
    //Полиморфный метод, принимающий любой числовой тип
    public static double square(Number num) {
        double d = num.doubleValue();
        return d * d;
    }
    
    //С проверкой типа для сохранения точности
    public static Number add(Number a, Number b) {
        // Для точных вычислений нужно знать тип
        if (a instanceof Integer && b instanceof Integer) {
            return a.intValue() + b.intValue();
        }
        if (a instanceof Double || b instanceof Double) {
            return a.doubleValue() + b.doubleValue();
        }
        if (a instanceof BigDecimal || b instanceof BigDecimal) {
            return toBigDecimal(a).add(toBigDecimal(b));
        }
        return a.doubleValue() + b.doubleValue();
    }
    
    private static BigDecimal toBigDecimal(Number n) {
        if (n instanceof BigDecimal) return (BigDecimal) n;
        return BigDecimal.valueOf(n.doubleValue());
    }
    
    //Ошибка: Number абстрактный
    // Number n = new Number(); // не компилируется
    
    //Правильно: создаем конкретные типы
    Number intNum = 42;           // autoboxing -> Integer
    Number doubleNum = 3.14;      // autoboxing -> Double
    Number longNum = 100L;        // autoboxing -> Long
    Number bigDec = new BigDecimal("123.45");
    
    //Демонстрация полиморфизма
    public static void main(String[] args) {
        List<Number> numbers = Arrays.asList(10, 3.14, 100L, new BigDecimal("99.99"));
        
        // Полиморфная обработка
        for (Number n : numbers) {
            System.out.println("Value: " + n);
            System.out.println("  int: " + n.intValue());
            System.out.println("  double: " + n.doubleValue());
            System.out.println("  square: " + square(n));
        }
        
        //Потеря точности при преобразовании
        Double precise = 123.456;
        Number asNumber = precise;
        int truncated = asNumber.intValue(); // 123 — потеряна дробная часть
        System.out.println("Truncated: " + truncated);
    }
}

import java.util.ArrayList;
import java.util.List;

public class Task290526 {
    public static void main(String[] args) {
        List<Number> numbers = new ArrayList<>();
        numbers.add(10);
        numbers.add(5.5);
        numbers.add(3);
        numbers.add(2L);

        Number sum = numbers.get(0).intValue() + numbers.get(1).doubleValue();
        System.out.println(sum.getClass().getSimpleName());

        Number product = numbers.get(2).longValue() * numbers.get(3).longValue();
        System.out.println(product.getClass().getSimpleName());
    }
}