Varsayalım, bir sınıfın üyeleri olarak koleksiyonlar (örneğin 3 ArrayLists) sabit bir dizi var. Şimdi, sadece tüm öğeler üzerinde yineleme böylece diğer sınıflar için tüm unsurları açığa çıkarmak istiyorum (ideal olarak okunur). Guava koleksiyonları kullanıyorum ve guava iterables/yineleyicisi iç koleksiyonuna mantıksal bir görünüm oluşturmak için kullanabilir miyim diye merak ediyorumolmadangeçici kopyalarını yapmak.

Tüm iterables, birleştirilmiş ve canlı bir görünüm oluşturur Iterables.concat(Iterable<T> ...), (iterables değiştirirseniz, birleştirilmiş versiyonu da değişir) kullanın. Sonra Iterables.unmodifiableIterable(Iterable<T>) ile birleştirilmiş bu iterable (salt okunur gereksinimi daha önce görmemiştim) sarın.

Iterables.concat( .. ) JavaDocs:

Bir çoklu iterables birleştirir iterable tek. Döndürülen iterable bu erişir bir yineleyici vardır girişler her iterable elemanları. Girdi kullanımına ankete değildir gerekli kadar. Döndürülen iterable nesnesine remove()destekler ilgili giriş yineleyici destekler.

Ederken bu değil açıkça söyle, bu bir canlı görünümü, son cümle, ima (destekleyici Iterator.remove() yöntem yalnızca destek yineleyici destekler mümkün değil sürece kullanarak canlı bir görünüm)

Örnek Kod:

final List<Integer> first  = Lists.newArrayList(1, 2, 3);
final List<Integer> second = Lists.newArrayList(4, 5, 6);
final List<Integer> third  = Lists.newArrayList(7, 8, 9);
final Iterable<Integer> all =
    Iterables.unmodifiableIterable(
        Iterables.concat(first, second, third));
System.out.println(all);
third.add(9999999);
System.out.println(all);

Çıkış:

[1, 2, 3, 4, 5, 6, 7, 8, 9]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 9999999]

Düzenleme:

Damian gelen İstek üzerine, burada canlı bir Koleksiyonunu görmek döndüren benzer bir yöntem

public final class CollectionsX {

    static class JoinedCollectionView<E> implements Collection<E> {

        private final Collection<? extends E>[] items;

        public JoinedCollectionView(final Collection<? extends E>[] items) {
            this.items = items;
        }

        @Override
        public boolean addAll(final Collection<? extends E> c) {
            throw new UnsupportedOperationException();
        }

        @Override
        public void clear() {
            for (final Collection<? extends E> coll : items) {
                coll.clear();
            }
        }

        @Override
        public boolean contains(final Object o) {
            throw new UnsupportedOperationException();
        }

        @Override
        public boolean containsAll(final Collection<?> c) {
            throw new UnsupportedOperationException();
        }

        @Override
        public boolean isEmpty() {
            return !iterator().hasNext();
        }

        @Override
        public Iterator<E> iterator() {
            return Iterables.concat(items).iterator();
        }

        @Override
        public boolean remove(final Object o) {
            throw new UnsupportedOperationException();
        }

        @Override
        public boolean removeAll(final Collection<?> c) {
            throw new UnsupportedOperationException();
        }

        @Override
        public boolean retainAll(final Collection<?> c) {
            throw new UnsupportedOperationException();
        }

        @Override
        public int size() {
            int ct = 0;
            for (final Collection<? extends E> coll : items) {
                ct  = coll.size();
            }
            return ct;
        }

        @Override
        public Object[] toArray() {
            throw new UnsupportedOperationException();
        }

        @Override
        public <T> T[] toArray(T[] a) {
            throw new UnsupportedOperationException();
        }

        @Override
        public boolean add(E e) {
            throw new UnsupportedOperationException();
        }

    }

    /**
     * Returns a live aggregated collection view of the collections passed in.
     * <p>
     * All methods except {@link Collection#size()}, {@link Collection#clear()},
     * {@link Collection#isEmpty()} and {@link Iterable#iterator()}
     *  throw {@link UnsupportedOperationException} in the returned Collection.
     * <p>
     * None of the above methods is thread safe (nor would there be an easy way
     * of making them).
     */
    public static <T> Collection<T> combine(
        final Collection<? extends T>... items) {
        return new JoinedCollectionView<T>(items);
    }

    private CollectionsX() {
    }

}