मैं जावा में दो सूचियों में कैसे शामिल हो सकता हूं?

Question

शर्तें: मूल सूचियों को संशोधित नहीं करना; JDK केवल, कोई बाहरी लाइब्रेरी नहीं। एक-लाइनर या जेडीके 1.3 संस्करण के लिए बोनस अंक।

क्या इससे सरल तरीका है:

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

Comments

यदि आप इसे पूरी तरह से पुनरावृत्ति प्रयोजनों के लिए कर रहे हैं, तो एक और प्रश्न देखें - वहाँ गूगल अमरूद और जावा 8 समाधान हैं stackoverflow.com/questions/4896662/…

— बोरिस ट्रेखोव

उपयोगिता विधि के साथ जावा 8 समाधान: stackoverflow.com/a/37386846/1216775

— akhil_mittal

कुछ उत्तरों को पढ़ने के बाद, मुझे क्षमा करें मैंने पूछा है।

— एंथनी रटलेज

Answer 1

जावा 8 में:

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

Comments

Gawd, यह जावा 8 में एक बात है? तकनीकी रूप से आप मुझे लगता है जीतते हैं, लेकिन यह एक लंबी लाइन की एक बिल्ली है :-)

— रॉबर्ट एटकिन्स

कैज़ुअल रीडर के लिए, यहाँ Java _ Streams: stackoverflow.com/a/34090554/363573

— Stephan

यह बदसूरत है, लेकिन कम से कम इसकी धाराप्रवाह और इसका उपयोग मल्टी लाइन लैम्ब्डा के बिना किया जा सकता है। मैं वास्तव में एक धाराप्रवाह addAll चाहता हूं जिसने समाप्‍त सूची वापस कर दी।

— उस्मान इस्माइल

मुझे लगता है कि यह ध्यान देने योग्य है कि इससे अलग सूची प्राप्त करना वास्तव में आसान है, जैसे कि:List<String> newList = Stream.concat(listOne.stream(), listTwo.stream()).distinct().collect(Collectors.toList());

— रोजर

कॉनकैट का विकल्प: धाराओं की धाराStream.of(listOne, listTwo).flatMap(Collection::stream).collect(Collectors.toList())

— पीटर वालसर

Answer 2

मेरे सिर के ऊपर से, मैं इसे एक पंक्ति से छोटा कर सकता हूं:

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

Comments

जब आप तकनीकी रूप से सही हो जाते हैं, तो आपने इसे एक पंक्ति में छोटा कर दिया है, मुझे इस कीड़े की विषमता। पर्याप्त है कि मैं अतिरिक्त लाइन "खर्च" करने के लिए खुश हूं।

— रॉबर्ट एटकिन्स

क्या यहाँ कोई समस्या नहीं है जहाँ newList के इंटरनल एरे को listOne के आकार में इनिशियलाइज़ किया जाएगा और फिर listTwo से सभी आइटम्स को जोड़ते समय संभावित विस्तार करना होगा? क्या बेहतर होगा कि प्रत्येक सूची का आकार लिया जाए और नए सरणी को आकार दिया जाए?

— एरिक

यही वह समाधान था जिसने मेरे लिए सबसे अच्छा काम किया। मैंने अलग-अलग समाधानों के प्रदर्शन पर तुलना की, जो विजेता बनकर आए, साथ में खाली सूची और फिर addAll()दोनों का निर्माण किया। मैंने उन सभी को आज़माया जो सूचियों की नकल नहीं करने का सुझाव देते हैं और उनके परिणामस्वरूप बहुत अधिक ओवरहेड होता है जिसकी हमें इस समय ज़रूरत नहीं थी।

— मैनुएलविग्रेसिया

अच्छा है, लेकिन आप इसे छोटा भी कर सकते हैं: सूची सूची = नया एरियर सूची <> (सूची 1) .addAll (list2);

— वेग

@ तरंग: नहीं, वह काम नहीं कर रहा है। addAll(Collection)एक रिटर्न boolean।

— Stijn Van Bael

Answer 3

आप अपाचे कॉमन्स-संग्रह पुस्तकालय का उपयोग कर सकते हैं :

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

Comments

अच्छा है, लेकिन अपाचे कॉमन्स की आवश्यकता है। उन्होंने 'कोई बाहरी पुस्तकालयों' को निर्दिष्ट नहीं किया

— क्वांटम 7

@ क्वांटम 7, अन्य लोगों के लिए अभी भी उपयोगी है?) इसके अलावा, अपाचे कॉमन्स भी एक बाहरी पुस्तकालय है? मैं इसके बिना कुछ भी शुरू नहीं करता!

— 23:12 पर tster

@ प्लेटिनम नहीं, डॉक्स के अनुसार ListUtils.union ओपी के कोड के बिल्कुल बराबर है। लेकिन शायद एक सूची संदर्भ में SET ऑपरेशन ("यूनियन") का उपयोग करना भ्रामक है। मैं देख सकता हूं कि आप डुप्लिकेट या कुछ को हटाने के लिए यह कैसे उम्मीद कर सकते हैं, लेकिन ऐसा लगता है कि विधि ऐसा नहीं करती है।

— क्वांटम 7

अपाचे कॉमन्स कलेक्शंस से बचें। यह कोई प्रकार नहीं है, कोई जेनरिक नहीं हैं। यदि आप जावा 1.4 का उपयोग करते हैं, लेकिन जावा 5 और इसके बाद के संस्करण के लिए, तो मुझे Google अमरूद पसंद आएगा।

— माइकल पिफेल

@MichaelPiefel नवीनतम Apache कॉमन्स कलेक्शंस 4 सुरक्षित है। जावा 8 विधि संदर्भ के साथ, इस तरह की स्थिर उपयोगिताओं बहुत महत्वपूर्ण हो जाती हैं।

— मिंगफ़ई

Answer 4

आपकी आवश्यकताओं में से एक मूल सूचियों को संरक्षित करना है। यदि आप एक नई सूची बनाते हैं और उपयोग करते हैं 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);

Comments

इस सवाल का असली जवाब यही है।

— राउटर लिवेन्स

यह एक व्यावहारिक समाधान है, लेकिन ध्यान दें कि यदि अंतर्निहित सूची ऑब्जेक्ट्स (सूची 1, सूची 2) बदल जाती हैं, तो इस सूची की सामग्री बदल जाती है। हो सकता है कि आप स्वयं कंपोज़िट यूएनएमोडिफ़िबल लिस्ट के एक उदाहरण को संशोधित करने में सक्षम न हों, लेकिन यदि आप मूल सूचियों का संदर्भ प्राप्त कर सकते हैं, तो आप कर सकते हैं। उन लोगों के लिए भी जो अपरिचित हैं: अंतिम संशोधक सिर्फ सूची ऑब्जेक्ट के संदर्भ को प्रभावित करता है खुद को बदल नहीं सकता है लेकिन सूची की सामग्री को बदलने के लिए अभी भी संभव है!

— jwj

@jj सभी बहुत अच्छे अंक, धन्यवाद। वर्ग नाम शायद कुछ स्पष्टीकरण के लायक है। मैं इस वर्ग को Collections.unmodifiableList()विधि के समान कुछ करने के रूप में देखता हूं , जो इसे अपरिवर्तनीय बनाने के लिए एक सूची लपेटता है। CompositeUnmodifiableListएक ही काम करता है, सिवाय इसके कि दो सूचियों को लपेटता है और एक संक्षिप्त दृश्य प्रदान करता है। आपके द्वारा किए गए सभी बिंदु CompositeUnmodifiableListसही भी हैं Collections.unmodifiableList()।

— केविन के

कंस्ट्रक्टर ले जा सकता हैList<? extends E>

— पैट्रिक पार्कर

Answer 5

शायद सरल नहीं है, लेकिन पेचीदा और बदसूरत:

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

इसे उत्पादन कोड में उपयोग न करें ...;)

Comments

बदसूरत और बुराई, बस के रूप में डबल ब्रेस आरंभीकरण के लगभग किसी भी उपयोग। हालांकि, यह छोटा है;)

— जोर्न

@ मार्निक्स क्लोस्टर: ग्रहण जानता है कि आपको इसका उपयोग नहीं करना चाहिए और इसे उपयोग करने के लिए अप्रिय बना देता है ;-)

— जोकिम सोर

हालांकि यह शारीरिक रूप से एक पंक्ति है, मैं इसे "वन-लाइनर" नहीं मानता।

— splungebob

लोग गुमनाम ब्लॉक इनिशियलाइज़र से क्यों नफरत करते हैं

— निमशिम्पस्की

@NimChimpsky मुझे लगता है कि यह ज्यादातर इसलिए है क्योंकि यह सिर्फ एक अनाम ब्लॉक इनिशियलाइज़र नहीं है, लेकिन आप वास्तव में एरेलेस्ट का एक अनाम उपवर्ग बना रहे हैं। यह कहा जा रहा है, यदि आप इस डबल ब्रेस Initization प्रश्न के परिणामों पर भरोसा करते हैं, तो यह ऐसा लगता है कि DBI से नफरत करना ज्यादातर शैलीगत स्वाद और सूक्ष्म अनुकूलन का मामला है। जहां तक ​​मैं बता सकता हूं, इसे करने के लिए कोई बड़ा दंड नहीं है। यदि आप कभी भी इसकी कक्षा की तुलना करने की कोशिश करते हैं तो डरपोक यह होगा कि यह एरेलेस्ट नहीं होगा।

— पैट्रिक

Answer 6

एक और जावा 8 एक-लाइनर:

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

Comments

x -> x.stream()के साथ प्रतिस्थापित किया जा सकता है Collection::stream।

— मार्टिन

... या साथ भी List::stream।

— एमसी सम्राट

Answer 7

सरल नहीं है, लेकिन उपरि का आकार बदले बिना:

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

Answer 8

यह प्रश्न मिला कि बाहरी पुस्तकालयों को ध्यान में न रखते हुए, सूचियों की मनमानी राशि को प्राप्त करना। तो, शायद यह किसी और की मदद करेगा:

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

उपयोगी है यदि आप एक ही तर्क को कई संग्रह में एक (एक) के लिए लागू करना चाहते हैं।

Comments

उदाहरण के लिए: Lists.newArrayList (Iterables.concat (list1, list2));

— माइलिच

आपको com.google.common.collect.Iterators#concat(java.util.Iterator<? extends java.util.Iterator<? extends T>>)इसके बजाय कॉल करना चाहिए Iterables#concat(); क्योंकि बाद में अभी भी अस्थायी लिंक में तत्वों की नकल!

— बॉब

Answer 9

जावा 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);

Comments

आप शायद यह कहना चाह रहे हैं कि लिस्ट <string> result1 = Stream.concat (Stream.concat (list1.stream) (, list2.stream ()), list3.stream ())। लीजिए (संग्राहक.toList ()); अपने पहले ऑपरेटर में। कृपया इसे ठीक करे।

— वेबकॉम

Answer 10

यहां दो लाइनों का उपयोग करके एक जावा 8 समाधान दिया गया है:

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

ध्यान रखें कि यदि इस विधि का उपयोग नहीं किया जाना चाहिए

• उद्गम newList ज्ञात नहीं है और यह पहले से ही अन्य थ्रेड्स के साथ साझा किया जा सकता है
• जिस स्ट्रीम को संशोधित करता है newListवह एक समानांतर स्ट्रीम है और उस तक पहुंच newListसिंक्रनाइज़ या थ्रेडसेफ़ नहीं है

साइड इफेक्ट विचार के कारण।

उपरोक्त दोनों शर्तें दो सूचियों में शामिल होने के उपरोक्त मामले के लिए लागू नहीं होती हैं, इसलिए यह सुरक्षित है।

इस सवाल के जवाब के आधार पर ।

Comments

अगर मैं गलत नहीं हूँ तो यह वास्तव में अनुशंसित नहीं है - docs.oracle.com/javase/8/docs/api/java/util/stream/… कृपया कृपया -effects अनुभाग देखें। > व्यवहार संबंधी मापदंडों में साइड-इफेक्ट ऑपरेशन को स्ट्रीम करने के लिए, सामान्य रूप से, हतोत्साहित किया जाता है, क्योंकि वे अक्सर स्टेटलेसनेस आवश्यकता के अनजाने उल्लंघन के साथ-साथ अन्य थ्रेड-सुरक्षा खतरों का कारण बन सकते हैं। तो इस मामले में यह कलेक्टरों का उपयोग करना बेहतर है।

— लिट्लिस्ट

@AntonBalaniuc प्रश्न है कि क्या यह वास्तव में एक साइड इफेक्ट है। उस बिंदु पर newListकिसी अन्य सूत्र द्वारा अवलोकन नहीं किया जाता है। लेकिन आप सही हैं कि यह संभवतया नहीं किया जाना चाहिए अगर यह अज्ञात है जहां से newListआया मूल्य (उदाहरण के लिए यदि newListएक पैरामीटर के रूप में पारित किया गया था।

— SpaceTrucker

मैं उत्सुक हूँ; .forEach(newList::addAll);इसके बजाय क्यों .collect(Collectors.toList());?

— 11684

@ 11684 क्योंकि कलेक्टर एक इकट्ठा करेगा List<List<Object>>। आपके मन में कुछ इस तरह से हो सकता है: stackoverflow.com/questions/189559/…

— स्पेसटुकर

@SpaceTrucker उफ़, मैंने उस पर ध्यान नहीं दिया। मेरा भ्रम दूर करने के लिए धन्यवाद। हां, मुझे सोचना चाहिए था flatMap।

— 11684

Answer 11

यह सरल और सिर्फ एक पंक्ति है, लेकिन सूची के अवयवों को सूची में जोड़ देगा। क्या आपको वास्तव में सामग्री को तीसरी सूची में रखने की आवश्यकता है?

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

Comments

मूल सूचियों को संशोधित नहीं करना मापदंड में से एक था, लेकिन यह यहां उन स्थितियों के लिए एक उदाहरण के रूप में उपयोगी है जहां यह बाधा नहीं है।

— रॉबर्ट एटकिन्स

धन्यवाद, या यहां तक ​​कि सरल सूची ।One.addAll (listTwo)

— जे

Answer 12

थोड़ा सरल:

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

Comments

क्या इससे स्ट्रिंग्स को दोहराया जाएगा? मतलब दोनों सूची में मौजूद एक स्ट्रिंग परिणामी सूची में दो बार मौजूद होगी?

— AgentKnopf

@Zainodis हाँ, डुप्लिकेट हो सकते हैं। Listसंरचना कोई विशिष्टता की कमी लगाता है। आप सेट के साथ एक ही काम करके दुपट्टे को हटा सकते हैं। Set<String> newSet = new HashSet<>(setOne); newSet.addAll(setTwo);

— पैट्रिक

Answer 13

थोड़ा छोटा होगा:

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

Answer 14

आप किसी भी संख्या को सूचीबद्ध करने के लिए अपना जेनेरिक जावा 8 उपयोगिता विधि बना सकते हैं ।

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

Answer 15

यदि आप लक्ष्य सूची पूर्ववर्ती है, तो आप एक oneliner कर सकते हैं।

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

Answer 16

में जावा 8 (दूसरा रास्ता):

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

Comments

इस उत्तर के द्वारा यह दृष्टिकोण पहले से ही सुझाया गया है: stackoverflow.com/a/37386846

— माइल्स

Answer 17

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]

Comments

मैं जोड़ूंगा कि यह समाधान संभवतः उपयोग करने वाले की तुलना में अधिक प्रदर्शनकारी है flatMap, क्योंकि सूची केवल एक बार एकत्र होने पर पुनरावृत्त होती है

— स्टीफन हैबरेल

Answer 18

मेरी राय में सबसे चतुर:

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

Comments

मत भूलना @SafeVarargs!

— रेडॉन रोसबोरो डे

Answer 19

आप इसे स्टैटिक इम्पोर्ट और हेल्पर क्लास के साथ कर सकते हैं

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

Comments

स्थैतिक आयात या सहायक वर्ग कैसे प्रासंगिक है?

— shmosel

Answer 20

ऑब्जेक्ट कुंजी से जुड़ने के लिए समर्थन के साथ जावा 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());
}

Answer 21

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

Answer 22

एक हेल्पर वर्ग का उपयोग करें।

मैं सुझाव देता हूँ:

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

Answer 23

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

Answer 24

हम 2 दृष्टिकोणों के साथ j88 का उपयोग करके 2 सूचियों में शामिल हो सकते हैं।

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

1) समवर्ती का उपयोग करना:

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

2) फ्लैटपाइप का उपयोग करना:

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

Comments

जब एक ग्यारह साल पुराने प्रश्न का तीस अन्य उत्तरों के साथ उत्तर देना सुनिश्चित करें कि आपके उत्तर के प्रश्न के कौन से नए पहलू हैं, और ध्यान दें कि क्या इन तकनीकों ने सवाल पूछे जाने पर काम किया होगा, या यदि वे उन विशेषताओं पर निर्भर करते हैं जो कि हो चुकी हैं वर्षों से पेश किया गया।

— जेसन एलर

Answer 25

लगभग सभी उत्तरों में एक ArrayList का उपयोग करने का सुझाव दिया गया है।

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

कुशल ऐड ऑपरेशन के लिए लिंक्डलिस्ट का उपयोग करना पसंद करते हैं।

ArrayList ऐड O (1) amortized है, लेकिन O (n) सबसे खराब स्थिति है क्योंकि सरणी को आकार और कॉपी किया जाना चाहिए। जबकि लिंक्डलिस्ट हमेशा ओ (1) स्थिर होता है।

अधिक जानकारी https://stackoverflow.com/a/322742/311420

Answer 26

मैं यह दावा नहीं कर रहा हूं कि यह सरल है, लेकिन आपने एक-लाइनर्स के लिए बोनस का उल्लेख किया ;-)

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

Comments

क्यों किसी को उन का उपयोग नहीं करना चाहिए?

— डेविड

@ डेविड क्योंकि इसका उद्देश्य JDK में आंतरिक रूप से उपयोग किया जाना था। यदि आपने उस कोड का उपयोग किया है, तो आपका कोड संभवतः गैर-सूर्य (या गैर-ओरेकल अब) JDK / JRE पर नहीं चलेगा।

— एड्रियन शुम

@AdrianShum ओरेकल की तुलना में अन्य JDK / JRE हैं? जो मुझे चौंका देगा। यहां तक ​​कि अगर सबसे आम एपीआई कार्यक्षमता तक सीमित है, तो उस पूरे सामान को फिर से बनाने में शायद उम्र लग जाएगी ...

— Egor Hans

काफी जेवीएम है। एंटरप्राइज़ की दुनिया में सबसे अधिक देखा जाने वाला एक आईबीएम होना चाहिए जो कि, iirc, websphere के साथ बंडल किया गया है

— Adrian Shum

Answer 27

वन-लाइनर के पास कोई रास्ता नहीं है, लेकिन मुझे लगता है कि यह सबसे सरल है:

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

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

Answer 28

यहां स्ट्रीम और जावा 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());
}

Answer 29

यदि आप इसे वैधानिक रूप से करना चाहते हैं तो आप निम्नलिखित कर सकते हैं।

उदाहरण प्राकृतिक-क्रम (== Enum- क्रम) में 2 EnumSets का उपयोग करते हैं 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);
                  }}
              );

Comments

यह एक नया उद्घोषित वर्ग पैदा करेगा। अनुशंसित दृष्टिकोण नहीं!

— क्रैविमीर

Answer 30

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

}