यह पता लगाने का सरल तरीका है कि क्या दो अलग-अलग सूचियों में समान तत्व हैं?

Question

यदि दो सूचियों में बिल्कुल समान तत्व हों, तो मानक जावा पुस्तकालयों में यह पता लगाने का सबसे सरल तरीका क्या है?

इससे कोई फर्क नहीं पड़ता कि दो सूचियाँ एक ही उदाहरण हैं या नहीं, और सूची के प्रकार के पैरामीटर अलग-अलग होने पर यह बात नहीं होनी चाहिए।

जैसे

List list1
List<String> list2; 
// ... construct etc

list1.add("A");
list2.add("A"); 
// the function, given these two lists, should return true

शायद मुझे पता है कि चेहरे में मुझे घूर कुछ है :-)

---

संपादित करें: स्पष्ट करने के लिए, मैं क्रम में समान तत्वों और तत्वों की संख्या की तलाश कर रहा था।

Comments

क्या तत्वों को एक ही क्रम में होना चाहिए?

— माइकल मायर्स

यह आपको कभी भी प्रभावित नहीं कर सकता है, लेकिन सावधान रहें कि हाइबरनेट लगातार सेट कभी-कभी समान अनुबंध का सम्मान नहीं करते हैं - खोज देखें खुलता है। स्रोत

— ।atlassian.com

Answer 1

यदि आप आदेश की परवाह करते हैं, तो बस बराबर विधि का उपयोग करें:

list1.equals(list2)

जावदोक से:

समानता के लिए इस सूची के साथ निर्दिष्ट ऑब्जेक्ट की तुलना करता है। यह सच है कि अगर और केवल निर्दिष्ट ऑब्जेक्ट भी एक सूची है, तो दोनों सूचियों का आकार समान है, और दो सूचियों में सभी संगत जोड़े समान हैं। (दो तत्व e1 और e2 समान हैं यदि (e1 == null? E2 == null: e1.equals (e2))। दूसरे शब्दों में, दो सूचियों को समान रूप से परिभाषित किया जाता है यदि उनमें समान तत्व समान क्रम में हों। । यह परिभाषा सुनिश्चित करती है कि सूची इंटरफ़ेस के विभिन्न कार्यान्वयनों में समान पद्धति ठीक से काम करती है।

यदि आप ऑर्डर की स्वतंत्र जांच करना चाहते हैं, तो आप सभी तत्वों को सेट पर कॉपी कर सकते हैं और परिणामस्वरूप सेट पर बराबर का उपयोग कर सकते हैं:

public static <T> boolean listEqualsIgnoreOrder(List<T> list1, List<T> list2) {
    return new HashSet<>(list1).equals(new HashSet<>(list2));
}

इस दृष्टिकोण की एक सीमा यह है कि यह न केवल आदेश की उपेक्षा करता है, बल्कि नकली तत्वों की आवृत्ति भी है। उदाहरण के लिए, यदि list1["ए", "बी", "ए"] और list2[[ए "," बी "," ए "] था।Set दृष्टिकोण है तो उन्हें समान माना जाएगा।

यदि आपको ऑर्डर करने के लिए असंवेदनशील होने की आवश्यकता है, लेकिन डुप्लिकेट की आवृत्ति के प्रति आप या तो संवेदनशील हो सकते हैं:

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

Comments

यदि आप ऑर्डर से स्वतंत्र जांचना चाहते हैं, तो क्या आप इसमें शामिल नहीं हो सकते?

— लाज

मुझे इसमें शामिल सभी विवरणों के कार्यान्वयन के बारे में नहीं पता है, लेकिन ऐसा लगता है कि यह खराब हो सकता है। यदि सभी कॉल में सम्‍मिलित हैं () बार-बार, आपके पास O (n ^ 2) alg होगा। सेट समग्र होना चाहिए O (nlogn)

— Tom

वास्तव में, यदि सेट केवल O (nlogn) होने जा रहे हैं, तो एक सूची पर एक अन्य दृष्टिकोण संग्रह (Sort) कॉल करना है, और फिर बराबर का उपयोग करना है। यदि आप आदेश को संरक्षित करना चाहते हैं, तो आपको सूची की प्रतिलिपि बनाने की आवश्यकता होगी, और यह महंगा हो सकता है और सेट समाधान का पक्ष ले सकता है ... इसलिए आपको अपनी स्थिति के बारे में सोचना होगा :-)।

— टॉम

@amischiefr: क्या आप सुझाव दे रहे हैं कि ओ (n ^ 2) सबसे अच्छा है जो आप कर सकते हैं?

— टॉम

@ डेनिस आकार की जांच वास्तव में केवल तभी काम करती है जब आप जानते हैं कि प्रत्येक सूची में केवल अलग तत्व होते हैं। उदाहरण के लिए, दिए गए a = [x, y, x]और b = [x, y, z]फिर आकार समान हैं और b.containsAll(a)सही वापस आएंगे, लेकिन bइसमें एक तत्व नहीं है a।

— लॉरेंस गोंसाल्वेस

Answer 2

मैंने टिप्पणी में सामान का एक गुच्छा पोस्ट किया, मुझे लगता है कि यह अपने स्वयं के उत्तर का वारंट करता है।

जैसा कि हर कोई यहां कहता है, बराबर () का उपयोग करना आदेश पर निर्भर करता है। यदि आपको ऑर्डर की परवाह नहीं है, तो आपके पास 3 विकल्प हैं।

विकल्प 1

उपयोग containsAll() । यह विकल्प आदर्श नहीं है, मेरी राय में, क्योंकि यह सबसे खराब स्थिति प्रदान करता है, ओ (एन ^ 2)।

विकल्प 2

इसके दो रूप हैं:

2a) यदि आप Collections.sort()अपनी सूची के क्रम को बनाए रखने की परवाह नहीं करते हैं ... दोनों सूची में उपयोग करें । तब का उपयोग करें equals()। यह O (nlogn) है, क्योंकि आप दो तरह से करते हैं, और फिर O (n) तुलना करते हैं।

2 बी) यदि आपको सूचियों के क्रम को बनाए रखने की आवश्यकता है, तो आप पहले दोनों सूचियों को कॉपी कर सकते हैं। जब आप समाधान 2a का उपयोग कर सकते हैं दोनों कॉपी किए गए सूचियों पर । हालाँकि यह अप्राप्य हो सकता है यदि नकल बहुत महंगी हो।

इससे यह होगा:

विकल्प 3

यदि आपकी आवश्यकताएं भाग 2 बी के समान हैं , लेकिन नकल बहुत महंगी है। आप के लिए छँटाई करने के लिए आप एक ट्रीसेट का उपयोग कर सकते हैं। प्रत्येक सूची को अपने ट्रीसेट में डंप करें। यह सेट में हल किया जाएगा, और मूल सूचियां बरकरार रहेंगी। फिर equals()दोनों TreeSetएस पर एक तुलना करें । TreeSetsरों ओ (nlogn) समय में बनाया जा सकता है, औरequals() हे (एन) है।

अपना चयन ले लो :-)।

संपादित करें: मैं लगभग एक ही चेतावनी को भूल गया कि लॉरेंस गोंसाल्विस बताते हैं। ट्रीसेट कार्यान्वयन डुप्लिकेट को समाप्त कर देगा। यदि आप डुप्लिकेट के बारे में परवाह करते हैं, तो आपको कुछ प्रकार के सॉर्ट किए गए मल्टीसेट की आवश्यकता होगी।

Comments

यदि आप डुप्लिकेट के बारे में परवाह करते हैं तो आप हमेशा परीक्षण कर सकते हैं कि संग्रह का आकार किसी भी अन्य परीक्षणों से पहले बराबर है।

— १०:५५

अधिक विशेष रूप से, यदि डुप्लिकेट होने से असमानता का संकेत मिलता है, तो सूचियों का आकार किसी भी समानता की जांच के सफल होने का मौका होने से पहले समान होना चाहिए।

— लाज

@laz: दो लिस्ट में अलग-अलग तत्वों के डुप्लिकेट होने पर साइज़ चेक करना काम नहीं करेगा। जैसे: [ए, ए, बी] बनाम [ए, बी, बी] समान आकार हैं।

— लारेंस गोंसाल्वेस

@ गौर: मैं मानता हूं कि लाज़ की पोस्ट थोड़ी भ्रमित करने वाली है (इसे समझने से पहले मैंने इसे कुछ बार पढ़ा)। मैं यह लेता हूं कि वह केवल विशेष स्थिति के लिए "शॉर्टकट" प्रदान करने की कोशिश कर रहा है जब 2 स्थितियां होती हैं: (1) मामले को डुप्लिकेट करते हैं, और (2) सूची आकार भिन्न होते हैं। आपके उदाहरण में, मुझे लगता है कि आलस अभी भी कह रहा है कि सभी समान जांचों को करने के लिए आवश्यक है। (कम से कम मैं इसे कैसे पढ़ता हूं)। यदि डुप्लिकेट मायने नहीं रखता है, तो आप एक विशेष मामले की जाँच के रूप में आकार का उपयोग नहीं कर सकते। लेकिन जब 2 स्थितियां होती हैं, तो आप बस "if (list1.size ()! = List2.size ()) गलत बता सकते हैं;

— टॉम

ContainsAll मुझे लगता है कि गलत जवाब देना होगा, आपको दोनों तरीकों को शामिल करना होगा। a.containsAll(b) && b.containsAll(a)

— रिचर्ड टिंगल

Answer 3

यदि आप Apache Commons संग्रह का उपयोग कर रहे हैं (या उपयोग करने में प्रसन्न हैं), तो आप CollectionUtils.isEqualCollection का उपयोग कर सकते हैं, जो "यदि सही दिया गया संग्रह सही देता है तो ठीक उसी कार्डिनैलिटी वाले समान तत्व होते हैं।"

Comments

बहुत अच्छा hashmap- आधारित कार्यान्वयन। रनटाइम ओ (एन) होना चाहिए, और यदि बहुत सारे दोहराए जाने वाले तत्व हैं, तो यह ट्रैक रखने के लिए न्यूनतम मेमोरी का उपयोग करता है (मूल रूप से प्रत्येक संग्रह के लिए नक्शे का उपयोग करके तत्वों की आवृत्ति (कार्डिनैलिटी) को ट्रैक करता है)। नकारात्मक पक्ष यह है कि इसमें एक अतिरिक्त O (n) मेमोरी उपयोग है।

— मुहम्मद

Answer 4

पार्टी के लिए बहुत देर हो चुकी है लेकिन इस अशक्त सुरक्षित चेक को जोड़ना चाहते हैं:

Objects.equals(list1, list2)

Answer 5

मुझे पता है कि यह एक पुराना धागा है, लेकिन किसी भी अन्य उत्तर ने मेरे उपयोग के मामले को पूरी तरह से हल नहीं किया है (मुझे लगता है कि अमरूद मल्टीसेट ऐसा ही कर सकता है, लेकिन यहां कोई उदाहरण नहीं है)। कृपया मेरे प्रारूपण का बहाना करें। स्टैक एक्सचेंज पर पोस्ट करने के लिए मैं अभी भी नया हूं। इसके अतिरिक्त अगर कोई त्रुटि हो तो मुझे बताएं

कहते हैं कि तुम List<T>एक हैList<T> बी है और आप जांचना चाहते हैं कि क्या वे निम्नलिखित स्थितियों के बराबर हैं:

1) O (n) अपेक्षित रनिंग टाइम
2) समानता को इस रूप में परिभाषित किया गया है: सभी तत्वों के लिए a या b में, तत्व जितनी बार घटित होता है, वह उतना ही होता है, जितना तत्व b में होता है। तत्व समानता को T.equals () के रूप में परिभाषित किया गया है

private boolean listsAreEquivelent(List<? extends Object> a, List<? extends Object> b) {
    if(a==null) {
        if(b==null) {
            //Here 2 null lists are equivelent. You may want to change this.
            return true;
        } else {
            return false;
        }
    }
    if(b==null) {
        return false;
    }
    Map<Object, Integer> tempMap = new HashMap<>();
    for(Object element : a) {
        Integer currentCount = tempMap.get(element);
        if(currentCount == null) {
            tempMap.put(element, 1);
        } else {
            tempMap.put(element, currentCount+1);
        }
    }
    for(Object element : b) {
        Integer currentCount = tempMap.get(element);
        if(currentCount == null) {
            return false;
        } else {
            tempMap.put(element, currentCount-1);
        }
    }
    for(Integer count : tempMap.values()) {
        if(count != 0) {
            return false;
        }
    }
    return true;
}

रनिंग टाइम O (n) है क्योंकि हम O (2 * n) इन्सर्ट एक हैशमैप में कर रहे हैं और O (3 * n) हैशमैप सेलेक्ट करते हैं। मैंने इस कोड का पूरी तरह से परीक्षण नहीं किया है, इसलिए सावधान रहें :)

//Returns true:
listsAreEquivelent(Arrays.asList("A","A","B"),Arrays.asList("B","A","A"));
listsAreEquivelent(null,null);
//Returns false:
listsAreEquivelent(Arrays.asList("A","A","B"),Arrays.asList("B","A","B"));
listsAreEquivelent(Arrays.asList("A","A","B"),Arrays.asList("A","B"));
listsAreEquivelent(Arrays.asList("A","A","B"),null);

Answer 6

इस संस्करण को आज़माएं जिसके लिए समान होने के लिए आदेश की आवश्यकता नहीं है, लेकिन एक ही मूल्य के कई होने का समर्थन करता है। वे केवल तभी मेल खाते हैं जब प्रत्येक में किसी भी मूल्य की समान मात्रा हो।

public boolean arraysMatch(List<String> elements1, List<String> elements2) {
    // Optional quick test since size must match
    if (elements1.size() != elements2.size()) {
        return false;
    }
    List<String> work = newArrayList(elements2);
    for (String element : elements1) {
        if (!work.remove(element)) {
            return false;
        }
    }
    return work.isEmpty();
}

Comments

work.remove (तत्व) O (n) है, इसलिए यह समाधान O (n ^ 2) है

— एंड्रयू

या O (n1 * n2) जो समान है

— ली मीडोर

मैंने भी एक ही रणनीति का उपयोग किया है क्योंकि यह सभी परिदृश्यों को संभाल रहा है और संग्रह का आकार इतना बड़ा नहीं है तो O (n ^ 2) मायने नहीं रखता है

— नरेश जोशी

Answer 7

सूची पर समान पद्धति ऐसा करेगी, सूचियाँ आदेशित हैं, इसलिए समान होने के लिए दो सूचियाँ समान क्रम में समान तत्व होनी चाहिए।

return list1.equals(list2);

Comments

जब तक आप उन्हें क्रमबद्ध नहीं करते हैं, तब तक सूचियों का आदेश नहीं दिया जाता है।

— माइकल मायर्स

@ मैं स्वयं आह। ऐसा स्पष्ट उत्तर। आपको पता है कि यह बहुत लंबा दिन है जब आप किसी वेब पेज को Ctrl + F भी नहीं कर सकते हैं। :)

— ग्रुंडफ्लेक

@ खरीदारों: सूचियों में आइटम तब तक ऑर्डर नहीं किए जाते जब तक आप उन्हें सॉर्ट नहीं करते। सूचियों में स्वयं आइटमों का एक अंतर्निहित क्रम होता है (सूचकांक द्वारा), जो तब तक नहीं बदलते जब तक आप सूची में आइटम नहीं बदलते। (बनाम सेट या कलेक्शन जहां दो बार के माध्यम से पुनरावृति करने पर लगातार ऑर्डर देने की गारंटी नहीं है)

— जेसन एस

मुझे लगता है कि सूचियों का आदेश देने से daveb का क्या अर्थ है कि List.equals समानता का निर्धारण करने के लिए तत्वों के क्रम को ध्यान में रखती है। जावदोक को देखें।

— लाज

मेरा मतलब यह है कि इस सूची में {"A", "B"} और {"B", "A"} वाली सूची असमान होगी। यह बहुत अच्छी तरह से हो सकता है कि इरादा क्या है, लेकिन मैं यह सुनिश्चित करना चाहता था कि कोई भी इसे देख नहीं रहा था।

— माइकल मायर्स

Answer 8

मामले के लिए समाधान जब दो सूचियों में एक ही तत्व होते हैं, लेकिन अलग-अलग क्रम:

public boolean isDifferentLists(List<Integer> listOne, List<Integer> listTwo) {
    if(isNullLists(listOne, listTwo)) {
        return false;
    }

    if (hasDifferentSize(listOne, listTwo)) {
        return true;
    }

    List<Integer> listOneCopy = Lists.newArrayList(listOne);
    List<Integer> listTwoCopy = Lists.newArrayList(listTwo);
    listOneCopy.removeAll(listTwoCopy);

    return CollectionUtils.isNotEmpty(listOneCopy);
}

private boolean isNullLists(List<Integer> listOne, List<Integer> listTwo) {
    return listOne == null && listTwo == null;
}

private boolean hasDifferentSize(List<Integer> listOne, List<Integer> listTwo) {
    return (listOne == null && listTwo != null) || (listOne != null && listTwo == null) || (listOne.size() != listTwo.size());
}

Comments

मुझे लगता है कि आपको लिस्ट कॉपी करने की आवश्यकता नहीं है।

— अजानचर्ल्स

आप यह भी नोट करना पसंद कर सकते हैं कि आपने removeAll()इसके बजाय क्यों उपयोग किया containsAll()(मेरी समझ यह है कि यदि listTwo में डुप्लिकेट शामिल हैं जो कि listOne में केवल एक बार समाहित हैं, तो ContAll () दृष्टिकोण गलत रूप से सूचियों को समान रूप से रिपोर्ट करेगा)।

— अजानचर्ल्स

Answer 9

टॉम का जवाब उत्कृष्ट है मैं उनके जवाबों से पूरी तरह सहमत हूँ!

इस प्रश्न का एक दिलचस्प पहलू यह है कि क्या आपको इसकी आवश्यकता है List स्वयं प्रकार और इसके अंतर्निहित क्रम की आवश्यकता है।

यदि आप को नीचा दिखा सकते हैं Iterableया नहींCollection जो आपको डेटा संरचनाओं के आसपास गुजरने पर कुछ लचीलापन देता है जो कि प्रविष्टि के समय की बजाय, जब आप जांचना चाहते हैं, तो।

यदि आदेश कभी मायने नहीं रखता (और आपके पास डुप्लिकेट तत्व नहीं हैं) तो एक का उपयोग करने पर विचार करें Set।

यदि ऑर्डर मायने रखता है, लेकिन प्रविष्टि समय द्वारा परिभाषित किया गया है (और आपके पास डुप्लिकेट नहीं है) तो विचार करें LinkedHashSetकि एक ट्रीसेट की तरह है लेकिन प्रविष्टि समय द्वारा आदेश दिया गया है (डुप्लिकेट की गणना नहीं की जाती है)। यह भी आप का O(1)उपयोग शुरू करने के लिए परिशोधित पहुँच देता है O(log n)।

Answer 10

नमूना कोड:

public static '<'T'>' boolean isListDifferent(List'<'T'>' previousList,
        List'<'T'>' newList) {

    int sizePrevoisList = -1;
    int sizeNewList = -1;

    if (previousList != null && !previousList.isEmpty()) {
        sizePrevoisList = previousList.size();
    }
    if (newList != null && !newList.isEmpty()) {
        sizeNewList = newList.size();
    }

    if ((sizePrevoisList == -1) && (sizeNewList == -1)) {
        return false;
    }

    if (sizeNewList != sizePrevoisList) {
        return true;
    }

    List n_prevois = new ArrayList(previousList);
    List n_new = new ArrayList(newList);

    try {
        Collections.sort(n_prevois);
        Collections.sort(n_new);
    } catch (ClassCastException exp) {
        return true;
    }

    for (int i = 0; i < sizeNewList; i++) {
        Object obj_prevois = n_prevois.get(i);
        Object obj_new = n_new.get(i);
        if (obj_new.equals(obj_prevois)) {
            // Object are same
        } else {
            return true;
        }
    }

    return false;
}

Answer 11

लारेंस के जवाब के अलावा, अगर आप इसे शून्य-सुरक्षित बनाना चाहते हैं:

private static <T> boolean listEqualsIgnoreOrder(List<T> list1, List<T> list2) {
    if (list1 == null)
        return list2==null;
    if (list2 == null)
        return list1 == null;
    return new HashSet<>(list1).equals(new HashSet<>(list2));
}

Comments

आप चेक को सरल बना सकते हैं:if (list1 == null) return list2==null; if (list2 == null) return false;

— ज़ेरुस

काम नहीं करता है अगर सूचियां [ए, ए, बी, सी] और [ए, बी, सी] हैं और तब तक सही वापस आ जाएगी जब तक कि सूचियों का आकार सुनिश्चित करने के लिए एक अतिरिक्त चेक नहीं जोड़ा जाता है।

— वेंकट माधव

Answer 12

list1.equals(list2);

यदि आपकी सूची में एक कस्टम वर्ग MyClass है, तो इस वर्ग को equalsफ़ंक्शन को ओवरराइड करना चाहिए ।

 class MyClass
  {
  int field=0;
  @0verride
  public boolean equals(Object other)
        {
        if(this==other) return true;
        if(other==null || !(other instanceof MyClass)) return false;
        return this.field== MyClass.class.cast(other).field;
        }
  }

नोट: यदि आप एक के बजाय एक java.util.Set पर बराबर परीक्षण करना चाहते हैं java.util.List, तो आपकी ऑब्जेक्ट को hashCode फ़ंक्शन को ओवरराइड करना चाहिए ।

Comments

लाइन चाहिए: इस वापसी .field == MyClass.class.cast (अन्य); इसे वापस करें। क्षेत्र == MyClass.class.cast (अन्य) .field;

— अल्फा

@alpere ओह! आप सही हे ! मैं इसे ठीक करने वाला हूं। धन्यवाद !

— पियरे

Answer 13

List.equals ()

http://java.sun.com/j2se/1.5/docs/api/java/util/List.html#equals(java.lang.Object)

Answer 14

आप अपाचे के org.apache.commons.collections लाइब्रेरी का उपयोग कर सकते हैं: http://commons.apache.org/collections/apidocs/org/apache/commons/collections/ListUtils.html

public static boolean isEqualList(java.util.Collection list1,
                              java.util.Collection list2)

Comments

इसके लिए सूची तत्वों को भी उसी क्रम में होना आवश्यक है।

— जोश-कैन

आप तुलना करने से पहले सूची को सॉर्ट कर सकते हैं

— डेविड झाओ

निश्चित रूप से, आप ऐसा कर सकते हैं जो सूची में संग्रहीत प्रकार प्रदान करता है या छांटने योग्य है (या आपके पास एक तुलनित्र स्थापित है)। हालाँकि, अपाचे कार्यान्वयन एल्गोरिथ्म नियमित सूची 1 से अलग नहीं है। असमान (सूची 2), स्थिर होने के अलावा। मैं यह देखता हूं कि मुझे सवाल कहां गलत लगा और यह वास्तव में यह पूछ रहा था कि समान क्रम में सूची आइटम की तुलना कैसे करें। मेरी गलती!

— josh-cain

@DavidZhao: लिंक मर चुका है।

— अनिकेत कुलकर्णी

commons.apache.org/proper/commons-collections/apidocs/org/…

— डेविड झाओ

Answer 15

दोनों सूचियों की जाँच करें नल नहीं हैं। यदि उनके आकार अलग-अलग हैं, तो ये सूची समान नहीं हैं। सूचियों के तत्वों को कुंजी के रूप में बनाएँ और मानों के रूप में उनके दोहराव और नक्शों की तुलना करें।

मान्यताओं, यदि दोनों सूची शून्य हैं, तो मैं उन्हें समान मानता हूं।

private boolean compareLists(List<?> l1, List<?> l2) {
    if (l1 == null && l2 == null) {
        return true;
    } else if (l1 == null || l2 == null) {
        return false;
    }

    if (l1.size() != l2.size()) {
        return false;
    }

    Map<?, Integer> m1 = toMap(l1);
    Map<?, Integer> m2 = toMap(l2);

    return m1.equals(m2);
}

private Map<Object, Integer> toMap(List<?> list) {
    //Effective size, not to resize in the future.
    int mapSize = (int) (list.size() / 0.75 + 1);
    Map<Object, Integer> map = new HashMap<>(mapSize);

    for (Object o : list) {
        Integer count = map.get(o);
        if (count == null) {
            map.put(o, 1);
        } else {
            map.put(o, ++count);
        }
    }

    System.out.println(map);
    return map;
}

कृपया, ध्यान दें, इन वस्तुओं के लिए विधि बराबर को ठीक से परिभाषित किया जाना चाहिए। https://stackoverflow.com/a/24814634/4587961

Comments

आपने मान लिया है कि प्रत्येक सूची में एक तत्व एक अलग संख्या में मौजूद नहीं हो सकता है जैसे कि [x, x, y]बनाम [x, y, y]आपके कार्यान्वयन के साथ सही होगा।

— अजानचर्ल्स

@CodeConfident, आपको बहुत बहुत धन्यवाद! मैंने जवाब अपडेट किया। मैं एक माओ का उपयोग करूँगा!

— यान खोंस्की

Answer 16

यह निर्भर करता है कि आप किस ठोस सूची वर्ग का उपयोग कर रहे हैं। अमूर्त वर्ग AbstractCollection में विधि (संग्रह) नामक एक विधि है जो एक और संग्रह लेती है (एक सूची एक संग्रह है) और:

यदि यह संग्रह निर्दिष्ट संग्रह में सभी तत्वों को सम्‍मिलित करता है, तो सही है।

तो अगर एक ArrayList आप में पारित किया जा रहा है, तो इस पद्धति को कॉल करके देख सकते हैं कि क्या वे बिल्कुल समान हैं।

       List foo = new ArrayList();
    List bar = new ArrayList();
    String str = "foobar";

    foo.add(str);
    bar.add(str);

    foo.containsAll(bar);

ContAll () का कारण यह है कि यह पहली सूची के माध्यम से पुनरावृत्ति करता है, दूसरी सूची में मैच की तलाश करता है। इसलिए यदि वे आउट ऑफ ऑर्डर बराबर हैं () इसे नहीं उठाएंगे।

संपादित करें: मैं बस यहाँ प्रस्तुत विभिन्न विकल्पों के प्रदर्शन के परिशोधन चल रहे समय के बारे में एक टिप्पणी करना चाहता हूँ। क्या रनिंग टाइम महत्वपूर्ण है? ज़रूर। क्या यह केवल एक चीज है जिस पर आपको विचार करना चाहिए? नहीं।

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

इसलिए यदि आपके JVM में मेमोरी चिंता का विषय नहीं है (जो कि आमतौर पर यह होना चाहिए) तो आपको अभी भी उस समय पर विचार करने की जरूरत है जो प्रत्येक सूची को दो ट्रीसेट्स में दो सूचियों से कॉपी करता है। याद रखें कि यह हर तत्व को छांट रहा है क्योंकि यह उनमें प्रवेश करता है।

मेरी अंतिम सलाह? आपको अपने डेटा सेट पर विचार करने की आवश्यकता है और आपके डेटा सेट में कितने तत्व हैं, और यह भी कि आपके डेटा सेट में कितनी बड़ी वस्तु है, इससे पहले कि आप यहाँ एक अच्छा निर्णय ले सकें। उनके साथ खेलते हैं, एक-एक रास्ता बनाते हैं और देखते हैं कि कौन सा तेज चलता है। यह एक अच्छा व्यायाम है।

Comments

क्या यह foo.containsAll (बार) && बार.containsAll (foo) नहीं होगा; ?

— कार्ल मैनस्टर

नहीं, यह फू में प्रत्येक तत्व से गुजरता है और देखता है कि क्या बार में वह तत्व है। यह तब सुनिश्चित करता है कि लंबाई दो सूचियों में से एक है। यदि प्रत्येक फू के लिए बार में एक तत्व होता है जैसे कि foo.element == bar.element और foo.length == bar.length तो उनमें समान तत्व होते हैं।

— जूलिस

क्या हमें पता है कि दक्षता की गारंटी है? या यह आमतौर पर हे (n ^ 2) है?

— टॉम

किसी भी अन्य सरणी की तरह जो एक मेल खाने वाले तत्व की तलाश में है, जो सबसे खराब स्थिति है जो समय चल रहा है वह O (n ^ 2) है। इस मामले में, ऐसा लगता है कि कार्यान्वयन वास्तव में मैच की तलाश में एक तत्व के माध्यम से पुनरावृत्ति कर रहा है। मैं चल रहे समय पर अटकलें नहीं लगाऊंगा, लेकिन हां सबसे खराब स्थिति हे (n ^ 2)।

— amischiefr

यह काम नहीं करता है: {1,2,2} .containsAll ({1,1,2}) और इसके विपरीत, और दो सूचियों का आकार समान है।

— comco