जावा में दो विशाल सूची <स्ट्रिंग> की तुलना कैसे करें? जावा, सरणीसूची

मेरा एप्लिकेशन 2 बड़ी सूचियां उत्पन्न करता है (3.5 मिलियन स्ट्रिंग रिकॉर्ड तक)। मुझे इसकी तुलना करने का सबसे अच्छा और तेज़ तरीका चाहिए। वर्तमान में मैं इसे इस तरह कर रहा हूं:

List list1 = ListUtils.subtract(sourceDbResults, hiveResults);
List list2 = ListUtils.subtract(hiveResults, sourceDbResults);

लेकिन यह विधि स्मृति पर वास्तव में महंगा है क्योंकि मैं jconsole से देखता हूं और कभी-कभी उस पर भी ढेर प्रक्रिया करता हूं। कोई अच्छा समाधान या विचार?

सूची में तत्व पद / आदेश हमेशा होते हैंवही, इसलिए मुझे इससे निपटने की ज़रूरत नहीं है। तुलना करने के बाद मुझे यह जानने की जरूरत है कि सूची समान है या नहीं और इन सूचीओं में अंतर प्राप्त करने के लिए यदि वे समान नहीं हैं। छोटे सूचियों के लिए सही काम घटाएं।

उत्तर:

जवाब के लिए 3 № 1

यह देखते हुए कि आपने कहा है कि आपकी दो सूचियां पहले से ही हैंक्रमबद्ध, उनकी तुलना ओ (एन) समय में की जा सकती है, जो आपके मौजूदा समाधान की तुलना में बहुत तेज है जो ListUtils का उपयोग करता है। निम्न विधि यह एक समान एल्गोरिदम का उपयोग करके करती है जो दो क्रमबद्ध सूचियों को विलीन करती है जो अधिकांश पाठ्यपुस्तकों में पाई जा सकती हैं।

import java.util.*;

public class CompareSortedLists {
public static void main(String[] args) {
List<Integer> sourceDbResults = Arrays.asList(1, 2, 3, 4, 5, 8);
List<Integer> hiveResults = Arrays.asList(2, 3, 6, 7);
List<Integer> inSourceDb_notInHive = new ArrayList<>();
List<Integer> inHive_notInSourceDb = new ArrayList<>();

compareSortedLists(
sourceDbResults, hiveResults,
inSourceDb_notInHive, inHive_notInSourceDb);

assert inSourceDb_notInHive.equals(Arrays.asList(1, 4, 5, 8));
assert inHive_notInSourceDb.equals(Arrays.asList(6, 7));
}

/**
* Compares two sorted lists (or other iterable collections in ascending order).
* Adds to onlyInList1 any and all elements in list1 that are not in list2; and
* conversely to onlyInList2. The caller must ensure the two input lists are
* already sorted and should initialize onlyInList1 and onlyInList2 to empty,
* writable collections.
*/
public static <T extends Comparable<? super T>> void compareSortedLists(
Iterable<T> list1, Iterable<T> list2,
Collection<T> onlyInList1, Collection<T> onlyInList2) {
Iterator<T> it1 = list1.iterator();
Iterator<T> it2 = list2.iterator();
T e1 = it1.hasNext() ? it1.next() : null;
T e2 = it2.hasNext() ? it2.next() : null;
while (e1 != null || e2 != null) {
if (e2 == null) {  // No more elements in list2, some remaining in list1
onlyInList1.add(e1);
e1 = it1.hasNext() ? it1.next() : null;
}
else if (e1 == null) {  // No more elements in list1, some remaining in list2
onlyInList2.add(e2);
e2 = it2.hasNext() ? it2.next() : null;
}
else {
int comp = e1.compareTo(e2);
if (comp < 0) {
onlyInList1.add(e1);
e1 = it1.hasNext() ? it1.next() : null;
}
else if (comp > 0) {
onlyInList2.add(e2);
e2 = it2.hasNext() ? it2.next() : null;
}
else /* comp == 0 */ {
e1 = it1.hasNext() ? it1.next() : null;
e2 = it2.hasNext() ? it2.next() : null;
}
}
}
}
}

उपर्युक्त विधि बाहरी पुस्तकालयों का उपयोग नहीं करती है, औरजावा के किसी भी संस्करण के साथ 6 ऊपर से उपयोग किया जा सकता है। यदि आप पेकिंगइटरेटर का उपयोग करते हैं, जैसे कि अपाचे कॉमन्स कलेक्शन, या गुवा से, या अपना खुद का लिखें, तो आप विधि को सरल बना सकते हैं, खासकर यदि आप जावा 8 का भी उपयोग करते हैं:

public static <T extends Comparable<? super T>> void compareSortedLists(
Iterable<T> list1, Iterable<T> list2,
Collection<T> onlyInList1, Collection<T> onlyInList2) {
PeekingIterator<T> it1 = new PeekingIterator<>(list1.iterator());
PeekingIterator<T> it2 = new PeekingIterator<>(list2.iterator());
while (it1.hasNext() && it2.hasNext()) {
int comp = it1.peek().compareTo(it2.peek());
if (comp < 0)
onlyInList1.add(it1.next());
else if (comp > 0)
onlyInList2.add(it2.next());
else /* comp == 0 */ {
it1.next();
it2.next();
}
}
it1.forEachRemaining(onlyInList1::add);
it2.forEachRemaining(onlyInList2::add);
}

संबंधित सवाल
सबसे लोकप्रिय