जावा में ArrayLists का अंतःक्रिया और संघटन

Question

क्या ऐसा करने की कोई विधियाँ हैं? मैं देख रहा था लेकिन कोई भी नहीं मिल रहा था।

एक और सवाल: मुझे इन तरीकों की ज़रूरत है ताकि मैं फ़ाइलों को फ़िल्टर कर सकूं। कुछ ANDफिल्टर हैं और कुछ हैंOR फ़िल्टर हैं (जैसे सेट सिद्धांत में), इसलिए मुझे सभी फ़ाइलों और उन फ़ाइलों को रखने वाले ArrayLists को एकजुट / प्रतिच्छेद करने के लिए फ़िल्टर करने की आवश्यकता है।

क्या मुझे फ़ाइलों को रखने के लिए एक अलग डेटा संरचना का उपयोग करना चाहिए? क्या कुछ और है जो बेहतर रनटाइम की पेशकश करेगा?

Comments

यदि आप एक नई सूची नहीं बनाना चाहते हैं, तो वेक्टर.retainAll (वेक्टर) आपके ओरिगनल वेक्टर को केवल दूसरे वेक्टर के साथ चौराहे तक पहुंचाता है।

— user2808054

@ user2808054 क्यों Vector? जावा 1.2 के बाद से उस वर्ग को हतोत्साहित किया गया है।

— dimo414

@ dimo414 एक इंटरफ़ेस जो मैं उपयोग कर रहा हूं (मेरे पास कोई विकल्प नहीं है) चीजों को वैक्टर के रूप में लौटाता है। मुझे नहीं पता था कि यह हतोत्साहित किया गया था! जानकारी के लिए धन्यवाद .. किसने हतोत्साहित किया? मैंने इसके बारे में कोई ध्यान नहीं दिया है कि यह पदावनत है इसलिए यह आश्चर्य की बात है

— user2808054

Javadocs से: " Java 2 प्लेटफॉर्म v1.2 के रूप में ... यह वेक्टर के स्थान पर ArrayList का उपयोग करने के लिए अनुशंसित है। " क्रॉस-थ्रेड इंटरैक्शन के लिए आपको केवल समय की आवश्यकता हो सकती Vectorहै, लेकिन उन उपयोग मामलों के लिए भी सुरक्षित डेटा संरचनाएं हैं। यह प्रश्न भी देखें । Vector2016 में अभी भी किसी भी पुस्तकालय का उपयोग मेरी राय में बहुत संदिग्ध है।

— dimo414

@ dimo414 यह एक आईबीएम लाइब्रेरी है, हाहा! (लोटस डोमिनोज डेटा एपी)। जानकारी के लिए धन्यवाद, बहुत उपयोगी

— user2808054

Answer 1

यहां किसी भी तृतीय-पक्ष लाइब्रेरी का उपयोग किए बिना एक सादा कार्यान्वयन है। मुख्य लाभ खत्म हो गया है retainAll, removeAllऔर addAllयह है कि ये विधियाँ मूल सूचियों के इनपुट को विधियों में नहीं बदलती हैं।

public class Test {

    public static void main(String... args) throws Exception {

        List<String> list1 = new ArrayList<String>(Arrays.asList("A", "B", "C"));
        List<String> list2 = new ArrayList<String>(Arrays.asList("B", "C", "D", "E", "F"));

        System.out.println(new Test().intersection(list1, list2));
        System.out.println(new Test().union(list1, list2));
    }

    public <T> List<T> union(List<T> list1, List<T> list2) {
        Set<T> set = new HashSet<T>();

        set.addAll(list1);
        set.addAll(list2);

        return new ArrayList<T>(set);
    }

    public <T> List<T> intersection(List<T> list1, List<T> list2) {
        List<T> list = new ArrayList<T>();

        for (T t : list1) {
            if(list2.contains(t)) {
                list.add(t);
            }
        }

        return list;
    }
}

Comments

आप List1 तत्वों के साथ नई सूची बना सकते हैं और फिर retainAll, addAll तरीकों कॉल

— lukastymo

आप इस समाधान में कड़ाई का उपयोग क्यों कर रहे हैं?

— लुकास्टिमो

के HashSetलिए उपयोग करना चाहिए intersectionताकि ओ (एन ^ 2) के बजाय औसत मामले का प्रदर्शन ओ (एन) हो।

— जोंग

यह पोस्ट जावा 8 स्ट्रीम एपीआई के लाभों को प्रदर्शित करने के लिए एक अपडेट का उपयोग कर सकती है।

— SME_Dev 15

जब मुझे यह मान असाइन करने का प्रयास करने में त्रुटि मिलती है -> उदाहरण: ArrayList <string> कुल कुल = (ArrayList <String>) चौराहा (सूची 2, सूची 1) ---> java.util.arraylist को java.util.arraylist <पर नहीं डाल सकता। string>

— delive

Answer 2

संग्रह (इसलिए ArrayList भी):

col.retainAll(otherCol) // for intersection
col.addAll(otherCol) // for union

यदि आप दोहराव को स्वीकार करते हैं तो सूची कार्यान्वयन का उपयोग करें, यदि आप नहीं करते हैं तो एक कार्यान्वयन लागू करें:

Collection<String> col1 = new ArrayList<String>(); // {a, b, c}
// Collection<String> col1 = new TreeSet<String>();
col1.add("a");
col1.add("b");
col1.add("c");

Collection<String> col2 = new ArrayList<String>(); // {b, c, d, e}
// Collection<String> col2 = new TreeSet<String>();
col2.add("b");
col2.add("c");
col2.add("d");
col2.add("e");

col1.addAll(col2);
System.out.println(col1); 
//output for ArrayList: [a, b, c, b, c, d, e]
//output for TreeSet: [a, b, c, d, e]

Comments

एक सुझाव दिया गया है कि यह संघ "गलत है क्योंकि इसमें दो बार आम तत्व शामिल होंगे" । इसके HashSetबजाय एडिट करने की सलाह दी गई ।

— कोस

वास्तव में इसे संपादित किया गया था, देखें: "यदि आप दोहराव को स्वीकार नहीं करते हैं तो एक सूची कार्यान्वयन का उपयोग करें, यदि आप नहीं करते हैं तो एक कार्यान्वयन लागू करें"

— lukastymo

नहीं, रिटेनरोल सूची के लिए प्रतिच्छेदन नहीं है। ऊपर, कॉल में अन्य तत्व जो अन्य में नहीं हैं उन्हें हटा दिया जाता है। मान लीजिए कि अन्य कॉल {ए, बी, बी, सी} और कॉल {बी, बी, बी, सी, डी} है। फिर कॉल {बी, बी, बी, सी} के साथ समाप्त होता है, जो कि दो का कड़ाई से अंतर नहीं है। मैं उम्मीद करूँगा कि {b, b, c} होना चाहिए। एक अलग ऑपरेशन किया जा रहा है।

— डेमॉन्गोलम

मैं यह भी नहीं देखता कि addAll()सूचियों के लिए संघ कैसा है; यह पहले के अंत में दूसरी सूची को संक्षिप्त कर रहा है। एक यूनियन ऑपरेशन एक तत्व को जोड़ने से बचता है यदि पहली सूची में पहले से ही यह शामिल है।

— dimo414

Answer 3

यह पोस्ट काफी पुरानी है, लेकिन फिर भी यह उस विषय की तलाश में गूगल पर पहला पॉपिंग था।

मैं एक ही लाइन में जावा 8 स्ट्रीम कर (मूल रूप से) एक ही चीज़ का उपयोग करके एक अपडेट देना चाहता हूं:

List<T> intersect = list1.stream()
    .filter(list2::contains)
    .collect(Collectors.toList());

List<T> union = Stream.concat(list1.stream(), list2.stream())
    .distinct()
    .collect(Collectors.toList());

अगर किसी के पास एक बेहतर / तेज समाधान है, तो मुझे बताएं, लेकिन यह समाधान एक अच्छा एक लाइनर है जिसे आसानी से एक अनावश्यक हेल्पर क्लास / पद्धति को शामिल किए बिना आसानी से शामिल किया जा सकता है और फिर भी पठनीयता बनाए रख सकते हैं।

Comments

Ooof, यह एक अच्छा वन-लाइनर हो सकता है लेकिन इसमें O (n ^ 2) समय लगता है। Setसेट की containsविधि का उपयोग करने के लिए सूचियों में से एक को परिवर्तित करें । जीवन में सब कुछ धाराओं के साथ नहीं करना पड़ता है।

— dimo414

Answer 4

list1.retainAll(list2) - is intersection

मिलन होगा removeAllऔर फिर होगाaddAll ।

संग्रह के दस्तावेज में और अधिक जानकारी प्राप्त करें (ArrayList एक संग्रह है) http://download.oracle.com/javase/1.5.0/docs/api/java/util/Collection.html

Comments

दोनों retainAll()और removeAll()कर रहे हैं O (n ^ 2) सूचियों पर कार्रवाई। हम बेहतर कर सकते हैं।

— dimo414

मैंने मतदान किया लेकिन अब मेरा सवाल है। retainAll{1, 2, 2, 3, 4, 5} से अधिक {1, 2, 3} परिणाम {1, 2, 2, 3} में। क्या यह चौराहा बनने के लिए {1, 2, 3} नहीं होना चाहिए?

— ग्यूहयोन चोई

Answer 5

यूनियनों और चौराहों को केवल सेटों के लिए परिभाषित किया गया है, सूचियों के लिए नहीं। जैसा आपने उल्लेख किया था।

फ़िल्टर के लिए अमरुद पुस्तकालय की जाँच करें । इसके अलावा अमरूद वास्तविक चौराहों और यूनियनों को प्रदान करता है

 static <E> Sets.SetView<E >union(Set<? extends E> set1, Set<? extends E> set2)
 static <E> Sets.SetView<E> intersection(Set<E> set1, Set<?> set2)

Answer 6

आप अपाचे कॉमन्सCollectionUtils से उपयोग कर सकते हैं ।

Comments

मामले में किसी को यह उत्तर थोड़ा छोटा लगता है: 'CollectionUtils.containsAny' और 'CollectionUtils.containsAll' विधियाँ हैं।

— सेबस्टियन

यह अजीब है कि Apache कॉमन्स से CollectionUtils जेनेरिक का समर्थन नहीं करता है

— Vasyl Sarzhynskyi

Answer 7

चिह्नित समाधान कुशल नहीं है। इसमें O (n ^ 2) समय की जटिलता है। हम दोनों सूचियों को क्रमबद्ध करने के लिए क्या कर सकते हैं, और नीचे के रूप में एक चौराहे एल्गोरिथ्म को निष्पादित करें।

private  static ArrayList<Integer> interesect(ArrayList<Integer> f, ArrayList<Integer> s) { 
    ArrayList<Integer> res = new ArrayList<Integer>();

    int i = 0, j = 0; 
    while (i != f.size() && j != s.size()) { 

        if (f.get(i) < s.get(j)) {
            i ++;
        } else if (f.get(i) > s.get(j)) { 
            j ++;
        } else { 
            res.add(f.get(i)); 
            i ++;  j ++;
        }
    }


    return res; 
}

इस ओ (एन लॉग एन + एन) की एक जटिलता है जो ओ (एन लॉग एन) में है। संघ समान तरीके से किया जाता है। बस यह सुनिश्चित करें कि आप if-ifif-else स्टेटमेंट पर उपयुक्त संशोधन करें।

आप चाहें तो पुनरावृत्तियों का उपयोग भी कर सकते हैं (मुझे पता है कि वे C ++ में अधिक कुशल हैं, मुझे नहीं पता कि यह जावा में भी सही है या नहीं)।

Comments

पर्याप्त सामान्य नहीं, T तुलनात्मक नहीं हो सकता है और कुछ मामलों में तुलना करना महंगा है ...

— बोरिस चुरज़िन

सामान्य नहीं, मैं पूरी तरह से सहमत हूं। तुलना करना महंगा है? आप इसे कैसे हल करेंगे?

— 21

अफसोस की बात है - यह ओ (एन ^ 2) में करना सस्ता होगा :) नंबरों के लिए यह समाधान अच्छा है ...

— बोरिस चुरज़िन

दुख की बात है - आपने मेरे सवाल का जवाब नहीं दिया। मुझे यह बताने की कोशिश करें कि ओ (एन ^ 2) को लागत सी (एन) की तुलनात्मक रूप से बेहतर कैसे दिया जाए?

— AJed

एक इनपुट को एक सेट contains()में बदलना और लूप में कॉल करना (जैसा कि देवेनव सुझाव है) O (n + m) समय लगेगा। सॉर्ट करना अनावश्यक रूप से जटिल है और O (n log n + m log n + n) समय लेता है। दी गई है जो O (n लॉग एन) समय को कम कर देता है, लेकिन यह अभी भी रैखिक समय से भी बदतर है, और बहुत अधिक जटिल है।

— dimo414

Answer 8

मुझे लगता है कि Setयदि आप उन पर चौराहा और संघ करना चाहते हैं, तो आपको फ़ाइलों को पकड़ने के लिए उपयोग करना चाहिए । तब आप अमरूद के सेट्स क्लास का उपयोग कर सकते हैं union, intersectionऔर Predicateसाथ ही फ़िल्टर भी कर सकते हैं। इन विधियों और अन्य सुझावों के बीच का अंतर यह है कि इन सभी तरीकों से दो सेटों के मिलन, चौराहे आदि के आलसी विचार पैदा होते हैं। Apache Commons एक नया संग्रह बनाता है और डेटा की प्रतिलिपि बनाता है। retainAllइसमें से तत्वों को निकालकर आपके किसी संग्रह को बदल देता है।

Answer 9

यहाँ एक तरीका है कि आप धाराओं के साथ एक चौराहा कैसे कर सकते हैं (याद रखें कि आपको धाराओं के लिए जावा 8 का उपयोग करना होगा):

List<foo> fooList1 = new ArrayList<>(Arrays.asList(new foo(), new foo()));
List<foo> fooList2 = new ArrayList<>(Arrays.asList(new foo(), new foo()));
fooList1.stream().filter(f -> fooList2.contains(f)).collect(Collectors.toList());

विभिन्न प्रकारों के साथ सूचियों के लिए एक उदाहरण। यदि आपके पास फू और बार के बीच का अंतर है और आप फू से बार-ऑब्जेक्ट प्राप्त कर सकते हैं, तो आप अपनी स्ट्रीम को संशोधित कर सकते हैं:

List<foo> fooList = new ArrayList<>(Arrays.asList(new foo(), new foo()));
List<bar> barList = new ArrayList<>(Arrays.asList(new bar(), new bar()));

fooList.stream().filter(f -> barList.contains(f.getBar()).collect(Collectors.toList());

Answer 10

• आपकी सूची को संशोधित करेगा
• अमरूद में सूची के लिए एपीआई (केवल सेट के लिए) नहीं है

मुझे इस उपयोग के मामले में ListUtils बहुत उपयोगी लगी।

यदि आप मौजूदा सूची को संशोधित नहीं करना चाहते हैं, तो org.apache.commons.collections से ListUtils का उपयोग करें।

ListUtils.intersection(list1, list2)

Answer 11

आप commons-collection4 CollectionUtils का उपयोग कर सकते हैं

Collection<Integer> collection1 = Arrays.asList(1, 2, 4, 5, 7, 8);
Collection<Integer> collection2 = Arrays.asList(2, 3, 4, 6, 8);

Collection<Integer> intersection = CollectionUtils.intersection(collection1, collection2);
System.out.println(intersection); // [2, 4, 8]

Collection<Integer> union = CollectionUtils.union(collection1, collection2);
System.out.println(union); // [1, 2, 3, 4, 5, 6, 7, 8]

Collection<Integer> subtract = CollectionUtils.subtract(collection1, collection2);
System.out.println(subtract); // [1, 5, 7]

Answer 12

जावा 8 में, मैं इस तरह से सरल सहायक विधियों का उपयोग करता हूं:

public static <T> Collection<T> getIntersection(Collection<T> coll1, Collection<T> coll2){
    return Stream.concat(coll1.stream(), coll2.stream())
            .filter(coll1::contains)
            .filter(coll2::contains)
            .collect(Collectors.toSet());
}

public static <T> Collection<T> getMinus(Collection<T> coll1, Collection<T> coll2){
    return coll1.stream().filter(not(coll2::contains)).collect(Collectors.toSet());
}

public static <T> Predicate<T> not(Predicate<T> t) {
    return t.negate();
}

Answer 13

यदि सूची में मौजूद वस्तुएं हैंज़ेबल (यानी एक सभ्य हैशकोड और समान फ़ंक्शन), तो तालिकाओं के बीच सबसे तेज़ दृष्टिकोण। आकार> 20 दो सूचियों में से बड़े के लिए एक हैशसेट का निर्माण करना है।

public static <T> ArrayList<T> intersection(Collection<T> a, Collection<T> b) {
    if (b.size() > a.size()) {
        return intersection(b, a);
    } else {
        if (b.size() > 20 && !(a instanceof HashSet)) {
            a = new HashSet(a);
        }
        ArrayList<T> result = new ArrayList();
        for (T objb : b) {
            if (a.contains(objb)) {
                result.add(objb);
            }
        }
        return result;
    }
}

Answer 14

मैं भी इसी तरह की स्थिति पर काम कर रहा था और मदद के लिए यहाँ पहुँच गया। Arrays के लिए मेरा अपना समाधान खोजने के लिए समाप्त हो गया। ArrayList AbsentDates = new ArrayList (); // विल स्टोर एरे 1-एरे 2

नोट: यदि यह किसी को इस पेज तक पहुँचने में मदद कर सकता है तो इसे पोस्ट करना।

ArrayList<String> AbsentDates = new ArrayList<String>();//This Array will store difference
      public void AbsentDays() {
            findDates("April", "2017");//Array one with dates in Month April 2017
            findPresentDays();//Array two carrying some dates which are subset of Dates in Month April 2017

            for (int i = 0; i < Dates.size(); i++) {

                for (int j = 0; j < PresentDates.size(); j++) {

                    if (Dates.get(i).equals(PresentDates.get(j))) {

                        Dates.remove(i);
                    }               

                }              
                AbsentDates = Dates;   
            }
            System.out.println(AbsentDates );
        }

Answer 15

सामान्य कुंजी के आधार पर अलग-अलग ऑब्जेक्ट की दो सूची का अंतर - जावा 8

 private List<User> intersection(List<User> users, List<OtherUser> list) {

        return list.stream()
                .flatMap(OtherUser -> users.stream()
                        .filter(user -> user.getId()
                                .equalsIgnoreCase(OtherUser.getId())))
                .collect(Collectors.toList());
    }

Comments

उन 2 सूची के बीच अंतर के बारे में कैसे?

— जीन

Answer 16

public static <T> Set<T> intersectCollections(Collection<T> col1, Collection<T> col2) {
    Set<T> set1, set2;
    if (col1 instanceof Set) {
        set1 = (Set) col1;
    } else {
        set1 = new HashSet<>(col1);
    }

    if (col2 instanceof Set) {
        set2 = (Set) col2;
    } else {
        set2 = new HashSet<>(col2);
    }

    Set<T> intersection = new HashSet<>(Math.min(set1.size(), set2.size()));

    for (T t : set1) {
        if (set2.contains(t)) {
            intersection.add(t);
        }
    }

    return intersection;
}

JDK8 + (संभवतः सर्वश्रेष्ठ प्रदर्शन)

public static <T> Set<T> intersectCollections(Collection<T> col1, Collection<T> col2) {
    boolean isCol1Larger = col1.size() > col2.size();
    Set<T> largerSet;
    Collection<T> smallerCol;

    if (isCol1Larger) {
        if (col1 instanceof Set) {
            largerSet = (Set<T>) col1;
        } else {
            largerSet = new HashSet<>(col1);
        }
        smallerCol = col2;
    } else {
        if (col2 instanceof Set) {
            largerSet = (Set<T>) col2;
        } else {
            largerSet = new HashSet<>(col2);
        }
        smallerCol = col1;
    }

    return smallerCol.stream()
            .filter(largerSet::contains)
            .collect(Collectors.toSet());
}

यदि आप प्रदर्शन के बारे में परवाह नहीं करते हैं और छोटे कोड का उपयोग करना चाहते हैं:

col1.stream().filter(col2::contains).collect(Collectors.toList());

Answer 17

अंतिम समाधान:

//all sorted items from both
public <T> List<T> getListReunion(List<T> list1, List<T> list2) {
    Set<T> set = new HashSet<T>();
    set.addAll(list1);
    set.addAll(list2);
    return new ArrayList<T>(set);
}

//common items from both
public <T> List<T> getListIntersection(List<T> list1, List<T> list2) {
    list1.retainAll(list2);
    return list1;
}

//common items from list1 not present in list2
public <T> List<T> getListDifference(List<T> list1, List<T> list2) {
    list1.removeAll(list2);
    return list1;
}

Answer 18

सबसे पहले, मैं सरणियों के सभी मानों को एकल सरणी में कॉपी कर रहा हूं फिर मैं सरणी में डुप्लिकेट मानों को हटा रहा हूं। पंक्ति 12, यह समझाते हुए कि यदि एक ही संख्या समय से अधिक होती है, तो कुछ अतिरिक्त कचरा मूल्य "जे" स्थिति में डाल दें। अंत में, स्टार्ट-एंड से ट्रैवर्स करें और जांचें कि क्या एक ही कचरा मूल्य होता है तो त्यागें।

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

    int arr1[]={1,3,3,2,4,2,3,3,5,2,1,99};
    int arr2[]={1,3,2,1,3,2,4,6,3,4};
    int arr3[]=new int[arr1.length+arr2.length];

    for(int i=0;i<arr1.length;i++)
        arr3[i]=arr1[i];

    for(int i=0;i<arr2.length;i++)
        arr3[arr1.length+i]=arr2[i];
    System.out.println(Arrays.toString(arr3));

    for(int i=0;i<arr3.length;i++)
    {
        for(int j=i+1;j<arr3.length;j++)
        {
            if(arr3[i]==arr3[j])
                arr3[j]=99999999;          //line  12
        }
    }
    for(int i=0;i<arr3.length;i++)
    {
        if(arr3[i]!=99999999)
            System.out.print(arr3[i]+" ");
    }
}   
}

Comments

ढेर अतिप्रवाह में आपका स्वागत है! कृपया ध्यान दें कि प्रश्न ArrayList के बारे में है। इसके अलावा, मुझे डर है कि यह विशेष कार्यान्वयन वांछित होने के लिए चीजों को छोड़ देता है। 99999999 का मान, जिसे एक प्रहरी के रूप में उपयोग किया जाता है, इनपुट में हो सकता है। ArrayListसंघ के परिणाम को स्टोर करने के लिए , एक गतिशील संरचना का उपयोग करना बेहतर होगा ।

— एसएल बार्थ -

कृपया केवल एक कोड उत्तर के बजाय आपके द्वारा प्रस्तुत कोड की व्याख्या करें।

— तमरोज

मैं सिर्फ एक सुराग दे रहा हूं कि आपको कोई कचरा मूल्य डालना है

— आशुतोष

मुझे यह देखकर खुशी हुई कि आपने एक स्पष्टीकरण जोड़ा। दुर्भाग्य से, जवाब अभी भी बुरा है। सरणियों का उपयोग करने का कोई कारण नहीं है। आपको ArrayList जैसी गतिशील संरचना का उपयोग करना चाहिए। यदि (किसी कारण से) आपको सरणियों का उपयोग करना चाहिए, तो आपको इसके Integerबजाय सरणी का उपयोग करने पर विचार करना चाहिए int। फिर आप nullअपने "कचरा मूल्य" के बजाय उपयोग कर सकते हैं । "कचरा मूल्य" या "संतरी मूल्य" आमतौर पर एक बुरा विचार है, क्योंकि ये मान अभी भी इनपुट में हो सकते हैं।

— एसएल बार्थ -

Answer 19

परीक्षण के बाद, यहां मेरा सबसे अच्छा चौराहा दृष्टिकोण है।

शुद्ध HashSet दृष्टिकोण की तुलना में तेज़ गति। नीचे हैशसेट और हैशपॉप में 1 मिलियन से अधिक रिकॉर्ड के साथ सरणियों के लिए समान प्रदर्शन है।

जावा 8 स्ट्रीम अप्रोच के लिए, अरै साइज़ बड़ा तो 10k के लिए गति काफी धीमी है।

उम्मीद है कि यह मदद कर सकता है।

public static List<String> hashMapIntersection(List<String> target, List<String> support) {
    List<String> r = new ArrayList<String>();
    Map<String, Integer> map = new HashMap<String, Integer>();
    for (String s : support) {
        map.put(s, 0);
    }
    for (String s : target) {
        if (map.containsKey(s)) {
            r.add(s);
        }
    }
    return r;
}
public static List<String> hashSetIntersection(List<String> a, List<String> b) {
    Long start = System.currentTimeMillis();

    List<String> r = new ArrayList<String>();
    Set<String> set = new HashSet<String>(b);

    for (String s : a) {
        if (set.contains(s)) {
            r.add(s);
        }
    }
    print("intersection:" + r.size() + "-" + String.valueOf(System.currentTimeMillis() - start));
    return r;
}

public static void union(List<String> a, List<String> b) {
    Long start = System.currentTimeMillis();
    Set<String> r= new HashSet<String>(a);
    r.addAll(b);
    print("union:" + r.size() + "-" + String.valueOf(System.currentTimeMillis() - start));
}

Answer 20

सामान्य तत्व को खोजने के लिए रिटेल () विधि का उपयोग करें। चौराहे की सूची 1। सही सूची (सूची 2)

Answer 21

यदि आपके पास सेट्स में आपका डेटा था तो आप अमरूद की Setsकक्षा का उपयोग कर सकते थे ।

Answer 22

यदि मैं जितनी संख्या की जाँच कर रहा हूँ, वह पहली बार हो रही है या "indexOf ()" की मदद से नहीं हो रही है यदि संख्या पहली बार मेल खाती है तो एक स्ट्रिंग में प्रिंट और सेव करें, ताकि जब अगली बार उसी संख्या से मिलान हो तो वह जीत जाए ' t प्रिंट क्योंकि "indexOf ()" के कारण स्थिति झूठी होगी।

class Intersection
{
public static void main(String[] args)
 {
  String s="";
    int[] array1 = {1, 2, 5, 5, 8, 9, 7,2,3512451,4,4,5 ,10};
    int[] array2 = {1, 0, 6, 15, 6, 5,4, 1,7, 0,5,4,5,2,3,8,5,3512451};


       for (int i = 0; i < array1.length; i++)
       {
           for (int j = 0; j < array2.length; j++)
           {
               char c=(char)(array1[i]);
               if(array1[i] == (array2[j])&&s.indexOf(c)==-1)
               {    
                System.out.println("Common element is : "+(array1[i]));
                s+=c;
                }
           }
       }    
}

}

Comments

एक उत्तर के रूप में कोड को पोस्ट न करें, आप जो कुछ भी कर रहे हैं, उसकी थोड़ी सी व्याख्या करें

— ब्रैंडन ज़मपैड

यह मेरा पहला कार्यक्रम है जिसे मैंने अपलोड किया है

— आशुतोष

हालाँकि यह कोड समस्या को हल करने में मदद कर सकता है, यह इस बात की व्याख्या नहीं करता है कि यह सवाल का जवाब क्यों और / या कैसे देता है। इस अतिरिक्त संदर्भ को प्रदान करने से इसके दीर्घकालिक मूल्य में काफी सुधार होगा। कृपया स्पष्टीकरण जोड़ने के लिए अपने जवाब को संपादित करें, जिसमें सीमाएं और मान्यताएं शामिल हैं।

— टोबे स्पाइट