web-dev-qa-db-ja.com

Java 8、重複要素を見つけるためのストリーム

たとえば、整数リストの重複する要素をリストしようとしています

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

jdk 8のStreamsを使用しています。重複を削除するには、distinct（）APIを使用できます。しかし、重複した要素を見つけるのはどうですか？誰でも私を助けることができますか？

javalambdajava-8java-stream
67
Siva

Collections.frequency を使用できます。

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

配列の内容全体を保持するには、セット（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]
46
Dave

基本的な例。前半は周波数マップを作成し、後半はフィルターされたリストにそれを縮小します。おそらくDaveの答えほど効率的ではありませんが、より多用途です（正確に2つを検出したい場合など）。

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

マイ StreamEx Java 8ストリームを強化するライブラリは、特別な操作を提供します distinct(atLeast) は、指定された回数以上出現する要素のみを保持できます。あなたの問題は次のように解決できます：

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

内部的には@Daveソリューションに似ており、他の必要な数量をサポートするためにオブジェクトをカウントし、並列フレンドリーです（並列ストリームにはConcurrentHashMapを使用しますが、順次にはHashMapを使用します）。大量のデータの場合、.parallel().distinct(2)を使用して高速化できます。

13
Tagir Valeev

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

このアプローチでは、スペースの複雑さは2倍になりますが、そのスペースは無駄ではありません。実際には、セットとしてだけでなく、すべての重複も削除された別のセットとしてのみ複製されています。

11
Thomas Mathew

このように複製することができます：

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());
4
Oussama Zoghlami

質問に対する基本的な解決策は次のようにすべきだと思います。

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

フィルター操作を実行することはお勧めできませんが、理解を深めるために使用しました。さらに、将来のバージョンではカスタムフィルターを使用する必要があります。

4
Prashant

追加のマップまたはストリームの作成は時間とスペースを消費します…

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]


…そしてその質問については、a[duplicate]

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

マルチセットは、各要素の出現回数を保持する構造です。 Guava実装の使用：

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

私はこのような問題を解決する良い方法があると思います-リスト=>リストをSomething.aとSomething.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（...）にあります:)

0
Константин Журов

インデックスのチェックはどうですか？

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

この解決策を試してください：

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

}
0
Ilia Galperin

重複の存在のみを検出する必要がある場合（OPが望んでいるものをリストするのではなく）、それらをリストとセットの両方に変換し、サイズを比較します。

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

このアプローチが好きなのは、ミスを犯す場所が少ないからです。

0
Patrick

Java 8イディオム（スチーム）を使用する必要がありますか？単純な解決策は、数値をキーとして（繰り返しなしで）保持し、値として発生する時間を保持するマップ構造のデータ構造に複雑さを移すことです。あなたはそれらを繰り返して、マップは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());
    }
  }
}
0
Victor