जावा दो सूचियों की तुलना करें

Question 1

मेरी दो सूची हैं (जावा सूची नहीं, आप दो कॉलम कह सकते हैं)

उदाहरण के लिए

**List 1**            **Lists 2**
  milan                 hafil
  dingo                 iga
  iga                   dingo
  elpha                 binga
  hafil                 mike
  meat                  dingo
  milan
  elpha
  meat
  iga                   
  neeta.peeta

मुझे एक विधि पसंद है जो कि कई तत्व समान हैं। इस उदाहरण के लिए यह 3 होना चाहिए और यह मुझे सूची और अलग-अलग मूल्यों के समान मूल्यों को भी वापस करना चाहिए।

क्या मुझे हैशमैप का उपयोग करना चाहिए यदि हां तो अपना परिणाम प्राप्त करने के लिए क्या तरीका है?

कृपया सहायता कीजिए

पुनश्च: यह एक स्कूल असाइनमेंट नहीं है :) इसलिए यदि आप मेरा मार्गदर्शन करते हैं तो यह पर्याप्त होगा

Question 2

संपादित करें

यहाँ दो संस्करण हैं। एक का उपयोग करना ArrayListऔर दूसरा उपयोग करनाHashSet

उनकी तुलना करें और अपना खुद का संस्करण बनाएं , जब तक कि आपको वह न मिले जो आपको चाहिए।

यह कवर करने के लिए पर्याप्त होना चाहिए:

पुनश्च: यह एक स्कूल असाइनमेंट नहीं है :) इसलिए यदि आप मेरा मार्गदर्शन करते हैं तो यह पर्याप्त होगा

आपके सवाल का हिस्सा है।

मूल उत्तर के साथ जारी रखना:

आप एक java.util.Collection और / या इसके java.util.ArrayListलिए उपयोग कर सकते हैं ।

RetainAll विधि निम्नलिखित है:

इस संग्रह में केवल वे तत्व हैं जो निर्दिष्ट संग्रह में निहित हैं

यह नमूना देखें:

import java.util.Collection;
import java.util.ArrayList;
import java.util.Arrays;

public class Repeated {
    public static void main( String  [] args ) {
        Collection listOne = new ArrayList(Arrays.asList("milan","dingo", "elpha", "hafil", "meat", "iga", "neeta.peeta"));
        Collection listTwo = new ArrayList(Arrays.asList("hafil", "iga", "binga", "mike", "dingo"));

        listOne.retainAll( listTwo );
        System.out.println( listOne );
    }
}

संपादित करें

दूसरे भाग (समान मान) के लिए आप निष्कासन विधि का उपयोग कर सकते हैं :

इस संग्रह के उन सभी तत्वों को हटा देता है जो निर्दिष्ट संग्रह में समाहित हैं।

यह दूसरा संस्करण आपको समान मूल्यों और बार-बार हैंडल करने (उन्हें छोड़ने से) को देता है।

इस बार Collectionएक के Setबजाय हो सकता है List(अंतर यह है, सेट दोहराया मूल्यों की अनुमति नहीं देता है)

import java.util.Collection;
import java.util.HashSet;
import java.util.Arrays;

class Repeated {
      public static void main( String  [] args ) {

          Collection<String> listOne = Arrays.asList("milan","iga",
                                                    "dingo","iga",
                                                    "elpha","iga",
                                                    "hafil","iga",
                                                    "meat","iga", 
                                                    "neeta.peeta","iga");

          Collection<String> listTwo = Arrays.asList("hafil",
                                                     "iga",
                                                     "binga", 
                                                     "mike", 
                                                     "dingo","dingo","dingo");

          Collection<String> similar = new HashSet<String>( listOne );
          Collection<String> different = new HashSet<String>();
          different.addAll( listOne );
          different.addAll( listTwo );

          similar.retainAll( listTwo );
          different.removeAll( similar );

          System.out.printf("One:%s%nTwo:%s%nSimilar:%s%nDifferent:%s%n", listOne, listTwo, similar, different);
      }
}

आउटपुट:

$ java Repeated
One:[milan, iga, dingo, iga, elpha, iga, hafil, iga, meat, iga, neeta.peeta, iga]

Two:[hafil, iga, binga, mike, dingo, dingo, dingo]

Similar:[dingo, iga, hafil]

Different:[mike, binga, milan, meat, elpha, neeta.peeta]

अगर यह आपकी जरूरत के अनुसार नहीं करता है, तो यह आपको एक अच्छी शुरुआत देता है ताकि आप यहां से संभाल सकें।

पाठक के लिए प्रश्न: आप सभी दोहराया मूल्यों को कैसे शामिल करेंगे?

Question 3

आप कोशिश कर सकते हैं intersection()और subtract()तरीकों से CollectionUtils।

intersection()विधि आपको एक संग्रह देती है जिसमें सामान्य तत्व होते हैं और यह subtract()विधि आपको सभी असामान्य चीजें देती है।

उन्हें समान तत्वों का भी ध्यान रखना चाहिए

Question 4

क्या ये वास्तव में सूचियाँ हैं (डुप्लिकेट के साथ) का आदेश दिया गया है, या क्या वे सेट किए गए हैं (अनियंत्रित, कोई डुप्लिकेट नहीं)?

क्योंकि अगर यह बाद का है, तो आप java.util.HashSet<E>सुविधाजनक का उपयोग करके अपेक्षित रैखिक समय में इसका उपयोग, कह सकते हैं और कर सकते हैं retainAll।

    List<String> list1 = Arrays.asList(
        "milan", "milan", "iga", "dingo", "milan"
    );
    List<String> list2 = Arrays.asList(
        "hafil", "milan", "dingo", "meat"
    );

    // intersection as set
    Set<String> intersect = new HashSet<String>(list1);
    intersect.retainAll(list2);
    System.out.println(intersect.size()); // prints "2"
    System.out.println(intersect); // prints "[milan, dingo]"

    // intersection/union as list
    List<String> intersectList = new ArrayList<String>();
    intersectList.addAll(list1);
    intersectList.addAll(list2);
    intersectList.retainAll(intersect);
    System.out.println(intersectList);
    // prints "[milan, milan, dingo, milan, milan, dingo]"

    // original lists are structurally unmodified
    System.out.println(list1); // prints "[milan, milan, iga, dingo, milan]"
    System.out.println(list2); // prints "[hafil, milan, dingo, meat]"

Question 5

जावा 8 हटाने का उपयोग करना

public int getSimilarItems(){
    List<String> one = Arrays.asList("milan", "dingo", "elpha", "hafil", "meat", "iga", "neeta.peeta");
    List<String> two = new ArrayList<>(Arrays.asList("hafil", "iga", "binga", "mike", "dingo")); //Cannot remove directly from array backed collection
    int initial = two.size();

    two.removeIf(one::contains);
    return initial - two.size();
}

Question 6

यदि आप दो संग्रह की समानता का परीक्षण करने के लिए एक आसान तरीका ढूंढ रहे हैं, तो आप उपयोग कर सकते हैं org.apache.commons.collections.CollectionUtils.isEqualCollection, जो क्रम की परवाह किए बिना दो संग्रह की तुलना करता है।

Question 7

सभी दृष्टिकोणों में से, मुझे लगता org.apache.commons.collections.CollectionUtils#isEqualCollectionहै कि सबसे अच्छा तरीका है। ये रहे कारण -

मुझे किसी अतिरिक्त सूची की घोषणा करने की आवश्यकता नहीं है
मैं इनपुट सूचियों को परिवर्तित नहीं कर रहा हूं
यह बहुत कुशल है। यह O (N) जटिलता में समानता की जांच करता है।

यदि यह apache.commons.collectionsनिर्भरता के रूप में संभव नहीं है , तो मैं दक्षता के कारण सूची की समानता की जांच करने के लिए एल्गोरिथ्म को लागू करने की सिफारिश करूंगा।

Question 8

सरल उपाय: -

    List<String> list = new ArrayList<String>(Arrays.asList("a", "b", "d", "c"));
    List<String> list2 = new ArrayList<String>(Arrays.asList("b", "f", "c"));

    list.retainAll(list2);
    list2.removeAll(list);
    System.out.println("similiar " + list);
    System.out.println("different " + list2);

आउटपुट: -

similiar [b, c]
different [f]

Question 9

मान लिया hash1औरhash2

List< String > sames = whatever
List< String > diffs = whatever

int count = 0;
for( String key : hash1.keySet() )
{
   if( hash2.containsKey( key ) ) 
   {
      sames.add( key );
   }
   else
   {
      diffs.add( key );
   }
}

//sames.size() contains the number of similar elements.

Question 10

मुझे सूची में सूची तुलना का एक बहुत ही मूल उदाहरण मिला। तुलना करें यह उदाहरण पहले आकार की पुष्टि करता है और फिर एक सूची के विशेष तत्व की उपलब्धता की दूसरे में जांच करता है।

Question 11

public static boolean compareList(List ls1, List ls2){
    return ls1.containsAll(ls2) && ls1.size() == ls2.size() ? true :false;
     }

public static void main(String[] args) {

    ArrayList<String> one = new ArrayList<String>();
    one.add("one");
    one.add("two");
    one.add("six");

    ArrayList<String> two = new ArrayList<String>();
    two.add("one");
    two.add("six");
    two.add("two");

    System.out.println("Output1 :: " + compareList(one, two));

    two.add("ten");

    System.out.println("Output2 :: " + compareList(one, two));
  }