여러 컬렉션을 하나의 논리적 컬렉션으로 결합 하시겠습니까?
클래스의 멤버로 일정한 수의 컬렉션 (예 : 3 개의 ArrayLists)이 있다고 가정합니다. 이제 모든 요소를 다른 클래스에 노출하여 모든 요소를 간단히 반복 할 수 있도록합니다 (이상적으로는 읽기 전용). 나는 구아바 컬렉션을 사용하고 있는데 어떻게 구아바 이터 러블 / 반복자를 사용하여 임시 복사본 을 만들지 않고 내부 컬렉션에 대한 논리적 뷰를 생성 할 수 있는지 궁금합니다 .
Guava를 사용하면을 사용할 수 있습니다 Iterables.concat(Iterable<T> ...). 모든 이터 러블의 라이브 뷰를 생성하고 하나로 연결합니다 (이터 러블을 변경하면 연결된 버전도 변경됨). 그런 다음 연결된 iterable을 Iterables.unmodifiableIterable(Iterable<T>)(이전에 읽기 전용 요구 사항을 본 적이 없었습니다)로 래핑하십시오 .
로부터 Iterables.concat( .. )JavaDoc을 :
여러 반복 가능 항목을 단일 반복 가능 항목으로 결합합니다. 반환 된 이터 러블에는 입력에서 각 이터 러블의 요소를 순회하는 이터레이터가 있습니다. 입력 반복자는 필요할 때까지 폴링되지 않습니다. 반환 된 이터 러블의 이터레이터는
remove()해당 입력 이터레이터가 지원할 때 지원합니다.
이것이 라이브 뷰라고 명시 적으로 말하지는 않지만 마지막 문장은 그것이 있음을 암시합니다 ( Iterator.remove()백킹 반복자가 지원하는 경우에만 메서드를 지원하는 것은 라이브 뷰를 사용하지 않는 한 불가능합니다)
샘플 코드 :
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);
산출:
[1, 2, 3, 4, 5, 6, 7, 8, 9]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 9999999]
편집하다:
Damian의 요청에 따라 라이브 컬렉션 뷰를 반환하는 유사한 메서드가 있습니다.
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() {
}
}
일반 자바 사용 a (8 개) 솔루션 Stream.
상수
가정 private Collection<T> c, c2, c3합니다.
하나의 솔루션 :
public Stream<T> stream() {
return Stream.concat(Stream.concat(c.stream(), c2.stream()), c3.stream());
}
Another solution:
public Stream<T> stream() {
return Stream.of(c, c2, c3).flatMap(Collection::stream);
}
Variable number
Assuming private Collection<Collection<T>> cs:
public Stream<T> stream() {
return cs.stream().flatMap(Collection::stream);
}
If you're using at least Java 8, see my other answer.
If you're already using Google Guava, see Sean Patrick Floyd's answer.
If you're stuck at Java 7 and don't want to include Google Guava, you can write your own (read-only) Iterables.concat() using no more than Iterable and Iterator:
Constant number
public static <E> Iterable<E> concat(final Iterable<? extends E> iterable1,
final Iterable<? extends E> iterable2) {
return new Iterable<E>() {
@Override
public Iterator<E> iterator() {
return new Iterator<E>() {
final Iterator<? extends E> iterator1 = iterable1.iterator();
final Iterator<? extends E> iterator2 = iterable2.iterator();
@Override
public boolean hasNext() {
return iterator1.hasNext() || iterator2.hasNext();
}
@Override
public E next() {
return iterator1.hasNext() ? iterator1.next() : iterator2.next();
}
};
}
};
}
Variable number
@SafeVarargs
public static <E> Iterable<E> concat(final Iterable<? extends E>... iterables) {
return concat(Arrays.asList(iterables));
}
public static <E> Iterable<E> concat(final Iterable<Iterable<? extends E>> iterables) {
return new Iterable<E>() {
final Iterator<Iterable<? extends E>> iterablesIterator = iterables.iterator();
@Override
public Iterator<E> iterator() {
return !iterablesIterator.hasNext() ? Collections.emptyIterator()
: new Iterator<E>() {
Iterator<? extends E> iterableIterator = nextIterator();
@Override
public boolean hasNext() {
return iterableIterator.hasNext();
}
@Override
public E next() {
final E next = iterableIterator.next();
findNext();
return next;
}
Iterator<? extends E> nextIterator() {
return iterablesIterator.next().iterator();
}
Iterator<E> findNext() {
while (!iterableIterator.hasNext()) {
if (!iterablesIterator.hasNext()) {
break;
}
iterableIterator = nextIterator();
}
return this;
}
}.findNext();
}
};
}
You could create a new List and addAll() of your other Lists to it. Then return an unmodifiable list with Collections.unmodifiableList().
Here is my solution for that:
EDIT - changed code a little bit
public static <E> Iterable<E> concat(final Iterable<? extends E> list1, Iterable<? extends E> list2)
{
return new Iterable<E>()
{
public Iterator<E> iterator()
{
return new Iterator<E>()
{
protected Iterator<? extends E> listIterator = list1.iterator();
protected Boolean checkedHasNext;
protected E nextValue;
private boolean startTheSecond;
public void theNext()
{
if (listIterator.hasNext())
{
checkedHasNext = true;
nextValue = listIterator.next();
}
else if (startTheSecond)
checkedHasNext = false;
else
{
startTheSecond = true;
listIterator = list2.iterator();
theNext();
}
}
public boolean hasNext()
{
if (checkedHasNext == null)
theNext();
return checkedHasNext;
}
public E next()
{
if (!hasNext())
throw new NoSuchElementException();
checkedHasNext = null;
return nextValue;
}
public void remove()
{
listIterator.remove();
}
};
}
};
}
'developer tip' 카테고리의 다른 글
| R에서 %> %는 무엇을 의미합니까? (0) | 2020.08.09 |
|---|---|
| 사전을 데이터 소스로 사용하는 C # DropDownList (0) | 2020.08.09 |
| UIImage를 파일에 어떻게 저장합니까? (0) | 2020.08.09 |
| 사전 병합 사전 (0) | 2020.08.09 |
| 추가하기 전에 클래스가 이미 할당되었는지 확인하십시오. (0) | 2020.08.09 |