एक ही आईडी के साथ लाखों आइटम के साथ 2 विशाल सूची को कैसे फ़िल्टर करें [डुप्लिकेट]

Question

यहां लाखों से अधिक आइटम के साथ मेरी 2 सूची है। दोनों में एक ही आईडी के साथ एक ही आइटम है। आईडी स्ट्रिंग में है। मुझे केवल उस आइटम की आवश्यकता है जो समान आईडी नहीं है। मैंने इस तरह से किया। लेकिन मुझे यकीन है कि बेहतर समाधान होना चाहिए और उच्च स्थायित्व के साथ: -

    List<Transaction> differentList = new ArrayList<>();

    for(Transaction tx : foundTransactions ){
        for(Transaction aTx : ArchivedTransactions) 
        {
            if(!tx.getId().equalsIgnoreCase(aTx.getId()) ){
                differentList .add(tx);
            }
        }
    }

मैंने स्ट्रीम का उपयोग करने की कोशिश की लेकिन मैं ऐसा नहीं कर सका। मुझे लगता है कि स्ट्रीम एपीआई के साथ बेहतर होना चाहिए। कृपया मुझे कोई सुधार बताएं।

Answer 1

आप इसे HashMapपहले, कुछ इस तरह से परिवर्तित करने की कोशिश कर सकते हैं:

Set<String> collect = ArchivedTransactions.stream().map(i -> i.getId().toLowerCase())
                                           .collect(Collectors.toSet());

for(Transaction tx : foundTransactions )
    if(!collect.contains(tx.getId()))
       differentList.add(tx);

Collectors.toSet()एक रिटर्न HashSet। आप कोड को सरल कर सकते हैं:

Set<String> collect = ArchivedTransactions.stream().map(i -> i.getId().toLowerCase())
                                          .collect(Collectors.toSet());

List<Transaction> differentList = foundTransactions.stream()
                                                   .filter(tx -> !collect.contains(tx.getId()))
                                                   .collect(Collectors.toList())

इंटरमीडिएट कदम के रूप IDsमें पहले को जोड़ना HashSetआपको ( स्रोत ) के बाद से बेहतर समग्र जटिलता समय प्रदान करेगा :

हैशसेट संचालन की समय जटिलता: हैशसेट के लिए अंतर्निहित डेटा संरचना हैशटेबल है। तो HashSet के O, (1) समय को जोड़ने , हटाने और देखने (शामिल करने की विधि) के संचालन के लिए औसत (सामान्य या सामान्य मामला) समय जटिलता है ।

नतीजतन, कुल time complexityका "HashMap"समाधान हो जाएगा O(N + M), जहां Nऔर Mसूचियों में तत्वों की संख्या शुरू ArchivedTransactionsऔर foundTransactionsक्रमश:। बहरहाल, space-wiseआप उस अतिरिक्त संरचना के होने की कीमत चुकाएंगे।

आपका समाधान space-wiseबेहतर है, लेकिन सबसे खराब समय जटिलता के साथ। यदि N = Mआपके समाधान की समय जटिलता है O(N^2), जबकि समाधान के साथ HashSetहोगा O(2N), इसलिए O(N)। यह बहुत बड़ा अंतर है।

बस कर रहे हैं

Set<Transaction> result = new LinkedHashSet<>();
result.addAll(foundTransactions);
result.addAll(ArchivedTransactions);

अकेले काम नहीं करेगा, क्योंकि आपने स्पष्ट रूप से अनुरोध किया है:

!tx.getId().equalsIgnoreCase(aTx.getId())

Answer 2

मेरे दिमाग में आने वाला सबसे सरल उपाय है, Setजो डुप्लिकेट तत्वों को स्वतः हटाता है।

Set<Transaction> result = new LinkedHashSet<>();
result.addAll(foundTransactions);
result.addAll(ArchivedTransactions);

//If you want to get a List<Transaction>
List<Transaction> differentList = new ArrayList<>(result);

नोट: मैंने LinkedHashSetप्रविष्टि क्रम को संरक्षित करने के लिए उपयोग किया है। यदि प्रविष्टि क्रम आपके लिए मायने नहीं रखता है, तो आप उपयोग कर सकते हैं HashSet।