Làm cách nào để tham gia hai danh sách trong Java?

Điều kiện: không sửa đổi danh sách ban đầu; Chỉ JDK, không có thư viện bên ngoài. Điểm thưởng cho phiên bản một lớp hoặc JDK 1.3.

Có cách nào đơn giản hơn:

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

Trong Java 8:

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

Ngoài đỉnh đầu, tôi có thể rút ngắn nó bằng một dòng:

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

Bạn có thể sử dụng thư viện bộ sưu tập chung của Apache :

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

Một trong những yêu cầu của bạn là giữ nguyên danh sách gốc. Nếu bạn tạo một danh sách mới và sử dụng addAll(), bạn đang nhân đôi số lượng tài liệu tham khảo cho các đối tượng trong danh sách của mình một cách hiệu quả. Điều này có thể dẫn đến các vấn đề về bộ nhớ nếu danh sách của bạn rất lớn.

Nếu bạn không cần sửa đổi kết quả được nối, bạn có thể tránh điều này bằng cách sử dụng triển khai danh sách tùy chỉnh. Lớp triển khai tùy chỉnh có nhiều hơn một dòng, rõ ràng ... nhưng sử dụng nó thì ngắn và ngọt ngào.

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();
    }
}

Sử dụng:

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

Có lẽ không đơn giản, nhưng hấp dẫn và xấu xí:

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

Đừng sử dụng nó trong mã sản xuất ...;)

Một lớp lót Java 8 khác:

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

Như một phần thưởng, vì Stream.of()là từ khóa , bạn có thể ghép bao nhiêu danh sách tùy thích.

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

Không đơn giản, nhưng không thay đổi kích thước trên đầu:

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

Tìm thấy câu hỏi này để tìm cách kết hợp số lượng danh sách tùy ý, không bận tâm đến các thư viện bên ngoài. Vì vậy, có lẽ nó sẽ giúp người khác:

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

Hữu ích nếu bạn muốn áp dụng cùng logic cho một số bộ sưu tập khác nhau trong một cho ().

Java 8 ( Stream.ofvà Stream.concat)

Giải pháp đề xuất là cho ba danh sách mặc dù nó cũng có thể được áp dụng cho hai danh sách. Trong Java 8, chúng ta có thể sử dụng Stream.of hoặc Stream.concat như:

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.concatlấy hai luồng làm đầu vào và tạo ra một luồng kết hợp một cách lười biếng với các phần tử là tất cả các phần tử của luồng đầu tiên, theo sau là tất cả các phần tử của luồng thứ hai. Khi chúng tôi có ba danh sách, chúng tôi đã sử dụng phương thức này ( Stream.concat) hai lần.

Chúng ta cũng có thể viết một lớp tiện ích với một phương thức lấy bất kỳ số lượng danh sách (sử dụng varargs ) và trả về một danh sách được nối như:

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

Sau đó, chúng ta có thể sử dụng phương pháp này như:

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

Đây là một giải pháp java 8 sử dụng hai dòng:

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

Xin lưu ý rằng phương pháp này không nên được sử dụng nếu

• nguồn gốc của newListkhông được biết và nó có thể đã được chia sẻ với các chủ đề khác
• luồng sửa đổi newListlà luồng song song và quyền truy cập newListkhông được đồng bộ hóa hoặc luồng an toàn

do cân nhắc tác dụng phụ.

Cả hai điều kiện trên đều không áp dụng cho trường hợp tham gia hai danh sách trên, vì vậy điều này là an toàn.

Dựa trên câu trả lời này cho câu hỏi khác.

Điều này đơn giản và chỉ một dòng, nhưng sẽ thêm nội dung của listTwo vào listOne. Bạn có thực sự cần phải đưa nội dung vào danh sách thứ ba?

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

Đơn giản hơn một chút:

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

Một chút ngắn hơn sẽ là:

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

Bạn có thể tạo phương thức tiện ích Java 8 chung của mình để nối bất kỳ số lượng danh sách nào .

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

Bạn có thể thực hiện một oneliner nếu danh sách mục tiêu được khai báo trước.

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

Trong Java 8 (cách khác):

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

một giải pháp lót khác sử dụng Java8luồng, vì flatMapgiải pháp đã được đăng, đây là một giải pháp không cóflatMap

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

hoặc là

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

mã

    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);

đầu ra

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

Thông minh nhất theo quan điểm của tôi:

/**
 * @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;
}

Bạn có thể làm điều đó với một nhập tĩnh và một lớp trợ giúp

nb sự khái quát của lớp này có thể được cải thiện

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;
   }

}

Sau đó, bạn có thể làm những việc như

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

Phiên bản Java 8 có hỗ trợ tham gia bằng khóa đối tượng:

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;
}

Sử dụng một lớp Helper.

Tôi đề nghị:

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;
  }

Chúng tôi có thể tham gia 2 danh sách bằng cách sử dụng java8 với 2 cách tiếp cận.

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

1) Sử dụng concat:

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

2) Sử dụng FlatMap:

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

Hầu hết các câu trả lời đề nghị sử dụng ArrayList.

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

Thích sử dụng LinkedList để hoạt động thêm hiệu quả.

ArrayList add là O (1) được khấu hao, nhưng trường hợp xấu nhất O (n) vì mảng phải được thay đổi kích thước và sao chép. Trong khi LinkedList add luôn không đổi O (1).

thêm thông tin https://stackoverflow.com/a/322742/311420

Tôi không khẳng định rằng nó đơn giản, nhưng bạn đã đề cập đến phần thưởng cho một lớp lót ;-)

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

Không có cách nào gần một lớp lót, nhưng tôi nghĩ đây là cách đơn giản nhất:

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

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

Đây là một cách tiếp cận sử dụng luồng và java 8 nếu danh sách của bạn có các loại khác nhau và bạn muốn kết hợp chúng với một danh sách loại khác.

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());
}

Nếu bạn muốn làm điều này một cách tĩnh, bạn có thể làm như sau.

Các ví dụ sử dụng 2 EnumSets theo thứ tự tự nhiên (== Enum-order) A, Bvà sau đó tham gia trong một ALLdanh sách.

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;
    }

}