Iterable과 Iterator

// java.lang.Iterable의 핵심
public interface Iterable<T> {
    Iterator<T> iterator();
}

// java.util.Iterator의 핵심
public interface Iterator<E> {
    boolean hasNext();
    E next();
}

// 우리가 쓰는 코드
for (String title : titles) {
    System.out.println(title);
}

// 컴파일러가 바꾼 모양
for (Iterator<String> it = titles.iterator(); it.hasNext(); ) {
    String title = it.next();
    System.out.println(title);
}

public final class NotIterable {
    public static void main(String[] args) {
        Box box = new Box();
        for (String s : box) System.out.println(s);
    }

    static final class Box {}
}

NotIterable.java:4: error: for-each not applicable to expression type
        for (String s : box) System.out.println(s);
                        ^
  required: array or java.lang.Iterable
  found:    Box
1 error

import java.util.Arrays;
import java.util.Iterator;
import java.util.NoSuchElementException;

public final class IterableArrayList {
    public static void main(String[] args) {
        MyArrayList<String> titles = new MyArrayList<>();
        titles.add("iterator");
        titles.add("iterable");
        titles.add("for-each");
        for (String title : titles) {
            System.out.println(title);
        }
        Iterator<String> first = titles.iterator();
        Iterator<String> second = titles.iterator();
        System.out.println("independent=" + first.next() + "/" + second.next());
    }

    private static final class MyArrayList<E> implements Iterable<E> {
        private Object[] values = new Object[2];
        private int size;

        void add(E value) {
            if (size == values.length) values = Arrays.copyOf(values, size * 2);
            values[size++] = value;
        }

        @SuppressWarnings("unchecked")
        E get(int index) {
            if (index < 0 || index >= size) throw new IndexOutOfBoundsException(index);
            return (E) values[index];
        }

        public Iterator<E> iterator() {
            return new Iterator<>() {
                private int cursor;

                public boolean hasNext() {
                    return cursor < size;
                }

                public E next() {
                    if (!hasNext()) throw new NoSuchElementException();
                    return get(cursor++);
                }
            };
        }
    }
}

iterator
iterable
for-each
independent=iterator/iterator

import java.util.Iterator;

public final class AdvancingHasNextFailure {
    public static void main(String[] args) {
        Iterator<Integer> iterator = new Broken(new int[] {10, 20, 30, 40});
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }

    private static final class Broken implements Iterator<Integer> {
        private final int[] values;
        private int cursor;

        Broken(int[] values) {
            this.values = values;
        }

        public boolean hasNext() {
            return ++cursor < values.length;
        }

        public Integer next() {
            return values[cursor++];
        }
    }
}

20
40

Iterator<Integer> iterator = new Broken(new int[] {10, 20, 30, 40});
System.out.println(iterator.hasNext()); // true
System.out.println(iterator.hasNext()); // true
System.out.println(iterator.next());    // 30

import java.util.Iterator;
import java.util.NoSuchElementException;

public final class LinkedNodeIterator {
    public static void main(String[] args) {
        Chain<Integer> chain = new Chain<>();
        chain.addLast(30);
        chain.addLast(40);
        chain.addLast(50);
        int total = 0;
        for (int value : chain) {
            total += value;
        }
        System.out.println("total=" + total);
    }

    private static final class Chain<E> implements Iterable<E> {
        private Node<E> head, tail;

        void addLast(E value) {
            Node<E> n = new Node<>(value);
            if (tail == null) head = tail = n;
            else {
                tail.next = n;
                tail = n;
            }
        }

        public Iterator<E> iterator() {
            return new Iterator<>() {
                private Node<E> current = head;

                public boolean hasNext() {
                    return current != null;
                }

                public E next() {
                    if (current == null) throw new NoSuchElementException();
                    E value = current.value;
                    current = current.next;
                    return value;
                }
            };
        }
    }

    private static final class Node<E> {
        final E value;
        Node<E> next;

        Node(E value) {
            this.value = value;
        }
    }
}

total=120

import java.util.Iterator;
import java.util.NoSuchElementException;

public final class SharedCursorBug {
    public static void main(String[] args) {
        Titles titles = new Titles("iterator", "iterable");
        for (String title : titles) {
            System.out.println("first " + title);
        }
        for (String title : titles) {
            System.out.println("second " + title);
        }
        System.out.println("end");
    }

    // 목록과 반복자를 한 객체가 겸하는 잘못된 설계
    private static final class Titles implements Iterable<String>, Iterator<String> {
        private final String[] values;
        private int cursor;

        Titles(String... values) {
            this.values = values;
        }

        public Iterator<String> iterator() {
            return this; // 매번 같은 반복자를 돌려준다
        }

        public boolean hasNext() {
            return cursor < values.length;
        }

        public String next() {
            if (!hasNext()) throw new NoSuchElementException();
            return values[cursor++];
        }
    }
}

first iterator
first iterable
end

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

public final class RemoveDuringForEach {
    public static void main(String[] args) {
        removeDrafts(new ArrayList<>(List.of("draft-a", "post-b", "draft-c", "post-d")));
        removeDrafts(new ArrayList<>(List.of("post-a", "draft-b", "draft-c")));
    }

    static void removeDrafts(List<String> titles) {
        try {
            for (String title : titles) {
                if (title.startsWith("draft")) {
                    titles.remove(title);
                }
            }
            System.out.println("no exception: " + titles);
        } catch (ConcurrentModificationException e) {
            System.out.println("CME: " + titles);
        }
    }
}

CME: [post-b, draft-c, post-d]
no exception: [post-a, draft-c]

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

public final class RemoveWithIterator {
    public static void main(String[] args) {
        List<String> titles = new ArrayList<>(List.of("draft-a", "post-b", "draft-c", "post-d"));
        Iterator<String> it = titles.iterator();
        while (it.hasNext()) {
            String title = it.next();
            if (title.startsWith("draft")) {
                it.remove(); // 방금 next()가 돌려준 원소를 지운다
            }
        }
        System.out.println("iterator.remove: " + titles);

        List<String> others = new ArrayList<>(List.of("draft-a", "post-b", "draft-c", "post-d"));
        others.removeIf(title -> title.startsWith("draft"));
        System.out.println("removeIf: " + others);
    }
}

iterator.remove: [post-b, post-d]
removeIf: [post-b, post-d]

import java.util.Arrays;
import java.util.ConcurrentModificationException;
import java.util.Iterator;
import java.util.NoSuchElementException;

public final class FailFastArrayList {
    public static void main(String[] args) {
        MyArrayList<String> titles = new MyArrayList<>();
        titles.add("draft-a");
        titles.add("post-b");
        titles.add("draft-c");

        Iterator<String> it = titles.iterator();
        while (it.hasNext()) {
            if (it.next().startsWith("draft")) it.remove();
        }
        System.out.println("after iterator.remove: " + titles);

        try {
            for (String title : titles) {
                titles.add(title + "-copy");
            }
        } catch (ConcurrentModificationException e) {
            System.out.println("caught " + e.getClass().getSimpleName());
        }
    }

    private static final class MyArrayList<E> implements Iterable<E> {
        private Object[] values = new Object[2];
        private int size;
        private int modCount; // 구조가 바뀐 횟수

        void add(E value) {
            if (size == values.length) values = Arrays.copyOf(values, size * 2);
            values[size++] = value;
            modCount++;
        }

        void removeAt(int index) {
            if (index < 0 || index >= size) throw new IndexOutOfBoundsException(index);
            System.arraycopy(values, index + 1, values, index, size - index - 1);
            values[--size] = null;
            modCount++;
        }

        @SuppressWarnings("unchecked")
        E get(int index) {
            if (index < 0 || index >= size) throw new IndexOutOfBoundsException(index);
            return (E) values[index];
        }

        @Override
        public String toString() {
            return Arrays.toString(Arrays.copyOf(values, size));
        }

        public Iterator<E> iterator() {
            return new Iterator<>() {
                private int cursor;
                private int lastReturned = -1; // remove()로 지울 위치, 없으면 -1
                private int expectedModCount = modCount;

                public boolean hasNext() {
                    return cursor < size;
                }

                public E next() {
                    checkForModification();
                    if (!hasNext()) throw new NoSuchElementException();
                    lastReturned = cursor;
                    return get(cursor++);
                }

                public void remove() {
                    if (lastReturned < 0) throw new IllegalStateException();
                    checkForModification();
                    removeAt(lastReturned);
                    cursor = lastReturned; // 뒤 원소가 당겨졌으니 같은 자리부터 다시 읽는다
                    lastReturned = -1; // next() 한 번에 remove() 한 번
                    expectedModCount = modCount; // 반복자 자신이 한 변경은 허용한다
                }

                private void checkForModification() {
                    if (modCount != expectedModCount) throw new ConcurrentModificationException();
                }
            };
        }
    }
}

after iterator.remove: [post-b]
caught ConcurrentModificationException

import java.util.List;

public final class IterableBoardSummary {
    public static void main(String[] args) {
        Iterable<Entry> entries = List.of(new Entry("iterator", 45), new Entry("for-each", 55));
        System.out.println("total=" + total(entries));
    }

    static int total(Iterable<Entry> entries) {
        int sum = 0;
        for (Entry e : entries) {
            sum += e.viewCount();
        }
        return sum;
    }

    private record Entry(String title, int viewCount) {}
}

total=100

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

public final class RemoveTargetQuiz {
    public static void main(String[] args) {
        run("a");
        run("b");
        run("c");
        run("d");
    }

    static void run(String target) {
        List<String> list = new ArrayList<>(List.of("a", "b", "c", "d"));
        List<String> visited = new ArrayList<>();
        try {
            for (String s : list) {
                visited.add(s);
                if (s.equals(target)) {
                    list.remove(s);
                }
            }
            System.out.println(target + ": no exception, list=" + list + ", visited=" + visited);
        } catch (ConcurrentModificationException e) {
            System.out.println(target + ": CME, list=" + list + ", visited=" + visited);
        }
    }
}