जावा 8, डुप्लिकेट तत्वों को खोजने के लिए स्ट्रीम करता है

Question 1

मैं पूर्णांक सूची में डुप्लिकेट तत्वों को सूचीबद्ध करने की कोशिश कर रहा हूं जैसे कि,

List<Integer> numbers = Arrays.asList(new Integer[]{1,2,1,3,4,4});

Jdk 8 की धाराओं का उपयोग करना। क्या किसी ने कोशिश की है। डुप्लिकेट को निकालने के लिए हम विशिष्ट () एपीआई का उपयोग कर सकते हैं। लेकिन डुप्लिकेट तत्वों को खोजने के बारे में क्या? कोई भी मेरी मदद कर सकता है?

Question 2

आप उपयोग कर सकते हैं Collections.frequency:

numbers.stream().filter(i -> Collections.frequency(numbers, i) >1)
                .collect(Collectors.toSet()).forEach(System.out::println);

Question 3

मूल उदाहरण। फ़र्स्ट-हाफ़ फ़्रीक्वेंसी-मैप बनाता है, सेकंड-हाफ़ इसे फ़िल्टर की गई सूची में कम कर देता है। शायद डेव के उत्तर के रूप में कुशल नहीं है, लेकिन अधिक बहुमुखी (जैसे कि यदि आप वास्तव में दो का पता लगाना चाहते हैं आदि)।

     List<Integer> duplicates = IntStream.of( 1, 2, 3, 2, 1, 2, 3, 4, 2, 2, 2 )
       .boxed()
       .collect( Collectors.groupingBy( Function.identity(), Collectors.counting() ) )
       .entrySet()
       .stream()
       .filter( p -> p.getValue() > 1 )
       .map( Map.Entry::getKey )
       .collect( Collectors.toList() );

Question 4

allItemsसंपूर्ण सरणी सामग्री को रखने के लिए आपको एक सेट ( नीचे) की आवश्यकता है, लेकिन यह O (n) है:

Integer[] numbers = new Integer[] { 1, 2, 1, 3, 4, 4 };
Set<Integer> allItems = new HashSet<>();
Set<Integer> duplicates = Arrays.stream(numbers)
        .filter(n -> !allItems.add(n)) //Set.add() returns false if the item was already in the set.
        .collect(Collectors.toSet());
System.out.println(duplicates); // [1, 4]

Question 5

एक O (n) तरीका इस प्रकार होगा:

List<Integer> numbers = Arrays.asList(1, 2, 1, 3, 4, 4);
Set<Integer> duplicatedNumbersRemovedSet = new HashSet<>();
Set<Integer> duplicatedNumbersSet = numbers.stream().filter(n -> !duplicatedNumbersRemovedSet.add(n)).collect(Collectors.toSet());

अंतरिक्ष की जटिलता इस दृष्टिकोण में दोगुनी हो जाएगी, लेकिन वह स्थान बेकार नहीं है; वास्तव में, अब हमारे पास केवल एक सेट के साथ-साथ दूसरे डुप्लिकेट को भी हटा दिया गया है।

Question 6

मेरी स्ट्रीमटेक्स लाइब्रेरी जो जावा 8 स्ट्रीम को बढ़ाती है, एक विशेष ऑपरेशन प्रदान करती है distinct(atLeast)जो कम से कम निर्दिष्ट समय में प्रदर्शित होने वाले तत्वों को बनाए रख सकती है। तो आपकी समस्या इस तरह हल हो सकती है:

List<Integer> repeatingNumbers = StreamEx.of(numbers).distinct(2).toList();

आंतरिक रूप से यह @Dave समाधान के समान है, यह वस्तुओं को गिनता है, अन्य वांछित मात्राओं का समर्थन करने के लिए और यह समानांतर-अनुकूल है (यह ConcurrentHashMapसमानांतर धारा के लिए उपयोग करता है, लेकिन HashMapअनुक्रमिक के लिए)। बड़ी मात्रा में डेटा के लिए आप स्पीड-अप का उपयोग कर प्राप्त कर सकते हैं .parallel().distinct(2)।

Question 7

आप इस तरह से डुप्लिकेट प्राप्त कर सकते हैं:

List<Integer> numbers = Arrays.asList(1, 2, 1, 3, 4, 4);
Set<Integer> duplicated = numbers
  .stream()
  .filter(n -> numbers
        .stream()
        .filter(x -> x == n)
        .count() > 1)
   .collect(Collectors.toSet());

Question 8

मुझे लगता है कि प्रश्न के मूल समाधान नीचे दिए गए होने चाहिए:

Supplier supplier=HashSet::new; 
HashSet has=ls.stream().collect(Collectors.toCollection(supplier));

List lst = (List) ls.stream().filter(e->Collections.frequency(ls,e)>1).distinct().collect(Collectors.toList());

ठीक है, यह एक फिल्टर ऑपरेशन करने के लिए अनुशंसित नहीं है, लेकिन बेहतर समझ के लिए, मैंने इसे इस्तेमाल किया है, इसके अलावा, भविष्य के संस्करणों में कुछ कस्टम निस्पंदन होना चाहिए।

Question 9

एक मल्टीसेट एक संरचना है जो प्रत्येक तत्व के लिए घटनाओं की संख्या को बनाए रखता है। अमरूद कार्यान्वयन का उपयोग:

Set<Integer> duplicated =
        ImmutableMultiset.copyOf(numbers).entrySet().stream()
                .filter(entry -> entry.getCount() > 1)
                .map(Multiset.Entry::getElement)
                .collect(Collectors.toSet());

Question 10

एक अतिरिक्त मानचित्र या स्ट्रीम का निर्माण समय- और अंतरिक्ष की खपत है ...

Set<Integer> duplicates = numbers.stream().collect( Collectors.collectingAndThen(
  Collectors.groupingBy( Function.identity(), Collectors.counting() ),
  map -> {
    map.values().removeIf( cnt -> cnt < 2 );
    return( map.keySet() );
  } ) );  // [1, 4]

... और जिस प्रश्न के लिए दावा किया जाता है कि एक [डुप्लिकेट]

public static int[] getDuplicatesStreamsToArray( int[] input ) {
  return( IntStream.of( input ).boxed().collect( Collectors.collectingAndThen(
      Collectors.groupingBy( Function.identity(), Collectors.counting() ),
      map -> {
        map.values().removeIf( cnt -> cnt < 2 );
        return( map.keySet() );
      } ) ).stream().mapToInt( i -> i ).toArray() );
}

Question 11

यदि आपको केवल डुप्लिकेट की उपस्थिति का पता लगाने की आवश्यकता है (उन्हें सूचीबद्ध करने के बजाय, जो ओपी चाहता था), बस उन्हें सूची और सेट दोनों में बदल दें, फिर आकारों की तुलना करें:

    List<Integer> list = ...;
    Set<Integer> set = new HashSet<>(list);
    if (list.size() != set.size()) {
      // duplicates detected
    }

मुझे यह दृष्टिकोण पसंद है क्योंकि इसमें गलतियों के लिए कम स्थान हैं।

Question 12

मुझे लगता है कि मेरे पास अच्छा समाधान है कि इस तरह की समस्या को कैसे ठीक किया जाए - सूची => कुछ और द्वारा समूह के साथ सूची। & Some.b। विस्तारित परिभाषा है:

public class Test {

    public static void test() {

        class A {
            private int a;
            private int b;
            private float c;
            private float d;

            public A(int a, int b, float c, float d) {
                this.a = a;
                this.b = b;
                this.c = c;
                this.d = d;
            }
        }


        List<A> list1 = new ArrayList<A>();

        list1.addAll(Arrays.asList(new A(1, 2, 3, 4),
                new A(2, 3, 4, 5),
                new A(1, 2, 3, 4),
                new A(2, 3, 4, 5),
                new A(1, 2, 3, 4)));

        Map<Integer, A> map = list1.stream()
                .collect(HashMap::new, (m, v) -> m.put(
                        Objects.hash(v.a, v.b, v.c, v.d), v),
                        HashMap::putAll);

        list1.clear();
        list1.addAll(map.values());

        System.out.println(list1);
    }

}

वर्ग A, list1 यह सिर्फ आने वाला डेटा है - जादू Objects.hash (...) :) में है

Question 13

क्या आपको जावा 8 मुहावरों (स्टीम) का उपयोग करना है? पेरैप्स एक सरल समाधान जटिलता को एक नक्शे डेटा संरचना में स्थानांतरित करने के लिए होगा जो संख्याओं को कुंजी के रूप में रखता है (दोहराए बिना) और समय इसे मान के रूप में ocurrs करता है। आप उन्हें बता सकते हैं कि मानचित्र केवल उन संख्याओं के साथ कुछ करता है जो ऑकुर> 1 हैं।

import java.lang.Math;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.HashMap;
import java.util.Iterator;

public class RemoveDuplicates
{
  public static void main(String[] args)
  {
   List<Integer> numbers = Arrays.asList(new Integer[]{1,2,1,3,4,4});
   Map<Integer,Integer> countByNumber = new HashMap<Integer,Integer>();
   for(Integer n:numbers)
   {
     Integer count = countByNumber.get(n);
     if (count != null) {
       countByNumber.put(n,count + 1);
     } else {
       countByNumber.put(n,1);
     }
   }
   System.out.println(countByNumber);
   Iterator it = countByNumber.entrySet().iterator();
    while (it.hasNext()) {
        Map.Entry pair = (Map.Entry)it.next();
        System.out.println(pair.getKey() + " = " + pair.getValue());
    }
  }
}

Question 14

इस समाधान का प्रयास करें:

public class Anagramm {

public static boolean isAnagramLetters(String word, String anagramm) {
    if (anagramm.isEmpty()) {
        return false;
    }

    Map<Character, Integer> mapExistString = CharCountMap(word);
    Map<Character, Integer> mapCheckString = CharCountMap(anagramm);
    return enoughLetters(mapExistString, mapCheckString);
}

private static Map<Character, Integer> CharCountMap(String chars) {
    HashMap<Character, Integer> charCountMap = new HashMap<Character, Integer>();
    for (char c : chars.toCharArray()) {
        if (charCountMap.containsKey(c)) {
            charCountMap.put(c, charCountMap.get(c) + 1);
        } else {
            charCountMap.put(c, 1);
        }
    }
    return charCountMap;
}

static boolean enoughLetters(Map<Character, Integer> mapExistString, Map<Character,Integer> mapCheckString) {
    for( Entry<Character, Integer> e : mapCheckString.entrySet() ) {
        Character letter = e.getKey();
        Integer available = mapExistString.get(letter);
        if (available == null || e.getValue() > available) return false;
    }
    return true;
}

}

Question 15

इंडेक्स की जाँच के बारे में क्या?

        numbers.stream()
            .filter(integer -> numbers.indexOf(integer) != numbers.lastIndexOf(integer))
            .collect(Collectors.toSet())
            .forEach(System.out::println);