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

// read() возвращает int, но данные прошли путь: диск -> page cache -> нативный буфер -> heap
int byteValue = fileInputStream.read();

// BufferedInputStream внутренне содержит byte[] buf размером по умолчанию 8192 байт
try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream("data.bin"))) {
    int b;
    while ((b = bis.read()) != -1) {
        processByte(b);
    }
}