public boolean hasNext() {
    return cursor != size;
}
Здесь cursor — это текущая позиция в массиве элементов, а size — размер списка.

public E next() {
    checkForComodification();  // Проверка на модификацию коллекции
    int i = cursor;  // Запоминаем текущую позицию
    if (i >= size)  // Проверяем выход за пределы списка
        throw new NoSuchElementException();
    Object[] elementData = ArrayList.this.elementData;  // Ссылка на данные
    cursor = i + 1;  // Смещаем курсор
    return (E) elementData[lastRet = i];
}
Этот метод также выполняет проверку на конкурентные изменения коллекции (checkForComodification()), что предотвращает возникновение ConcurrentModificationException.

public void remove() {
    if (lastRet < 0)  // Проверка, был ли вызван метод next()
        throw new IllegalStateException();
    checkForComodification();  // Проверка на модификацию
    try {
        ArrayList.this.remove(lastRet);  // Удаление элемента
        cursor = lastRet;  // Корректировка курсора
        lastRet = -1;
        expectedModCount = modCount;  // Обновление состояния
    } catch (IndexOutOfBoundsException ex) {
        throw new ConcurrentModificationException();
    }
}
Здесь expectedModCount и modCount используются для контроля изменений коллекции во время итерации.

public E previous() {
    checkForComodification();
    int i = cursor - 1;
    if (i < 0)
        throw new NoSuchElementException();
    Object[] elementData = ArrayList.this.elementData;
    cursor = i;
    return (E) elementData[lastRet = i];
}
Здесь cursor перемещается назад, а метод возвращает элемент на новой позиции.

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

public class RemoveIfExample {
    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<>();
        for (int i = 1; i <= 10; i++) {
            numbers.add(i);
        }

        Iterator<Integer> iterator = numbers.iterator();
        while (iterator.hasNext()) {
            Integer number = iterator.next();
            if (number % 2 == 0) {  // Удаление четных чисел
                iterator.remove();
            }
        }

        System.out.println(numbers);  // [1, 3, 5, 7, 9]
    }
}

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

public class ModifyElementsExample {
    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()) {
            String name = listIterator.next();
            if ("Bob".equals(name)) {
                listIterator.set("Robert");  // Замена "Bob" на "Robert"
            }
        }

        System.out.println(names);  // [Alice, Robert, Charlie]
    }
}

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

public class BiDirectionalTraversalExample {
    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

public static native void sleep(long millis) throws InterruptedException;
public static void sleep(long millis, int nanos) throws InterruptedException;
millis — время в миллисекундах, на которое поток должен быть приостановлен.
nanos — дополнительное время в наносекундах (второй вариант метода).

public class SleepExample {
    public static void main(String[] args) {
        System.out.println("Программа начинается.");
        try {
            Thread.sleep(2000); // Ожидание 2 секунды
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("2 секунды прошли.");
    }
}

public class SleepSynchronization {
    public static void main(String[] args) {
        Thread thread1 = new Thread(new Task("Поток 1"));
        Thread thread2 = new Thread(new Task("Поток 2"));

        thread1.start();
        thread2.start();
    }
}

class Task implements Runnable {
    private String name;

    public Task(String name) {
        this.name = name;
    }

    public void run() {
        try {
            System.out.println(name + " запущен.");
            Thread.sleep(1000); // Ожидание 1 секунда
            System.out.println(name + " завершен.");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

public class Task101024_1 {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            try {
                System.out.print("A");
                Thread.sleep(500);
                System.out.print("B");
            } catch (InterruptedException e) {
                System.out.print("E");
            }
        });

        Thread t2 = new Thread(() -> {
            try {
                System.out.print("C");
                Thread.sleep(200);
                System.out.print("D");
            } catch (InterruptedException e) {
                System.out.print("F");
            }
        });

        t1.start();
        t2.start();
        t1.join();
        t2.join();
    }
}

import java.util.regex.*;

public class Task101024_2 {
    public static void main(String[] args) {
        String input = "a1b2c3";
        Pattern pattern = Pattern.compile("\\d");
        Matcher matcher = pattern.matcher(input);

        StringBuilder result = new StringBuilder();
        while (matcher.find()) {
            result.append(matcher.group());
        }
        System.out.println(result.toString());
    }
}

import java.util.concurrent.TimeUnit;

public class TimeUnitExample {
    public static void main(String[] args) {
        long hours = 2;
        long minutes = TimeUnit.HOURS.toMinutes(hours);
        long seconds = TimeUnit.HOURS.toSeconds(hours);
        
        System.out.println(hours + " часа = " + minutes + " минут.");
        System.out.println(hours + " часа = " + seconds + " секунд.");
    }
}

import java.util.concurrent.TimeUnit;

public class TimeUnitSleepExample {
    public static void main(String[] args) {
        System.out.println("Программа начинается.");
        try {
            TimeUnit.SECONDS.sleep(2); // Ожидание 2 секунды
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("2 секунды прошли.");
    }
}

import java.util.concurrent.*;

public class ExecutorServiceExample {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(1);
        
        executor.submit(() -> {
            try {
                System.out.println("Задача началась.");
                TimeUnit.SECONDS.sleep(3); // Ожидание 3 секунды
                System.out.println("Задача завершена.");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        executor.shutdown();
        try {
            if (!executor.awaitTermination(5, TimeUnit.SECONDS)) {
                executor.shutdownNow(); // Принудительное завершение
            }
        } catch (InterruptedException e) {
            executor.shutdownNow();
        }
    }
}

public class MemoryExample {
    public static void main(String[] args) {
        int localVariable = 10;  // Локальная переменная в стеке
        String greeting = "Hello, World!";  // Строка в пуле строк (String Pool)
        Object obj = new Object();  // Объект в куче
        MemoryExample example = new MemoryExample();  // Новый экземпляр в куче
        example.printGreeting(greeting);
    }

    public void printGreeting(String message) {
        System.out.println(message);  // Параметр метода в стеке
    }
}

public class Task111024 {
    private static int counter = 0;

    static {
        counter += 5;
        System.out.println("Static block: " + counter);
    }

    {
        counter += 10;
        System.out.println("Instance block: " + counter);
    }

    public Main() {
        counter += 20;
        System.out.println("Constructor: " + counter);
    }

    public static void main(String[] args) {
        System.out.println("Main Start: " + counter);
        Main obj = new Main();
        System.out.println("Main End: " + counter);
    }
}

class Counter {
    private int count = 0;
    
    public synchronized void increment() {
        count++;  // Этот блок синхронизирован, изменения видны другим потокам.
    }
    
    public synchronized int getCount() {
        return count;
    }
}

class FlagExample {
    private volatile boolean flag = false;

    public void setFlagTrue() {
        flag = true;
    }

    public void checkFlag() {
        if (flag) {
            System.out.println("Flag is true!");
        }
    }
}

int x = 0, y = 0;
x = 1;       // A
y = x + 1;   // B
// Компилятор может поменять A и B местами, если это ускоряет выполнение.

class SharedObject {
    private int counter = 0;

    public void increment() {
        counter++;  // Несинхронизированный доступ к переменной.
    }

    public int getCounter() {
        return counter;
    }
}
Если несколько потоков одновременно вызывают метод increment, результат может быть непредсказуемым из-за отсутствия синхронизации: один поток может перезаписать значение, измененное другим потоком.

public synchronized void increment() {
    counter++;
}
Применение AtomicInteger для безопасного инкремента:

java
Копировать код
import java.util.concurrent.atomic.AtomicInteger;

class SharedObject {
    private AtomicInteger counter = new AtomicInteger(0);

    public void increment() {
        counter.incrementAndGet();  // Безопасная атомарная операция.
    }

    public int getCounter() {
        return counter.get();
    }
}