Как объединить итераторы в Java?

Конечно, вот перевод вашего ответа на русский язык в стиле StackOverflow:

Я давно не писал на Java, и это вызвало у меня любопытство: не забыл ли я свои навыки.

Вот мой первый вариант кода:

import java.util.Iterator;
import java.util.Arrays; /* Для примера кода */

public class IteratorIterator<T> implements Iterator<T> {
    private final Iterator<T> is[];
    private int current;

    public IteratorIterator(Iterator<T>... iterators)
    {
            is = iterators;
            current = 0;
    }

    public boolean hasNext() {
            while ( current < is.length && !is[current].hasNext() )
                    current++;

            return current < is.length;
    }

    public T next() {
            while ( current < is.length && !is[current].hasNext() )
                    current++;

            return is[current].next();
    }

    public void remove() { /* не реализовано */ }

    /* Пример использования */
    public static void main(String... args)
    {
            Iterator<Integer> a = Arrays.asList(1,2,3,4).iterator();
            Iterator<Integer> b = Arrays.asList(10,11,12).iterator();
            Iterator<Integer> c = Arrays.asList(99, 98, 97).iterator();

            Iterator<Integer> ii = new IteratorIterator<Integer>(a,b,c);

            while ( ii.hasNext() )
                    System.out.println(ii.next());
    }
}

Разумеется, вы могли бы использовать больше классов коллекций, а не просто массив и счетчик индекса, но на мой взгляд, это выглядит немного чище, чем альтернатива. Или я просто предвзят из-за того, что в последнее время пишу в основном на C?

В любом случае, вот ответ на ваш вопрос: "да, вероятно".

Конечно! Вот перевод кода на русский язык с пояснениями в стиле ответа на StackOverflow:

public class IteratorJoin<T> implements Iterator<T> {
    private final Iterator<T> first; // Первый итератор
    private final Iterator<T> next;   // Второй итератор

    public IteratorJoin(Iterator<T> first, Iterator<T> next) {
        this.first = first; // Инициализируем первый итератор
        this.next = next;   // Инициализируем второй итератор
    }

    @Override
    public boolean hasNext() {
        // Проверяем, есть ли ещё элементы в первом или втором итераторе
        return first.hasNext() || next.hasNext();
    }

    @Override
    public T next() {
        // Если в первом итераторе есть следующий элемент, возвращаем его
        if (first.hasNext())
            return first.next();
        // Иначе возвращаем следующий элемент из второго итератора
        return next.next();
    }
}

В данном классе IteratorJoin создаётся объединённый итератор, который последовательно обходит два других итератора. Метод hasNext() проверяет, остались ли элементы для итерации в одном из итераторов, а метод next() возвращает следующий элемент из первого итератора, если он доступен, или из второго, если первого больше нет. Этот подход удобен для последовательной обработки элементов из двух источников.

Вы можете вынести ваш цикл в отдельный метод и передать итератор как параметр. Вот пример реализации:

void methodX(Iterator x) {
    while (x.hasNext()) {
        // Ваш код обработки элемента итератора
        Object element = x.next();
        // ... обработка элемента
    }
}

Таким образом, вы сможете повторно использовать этот метод с разными итераторами, что сделает ваш код более удобным и легким для обслуживания.

Итератор "происходит" из коллекции или множества.

Почему бы не использовать уже доступный метод

Collection.addAll(Collection c);

а затем не создать итератор из последнего объекта?

Таким образом, ваш итератор будет итерировать все элементы обеих коллекций.

Отвечая на ваш вопрос, следует отметить, что использование Collection.addAll(Collection c) действительно позволяет объединять две коллекции, однако это не всегда может быть оптимальным решением. Например:

1. Изменение оригинальных коллекций: Если вы используете addAll, вы изменяете оригинальную коллекцию, что может быть нежелательно, если вам нужно сохранить исходные данные.

2. Производительность: Если коллекции большие, создание новой коллекции (через addAll) может занять больше памяти и времени, чем просто создание итератора для каждой из них.

3. Итерация: Создавая итератор прямо из двух коллекций, вы можете итерировать по ним "на лету", без необходимости создавать временные объекты, что может быть полезно для снижения использования памяти.

Таким образом, при выборе метода стоит учитывать контекст и цели вашего кода. Если вам нужно сохранить оригинальные коллекции неизменными, или вы хотите избежать дополнительных затрат по памяти, то создание итераторов отдельно — более подходящее решение.

Вы можете использовать следующий код для реализации класса ConcatIterator, который объединяет несколько Iterable в один:

import static java.util.Arrays.asList;

import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.NoSuchElementException;

public class ConcatIterator<T> implements Iterator<T> {

    private final List<Iterable<T>> iterables;
    private Iterator<T> current;

    @SafeVarargs
    public ConcatIterator(final Iterable<T>... iterables) {
        this.iterables = new LinkedList<>(asList(iterables));
    }

    @Override
    public boolean hasNext() {
        checkNext();
        return current != null && current.hasNext();
    }

    @Override
    public T next() {
        checkNext();
        if (current == null || !current.hasNext()) throw new NoSuchElementException();
        return current.next();
    }

    @Override
    public void remove() {
        if (current == null) throw new IllegalStateException();
        current.remove();
    }

    private void checkNext() {
        while ((current == null || !current.hasNext()) && !iterables.isEmpty()) {
            current = iterables.remove(0).iterator();
        }
    }
}

Метод concat для создания Iterable:

@SafeVarargs
public static <T> Iterable<T> concat(final Iterable<T>... iterables) {
    return () -> new ConcatIterator<>(iterables);
}

Пример простого теста с использованием JUnit:

@Test
public void testConcat() throws Exception {
    final Iterable<Integer> it1 = asList(1, 2, 3);
    final Iterable<Integer> it2 = asList(4, 5);
    int j = 1;
    for (final int i : concat(it1, it2)) {
        assertEquals(j, i);
        j++;
    }
}

Объяснение:

• ConcatIterator реализует интерфейс Iterator<T> и принимает массив объектов Iterable<T>. Он последовательно объединяет их, позволяя итерироваться по всем элементам получившегося объединённого множества.
• Метод hasNext() проверяет, есть ли еще элементы для итерации, в то время как метод next() возвращает следующий элемент, выбрасывая исключение NoSuchElementException, если элементов больше нет.
• Метод remove() удаляет последний возвращенный элемент.
• checkNext() отвечает за обновление текущего итератора на следующий, когда текущий больше не имеет элементов.
• Метод concat возвращает новую Iterable, инициализируя ConcatIterator с переданными в него iterables.

Тест testConcat проверяет, что элементы из двух списков правильно объединились в один и поколены в ожидаемом порядке.