public class FloatLoopProblem {
    
    //Антипаттерн: бесконечный цикл
    public static void badLoop() {
        int iterations = 0;
        for (double d = 0.0; d != 1.0; d += 0.1) {
            iterations++;
            System.out.printf("Итерация %d: %.20f%n", iterations, d);
            if (iterations > 20) break; // защита от вечности
        }
        // Реальный вывод: d проходит через 0.0, 0.1, 0.2, ..., 0.9, 1.0000000000000002, ...
        // Никогда не равно 1.0
    }
    
    //Ошибка с float
    public static void badFloatLoop() {
        for (float f = 0.0f; f != 1.0f; f += 0.1f) {
            // Тоже бесконечный
        }
    }
    
    //Решение 1: целочисленный счетчик
    public static void goodLoopWithCounter() {
        for (int i = 0; i <= 10; i++) {
            double d = i * 0.1; // Вычисляем на каждой итерации
            System.out.println("d = " + d);
        }
    }
    
    //Решение 2: сравнение с эпсилон (допуском)
    public static void goodLoopWithEpsilon() {
        double d = 0.0;
        final double EPSILON = 1e-10;
        while (Math.abs(d - 1.0) > EPSILON) {
            System.out.println("d = " + d);
            d += 0.1;
        }
        System.out.println("Достигнуто: " + d);
    }
    
    //Решение 3: фиксированное количество итераций
    public static void goodFixedIterations() {
        int steps = 10;
        for (int step = 0; step <= steps; step++) {
            double ratio = (double) step / steps; // От 0.0 до 1.0
            System.out.println(ratio);
        }
    }
    
    // Демонстрация погрешности
    public static void demonstratePrecision() {
        double sum = 0.0;
        for (int i = 0; i < 10; i++) {
            sum += 0.1;
        }
        System.out.println("Сумма десяти 0.1: " + sum);           // 0.9999999999999999
        System.out.println("Сравнение с 1.0: " + (sum == 1.0)); // false
    }
    
    public static void main(String[] args) {
        demonstratePrecision();
        goodLoopWithCounter();
    }
}

public class Task170426 {
    public static void main(String[] args) {
        double sum = 0;
        for (double d = 0.0; d != 1.0; d += 0.1) {
            sum += d;
        }
        System.out.println(sum);
    }
}

// Антипаттерн: прямая передача SQLException через все слои
public User findUser(String id) throws SQLException {  // Нарушение абстракции
    return database.query("SELECT * FROM users WHERE id = ?", id);
}

// Паттерн Exception Translation: оборачивание в доменное исключение
public User findUser(String id) {
    try {
        return database.query("SELECT * FROM users WHERE id = ?", id);
    } catch (SQLException e) {
        throw new DataAccessException("Failed to load user: " + id, e);
    }
}

public void processOrder(Order order) throws OrderValidationException {
    try {
        validate(order);
    } catch (OrderValidationException e) {
        auditLog.recordValidationFailure(order.getId(), e);
        throw e;  // Тот же тип, тот же стектрейс
    }
}

public Configuration loadConfiguration() {
    try {
        return parser.parse(configFile);
    } catch (IOException e) {
        throw new ConfigurationLoadException("Cannot read config from " + configFile, e);
    }
}

// Интерфейс объявляет checked-исключение
interface DataStore {
    String read(String key) throws IOException;
}

// Реализация на основе памяти не может выбросить IOException,
// но вынуждена объявлять его или оборачивать в RuntimeException
class InMemoryStore implements DataStore {
    @Override
    public String read(String key) throws IOException {  // Нелогично
        return memoryMap.get(key);
    }
}

// Метод с checked-исключением не может быть использован как лямбда
public String fetchUrl(String url) throws IOException {
    return httpClient.get(url);
}

// Ошибка компиляции: IOException не обработано
List<String> results = urls.stream()
    .map(this::fetchUrl)  // Не компилируется
    .collect(Collectors.toList());