public static void expandListWithPrimes(List<Integer> numbers) {
    ListIterator<Integer> iterator = numbers.listIterator();
    
    while (iterator.hasNext()) {
        Integer current = iterator.next();
        
        if (isPrime(current)) {
            // Вставляем квадрат простого числа перед ним
            iterator.previous(); // Возвращаемся к простому числу
            iterator.add(current * current);
            iterator.next(); // Продолжаем с исходного элемента
        }
    }
}

public static void interpolateMissing(List<Double> values) {
    if (values.size() < 2) return;
    
    ListIterator<Double> iterator = values.listIterator();
    Double prev = iterator.next();
    
    while (iterator.hasNext()) {
        Double current = iterator.next();
        
        if (current == null && prev != null) {
            // Нашли null после non-null значения
            // Возвращаемся к null и заменяем его интерполированным значением
            iterator.previous(); // Переходим к null
            iterator.set((prev + getNextNonNull(iterator)) / 2);
            iterator.next(); // Продолжаем
        }
        
        prev = current;
    }
}

public static <T extends Comparable<T>> void insertSorted(List<T> sortedList, T newElement) {
    ListIterator<T> iterator = sortedList.listIterator();
    
    while (iterator.hasNext()) {
        if (newElement.compareTo(iterator.next()) < 0) {
            // Нашли позицию для вставки
            iterator.previous(); // Возвращаемся к элементу, который больше нового
            iterator.add(newElement);
            return;
        }
    }
    
    // Новый элемент больше всех существующих
    iterator.add(newElement);
}

public class AdvancedListProcessing {
    
    public static <T> void bidirectionalTransform(List<T> list, 
                                                  Function<T, T> forwardTransform,
                                                  Function<T, T> backwardTransform) {
        ListIterator<T> iterator = list.listIterator();
        
        // Фаза 1: Прямой обход с трансформацией
        while (iterator.hasNext()) {
            T original = iterator.next();
            T transformed = forwardTransform.apply(original);
            iterator.set(transformed);
        }
        
        // Фаза 2: Обратный обход с дополнительной трансформацией
        while (iterator.hasPrevious()) {
            T current = iterator.previous();
            T doublyTransformed = backwardTransform.apply(current);
            
            // Условная вставка нового элемента
            if (shouldInsertAfter(current)) {
                iterator.next(); // Переходим к следующей позиции для вставки
                iterator.add(generateNewElement(current));
                iterator.previous(); // Возвращаемся к текущему элементу
            }
            
            iterator.set(doublyTransformed);
        }
    }
    
    public static <T> List<T> mergeAdjacentDuplicates(List<T> list) {
        if (list.size() < 2) {
            return new ArrayList<>(list);
        }
        
        ListIterator<T> iterator = list.listIterator();
        List<T> result = new ArrayList<>();
        
        T current = iterator.next();
        result.add(current);
        
        while (iterator.hasNext()) {
            T next = iterator.next();
            
            if (!current.equals(next)) {
                // Разные элементы - добавляем в результат
                result.add(next);
                current = next;
            } else {
                // Дубликат - пропускаем
                // При необходимости можно выполнить merge операцию
                mergeLastTwo(result);
            }
        }
        
        return result;
    }
    
    public static <T> void processWithLookaheadAndLookbehind(List<T> list,

                                                             BiFunction<T, T, T> lookaheadProcessor,
                                                             BiFunction<T, T, T> lookbehindProcessor) {
        if (list.size() < 2) return;
        
        ListIterator<T> iterator = list.listIterator();
        
        // Обработка с lookahead
        while (iterator.hasNext()) {
            int currentIndex = iterator.nextIndex();
            T current = iterator.next();
            
            if (iterator.hasNext()) {
                // Есть следующий элемент для lookahead
                T lookahead = iterator.next();
                T processed = lookaheadProcessor.apply(current, lookahead);
                
                // Возвращаемся и заменяем текущий элемент
                iterator.previous(); // К lookahead
                iterator.previous(); // К current
                iterator.set(processed);
                iterator.next(); // К lookahead
                iterator.next(); // К следующему элементу для продолжения
            }
        }
        
        // Обработка с lookbehind
        while (iterator.hasPrevious()) {
            T current = iterator.previous();
            
            if (iterator.hasPrevious()) {
                T lookbehind = iterator.previous();
                T processed = lookbehindProcessor.apply(current, lookbehind);
                
                // Возвращаемся и заменяем
                iterator.next(); // К lookbehind
                iterator.next(); // К current
                iterator.set(processed);
                iterator.previous(); // К lookbehind для продолжения
            }
        }
    }
}

Управление состоянием и переходы

Диаграмма состояний ListIterator

Состояния:
1. Инициализация: lastReturned = null, cursor = 0
2. После next(): lastReturned = элемент, cursor = nextIndex
3. После previous(): lastReturned = элемент, cursor = previousIndex + 1
4. После remove(): lastReturned = null
5. После set(): lastReturned остается установленным
6. После add(): lastReturned = null, cursor увеличивается на 1

Допустимые переходы:
- next() → remove() ✓, set() ✓, add() ✓
- previous() → remove() ✓, set() ✓, add() ✓
- remove() → next() ✓, previous() ✓, add() ✗, set() ✗, remove() ✗
- set() → next() ✓, previous() ✓, remove() ✗, add() ✗
- add() → next() ✓, previous() ✓, remove() ✗, set() ✗

public class ListIteratorValidator {
    
    public static <T> boolean validateOperationSequence(ListIterator<T> iterator, 
                                                       List<String> operations) {
        boolean canRemoveOrSet = false;
        
        for (String op : operations) {
            switch (op) {
                case "next":
                    if (!iterator.hasNext()) return false;
                    iterator.next();
                    canRemoveOrSet = true;
                    break;
                    
                case "previous":
                    if (!iterator.hasPrevious()) return false;
                    iterator.previous();
                    canRemoveOrSet = true;
                    break;
                    
                case "remove":
                    if (!canRemoveOrSet) return false;
                    iterator.remove();
                    canRemoveOrSet = false;
                    break;
                    
                case "set":
                    if (!canRemoveOrSet) return false;
                    // Необходим элемент для замены
                    iterator.set(null); // Упрощенная проверка
                    canRemoveOrSet = false;
                    break;
                    
                case "add":
                    iterator.add(null); // Всегда допустимо
                    canRemoveOrSet = false;
                    break;
                    
                default:
                    return false;
            }
        }
        
        return true;
    }
}

public class ArrayListOptimizations {
    
    // Избегайте частых add() и remove() в середине списка
    public static void efficientArrayListProcessing(List<String> list) {
        // Вместо множественных add() через ListIterator
        // Собирайте изменения и применяйте их пакетно
        
        List<String> toAdd = new ArrayList<>();
        ListIterator<String> iterator = list.listIterator();
        
        while (iterator.hasNext()) {
            String current = iterator.next();
            if (shouldDuplicate(current)) {
                toAdd.add(current + "_copy");
            }
        }
        
        // Пакетное добавление в конец
        list.addAll(toAdd);
    }
    
    // Используйте set() вместо remove() + add() для замены
    public static void replaceEfficiently(List<Integer> numbers) {
        ListIterator<Integer> iterator = numbers.listIterator();
        
        while (iterator.hasNext()) {
            Integer current = iterator.next();
            if (current % 2 == 0) {
                iterator.set(current * 2); // Эффективнее, чем remove() + add()
            }
        }
    }
}

public class LinkedListOptimizations {
    
    // LinkedList идеально подходит для частых вставок/удалений через ListIterator
    public static void efficientLinkedListProcessing(LinkedList<String> list) {
        ListIterator<String> iterator = list.listIterator();
        
        // Частые вставки эффективны
        while (iterator.hasNext()) {
            String current = iterator.next();
            if (requiresPrefix(current)) {
                iterator.add("prefix_" + current);
            }
        }
        
        // Частые удаления также эффективны
        iterator = list.listIterator();
        while (iterator.hasNext()) {
            if (shouldRemove(iterator.next())) {
                iterator.remove();
            }
        }
    }
    
    // Использование previous() для навигации назад
    public static void findAndProcessFromEnd(LinkedList<String> list, String target) {
        ListIterator<String> iterator = list.listIterator(list.size());
        
        while (iterator.hasPrevious()) {
            String current = iterator.previous();
            if (current.equals(target)) {
                // Нашли - обрабатываем и можем идти в обе стороны
                processFound(current);
                
                // Можем продолжить в любом направлении
                if (iterator.hasPrevious()) {
                    processPrevious(iterator.previous());
                }
                if (iterator.hasNext()) {
                    processNext(iterator.next());
                }
                break;
            }
        }
    }
}

// Начинайте с нужной позиции, а не всегда с начала
ListIterator<T> iterator = list.listIterator(startPosition);

// Для обработки с конца
ListIterator<T> reverseIterator = list.listIterator(list.size());

// Неэффективно:
while (iterator.hasNext()) {
    T current = iterator.next();
    if (condition(current)) {
        iterator.previous(); // Дорогой переход
        iterator.add(newElement);
        iterator.next(); // Еще один переход
        iterator.next(); // Пропускаем добавленный элемент
    }
}

// Более эффективно:
while (iterator.hasNext()) {
    T current = iterator.next();
    if (condition(current)) {
        iterator.add(newElement);
        // current остался тем же, newElement теперь перед ним
    }
}

ListIterator<T> iterator = list.listIterator();
while (iterator.hasNext()) {
    int currentIndex = iterator.nextIndex();
    T element = iterator.next();
    
    if (currentIndex % 2 == 0) {
        // Обработка четных позиций
        processEven(element, currentIndex);
    }
}

// Всегда синхронизируйте доступ к ListIterator
synchronized(list) {
    ListIterator<T> iterator = list.listIterator();
    while (iterator.hasNext()) {
        // Обработка
    }
}

// Или используйте потокобезопасные альтернативы
List<T> syncList = Collections.synchronizedList(new ArrayList<>());
// Но даже synchronizedList требует внешней синхронизации для итерации

import java.util.*;

public class Task121225 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>(Arrays.asList("A", "B", "C", "D"));
        ListIterator<String> it = list.listIterator();
        
        System.out.print(it.next() + " ");
        System.out.print(it.next() + " ");
        
        it.add("X");
        
        System.out.print(it.previous() + " ");
        System.out.print(it.next() + " ");
        System.out.print(it.previous() + " ");
        
        it.remove();
        
        System.out.println(list);
    }
}