Java에서 두 목록에 어떻게 참여합니까?

조건 : 원본 목록을 수정하지 마십시오. 외부 라이브러리가없는 JDK 전용 1 라이너 또는 JDK 1.3 버전의 보너스 포인트.

다음보다 간단한 방법이 있습니까?

List<String> newList = new ArrayList<String>();
newList.addAll(listOne);
newList.addAll(listTwo);

자바 8 :

List<String> newList = Stream.concat(listOne.stream(), listTwo.stream())
                             .collect(Collectors.toList());

내 머리 꼭대기에서 한 줄씩 줄일 수 있습니다.

List<String> newList = new ArrayList<String>(listOne);
newList.addAll(listTwo);

Apache commons-collections 라이브러리를 사용할 수 있습니다 .

List<String> newList = ListUtils.union(list1, list2);

요구 사항 중 하나는 원본 목록을 유지하는 것입니다. 새 목록을 작성하고를 사용 addAll()하면 목록 의 객체에 대한 참조 수가 효과적으로 두 배가됩니다. 목록이 매우 큰 경우 메모리 문제가 발생할 수 있습니다.

연결된 결과를 수정할 필요가없는 경우 사용자 정의 목록 구현을 사용하여이를 피할 수 있습니다. 커스텀 구현 클래스는 두 줄 이상이지만 분명히 사용하는 것은 짧고 달콤합니다.

CompositeUnmodifiableList.java :

public class CompositeUnmodifiableList<E> extends AbstractList<E> {

    private final List<E> list1;
    private final List<E> list2;

    public CompositeUnmodifiableList(List<E> list1, List<E> list2) {
        this.list1 = list1;
        this.list2 = list2;
    }

    @Override
    public E get(int index) {
        if (index < list1.size()) {
            return list1.get(index);
        }
        return list2.get(index-list1.size());
    }

    @Override
    public int size() {
        return list1.size() + list2.size();
    }
}

용법:

List<String> newList = new CompositeUnmodifiableList<String>(listOne,listTwo);

아마도 더 단순하지는 않지만 흥미롭고 추악합니다.

List<String> newList = new ArrayList<String>() { { addAll(listOne); addAll(listTwo); } };

프로덕션 코드에서 사용하지 마십시오 ...;)

또 다른 Java 8 one-liner :

List<String> newList = Stream.of(listOne, listTwo)
                            .flatMap(Collection::stream)
                            .collect(Collectors.toList());

보너스 Stream.of()는 가변적이므로 원하는만큼 많은 목록을 연결할 수 있습니다.

List<String> newList = Stream.of(listOne, listTwo, listThree)
                            .flatMap(Collection::stream)
                            .collect(Collectors.toList());

더 간단하지는 않지만 오버 헤드 크기를 조정하지 않은 경우 :

List<String> newList = new ArrayList<>(listOne.size() + listTwo.size());
newList.addAll(listOne);
newList.addAll(listTwo);

이 질문은 외부 라이브러리를 신경 쓰지 않고 임의의 양의 목록을 연결하려고합니다. 따라서 아마도 다른 사람을 도울 것입니다.

com.google.common.collect.Iterables#concat()

하나의 for ()에있는 여러 다른 컬렉션에 동일한 논리를 적용하려는 경우에 유용합니다.

자바 8 ( Stream.of및 Stream.concat)

제안 된 솔루션은 세 개의 목록에 대한 것이지만 두 개의 목록에도 적용될 수 있습니다. Java 8에서는 Stream.of 또는 Stream.concat 을 다음과 같이 사용할 수 있습니다 .

List<String> result1 = Stream.concat(Stream.concat(list1.stream(),list2.stream()),list3.stream()).collect(Collectors.toList());
List<String> result2 = Stream.of(list1,list2,list3).flatMap(Collection::stream).collect(Collectors.toList());

Stream.concat입력으로 두 개의 스트림을 가져 와서 요소가 첫 번째 스트림의 모든 요소와 두 번째 스트림의 모든 요소가 뒤섞인 지연 연결된 스트림을 만듭니다. 세 개의 목록이 있으므로이 방법 ( Stream.concat)을 두 번 사용했습니다.

varargs를 사용하여 여러 목록을 가져와 연결된 목록을 다음과 같이 반환하는 메서드를 사용하여 유틸리티 클래스를 작성할 수도 있습니다 .

public static <T> List<T> concatenateLists(List<T>... collections) {
        return Arrays.stream(collections).flatMap(Collection::stream).collect(Collectors.toList()); 
}

그런 다음이 방법을 다음과 같이 사용할 수 있습니다.

List<String> result3 = Utils.concatenateLists(list1,list2,list3);

다음은 두 줄을 사용하는 Java 8 솔루션입니다.

List<Object> newList = new ArrayList<>();
Stream.of(list1, list2).forEach(newList::addAll);

이 방법을 사용하면 안됩니다

• 의 출처를 newList알 수 없으며 이미 다른 스레드와 공유되었을 수 있습니다
• 수정하는 스트림 newList은 병렬 스트림이며 이에 대한 액세스 newList는 동기화되거나 스레드로부터 안전하지 않습니다.

부작용 고려로 인해.

위의 두 조건이 위의 두 목록에 참여하는 경우에는 적용되지 않으므로 안전합니다.

다른 질문 에 대한 이 답변 을 바탕으로 합니다 .

이것은 간단하고 단 한 줄이지 만 listTone의 내용을 listOne에 추가합니다. 내용을 세 번째 목록에 넣어야합니까?

Collections.addAll(listOne, listTwo.toArray());

약간 더 간단합니다 :

List<String> newList = new ArrayList<String>(listOne);
newList.addAll(listTwo);

조금 더 짧을 것입니다 :

List<String> newList = new ArrayList<String>(listOne);
newList.addAll(listTwo);

일반 Java 8 유틸리티 메소드를 작성하여 원하는 수의 목록을 연결할 수 있습니다 .

@SafeVarargs
public static <T> List<T> concat(List<T>... lists) {
    return Stream.of(lists).flatMap(List::stream).collect(Collectors.toList());
}

대상 목록이 미리 선언 된 경우 oneliner를 수행 할 수 있습니다.

(newList = new ArrayList<String>(list1)).addAll(list2);

에서 자바 8 (다른 방법) :

List<?> newList = 
Stream.of(list1, list2).flatMap(List::stream).collect(Collectors.toList());

솔루션이 이미 게시되어 Java8있으므로 스트림 을 사용하는 또 하나의 라이너 솔루션 flatMap입니다.flatMap

List<E> li = lol.stream().collect(ArrayList::new, List::addAll, List::addAll);

또는

List<E> ints = Stream.of(list1, list2).collect(ArrayList::new, List::addAll, List::addAll);

암호

    List<List<Integer>> lol = Arrays.asList(Arrays.asList(1, 2, 3), Arrays.asList(4, 5, 6));
    List<Integer> li = lol.stream().collect(ArrayList::new, List::addAll, List::addAll);
    System.out.println(lol);
    System.out.println(li);

산출

[[1, 2, 3], [4, 5, 6]]
[1, 2, 3, 4, 5, 6]

내 의견으로는 가장 똑똑하다.

/**
 * @param smallLists
 * @return one big list containing all elements of the small ones, in the same order.
 */
public static <E> List<E> concatenate (final List<E> ... smallLists)
{
    final ArrayList<E> bigList = new ArrayList<E>();
    for (final List<E> list: smallLists)
    {
        bigList.addAll(list);
    }
    return bigList;
}

정적 가져 오기 및 도우미 클래스를 사용하여 수행 할 수 있습니다.

NB 이 클래스의 총칭 아마 개선 될 수

public class Lists {

   private Lists() { } // can't be instantiated

   public static List<T> join(List<T>... lists) {
      List<T> result = new ArrayList<T>();
      for(List<T> list : lists) {
         result.addAll(list);
      }
      return results;
   }

}

그럼 당신은 같은 일을 할 수 있습니다

import static Lists.join;
List<T> result = join(list1, list2, list3, list4);

객체 키로 결합을 지원하는 Java 8 버전 :

public List<SomeClass> mergeLists(final List<SomeClass> left, final List<SomeClass> right, String primaryKey) {
    final Map<Object, SomeClass> mergedList = new LinkedHashMap<>();

    Stream.concat(left.stream(), right.stream())
        .map(someObject -> new Pair<Object, SomeClass>(someObject.getSomeKey(), someObject))
        .forEach(pair-> mergedList.put(pair.getKey(), pair.getValue()));

    return new ArrayList<>(mergedList.values());
}

public static <T> List<T> merge(List<T>... args) {
    final List<T> result = new ArrayList<>();

    for (List<T> list : args) {
        result.addAll(list);
    }

    return result;
}

헬퍼 클래스를 사용하십시오.

나는 제안한다 :

public static <E> Collection<E> addAll(Collection<E> dest, Collection<? extends E>... src) {
    for(Collection<? extends E> c : src) {
        dest.addAll(c);
    }

    return dest;
}

public static void main(String[] args) {
    System.out.println(addAll(new ArrayList<Object>(), Arrays.asList(1,2,3), Arrays.asList("a", "b", "c")));

    // does not compile
    // System.out.println(addAll(new ArrayList<Integer>(), Arrays.asList(1,2,3), Arrays.asList("a", "b", "c")));

    System.out.println(addAll(new ArrayList<Integer>(), Arrays.asList(1,2,3), Arrays.asList(4, 5, 6)));
}

public static <T> List<T> merge(@Nonnull final List<T>... list) {
    // calculate length first
    int mergedLength = 0;
    for (List<T> ts : list) {
      mergedLength += ts.size();
    }

    final List<T> mergedList = new ArrayList<>(mergedLength);

    for (List<T> ts : list) {
      mergedList.addAll(ts);
    }

    return mergedList;
  }

우리는 두 가지 접근 방식으로 java8을 사용하여 두 목록에 참여할 수 있습니다.

    List<String> list1 = Arrays.asList("S", "T");
    List<String> list2 = Arrays.asList("U", "V");

1) concat 사용 :

    List<String> collect2 = Stream.concat(list1.stream(), list2.stream()).collect(toList());
    System.out.println("collect2 = " + collect2); // collect2 = [S, T, U, V]

2) flatMap 사용 :

    List<String> collect3 = Stream.of(list1, list2).flatMap(Collection::stream).collect(toList());
    System.out.println("collect3 = " + collect3); // collect3 = [S, T, U, V]

대부분의 답변은 ArrayList를 사용하는 것이 좋습니다.

List<String> newList = new LinkedList<>(listOne);
newList.addAll(listTwo);

효율적인 추가 작업을 위해 LinkedList를 사용하는 것이 좋습니다.

ArrayList add는 O (1) 상각되지만 배열의 크기를 조정하고 복사해야하므로 O (n) 최악의 경우입니다. LinkedList add는 항상 상수 O (1)입니다.

더 많은 정보 https://stackoverflow.com/a/322742/311420

나는 그것이 간단하다고 주장하지는 않지만 원 라이너에 대한 보너스를 언급했다. ;-)

Collection mergedList = Collections.list(new sun.misc.CompoundEnumeration(new Enumeration[] {
    new Vector(list1).elements(),
    new Vector(list2).elements(),
    ...
}))

한 줄짜리 근처에는 방법이 없지만 이것이 가장 간단하다고 생각합니다.

List<String> newList = new ArrayList<String>(l1);
newList.addAll(l2);

for(String w:newList)
        System.out.printf("%s ", w);

목록에 다른 유형이 있고 다른 유형의 목록과 결합하려는 경우 스트림과 Java 8을 사용하는 접근 방식이 있습니다.

public static void main(String[] args) {
    List<String> list2 = new ArrayList<>();
    List<Pair<Integer, String>> list1 = new ArrayList<>();

    list2.add("asd");
    list2.add("asdaf");
    list1.add(new Pair<>(1, "werwe"));
    list1.add(new Pair<>(2, "tyutyu"));

    Stream stream = Stream.concat(list1.stream(), list2.stream());

    List<Pair<Integer, String>> res = (List<Pair<Integer, String>>) stream
            .map(item -> {
                if (item instanceof String) {
                    return new Pair<>(0, item);
                }
                else {
                    return new Pair<>(((Pair<Integer, String>)item).getKey(), ((Pair<Integer, String>)item).getValue());
                }
            })
            .collect(Collectors.toList());
}

이 작업을 정적으로 수행하려면 다음을 수행 할 수 있습니다.

이 예제에서는 자연 순서 (== 순)로 2 개의 EnumSet을 사용 A, B하고 ALL목록 에서 조인 합니다.

public static final EnumSet<MyType> CATEGORY_A = EnumSet.of(A_1, A_2);
public static final EnumSet<MyType> CATEGORY_B = EnumSet.of(B_1, B_2, B_3);

public static final List<MyType> ALL = 
              Collections.unmodifiableList(
                  new ArrayList<MyType>(CATEGORY_A.size() + CATEGORY_B.size())
                  {{
                      addAll(CATEGORY_A);
                      addAll(CATEGORY_B);
                  }}
              );

import java.util.AbstractList;
import java.util.List;


/**
 * The {@code ConcatList} is a lightweight view of two {@code List}s.
 * <p>
 * This implementation is <em>not</em> thread-safe even though the underlying lists can be.
 * 
 * @param <E>
 *            the type of elements in this list
 */
public class ConcatList<E> extends AbstractList<E> {

    /** The first underlying list. */
    private final List<E> list1;
    /** The second underlying list. */
    private final List<E> list2;

    /**
     * Constructs a new {@code ConcatList} from the given two lists.
     * 
     * @param list1
     *            the first list
     * @param list2
     *            the second list
     */
    public ConcatList(final List<E> list1, final List<E> list2) {
        this.list1 = list1;
        this.list2 = list2;
    }

    @Override
    public E get(final int index) {
        return getList(index).get(getListIndex(index));
    }

    @Override
    public E set(final int index, final E element) {
        return getList(index).set(getListIndex(index), element);
    }

    @Override
    public void add(final int index, final E element) {
        getList(index).add(getListIndex(index), element);
    }

    @Override
    public E remove(final int index) {
        return getList(index).remove(getListIndex(index));
    }

    @Override
    public int size() {
        return list1.size() + list2.size();
    }

    @Override
    public boolean contains(final Object o) {
        return list1.contains(o) || list2.contains(o);
    }

    @Override
    public void clear() {
        list1.clear();
        list2.clear();
    }

    /**
     * Returns the index within the corresponding list related to the given index.
     * 
     * @param index
     *            the index in this list
     * 
     * @return the index of the underlying list
     */
    private int getListIndex(final int index) {
        final int size1 = list1.size();
        return index >= size1 ? index - size1 : index;
    }

    /**
     * Returns the list that corresponds to the given index.
     * 
     * @param index
     *            the index in this list
     * 
     * @return the underlying list that corresponds to that index
     */
    private List<E> getList(final int index) {
        return index >= list1.size() ? list2 : list1;
    }

}