দুটি তালিকায় সাধারণ উপাদান


99

আমার ArrayListতিনটি পূর্ণসংখ্যার দুটি জিনিস রয়েছে। আমি দুটি তালিকার সাধারণ উপাদানগুলি ফেরত দেওয়ার একটি উপায় খুঁজতে চাই। কারও কি ধারণা আছে যে আমি কীভাবে এটি অর্জন করতে পারি?

উত্তর:


164

ব্যবহার 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.

রিটেইনএল নতুন তালিকা ফিরিয়ে দেয়? আমি টেম্পললিস্ট.এডএলএল (listA.retainAll (listB)) এর মতো একটি নতুন তালিকার কাছে সংরক্ষণের আউটপুট সংরক্ষণ করার চেষ্টা করেছি; তবে এটি কাজ করে না
জেনাইটিস

4
পিছনের লিঙ্কে Collection#retainAll()এবং কোড স্নিপেটে দেওয়া মন্তব্যে যেমন উত্তর দেওয়া হয়েছে , না, তা হয় না। আপনি যে পদ্ধতিতে পদ্ধতিটি কল করছেন সেই তালিকায় পরিবর্তনগুলি প্রতিফলিত হবে।
বালুসসি

সমস্যাটি হল যে তালিকাটি সাধারণ আকারটি 3 মাপের সাথে সূচনা করা হয়, তারপরে আপনি কেবলমাত্র একটি বা দুটি উপাদান দিয়ে ফিরে তার আকার পরিবর্তন করার চেষ্টা করেন। আপনার পরামর্শ অনুসারে আমি চেষ্টা করে দেখি এবং এটি আমাকে সীমার ব্যতিক্রম থেকে সরিয়ে দেয়।
জেনাইটিস

এই পদ্ধতির সাথে, আমি উপাদানগুলির সংঘটন সংখ্যার সাথে মিল করতে পারব না ....... উদাহরণস্বরূপ বলুন তালিকার জন্য A 2,3,5 B এবং তালিকা বি {5 5}, যদি আমি তালিকা বি.রেইনআল (listA) করব , লিস্টবিতে এখন {5,5} হবে ...... আমি তালিকার এ এবং লিস্টবি কে {5 as হিসাবে তুলনা করার পরে আমার চূড়ান্ত ফলাফল চাই} দয়া করে পরামর্শ দিন আমরা কীভাবে এটি অর্জন করতে পারি
NanceY

4
সংগ্রহের অবজেক্টের দুর্বল পছন্দ দিয়ে করা হলে এটি একটি অসমর্থিত অপারেশন এক্সেক্সশন ফেলে দিতে পারে। অ্যারেলিস্ট সহ উপরের উদাহরণটি অবশ্যই কাজ করে।
ডেমোঙ্গোলেম

39

আপনি আপনার 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]

6
নোট করুন যে এইভাবে পরিবর্তনগুলিও প্রতিফলিত হয় l2। আপনি সম্ভবত List<Integer> l3 = new ArrayList<Integer>(l2);পরিবর্তে বলতে চেয়েছিলেন।
বালুসসি

যদি এল 1 এর 2 টি উপাদান থাকে এবং এল 2 এর সাথে একই উপাদানটির 3 থাকে তবে সমস্যাটি একটু মেসির হয়ে যায়। ধরে রাখুন সমস্ত রিটার্ন 3 টি l3 তে রাখে যদিও এটি কেবলমাত্র l1 এ দুবার অন্তর্ভুক্ত থাকে।
ডেমোঙ্গোলেম

35

চাকা পুনরুদ্ধার কেন? সাধারণ সংগ্রহগুলি ব্যবহার করুন :

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

এটি একটি দুর্দান্ত সমাধান, যদিও আমি উপরে উল্লেখ করেছি যে এটির retainAll()পুনরাবৃত্তি উপাদানগুলির চেয়ে আলাদা আচরণ রয়েছে। সুতরাং সম্ভবত আপনি সঠিকভাবে সমস্যা সমাধান করেন এবং এর মধ্যে একটি সঠিক এবং তার মধ্যে একটি ভুল approach
ডেমোঙ্গোলেম

19

সাথে জাভা 8 এর Stream.filter()পদ্ধতিটি ব্যবহার করে 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());

4
ধারণ করে দেখে মনে হচ্ছে এটি কোনও ও (এন) অপারেশন হবে, যাকে এন টাইম বলা হবে, যদি না সংকলক কিছু চালাক করে না। উপরেরটি লিনিয়ার বা চতুষ্কোণ সময়ে চালিত কিনা তা কি কেউ জানেন?
Regorsmitz

4
এটি একটি * এন অপারেশন হবে!
লক্ষ্মীকান্ত দেশপাণ্ডে

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

যদিও এই কোডটি প্রশ্নের উত্তর দিতে পারে, কীভাবে এবং / বা কেন এটি সমস্যার সমাধান করে তা সম্পর্কিত অতিরিক্ত প্রসঙ্গ সরবরাহ করলে উত্তরের দীর্ঘমেয়াদী মান উন্নত হবে।
মাইকেল পার্কার

5
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]


-Improvementwe তালিকা <Integer> listA = asList (1, 5, 3, 4) হিসাবে তালিকাটিকে সংজ্ঞায়িত করতে পারে; তালিকা <Integer> listB = asList (1, 5, 6, 7);
রাজীব রঞ্জন

4

"রিটেনএল" পদ্ধতিটি ব্যবহার করে আপনি দুটি তালিকার মধ্যে সাধারণ উপাদানগুলি পেতে পারেন। এই পদ্ধতিতে এটি প্রয়োগ হয় এমন তালিকা থেকে সমস্ত মেলে না এমন উপাদানগুলি সরিয়ে ফেলবে।

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]

দ্রষ্টব্য: ধরে রাখার পরে সমস্ত তালিকায় প্রয়োগ হওয়ার পরে, তালিকায় তালিকা এবং তালিকা 1 এর মধ্যে সাধারণ উপাদান রয়েছে।



4

দুটি তালিকা বিবেচনা করুন L1 উত্তর এল 2

জাভা 8 ব্যবহার করে আমরা এটি সহজেই খুঁজে পেতে পারি

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


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

1

যদি আপনি নিজে এটি করতে চান ..

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

4
ওপিতে কোন উপাদানগুলি সাধারণ ছিল তা সন্ধানের জন্য একটি উপায় জিজ্ঞাসা করছিল, কতগুলি সাধারণ উপাদান নেই।
ব্রেন্ডন ডুগান

@ ব্রেন্ডনডুগান - এই কোডটি এটাই করে। তালিকায় commonsসাধারণ উপাদান রয়েছে। দ্বিতীয় জন্য লুপ এগুলি কনসোলে মুদ্রণ করে। কোডটি সাধারণ উপাদানগুলি কোথায় গণনা করছে তা আমি দেখতে পাচ্ছি না।
অজয় ভাটিয়া

@ অজয়ভাটিয়া - আমি যখন আমার মন্তব্য করেছি (2013 সালে) কোডটি কেবলমাত্র সাধারণ উপাদানগুলির একটি গণনা ফিরিয়েছিল।
ব্রেন্ডন ডুগান

@ ব্র্যান্ডনডুগান ওহ, ঠিক আছে এর জন্যে দুঃখিত. আমার মনে রাখা উচিত যে উত্তরটি জায়গায় সম্পাদনা করা যেতে পারে তবে মন্তব্যগুলি সাধারণত কালানুক্রমিকভাবে রেখে যায় :-)
অজয় ভাটিয়া

0

উপরের কিছু উত্তর একই রকম তবে একই নয় তবে এটি একটি নতুন উত্তর হিসাবে পোস্ট করা।

সমাধান:
1. উপাদানগুলি মুছে
ফেলার জন্য হ্যাশসেট ব্যবহার করুন 2. হ্যাশসেটে তালিকার 1 এর সমস্ত উপাদান যুক্ত করুন list. তালিকা 2
পুনরাবৃত্তি করুন এবং একটি হ্যাশসেট থেকে উপাদানগুলি সরান যা তালিকা 2 ==> যা উভয় তালিকায় রয়েছে 1 এবং তালিকা
2 4 এখন হ্যাশসেটের উপর পুনরাবৃত্তি করুন এবং তালিকা 1 থেকে উপাদানগুলি সরিয়ে দিন (যেহেতু আমরা তালিকা 1 এর সমস্ত উপাদান সেট করার জন্য যুক্ত করেছি), শেষ পর্যন্ত তালিকা 1 তে সমস্ত সাধারণ উপাদান রয়েছে
দ্রষ্টব্য: আমরা তালিকা 2 এর সমস্ত উপাদান যুক্ত করতে পারি এবং তৃতীয় পুনরাবৃত্তিতে আমাদের উপাদানগুলি অপসারণ করা উচিত list2।

সময়ের জটিলতা: ও (এন)
স্পেস জটিলতা: ও (এন)

কোড:

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]

0

কোডের নীচে তালিকার সাধারণ উপাদানগুলি সরান

List<String> result =  list1.stream().filter(item-> !list2.contains(item)).collect(Collectors.toList());

সাধারণ উপাদানগুলি পুনরুদ্ধার করুন

List<String> result = list1.stream()
                .distinct()
                .filter(list::contains)
                .collect(Collectors.toList());
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.