मैं दो ArrayLists के बीच अंतर की गणना कैसे कर सकता हूं?

Question 1

मेरे पास दो ArrayLists हैं।

ArrayList A में है:

['2009-05-18','2009-05-19','2009-05-21']

ArrayList B में शामिल हैं:

['2009-05-18','2009-05-18','2009-05-19','2009-05-19','2009-05-20','2009-05-21','2009-05-21','2009-05-22']

मुझे ArrayList A और ArrayList B की तुलना करनी है। ArrayList के परिणाम में वह सूची होनी चाहिए जो ArrayList A में मौजूद नहीं है।

ArrayList परिणाम होना चाहिए:

['2009-05-20','2009-05-22']

तुलना कैसे करें?

Question 2

जावा में, आप Collectionइंटरफ़ेस की removeAllविधि का उपयोग कर सकते हैं ।

// Create a couple ArrayList objects and populate them
// with some delicious fruits.
Collection firstList = new ArrayList() {{
    add("apple");
    add("orange");
}};

Collection secondList = new ArrayList() {{
    add("apple");
    add("orange");
    add("banana");
    add("strawberry");
}};

// Show the "before" lists
System.out.println("First List: " + firstList);
System.out.println("Second List: " + secondList);

// Remove all elements in firstList from secondList
secondList.removeAll(firstList);

// Show the "after" list
System.out.println("Result: " + secondList);

उपरोक्त कोड निम्नलिखित आउटपुट का उत्पादन करेगा:

First List: [apple, orange]
Second List: [apple, orange, banana, strawberry]
Result: [banana, strawberry]

Question 3

आपके पास पहले से ही सही जवाब है। और यदि आप सूचियों (संग्रहों) के बीच अधिक जटिल और रोचक संचालन करना चाहते हैं, तो अपाचे कॉमन्स संग्रह ( कलेक्शन यूटिल्स ) का उपयोग करें यह आपको संयोजन / विघटन बनाने, चौराहे खोजने की अनुमति देता है, जांचें कि क्या एक संग्रह दूसरे और अन्य अच्छी चीजों का सबसेट है।

Question 4

जावा 8 में स्ट्रीम के साथ, यह वास्तव में बहुत सरल है। संपादित करें: धाराओं के बिना कुशल हो सकता है, कम देखें।

List<String> listA = Arrays.asList("2009-05-18","2009-05-19","2009-05-21");
List<String> listB = Arrays.asList("2009-05-18","2009-05-18","2009-05-19","2009-05-19",
                                   "2009-05-20","2009-05-21","2009-05-21","2009-05-22");

List<String> result = listB.stream()
                           .filter(not(new HashSet<>(listA)::contains))
                           .collect(Collectors.toList());

ध्यान दें कि हैश सेट केवल एक बार बनाया जाता है: विधि संदर्भ में इसकी विधि शामिल है। लैम्ब्डा के साथ ऐसा करने से सेट को एक चर में रखने की आवश्यकता होगी। एक चर बनाना एक बुरा विचार नहीं है, खासकर यदि आप इसे समझने में भद्दा या कठिन पाते हैं।

आप आसानी से इस उपयोगिता विधि (या स्पष्ट डाली) की तरह कुछ के बिना विधेय को नकार नहीं सकते हैं , क्योंकि आप सीधे नकारात्मक विधि संदर्भ को कॉल नहीं कर सकते हैं (प्रकार पहले अनुमान की आवश्यकता है)।

private static <T> Predicate<T> not(Predicate<T> predicate) {
    return predicate.negate();
}

यदि धाराओं में एक filterOutविधि या कुछ और होता है, तो यह अच्छा लगेगा।

साथ ही, @ होल्गर ने मुझे एक विचार दिया। ArrayListइसकी removeAllविधि कई निष्कासन के लिए अनुकूलित है, यह केवल एक बार अपने तत्वों को पुनर्व्यवस्थित करता है। हालांकि, यह containsदिए गए संग्रह द्वारा प्रदान की गई विधि का उपयोग करता है , इसलिए हमें उस हिस्से को अनुकूलित करने की आवश्यकता है यदि listAकुछ भी लेकिन छोटे हैं।

पहले listAऔर listBघोषित के साथ , इस समाधान को जावा 8 की आवश्यकता नहीं है और यह बहुत ही कुशल है।

List<String> result = new ArrayList(listB);
result.removeAll(new HashSet<>(listA));

Question 5

संपादित करें: मूल प्रश्न में भाषा निर्दिष्ट नहीं थी। मेरा उत्तर C # में है।

आपको इस उद्देश्य के लिए HashSet का उपयोग करना चाहिए। यदि आपको ArrayList का उपयोग करना चाहिए, तो आप निम्नलिखित एक्सटेंशन विधियों का उपयोग कर सकते हैं:

var a = arrayListA.Cast<DateTime>();
var b = arrayListB.Cast<DateTime>();    
var c = b.Except(a);

var arrayListC = new ArrayList(c.ToArray());

हैशसेट का उपयोग ...

var a = new HashSet<DateTime>(); // ...and fill it
var b = new HashSet<DateTime>(); // ...and fill it
b.ExceptWith(a); // removes from b items that are in a

Question 6

मैंने अमरूद सेट्स का उपयोग किया है ।

मापदंडों सेट और सामान्य नहीं संग्रह, लेकिन एक आसान तरीका किसी भी संग्रह से सेट बनाने के (अद्वितीय आइटम के साथ) अमरूद है ImmutableSet.copyOf (Iterable)।

(मैंने पहले इसे संबंधित / डुप्लीकेट प्रश्न पर पोस्ट किया था , लेकिन मैं इसे यहां भी कॉपी कर रहा हूं क्योंकि मुझे लगता है कि यह एक अच्छा विकल्प है जो अब तक गायब है।)

Question 7

हालाँकि यह जावा 8 में एक बहुत पुराना सवाल है, लेकिन आप ऐसा कुछ कर सकते हैं

 List<String> a1 = Arrays.asList("2009-05-18", "2009-05-19", "2009-05-21");
 List<String> a2 = Arrays.asList("2009-05-18", "2009-05-18", "2009-05-19", "2009-05-19", "2009-05-20", "2009-05-21","2009-05-21", "2009-05-22");

 List<String> result = a2.stream().filter(elem -> !a1.contains(elem)).collect(Collectors.toList());

Question 8

मुझे लगता है कि आप C # के बारे में बात कर रहे हैं। यदि हां, तो आप यह कोशिश कर सकते हैं

    ArrayList CompareArrayList(ArrayList a, ArrayList b)
    {
        ArrayList output = new ArrayList();
        for (int i = 0; i < a.Count; i++)
        {
            string str = (string)a[i];
            if (!b.Contains(str))
            {
                if(!output.Contains(str)) // check for dupes
                    output.Add(str);
            }
        }
        return output;
    }

Question 9

आप सिर्फ तार की तुलना कर रहे हैं।

ArrayList A में कुंजियों को HashTable A में कुंजी के रूप में
रखें। ArrayList B में मान को HashTable B में कुंजियों के रूप में रखें।

फिर, हैशटेबल ए में प्रत्येक कुंजी के लिए, हैशटेबल बी से इसे हटा दें यदि यह मौजूद है।

हैशटेबल बी में आपके पास जो चीजें बची हैं, वे स्ट्रिंग्स (कीज़) हैं जो एरेलेस्ट ए में मूल्य नहीं थे।

कोड के अनुरोध के जवाब में C # (3.0) उदाहरण जोड़ा गया:

List<string> listA = new List<string>{"2009-05-18","2009-05-19","2009-05-21'"};
List<string> listB = new List<string>{"2009-05-18","2009-05-18","2009-05-19","2009-05-19","2009-05-20","2009-05-21","2009-05-21","2009-05-22"};

HashSet<string> hashA = new HashSet<string>();
HashSet<string> hashB = new HashSet<string>();

foreach (string dateStrA in listA) hashA.Add(dateStrA);
foreach (string dateStrB in listB) hashB.Add(dateStrB);

foreach (string dateStrA in hashA)
{
    if (hashB.Contains(dateStrA)) hashB.Remove(dateStrA);
}

List<string> result = hashB.ToList<string>();

Question 10

हाय इस वर्ग का उपयोग करें यह दोनों सूचियों की तुलना करेगा और दोनों सूची को बिल्कुल बेमेल / डब्ल्यू दिखाता है।

import java.util.ArrayList;
import java.util.List;


public class ListCompare {

    /**
     * @param args
     */
    public static void main(String[] args) {
        List<String> dbVinList;
        dbVinList = new ArrayList<String>();
        List<String> ediVinList;
        ediVinList = new ArrayList<String>();           

        dbVinList.add("A");
        dbVinList.add("B");
        dbVinList.add("C");
        dbVinList.add("D");

        ediVinList.add("A");
        ediVinList.add("C");
        ediVinList.add("E");
        ediVinList.add("F");
        /*ediVinList.add("G");
        ediVinList.add("H");
        ediVinList.add("I");
        ediVinList.add("J");*/  

        List<String> dbVinListClone = dbVinList;
        List<String> ediVinListClone = ediVinList;

        boolean flag;
        String mismatchVins = null;
        if(dbVinListClone.containsAll(ediVinListClone)){
            flag = dbVinListClone.removeAll(ediVinListClone);   
            if(flag){
                mismatchVins = getMismatchVins(dbVinListClone);
            }
        }else{
            flag = ediVinListClone.removeAll(dbVinListClone);
            if(flag){
                mismatchVins = getMismatchVins(ediVinListClone);
            }
        }
        if(mismatchVins != null){
            System.out.println("mismatch vins : "+mismatchVins);
        }       

    }

    private static String getMismatchVins(List<String> mismatchList){
        StringBuilder mismatchVins = new StringBuilder();
        int i = 0;
        for(String mismatch : mismatchList){
            i++;
            if(i < mismatchList.size() && i!=5){
                mismatchVins.append(mismatch).append(",");  
            }else{
                mismatchVins.append(mismatch);
            }
            if(i==5){               
                break;
            }
        }
        String mismatch1;
        if(mismatchVins.length() > 100){
            mismatch1 = mismatchVins.substring(0, 99);
        }else{
            mismatch1 = mismatchVins.toString();
        }       
        return mismatch1;
    }

}

Question 11

Arraylist के साथ यह काम भी करें

    // Create a couple ArrayList objects and populate them
    // with some delicious fruits.
    ArrayList<String> firstList = new ArrayList<String>() {/**
         * 
         */
        private static final long serialVersionUID = 1L;

    {
        add("apple");
        add("orange");
        add("pea");
    }};

    ArrayList<String> secondList = new ArrayList<String>() {

    /**
         * 
         */
        private static final long serialVersionUID = 1L;

    {
        add("apple");
        add("orange");
        add("banana");
        add("strawberry");
    }};

    // Show the "before" lists
    System.out.println("First List: " + firstList);
    System.out.println("Second List: " + secondList);

    // Remove all elements in firstList from secondList
    secondList.removeAll(firstList);

    // Show the "after" list
    System.out.println("Result: " + secondList);