दो सूचियों में आम तत्व

Question

मेरे पास ArrayListतीन पूर्णांक वाले दो ऑब्जेक्ट हैं। मैं दो सूचियों के सामान्य तत्वों को लौटाने का तरीका खोजना चाहता हूं। किसी को भी एक विचार है कि मैं इसे कैसे प्राप्त कर सकता हूं?

Answer 1

का उपयोग करें Collection#retainAll()।

listA.retainAll(listB);
// listA now contains only the elements which are also contained in listB.

यदि आप इससे बचना चाहते हैं कि परिवर्तन प्रभावित हो रहे हैं listA, तो आपको एक नया निर्माण करने की आवश्यकता है।

List<Integer> common = new ArrayList<Integer>(listA);
common.retainAll(listB);
// common now contains only the elements which are contained in listA and listB.

Comments

RetainAll एक नई सूची देता है? मैंने एक नई सूची sth के आउटपुट को स्टोर करने की कोशिश की, जैसे कि tempList.addAll (listA.retainAll (listB)); लेकिन यह काम नहीं करता है

— zenitis

जैसा कि पीछे के लिंक Collection#retainAll()में और कोड स्निपेट में टिप्पणियों का जवाब दिया गया है , नहीं, यह नहीं है। जिस सूची में आप विधि को कॉल कर रहे हैं, उसमें परिवर्तन दिखाई देते हैं।

— बालुसक

समस्या यह है कि सूची सामान्य का आकार 3 से आरंभ किया जाता है, तो आप केवल एक या दो तत्वों को वापस करके इसके आकार को बदलने का प्रयास करते हैं। मैं कोशिश करता हूं कि आप क्या सुझाव देते हैं और यह मुझे सीमा अपवाद से बाहर लौटाता है।

— जेनाइटिस

इस दृष्टिकोण में, मैं तत्व की घटना संख्या से मेल नहीं खा पाऊंगा ....... उदाहरण के लिए कहो सूची {2,3,5} और सूची {5 5}, अगर मैं सूची करूंगा। श्रेयांस (सूची) , listB में अब {5,5} होगा। मैं listA और listB को {5} के रूप में तुलना करने के बाद अपना अंतिम परिणाम चाहता हूं। कृपया सुझाव है कि कैसे हम इस लक्ष्य को हासिल कर सकते हैं

— नैंसी

यदि संग्रह ऑब्जेक्ट के खराब विकल्प के साथ किया जाता है, तो यह एक UnsupportedOperationException को फेंक सकता है। ArrayList के साथ उपरोक्त उदाहरण बेशक काम करता है।

— डेमोन्गोलम

Answer 2

आप अपनी ArrayListवस्तुओं के साथ सेट चौराहे संचालन का उपयोग कर सकते हैं ।

कुछ इस तरह:

List<Integer> l1 = new ArrayList<Integer>();

l1.add(1);
l1.add(2);
l1.add(3);

List<Integer> l2= new ArrayList<Integer>();
l2.add(4);
l2.add(2);
l2.add(3);

System.out.println("l1 == "+l1);
System.out.println("l2 == "+l2);

List<Integer> l3 = new ArrayList<Integer>(l2);
l3.retainAll(l1);

    System.out.println("l3 == "+l3);

अब, के l3बीच l1और केवल आम तत्व होना चाहिए l2।

CONSOLE OUTPUT
l1 == [1, 2, 3]
l2 == [4, 2, 3]
l3 == [2, 3]

Comments

ध्यान दें कि इस तरह से परिवर्तन भी परिलक्षित होते हैं l2। आप शायद List<Integer> l3 = new ArrayList<Integer>(l2);इसके बजाय कहने के लिए थे ।

— बालुसक

समस्या थोड़ी गड़बड़ हो जाती है अगर कहते हैं कि एल 1 में एक तत्व के 2 हैं और एल 2 में उसी तत्व के 3 थे। रिटेल ऑल रिटर्न उस तत्व के 3 को l3 में रखता है, भले ही यह केवल l1 में दो बार निहित हो।

— डिमॉन्गोलेम

Answer 3

पहिया को क्यों मजबूत करें? कॉमन्स संग्रह का उपयोग करें :

CollectionUtils.intersection(java.util.Collection a, java.util.Collection b)

Comments

यह एक महान समाधान है, हालांकि जैसा कि मैंने ऊपर उल्लेख किया है, इसमें retainAll()दोहराया तत्वों की तुलना में अलग व्यवहार है । तो संभावना है कि एक सही है और एक समस्या के आधार पर गलत है कि आप समस्या का सामना कैसे कर रहे हैं।

— डेमॉन्गोलम

Answer 4

के Stream.filter()साथ संयोजन में जावा 8 की विधि का उपयोग करना List.contains():

import static java.util.Arrays.asList;
import static java.util.stream.Collectors.toList;

/* ... */

List<Integer> list1 = asList(1, 2, 3, 4, 5);
List<Integer> list2 = asList(1, 3, 5, 7, 9);

List<Integer> common = list1.stream().filter(list2::contains).collect(toList());

Comments

इसमें ऐसा लगता है कि यह एक O (n) ऑपरेशन होगा, जिसे n बार कहा जाएगा, जब तक कंपाइलर कुछ चालाक नहीं करता। क्या किसी को पता है कि ऊपर रैखिक या द्विघात समय में चलता है?

— Regorsmitz

यह एक * n ऑपरेशन होगा!

— लक्ष्मीकांत देशपांडे

Answer 5

            List<String> lista =new ArrayList<String>();
            List<String> listb =new ArrayList<String>();

            lista.add("Isabella");
            lista.add("Angelina");
            lista.add("Pille");
            lista.add("Hazem");

            listb.add("Isabella");
            listb.add("Angelina");
            listb.add("Bianca");

            // Create an aplusb list which will contain both list (list1 and list2) in which common element will occur twice 
            List<String> listapluslistb =new ArrayList<String>(lista);    
            listapluslistb.addAll(listb);

            // Create an aunionb set which will contain both list (list1 and list2) in which common element will occur once
            Set<String> listaunionlistb =new HashSet<String>(lista);
            listaunionlistb.addAll(listb);

            for(String s:listaunionlistb)
            {
                listapluslistb.remove(s);
            }
            System.out.println(listapluslistb);

Comments

इस कोड को इस सवाल का जवाब कर सकते हैं, के बारे में अतिरिक्त संदर्भ प्रदान करने के लिए कैसे और / या क्यों यह हल करती है समस्या जवाब की दीर्घकालिक मूल्य में सुधार होगा।

— माइकल पार्कर

Answer 6

List<Integer> listA = new ArrayList<>();
    listA.add(1);
    listA.add(5);
    listA.add(3);
    listA.add(4);   

List<Integer> listB = new ArrayList<>();
    listB.add(1);
    listB.add(5);
    listB.add(6);
    listB.add(7);
System.out.println(listA.stream().filter(listB::contains).collect(Collectors.toList()));


Java 1.8 Stream API Solutions

आउटपुट [1, 5]

Comments

-Improvementwe सूची को सूची <Integer> listA = asList (1, 5, 3, 4) के रूप में परिभाषित कर सकता है; सूची <Integer> listB = asList (1, 5, 6, 7);

— राजीव रंजन

Answer 7

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

Ex.: list.retainAll(list1);

सूची से इस मामले में, वे सभी तत्व जो सूची 1 में नहीं हैं, उन्हें हटा दिया जाएगा और केवल वे ही शेष रहेंगे जो सूची और सूची 1 के बीच सामान्य हैं।

List<Integer> list = new ArrayList<>();
list.add(10);
list.add(13);
list.add(12);
list.add(11);

List<Integer> list1 = new ArrayList<>();
list1.add(10);
list1.add(113);
list1.add(112);
list1.add(111);
//before retainAll
System.out.println(list);
System.out.println(list1);
//applying retainAll on list
list.retainAll(list1);
//After retainAll
System.out.println("list::"+list);
System.out.println("list1::"+list1);

आउटपुट:

[10, 13, 12, 11]
[10, 113, 112, 111]
list::[10]
list1::[10, 113, 112, 111]

नोट: सूची पर लागू किया गयाAllAAll के बाद, सूची में सूची और list1 के बीच सामान्य तत्व शामिल हैं।

Answer 8

public <T> List<T> getIntersectOfCollections(Collection<T> first, Collection<T> second) {
        return first.stream()
                .filter(second::contains)
                .collect(Collectors.toList());
    }

Answer 9

    // Create two collections:
    LinkedList<String> listA =  new LinkedList<String>();
    ArrayList<String> listB =  new ArrayList<String>();

    // Add some elements to listA:
    listA.add("A");
    listA.add("B");
    listA.add("C");
    listA.add("D");

    // Add some elements to listB:
    listB.add("A");
    listB.add("B");
    listB.add("C");

    // use 

    List<String> common = new ArrayList<String>(listA);
    // use common.retainAll

    common.retainAll(listB);

    System.out.println("The common collection is : " + common);

Answer 10

दो सूची L1 ans L2 पर विचार करें

Java8 का उपयोग करके हम आसानी से इसका पता लगा सकते हैं

L1.stream().filter(L2::contains).collect(Collectors.toList())

Answer 11

मामले में आप इसे खुद करना चाहते हैं ..

List<Integer> commons = new ArrayList<Integer>();

for (Integer igr : group1) {
    if (group2.contains(igr)) {
        commons.add(igr);
    }
}

System.out.println("Common elements are :: -");
for (Integer igr : commons) {
    System.out.println(" "+igr);
}

Comments

ओपी एक रास्ता खोजने के लिए कह रहा था कि कौन से तत्व सामान्य थे, न कि कितने सामान्य तत्व हैं।

— ब्रेंडन डुगन

@BrendonDugan - यह कोड क्या करता है। सूची commonsमें सामान्य तत्व शामिल हैं। दूसरा फॉर-लूप उन्हें कंसोल पर प्रिंट करता है। मैं यह नहीं देखता कि कोड आम तत्वों की गिनती कहां कर रहा है।

— अजोना भाटिया

@AjoyBhatia - जब मैंने अपनी टिप्पणी की (2013 में) तो कोड में केवल सामान्य तत्वों की गिनती थी।

— ब्रेंडन दुगन

@ ब्रेंडनडूगन ओह, ठीक है। उसके लिए माफ़ करना। मुझे यह ध्यान रखना चाहिए कि उत्तर को जगह में संपादित किया जा सकता है, लेकिन आमतौर पर टिप्पणियों को कालानुक्रमिक क्रम में छोड़ दिया जाता है :-)

— अजोय भाटिया

Answer 12

ऊपर दिए गए कुछ उत्तर समान हैं लेकिन नए उत्तर के रूप में इसे पोस्ट करना समान नहीं है।

समाधान:
1.
उन तत्वों को रखने के लिए हैशसेट का उपयोग करें जिन्हें निकालने की आवश्यकता है । सूची 1 के सभी तत्वों को हैशसेट में जोड़ें
। पुनरावृति सूची 2 और हैशसेट से उन तत्वों को हटा दें जो सूची 2 ==> में मौजूद हैं जो
1 और सूची 2 दोनों में मौजूद हैं। अब HashSet पर पुनरावृति करें और सूची 1 से तत्वों को हटा दें (क्योंकि हमने सूची 1 के सभी तत्वों को सेट करने के लिए जोड़ा है), आखिरकार, सूची 1 में सभी सामान्य तत्व हैं
नोट: हम सूची 2 के सभी तत्वों को जोड़ सकते हैं और एक 3 पुनरावृत्ति में, हमें तत्वों को जोड़ना चाहिए। List2।

समय की जटिलता: O (n)
अंतरिक्ष जटिलता: O (n)

कोड:

import com.sun.tools.javac.util.Assert;
import org.apache.commons.collections4.CollectionUtils;

    List<Integer> list1 = new ArrayList<>();
    list1.add(1);
    list1.add(2);
    list1.add(3);
    list1.add(4);
    list1.add(5);

    List<Integer> list2 = new ArrayList<>();
    list2.add(1);
    list2.add(3);
    list2.add(5);
    list2.add(7);
    Set<Integer> toBeRemoveFromList1 = new HashSet<>(list1);
    System.out.println("list1:" + list1);
    System.out.println("list2:" + list2);
    for (Integer n : list2) {
        if (toBeRemoveFromList1.contains(n)) {
            toBeRemoveFromList1.remove(n);
        }
    }
    System.out.println("toBeRemoveFromList1:" + toBeRemoveFromList1);
    for (Integer n : toBeRemoveFromList1) {
        list1.remove(n);
    }
    System.out.println("list1:" + list1);
    System.out.println("collectionUtils:" + CollectionUtils.intersection(list1, list2));
    Assert.check(CollectionUtils.intersection(list1, list2).containsAll(list1));

उत्पादन:

list1:[1, 2, 3, 4, 5]
list2:[1, 3, 5, 7]
toBeRemoveFromList1:[2, 4]
list1:[1, 3, 5]
collectionUtils:[1, 3, 5]