Java 8, Luồng để tìm các phần tử trùng lặp

Tôi đang cố gắng liệt kê các phần tử trùng lặp trong danh sách số nguyên, ví dụ:

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

bằng cách sử dụng Streams of jdk 8. Có ai đã thử. Để loại bỏ các bản sao, chúng ta có thể sử dụng api riêng biệt (). Nhưng còn việc tìm các phần tử trùng lặp thì sao? Ai có thể giúp tôi ra ngoài?

Bạn có thể sử dụng Collections.frequency:

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

Ví dụ cơ bản. Nửa đầu xây dựng bản đồ tần suất, nửa sau giảm nó thành một danh sách được lọc. Có lẽ không hiệu quả như câu trả lời của Dave, nhưng linh hoạt hơn (như nếu bạn muốn phát hiện chính xác hai, v.v.)

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

Bạn cần một bộ ( allItemsbên dưới) để chứa toàn bộ nội dung mảng, nhưng đây là 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]

Một cách O (n) sẽ như sau:

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

Sự phức tạp về không gian sẽ tăng gấp đôi trong cách tiếp cận này, nhưng không gian đó không phải là một sự lãng phí; trên thực tế, bây giờ chúng ta chỉ có một bộ trùng lặp dưới dạng một Bộ cũng như một Bộ khác với tất cả các bản sao cũng bị loại bỏ.

Thư viện StreamEx của tôi giúp tăng cường các luồng Java 8 cung cấp một hoạt động đặc biệt distinct(atLeast)có thể chỉ giữ lại các phần tử xuất hiện ít nhất một số lần được chỉ định. Vì vậy, vấn đề của bạn có thể được giải quyết như sau:

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

Bên trong nó tương tự như giải pháp @Dave, nó đếm các đối tượng, để hỗ trợ các số lượng mong muốn khác và nó thân thiện với song song (nó sử dụng ConcurrentHashMapcho luồng song song, nhưng HashMapcho tuần tự). Đối với lượng lớn dữ liệu, bạn có thể tăng tốc độ bằng cách sử dụng .parallel().distinct(2).

Bạn có thể nhận được bản sao như thế này:

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

Tôi nghĩ các giải pháp cơ bản cho câu hỏi nên như sau:

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

tốt, bạn không nên thực hiện thao tác bộ lọc, nhưng để hiểu rõ hơn, tôi đã sử dụng nó, hơn nữa, nên có một số bộ lọc tùy chỉnh trong các phiên bản sau.

Tập hợp nhiều là cấu trúc duy trì số lần xuất hiện cho mỗi phần tử. Sử dụng Guava thực hiện:

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

việc tạo một bản đồ hoặc luồng bổ sung tốn nhiều thời gian và không gian…

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]

… Và đối với câu hỏi được cho là [trùng lặp]

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

Nếu bạn chỉ cần phát hiện sự hiện diện của các bản sao (thay vì liệt kê chúng, đó là điều OP muốn), chỉ cần chuyển đổi chúng thành cả Danh sách và Tập hợp, sau đó so sánh các kích thước:

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

Tôi thích cách tiếp cận này vì nó có ít chỗ sai hơn.

Tôi nghĩ rằng tôi có giải pháp tốt để khắc phục sự cố như thế này - Danh sách => Danh sách với nhóm theo Something.a & Something.b. Có định nghĩa mở rộng:

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

}

class A, list1 nó chỉ là dữ liệu đến - phép thuật nằm trong Objects.hash (...) :)

Bạn có phải sử dụng các thành ngữ java 8 (hơi nước) không? Có lẽ một giải pháp đơn giản sẽ là chuyển độ phức tạp sang một cấu trúc dữ liệu giống như bản đồ, giữ các số làm khóa (không lặp lại) và thời gian nó xuất hiện dưới dạng giá trị. Bạn có thể họ lặp lại bản đồ đó để làm điều gì đó chỉ với những con số có giá trị> 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());
    }
  }
}

Hãy thử giải pháp này:

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

}

Điều gì về việc kiểm tra các chỉ mục?

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