Extraiga objetos duplicados de una Lista en Java 8

Esta crónica ha sido evaluado por nuestros especialistas para que tengas la garantía de la exactitud de este escrito.

Solución:

Para identificar duplicados, ningún método que conozco es más adecuado que Collectors.groupingBy(). Esto le permite agrupar la lista en un mapa según una condición de su elección.

Su condición es una combinación de id y firstName. Extraigamos esta parte en un método propio en Person:

String uniqueAttributes() 
  return id + firstName;

Él getDuplicates() El método ahora es bastante sencillo:

public static List getDuplicates(final List personList) 
  return getDuplicatesMap(personList).values().stream()
      .filter(duplicates -> duplicates.size() > 1)
      .flatMap(Collection::stream)
      .collect(Collectors.toList());


private static Map> getDuplicatesMap(List personList) 
  return personList.stream().collect(groupingBy(Person::uniqueAttributes));

• La primera línea llama a otro método. getDuplicatesMap() para crear el mapa como se explicó anteriormente.
• Luego transmite los valores del mapa, que son listas de personas.
• Filtra todo excepto las listas con un tamaño superior a 1, es decir, encuentra los duplicados.
• Por fin, flatMap() se utiliza para aplanar el flujo de listas en un solo flujo de personas y recopila el flujo en una lista.

---

Una alternativa, si realmente identificas a las personas como iguales si tienen las mismas id y firstName es ir con la solución de Jonathan Johx e implementar un equals() método.

En este escenario, debe escribir su lógica personalizada para extraer los duplicados de la lista, obtendrá todos los duplicados en el Person lista

   public static List extractDuplicates(final List personList) 

    return personList.stream().flatMap(i -> 
        final AtomicInteger count = new AtomicInteger();
        final List duplicatedPersons = new ArrayList<>();

        personList.forEach(p -> 

            if (p.getId().equals(i.getId()) && p.getFirstName().equals(i.getFirstName())) 
                count.getAndIncrement();
            

            if (count.get() == 2) 
                duplicatedPersons.add(i);
            

        );

        return duplicatedPersons.stream();
    ).collect(Collectors.toList());

Aplicado a:

 List l = new ArrayList<>();
           Person alex = new 
 Person.Builder().id(1L).firstName("alex").secondName("salgado").build();
            Person lolita = new 
 Person.Builder().id(2L).firstName("lolita").secondName("llanero").build();
            Person elpidio = new 
 Person.Builder().id(3L).firstName("elpidio").secondName("ramirez").build();
            Person romualdo = new 
 Person.Builder().id(4L).firstName("romualdo").secondName("gomez").build();
            Person otroRomualdo = new 
 Person.Builder().id(4L).firstName("romualdo").secondName("perez").build();
      l.add(alex);
      l.add(lolita);
      l.add(elpidio);
      l.add(romualdo);
      l.add(otroRomualdo);

Producción:

[Person [id=4, firstName=romualdo, secondName=gomez], Person [id=4, firstName=romualdo, secondName=perez]]

Si pudieras implementar equals y hashCode sobre Person entonces podría usar un colector aguas abajo de conteo de la groupingBy para obtener distintos elementos que han sido duplicados.

List duplicates = personList.stream()
  .collect(groupingBy(identity(), counting()))
  .entrySet().stream()
  .filter(n -> n.getValue() > 1)
  .map(n -> n.getKey())
  .collect(toList());

Si desea mantener una lista de elementos repetidos secuenciales, puede expandirla usando Collections.nCopies para expandirla nuevamente. Este método garantizará que los elementos repetidos se ordenen juntos.

List duplicates = personList.stream()
    .collect(groupingBy(identity(), counting()))
    .entrySet().stream()
    .filter(n -> n.getValue() > 1)
    .flatMap(n -> nCopies(n.getValue().intValue(), n.getKey()).stream())
    .collect(toList());

Sección de Reseñas y Valoraciones

Acuérdate de que tienes la capacidad de decir .

---

---

Utiliza Nuestro Buscador