Java 8, Streams, um die doppelten Elemente zu finden

Benötigen Sie ein set (allItems unten) zu halten, die ganze array-Inhalte, aber das ist 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]

InformationsquelleAutor der Antwort Dave

Meine StreamEx Bibliothek verbessert die Java-8-streams bietet eine spezielle operation distinct(mindestens)die können behalten Sie nur Elemente, die mindestens die angegebene Anzahl von Zeiten. So kann dein problem gelöst werden, wie dieses:

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

Intern ist es ähnlich wie @Dave Lösung zählt es Objekte, zu unterstützen, andere wollten Mengen und es ist-parallel-freundlich (es verwendet ConcurrentHashMap für parallelisiert stream, aber HashMap für sequenziell). Für große Datenmengen können Sie Holen Sie sich ein speed-up mit .parallel().distinct(2).

InformationsquelleAutor der Antwort Tagir Valeev

Können Sie die duplizierte wie diese :

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

InformationsquelleAutor der Antwort Oussama Zoghlami

Ich denke, ich habe eine gute Lösung wie kann man das problem, wie diese - Liste => Liste mit Gruppierung nach Etwas.a & Etwas.b.
Es gibt erweiterte definition:

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

}

Klasse A, Liste1 es ist nur eingehenden Daten - die Magie der Objekte.hash(...) 🙂

InformationsquelleAutor der Antwort Константин Журов

Probieren Sie diese Lösung:

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

}

InformationsquelleAutor der Antwort Ilia Galperin