StringReader reader = new StringReader("Hello, World!");

import java.io.StringReader;
import java.io.IOException;

public class StringReaderExample {
    public static void main(String[] args) {
        String text = "Hello, Java!";
        StringReader reader = new StringReader(text);

        try {
            int character;
            // Чтение символов один за другим
            while ((character = reader.read()) != -1) {
                System.out.print((char) character); // Печатает каждый символ строки
            }
            reader.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Hello, Java!
В этом примере мы используем StringReader для чтения строки посимвольно. Метод read() возвращает код символа, который мы приводим к char для отображения.

import java.io.StringReader;
import java.io.IOException;

public class StringReaderBufferExample {
    public static void main(String[] args) {
        String text = "This is an example of using StringReader.";
        StringReader reader = new StringReader(text);
        char[] buffer = new char[10];  // Создаем буфер для чтения 10 символов

        try {
            int charsRead;
            while ((charsRead = reader.read(buffer, 0, buffer.length)) != -1) {
                System.out.print(new String(buffer, 0, charsRead));
            }
            reader.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

This is an example of using StringReader.
Здесь мы используем буфер для чтения группы символов за один раз, что упрощает обработку больших строк.

import java.io.StringReader;
import java.io.IOException;

public class StringReaderMarkResetExample {
    public static void main(String[] args) {
        String text = "Mark and reset example";
        StringReader reader = new StringReader(text);

        try {
            System.out.print((char) reader.read());  // Читаем первый символ 'M'
            reader.mark(10);                         // Ставим метку после первого символа
            System.out.print((char) reader.read());  // Читаем следующий символ 'a'
            System.out.print((char) reader.read());  // Читаем символ 'r'
            reader.reset();                          // Возвращаемся к метке
            System.out.print((char) reader.read());  // Читаем снова символ 'a'
            reader.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Метод mark() позволяет установить точку возврата в потоке, а reset() перемещает указатель обратно к этой точке. В примере видно, что после вызова reset() символ 'a' читается повторно.

import java.io.*;

public class Main {
    public static void Task071024_1(String[] args) throws IOException {
        String input = "Java\nis\nawesome!";
        StringReader reader = new StringReader(input);
        int character;
        int count = 0;

        while ((character = reader.read()) != -1) {
            if ((char) character == '\n') {
                count++;
            }
        }

        System.out.println(count);
    }
}

import java.util.regex.*;

public class Task071024_2 {
    public static void main(String[] args) {
        String input = "abc123xyz456def789";
        String regex = "\\d{3}";
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(input);

        StringBuilder result = new StringBuilder();

        while (matcher.find()) {
            result.append(matcher.group()).append("-");
        }

        System.out.println(result.substring(0, result.length() - 1));
    }
}

StringWriter writer = new StringWriter();

String result = writer.toString();

import java.io.StringWriter;

public class StringWriterExample {
    public static void main(String[] args) {
        StringWriter writer = new StringWriter();

        // Записываем строку по символам
        writer.write('H');
        writer.write('e');
        writer.write('l');
        writer.write('l');
        writer.write('o');

        // Преобразуем результат в строку
        String result = writer.toString();
        System.out.println("Result: " + result);  // Вывод: "Hello"
    }
}
В этом примере мы записываем строку "Hello" посимвольно. Метод write(int c) принимает код символа и добавляет его в буфер.

import java.io.StringWriter;

public class StringWriterStringExample {
    public static void main(String[] args) {
        StringWriter writer = new StringWriter();

        // Записываем строку целиком
        writer.write("Hello, ");
        
        // Записываем часть массива символов
        char[] chars = {'J', 'a', 'v', 'a'};
        writer.write(chars, 0, chars.length);

        System.out.println("Output: " + writer.toString());  // Вывод: "Hello, Java"
    }
}
В этом примере используется метод write(char[] cbuf, int off, int len), чтобы записать часть массива символов в буфер. Это удобно, если нужно динамически формировать строку из различных фрагментов.

import java.io.StringWriter;

public class StringWriterAppendExample {
    public static void main(String[] args) {
        StringWriter writer = new StringWriter();

        writer.append("Learning ").append("Java ").append("with ").append("StringWriter.");

        System.out.println("Output: " + writer.toString());  // Вывод: "Learning Java with StringWriter."
    }
}
Метод append() позволяет добавлять строки или части строк к текущему содержимому. Это полезно для конкатенации строковых данных.

enum Day {
    MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
}
В этом примере Day — это перечисление, которое содержит дни недели как свои элементы.

enum Color {
    RED, GREEN, BLUE
}

final class Color extends Enum<Color> {
    public static final Color RED = new Color("RED", 0);
    public static final Color GREEN = new Color("GREEN", 1);
    public static final Color BLUE = new Color("BLUE", 2);

    private Color(String name, int ordinal) {
        super(name, ordinal);
    }

    public static Color[] values() {
        return new Color[]{RED, GREEN, BLUE};
    }

    public static Color valueOf(String name) {
        return Enum.valueOf(Color.class, name);
    }
}

enum Fruit {
    APPLE("Red"), BANANA("Yellow"), GRAPE("Purple");

    private String color;

    // Конструктор перечисления
    Fruit(String color) {
        this.color = color;
    }

    // Метод для получения цвета фрукта
    public String getColor() {
        return color;
    }
}

public class EnumExample {
    public static void main(String[] args) {
        for (Fruit fruit : Fruit.values()) {
            System.out.println(fruit + " is " + fruit.getColor());
        }
    }
}

APPLE is Red
BANANA is Yellow
GRAPE is Purple
В этом примере у каждого элемента перечисления есть дополнительное поле color и метод getColor(), который возвращает значение этого поля.

enum Day {
    MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
}

public class EnumSwitchExample {
    public static void main(String[] args) {
        Day day = Day.FRIDAY;

        switch (day) {
            case MONDAY:
                System.out.println("Start of the work week!");
                break;
            case FRIDAY:
                System.out.println("Almost the weekend!");
                break;
            case SATURDAY:
            case SUNDAY:
                System.out.println("Weekend!");
                break;
            default:
                System.out.println("Midweek day.");
                break;
        }
    }
}

enum LogLevel {
    DEBUG, INFO, WARNING, ERROR, CRITICAL
}

public class Logger {
    private LogLevel logLevel;

    public Logger(LogLevel logLevel) {
        this.logLevel = logLevel;
    }

    public void log(String message) {
        if (logLevel.ordinal() >= LogLevel.WARNING.ordinal()) {
            System.out.println("LOG [" + logLevel + "]: " + message);
        }
    }

    public static void main(String[] args) {
        Logger logger = new Logger(LogLevel.WARNING);
        logger.log("This is a debug message.");  // Не будет напечатано
        logger.log("This is a warning.");  // Будет напечатано
    }
}
В этом примере LogLevel используется для управления уровнем логирования.

enum Singleton {
    INSTANCE;

    public void showMessage() {
        System.out.println("Singleton instance");
    }

    public static void main(String[] args) {
        Singleton.INSTANCE.showMessage();
    }
}
Этот пример показывает, как создать Singleton с помощью enum. В отличие от обычных классов, этот подход гарантирует, что будет создан только один экземпляр, даже в условиях многопоточности.

public class Task081024 {
    enum Status {
        START(1), PROCESS(2), FINISH(3);

        private int code;

        Status(int code) {
            this.code = code;
        }

        int getCode() {
            return code;
        }
    }

    public static void main(String[] args) {
        Status s1 = Status.START;
        Status s2 = Status.FINISH;

        if (s1.ordinal() < s2.ordinal()) {
            System.out.println("Code1: " + s1.getCode() + ", Code2: " + s2.getCode());
        } else {
            System.out.println("Code Mismatch");
        }

        switch (s2) {
            case START:
                System.out.println("Initial Phase");
                break;
            case PROCESS:
                System.out.println("In Progress");
                break;
            case FINISH:
                System.out.println("Completed");
                break;
            default:
                System.out.println("Unknown");
        }
    }
}

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

// Интерфейс
interface GreetingService {
    void sayHello(String name);
}

// Реализация интерфейса
class GreetingServiceImpl implements GreetingService {
    @Override
    public void sayHello(String name) {
        System.out.println("Hello, " + name);
    }
}

// InvocationHandler для перехвата вызовов
class GreetingHandler implements InvocationHandler {
    private Object target;

    // Конструктор для передачи реального объекта
    public GreetingHandler(Object target) {
        this.target = target;
    }

    // Перехватчик вызова метода
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("Before method: " + method.getName());
        Object result = method.invoke(target, args); // Вызов реального метода
        System.out.println("After method: " + method.getName());
        return result;
    }
}

public class DynamicProxyExample {
    public static void main(String[] args) {
        // Создание реального объекта
        GreetingService realService = new GreetingServiceImpl();

        // Создание прокси-объекта
        GreetingService proxy = (GreetingService) Proxy.newProxyInstance(
                realService.getClass().getClassLoader(),
                realService.getClass().getInterfaces(),
                new GreetingHandler(realService)
        );

        // Вызов метода на прокси-объекте
        proxy.sayHello("John");
    }
}

Before method: sayHello
Hello, John
After method: sayHello

class LoggingHandler implements InvocationHandler {
    private final Object target;

    public LoggingHandler(Object target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("Invoking method: " + method.getName());
        if (args != null) {
            for (Object arg : args) {
                System.out.println("Arg: " + arg);
            }
        }
        return method.invoke(target, args);
    }
}

class SecurityHandler implements InvocationHandler {
    private final Object target;

    public SecurityHandler(Object target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        if (!method.getName().equals("sayHello")) {
            throw new IllegalAccessException("Access denied to method: " + method.getName());
        }
        return method.invoke(target, args);
    }
}

class CachingHandler implements InvocationHandler {
    private final Object target;
    private final Map<String, Object> cache = new HashMap<>();

    public CachingHandler(Object target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        String key = method.getName() + Arrays.toString(args);
        if (cache.containsKey(key)) {
            return cache.get(key);
        }
        Object result = method.invoke(target, args);
        cache.put(key, result);
        return result;
    }
}

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

public class IteratorExample {
    public static void main(String[] args) {
        List<String> names = new ArrayList<>();
        names.add("Alice");
        names.add("Bob");
        names.add("Charlie");

        Iterator<String> iterator = names.iterator();  // Получение итератора
        while (iterator.hasNext()) {
            String name = iterator.next();  // Получение следующего элемента
            System.out.println(name);
        }
    }
}

Alice
Bob
Charlie
В данном примере итератор используется для перебора списка строк и вывода каждого элемента.

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

public class ListIteratorExample {
    public static void main(String[] args) {
        List<String> names = new ArrayList<>();
        names.add("Alice");
        names.add("Bob");
        names.add("Charlie");

        ListIterator<String> listIterator = names.listIterator();
        while (listIterator.hasNext()) {
            System.out.println("Next: " + listIterator.next());
        }

        while (listIterator.hasPrevious()) {
            System.out.println("Previous: " + listIterator.previous());
        }
    }
}

Next: Alice
Next: Bob
Next: Charlie
Previous: Charlie
Previous: Bob
Previous: Alice

import java.util.Iterator;
import java.util.concurrent.CopyOnWriteArrayList;

public class ThreadSafeIteratorExample {
    public static void main(String[] args) {
        CopyOnWriteArrayList<String> names = new CopyOnWriteArrayList<>();
        names.add("Alice");
        names.add("Bob");
        names.add("Charlie");

        Iterator<String> iterator = names.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }
}
Использование CopyOnWriteArrayList позволяет безопасно обходить элементы даже в условиях многопоточности.