Avec la goyave, vous pouvez utiliser Iterables.concat(Iterable<T> ...) Il crée une vue en direct de toutes les itérables, concaténées en une seule (si vous modifiez les itérables, la version concaténée change également). Enveloppez ensuite l'itérable concaténée avec Iterables.unmodifiableIterable(Iterable<T>) (Je n'avais pas vu l'exigence de lecture seule plus tôt).
De la Iterables.concat( .. ) JavaDocs :
Combine plusieurs itérables en un seul unique itérable. L'itérable retourné retournée possède un itérateur qui parcourt les éléments de chaque itérable en entrée. Les itérateurs d'entrée ne sont pas interrogés jusqu'à ce que cela soit nécessaire. L'itérable retourné retourné supporte remove() lorsque l'itérateur d'entrée correspondant le supporte.
Bien qu'il ne soit pas explicitement dit qu'il s'agit d'une vue en direct, la dernière phrase laisse entendre que c'est le cas (en appuyant le Iterator.remove() seulement si l'itérateur de support le supporte, ce qui n'est pas possible à moins d'utiliser une vue en direct).
Code échantillon :
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);
Sortie :
[1, 2, 3, 4, 5, 6, 7, 8, 9]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 9999999]
Edit :
À la demande de Damian, voici une méthode similaire qui renvoie une vue de collection en direct
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() {
}
}
0 votes
^^ Lien brisé. Je pense qu'il pointait vers cette méthode dans la Javadoc de Guava