Java 8, Yinelenen öğeleri bulmak için Akışlar

Tamsayı listesindeki yinelenen öğeleri listelemeye çalışıyorum, örneğin örneğin,

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

jdk 8 Akışlarını kullanarak. Kimse denedi mi. Yinelenenleri kaldırmak için, farklı () api kullanabiliriz. Peki yinelenen öğeleri bulmaya ne dersiniz? Bana yardım edebilecek biri var mı?

Şunları kullanabilirsiniz Collections.frequency:

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

Temel örnek. İlk yarı frekans haritasını oluşturur, ikinci yarı onu filtrelenmiş bir listeye indirger. Muhtemelen Dave'in cevabı kadar verimli değil, ancak daha çok yönlü (tam olarak iki tane tespit etmek istiyorsanız gibi)

     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() );

allItemsTüm dizi içeriğini tutmak için bir kümeye ( aşağıda) ihtiyacınız var , ancak bu 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]

Bir O (n) yolu aşağıdaki gibi olacaktır:

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());

Bu yaklaşımda uzay karmaşıklığı iki katına çıkar, ancak bu alan bir israf değildir; aslında, artık sadece bir Set olarak tek başına kopyalananların yanı sıra tüm kopyaların kaldırıldığı başka bir Set olarak da var.

Java 8 akışlarını geliştiren My StreamEx kitaplığı, distinct(atLeast)yalnızca en az belirtilen sayıda görünen öğeleri tutabilen özel bir işlem sağlar . Yani probleminiz şu şekilde çözülebilir:

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

Dahili olarak @Dave çözümüne benzer, diğer istenen miktarları desteklemek için nesneleri sayar ve paralel dostudur ( ConcurrentHashMapparalelleştirilmiş akış için kullanır , ancak HashMapsıralı için). Büyük miktarda veri için kullanarak hızlandırabilirsiniz .parallel().distinct(2).

Kopyalanmış olanı şu şekilde elde edebilirsiniz:

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());

Sorunun temel çözümlerinin aşağıdaki gibi olması gerektiğini düşünüyorum:

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());

Eh, bir filtre işlemi yapmanız tavsiye edilmez, ancak daha iyi anlamak için kullandım, ayrıca gelecekteki sürümlerde bazı özel filtreleme olması gerekir.

Çoklu set, her bir elemanın oluşum sayısını koruyan bir yapıdır. Guava uygulamasını kullanma:

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

Ek bir haritanın veya akışın oluşturulması zaman ve yer kaplar…

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]

… Ve hangisinin [kopya] olduğu iddia edilen soru için

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() );
}

Yalnızca yinelenenlerin varlığını tespit etmeniz gerekiyorsa (bunları listelemek yerine, ki bu OP'nin istediği şeydir), onları hem Liste hem de Küme'ye dönüştürün, ardından boyutları karşılaştırın:

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

Bu yaklaşımı seviyorum çünkü daha az hata yeri var.

Sanırım böyle bir sorunu nasıl çözeceğime dair iyi bir çözüme sahip olduğumu düşünüyorum - Liste => Bir Şeye göre gruplama ile Liste. Genişletilmiş tanım var:

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);
    }

}

sınıf A, liste1 sadece gelen veri - sihir Objects.hash (...) :)

Java 8 deyimlerini (steams) kullanmak zorunda mısınız? Basit bir çözüm, karmaşıklığı, sayıları anahtar olarak (tekrar etmeden) ve bir değer olarak ortaya çıktığı zamanları tutan veri yapısına benzer bir haritaya taşımak olabilir. Bu haritayı yineleyebilir ve yalnızca> 1 olan sayılarla bir şeyler yapabilirsin.

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());
    }
  }
}

Bu çözümü deneyin:

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;
}

}

Dizinlerin kontrol edilmesine ne dersiniz?

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