Java'da iki listeye nasıl katılabilirim?

Koşullar: orijinal listeleri değiştirmeyin; Yalnızca JDK, harici kitaplık yok. Tek astarlı veya JDK 1.3 sürümü için bonus puanlar.

Şundan daha basit bir yol var mı:

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

Java 8'de:

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

Başımın üstünden, bir satır kısaltabilirim:

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

Sen kullanabilirsiniz Apache commons-koleksiyonları kütüphane:

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

Gereksinimlerinizden biri orijinal listeleri korumaktır. Yeni bir liste oluşturup kullanırsanız addAll(), listelerinizdeki nesnelere yapılan başvuru sayısını etkili bir şekilde iki katına çıkarırsınız . Listeleriniz çok büyükse bu, bellek sorunlarına yol açabilir.

Birleştirilmiş sonucu değiştirmeniz gerekmiyorsa, özel bir liste uygulaması kullanarak bundan kaçınabilirsiniz. Özel uygulama sınıfı, birden fazla satırdan oluşuyor, tabii ki ... ama onu kullanmak kısa ve tatlı.

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

Kullanımı:

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

Muhtemelen daha basit değil, ilgi çekici ve çirkin:

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

Üretim kodunda kullanmayın ...;)

Başka bir Java 8 tek katlı:

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

Bonus olarak, Stream.of()değişken olduğu için, istediğiniz sayıda listeyi birleştirebilirsiniz.

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

Daha basit değil, ek yükü yeniden boyutlandırmadan:

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

Bu soruyu, harici kütüphanelere bakılmaksızın, rastgele sayıda listeyi birleştirmek isteyen buldum. Yani, belki başka birine yardımcı olacaktır:

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

() İçin aynı mantığı bir arada bulunan farklı koleksiyonlara uygulamak istiyorsanız kullanışlıdır.

Java 8 ( Stream.ofve Stream.concat)

Önerilen çözüm üç liste içindir, ancak iki liste için de uygulanabilir. Java 8'de Stream.of veya Stream.concat'i şu şekilde kullanabiliriz :

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.concatiki akışı girdi olarak alır ve öğeleri birinci akışın tüm elemanları, ardından ikinci akışın tüm elemanları olan tembel olarak birleştirilmiş bir akış oluşturur. Üç listemiz olduğu için bu yöntemi ( Stream.concat) iki kez kullandık.

Ayrıca, herhangi bir sayıda listeyi ( varargs kullanarak ) alan ve birleştirilmiş listeyi şu şekilde döndüren bir yöntemle bir yardımcı program sınıfı yazabiliriz :

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

O zaman bu yöntemi kullanabiliriz:

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

İşte iki satır kullanan bir java 8 çözümü:

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

Bu yöntemin aşağıdaki durumlarda kullanılmaması gerektiğini unutmayın.

• kaynağı newListbilinmemektedir ve zaten diğer konularla paylaşılmış olabilir
• değiştirilen newListakış paralel bir akıştır ve erişim newListsenkronize veya iş parçacığı için güvenli değildir

yan etki nedeniyle.

Yukarıdaki koşulların her ikisi de yukarıdaki iki listeye katılma durumu için geçerli değildir, bu nedenle güvenlidir.

Başka bir soruya verilen bu cevaba dayanarak .

Bu basit ve sadece bir satır, ancak listTwo içeriğini listOne öğesine ekleyecektir. İçeriği gerçekten üçüncü bir listeye koymanız gerekiyor mu?

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

Biraz daha basit:

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

Biraz daha kısa olurdu:

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

İstediğiniz sayıda listeyi birleştirmek için genel Java 8 yardımcı programı yönteminizi oluşturabilirsiniz .

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

Hedef listesi önceden tahmin edilirse bir oneliner yapabilirsiniz.

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

In Java 8 (başka bir yol):

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

Java8akım flatMapzaten kullanan başka bir tek çözüm , çözüm zaten gönderildiğinden, işte olmayan bir çözümflatMap

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

veya

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

kod

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

çıktı

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

Bence en akıllısı:

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

Statik bir içe aktarma ve bir yardımcı sınıfla yapabilirsiniz

nb bu sınıfın türetilmesi muhtemelen geliştirilebilir

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

}

Sonra gibi şeyler yapabilirsiniz

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

Nesne anahtarıyla katılma desteğine sahip Java 8 sürümü:

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

Bir Helper sınıfı kullanın.

Öneririm:

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

2 yaklaşımla java8 kullanarak 2 listeye katılabiliriz.

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

1) Concat kullanımı:

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

2) flatMap kullanma:

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

Cevapların neredeyse tamamı bir ArrayList kullanmanızı önerir.

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

Verimli ekleme işlemleri için LinkedList kullanmayı tercih edin.

ArrayList eklentisi O (1) amortismana tabi tutulur, ancak dizinin yeniden boyutlandırılması ve kopyalanması gerektiğinden O (n) en kötü durumdur. LinkedList ekleme her zaman sabit O (1) iken.

daha fazla bilgi https://stackoverflow.com/a/322742/311420

Basit olduğunu iddia etmiyorum, ama tek gömlekli bonusdan bahsettin ;-)

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

Tek astarlı bir yol yok, ama bunun en basit olduğunu düşünüyorum:

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

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

Listeleriniz farklı türlere sahipse ve bunları başka bir tür listeyle birleştirmek istiyorsanız, akışları ve java 8'i kullanan bir yaklaşım.

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

Bunu statik olarak yapmak istiyorsanız aşağıdakileri yapabilirsiniz.

Örnekler, doğal sırayla (== Enum-order) 2 EnumSets kullanır A, Bve ardından bir ALLlisteye katılır .

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

}