import lombok.extern.slf4j.Slf4j;

@Slf4j
public class UserService {
    public void createUser(String name) {
        log.info("Creating user: {}", name);
    }
}

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

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

    public void createUser(String name) {
        log.info("Creating user: {}", name);
    }
}

import lombok.SneakyThrows;

public class FileService {
    @SneakyThrows
    public void readFile(String path) {
        // Код, который может выбросить IOException
        Files.readAllBytes(Paths.get(path));
    }
}

public void readFile(String path) {
    try {
        Files.readAllBytes(Paths.get(path));
    } catch (IOException e) {
        throw Lombok.sneakyThrow(e); // Преобразование в unchecked исключение
    }
}

public static <T extends Throwable> RuntimeException sneakyThrow(Throwable t) throws T {
    throw (T) t;
}

@SneakyThrows(IOException.class)
public void readFile(String path) {
    Files.readAllBytes(Paths.get(path));
}

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

public class Task150125_1 {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.addFirst(4);
        list.clear();
        list.remove(2);
        System.out.println(list);
    }
}

import lombok.Synchronized;

public class Counter {
    private int count = 0;

    @Synchronized
    public void increment() {
        count++;
    }

    @Synchronized("lock")
    public void decrement() {
        count--;
    }

    private final Object lock = new Object();
}

public class Counter {
    private int count = 0;
    private final Object $lock = new Object(); // Скрытое поле для синхронизации
    private final Object lock = new Object();

    public void increment() {
        synchronized ($lock) {
            count++;
        }
    }

    public void decrement() {
        synchronized (lock) {
            count--;
        }
    }
}

import lombok.Value;

@Value
public class User {
    String name;
    int age;
}

public final class User {
    private final String name;
    private final int age;

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    @Override
    public String toString() {
        return "User(name=" + this.name + ", age=" + this.age + ")";
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        User user = (User) o;
        return age == user.age && Objects.equals(name, user.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

import lombok.With;

@With
public class User {
    private final String name;
    private final int age;

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

// Использование:
User user = new User("John", 30);
User newUser = user.withAge(31); // Создает новый объект с измененным возрастом

public class User {
    private final String name;
    private final int age;

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public User withName(String name) {
        return this.name == name ? this : new User(name, this.age);
    }

    public User withAge(int age) {
        return this.age == age ? this : new User(this.name, age);
    }
}

public class Task160125_1 {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder("hello");
        sb.append(" world").delete(5, 11).insert(5, " java");
        System.out.println(sb);
    }
}

import lombok.Value;
import lombok.With;
import lombok.experimental.Accessors;

@Value
@With
@Accessors(fluent = true)
public @interface ImmutableUser {
}

@ImmutableUser
public class User {
    String name;
    int age;
}

@Value
@With
@Builder
public @interface ImmutableUserWithBuilder {
}

import lombok.Cleanup;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;

public class FileService {
    public void readFile(String path) throws IOException {
        @Cleanup InputStream inputStream = new FileInputStream(path);
        // Использование inputStream
    }
}

public void readFile(String path) throws IOException {
    InputStream inputStream = new FileInputStream(path);
    try {
        // Использование inputStream
    } finally {
        if (inputStream != null) {
            inputStream.close();
        }
    }
}

import lombok.experimental.Delegate;

public class UserService {
    @Delegate
    private final UserRepository userRepository = new UserRepository();

    // Дополнительные методы
}

public class UserService {
    private final UserRepository userRepository = new UserRepository();

    public void save(User user) {
        userRepository.save(user);
    }

    public User findById(Long id) {
        return userRepository.findById(id);
    }
}

@Delegate(types = {UserRepository.class, AnotherInterface.class})

import lombok.experimental.UtilityClass;

@UtilityClass
public class StringUtils {
    public boolean isEmpty(String str) {
        return str == null || str.isEmpty();
    }
}

public final class StringUtils {
    private StringUtils() {
        throw new UnsupportedOperationException("Utility class");
    }

    public static boolean isEmpty(String str) {
        return str == null || str.isEmpty();
    }
}

import lombok.experimental.FieldDefaults;
import lombok.AccessLevel;

@FieldDefaults(level = AccessLevel.PRIVATE, makeFinal = true)
public class User {
    String name;
    int age;
}

public class User {
    private final String name;
    private final int age;
}

public class Task170125_1 {
    public static void main(String[] args) {
        int i = 0;
        while (i++ < 5) {
            if (i == 3) continue;
            System.out.print(i + " ");
        }
    }
}