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

Question 1

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

Question 2

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

Question 3

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

Question 4

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

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

Question 5

সাথে জাভা 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());

Question 6

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

Question 7

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]

Question 8

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

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 এর মধ্যে সাধারণ উপাদান রয়েছে।

Question 9

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

Question 10

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

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

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

Question 11

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

Question 12

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

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

Question 13

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

সমাধান:
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]

Question 14

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

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