public class StringSplitRegex {
    
    public static void main(String[] args) {
        String ip = "192.168.1.1";
        String csv = "a|b|c";
        String math = "10*20*30";
        
        //Антипаттерн: без экранирования
        String[] badSplit = ip.split(".");
        System.out.println("split(\".\") length: " + badSplit.length); // 0
        // Регулярка '.' совпала с каждым символом, результат пустой
        
        String[] badPipe = csv.split("|");
        System.out.println("split(\"|\") length: " + badPipe.length); // 7
        // '|' в regex означает "или" — результат каждый символ
        
        //Решение 1: экранирование двойным слешем
        String[] goodDot = ip.split("\\.");
        System.out.println("split(\"\\\\.\") : " + String.join(", ", goodDot));
        
        String[] goodPipe = csv.split("\\|");
        System.out.println("split(\"\\\\|\") : " + String.join(", ", goodPipe));
        
        //Решение 2: Pattern.quote() — экранирует всё
        String[] quoted = ip.split(Pattern.quote("."));
        System.out.println("Pattern.quote(\".\") : " + String.join(", ", quoted));
        
        //Решение 3: для сложных случаев — ограничение на количество частей
        String[] limited = "one:two:three:four".split(":", 3);
        System.out.println("split with limit: " + String.join(", ", limited)); // [one, two, three:four]
                
        // Альтернатива: ручная работа без regex
        String[] manual = "one,two,three".split(",", -1); // -1 сохраняет пустые хвосты
        System.out.println("Manual: " + String.join(", ", manual));
        
        // Внимание: обратный слеш требует четыре слеша в Java
        String path = "C:\\Users\\Name\\file.txt";
        String[] pathParts = path.split("\\\\"); // \\\\ экранирует один \
        System.out.println("Path parts: " + String.join(" | ", pathParts));
    }
}

import java.util.Arrays;

public class Task190526 {
    public static void main(String[] args) {
        String str = "1.2.3.";
        String[] parts = str.split(".");
        System.out.println(parts.length);
        System.out.println(Arrays.toString(parts));
    }
}

// Правильно: throwable — последний параметр, SLF4J выведет стектрейс
logger.error("Payment processing failed for order {}", orderId, exception);

// SLF4J интерпретирует exception как Throwable, а не как параметр подстановки
logger.error("Database connection lost", exception);

// Вывод при logger.error(e.getMessage(), e)
2024-01-15 10:23:14 ERROR Connection timeout after 30000ms
java.net.SocketTimeoutException: Connection timeout after 30000ms
    at java.net.SocketInputStream.socketRead0(Native Method)
    ...

// Антипаттерн: что за заказ? какой шлюз?
logger.error(e.getMessage(), e);

// Правильно: контекст в сообщении, детали в стектрейсе
logger.error("Payment failed for order {} via gateway {}", orderId, gatewayId, e);

public void transferFunds(String fromAccount, String toAccount, BigDecimal amount) {
    try {
        bankingGateway.transfer(fromAccount, toAccount, amount);
        logger.info("Transfer completed: {} -> {}, amount {}", fromAccount, toAccount, amount);
    } catch (BankingException e) {
        logger.error("Transfer failed: {} -> {}, amount {}, reason: {}", 
            fromAccount, toAccount, amount, e.getMessage(), e);
    }
}

try {
    executeOperation();
} catch (IOException e) {
    logger.error("Operation failed", e);
    throw new ServiceException("Execution error", e);
}

List<String> processed = items.stream()
    .map(item -> {
        try {
            return processor.process(item);
        } catch (ProcessingException e) {
            logger.warn("Skipping item {}: {}", item.getId(), e.getMessage(), e);
            return null;
        }
    })
    .filter(Objects::nonNull)
    .collect(Collectors.toList());

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class Task200526 {
    private static final Logger log = LoggerFactory.getLogger(Task200526.class);

    public static void main(String[] args) {
        try {
            throw new RuntimeException("BOOM");
        } catch (Exception e) {
            log.error("Error occurred: {}", e);
        }
    }
}

public class TryCatchScope {
    
    //Антипаттерн: переменная объявлена в try, недоступна в finally
    public static void badScope() {
        try {
            BufferedReader reader = new BufferedReader(new FileReader("file.txt"));
            String line = reader.readLine();
        } catch (IOException e) {
            System.err.println(e);
        } finally {
            // reader.close(); // Ошибка компиляции: reader не виден!
        }
    }
    
    //Громоздкое ручное управление (не рекомендуется)
    public static void manualManagement() {
        BufferedReader reader = null;
        try {
            reader = new BufferedReader(new FileReader("file.txt"));
            String line = reader.readLine();
        } catch (IOException e) {
            System.err.println(e);
        } finally {
            if (reader != null) {
                try {
                    reader.close();
                } catch (IOException e) {
                    // Проглатывание или логирование
                }
            }
        }
    }
    
    //Решение: try-with-resources (лучший способ)
    public static void goodTryWithResources() throws IOException {
        try (BufferedReader reader = new BufferedReader(new FileReader("file.txt"))) {
            String line = reader.readLine();
            // reader доступен здесь
        } catch (IOException e) {
            System.err.println("Ошибка: " + e);
            // reader уже закрыт автоматически
        }
    }
    
    //Если ресурс не реализует AutoCloseable, объявляйте вне try
    public static void legacyResource() {
        final int[] fileDescriptor = { -1 }; // имитация
        try {
            fileDescriptor[0] = openNativeResource();
        } finally {
            if (fileDescriptor[0] != -1) {
                closeNativeResource(fileDescriptor[0]);
            }
        }
    }
    
    private static int openNativeResource() { return 42; }
    private static void closeNativeResource(int fd) { }
}

import java.io.*;

public class Task210526 {
    public static void main(String[] args) throws IOException {
        BufferedReader reader = null;
        String result = "";
        
        try {
            reader = new BufferedReader(new StringReader("hello"));
            result = reader.readLine();
            throw new RuntimeException("error");
        } catch (RuntimeException | IOException e) {
            reader.close();
            result = "catch";
        } finally {
            reader.close();
        }
        
        System.out.println(result);
    }
}