Java: ¿Detectar duplicados en ArrayList?

¿Cómo podría detectar (devolver verdadero / falso) si una ArrayList contiene más de uno del mismo elemento en Java?

Muchas gracias Terry

Editar Olvidé mencionar que no estoy buscando comparar "Bloques" entre sí, sino sus valores enteros. Cada "bloque" tiene un int y esto es lo que los hace diferentes. Encuentro el int de un Bloque en particular llamando a un método llamado "getNum" (por ejemplo, table1 [0] [2] .getNum ();

Lo más simple: volcar toda la colección en un Conjunto (usando el constructor Set (Colección) o Set.addAll), luego ver si el Conjunto tiene el mismo tamaño que ArrayList.

List<Integer> list = ...;
Set<Integer> set = new HashSet<Integer>(list);

if(set.size() < list.size()){
    /* There are duplicates */
}

Actualización: si entiendo su pregunta correctamente, tiene una matriz 2d de Block, como en

Tabla de bloques [] [];

y quieres detectar si alguna fila de ellos tiene duplicados?

En ese caso, podría hacer lo siguiente, asumiendo que Block implementa "equals" y "hashCode" correctamente:

for (Block[] row : table) {
   Set set = new HashSet<Block>(); 
   for (Block cell : row) {
      set.add(cell);
   }
   if (set.size() < 6) { //has duplicate
   }
}

No estoy 100% seguro de eso para la sintaxis, por lo que sería más seguro escribirlo como

for (int i = 0; i < 6; i++) {
   Set set = new HashSet<Block>(); 
   for (int j = 0; j < 6; j++)
    set.add(table[i][j]);
 ...

Set.adddevuelve un booleano falso si el elemento que se está agregando ya está en el conjunto, por lo que incluso podría hacer un cortocircuito y descartar cualquier adición que devuelva falsesi todo lo que desea saber es si hay duplicados.

Código mejorado, usando el valor de retorno de en Set#addlugar de comparar el tamaño de la lista y el conjunto.

public static <T> boolean hasDuplicate(Iterable<T> all) {
    Set<T> set = new HashSet<T>();
    // Set#add returns false if the set does not change, which
    // indicates that a duplicate element has been added.
    for (T each: all) if (!set.add(each)) return true;
    return false;
}

Si está buscando evitar tener duplicados, entonces debe cortar el proceso intermedio de detección de duplicados y usar un Conjunto .

Código mejorado para devolver los elementos duplicados.

• Puede encontrar duplicados en una colección
• devolver el conjunto de duplicados
• Los elementos únicos se pueden obtener del conjunto

public static <T> List getDuplicate(Collection<T> list) {

    final List<T> duplicatedObjects = new ArrayList<T>();
    Set<T> set = new HashSet<T>() {
    @Override
    public boolean add(T e) {
        if (contains(e)) {
            duplicatedObjects.add(e);
        }
        return super.add(e);
    }
    };
   for (T t : list) {
        set.add(t);
    }
    return duplicatedObjects;
}


public static <T> boolean hasDuplicate(Collection<T> list) {
    if (getDuplicate(list).isEmpty())
        return false;
    return true;
}

Si sus elementos son de alguna manera Comparables (el hecho de que el orden tenga un significado real es indiferente, solo debe ser consistente con su definición de igualdad), la solución de eliminación de duplicados más rápida será ordenar la lista (0 (n log ( n))) luego hacer una sola pasada y buscar elementos repetidos (es decir, elementos iguales que se suceden) (esto es O (n)).

La complejidad general será O (n log (n)), que es aproximadamente la misma que obtendría con un Conjunto (n veces largo (n)), pero con una constante mucho menor. Esto se debe a que la constante en ordenar / deducir resulta del costo de comparar elementos, mientras que el costo del conjunto es más probable que resulte de un cálculo hash, más una (posiblemente varias) comparaciones hash. Si está utilizando una implementación de conjunto basada en hash, es decir, porque una basada en árbol le dará un O (n log² (n)), que es incluso peor.

Sin embargo, según tengo entendido, no es necesario eliminar los duplicados, sino simplemente probar su existencia. Por lo tanto, debe codificar manualmente un algoritmo de combinación o clasificación de montón en su matriz, que simplemente sale devolviendo verdadero (es decir, "hay un dup") si su comparador devuelve 0, y de lo contrario completa la clasificación, y atraviesa la prueba de matriz ordenada para repeticiones . En una combinación o clasificación de pila, de hecho, cuando se complete la clasificación, habrá comparado cada par duplicado a menos que ambos elementos ya estuvieran en sus posiciones finales (lo cual es poco probable). Por lo tanto, un algoritmo de clasificación modificado debería producir una gran mejora en el rendimiento (tendría que demostrar eso, pero supongo que el algoritmo modificado debería estar en O (log (n)) en datos uniformemente aleatorios)

Necesitaba hacer una operación similar para a Stream, pero no pude encontrar un buen ejemplo. Esto es lo que se me ocurrió.

public static <T> boolean areUnique(final Stream<T> stream) {
    final Set<T> seen = new HashSet<>();
    return stream.allMatch(seen::add);
}

Esto tiene la ventaja de producir un cortocircuito cuando los duplicados se encuentran temprano en lugar de tener que procesar todo el flujo y no es mucho más complicado que simplemente poner todo en un Sety verificar el tamaño. Entonces este caso sería aproximadamente:

List<T> list = ...
boolean allDistinct = areUnique(list.stream());

Con Java 8+ puede utilizar Stream API:

boolean areAllDistinct(List<Block> blocksList) {
    return blocksList.stream().map(Block::getNum).distinct().count() == blockList.size();
}

En pocas palabras: 1) asegúrese de que todos los elementos sean comparables 2) ordene la matriz 2) repita la matriz y encuentre duplicados

Para conocer los Duplicados en una Lista use el siguiente código: Le dará el conjunto que contiene los duplicados.

 public Set<?> findDuplicatesInList(List<?> beanList) {
    System.out.println("findDuplicatesInList::"+beanList);
    Set<Object> duplicateRowSet=null;
    duplicateRowSet=new LinkedHashSet<Object>();
            for(int i=0;i<beanList.size();i++){
                Object superString=beanList.get(i);
                System.out.println("findDuplicatesInList::superString::"+superString);
                for(int j=0;j<beanList.size();j++){
                    if(i!=j){
                         Object subString=beanList.get(j);
                         System.out.println("findDuplicatesInList::subString::"+subString);
                         if(superString.equals(subString)){
                             duplicateRowSet.add(beanList.get(j));
                         }
                    }
                }
            }
            System.out.println("findDuplicatesInList::duplicationSet::"+duplicateRowSet);
        return duplicateRowSet;
  }

La mejor manera de manejar este problema es usar un HashSet :

ArrayList<String> listGroupCode = new ArrayList<>();
listGroupCode.add("A");
listGroupCode.add("A");
listGroupCode.add("B");
listGroupCode.add("C");
HashSet<String> set = new HashSet<>(listGroupCode);
ArrayList<String> result = new ArrayList<>(set);

Simplemente imprima la lista de matrices de resultados y vea el resultado sin duplicados :)

Si desea el conjunto de valores duplicados:

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

public class FindDuplicateInArrayList {

    public static void main(String[] args) {

        Set<String> uniqueSet = new HashSet<String>();
        List<String> dupesList = new ArrayList<String>();
        for (String a : args) {
            if (uniqueSet.contains(a))
                dupesList.add(a);
            else
                uniqueSet.add(a);
        }
        System.out.println(uniqueSet.size() + " distinct words: " + uniqueSet);
        System.out.println(dupesList.size() + " dupesList words: " + dupesList);
    }
}

Y probablemente también piense en recortar valores o usar minúsculas ... según su caso.

    String tempVal = null;
    for (int i = 0; i < l.size(); i++) {
        tempVal = l.get(i); //take the ith object out of list
        while (l.contains(tempVal)) {
            l.remove(tempVal); //remove all matching entries
        }
        l.add(tempVal); //at last add one entry
    }

Nota: esto tendrá un gran impacto en el rendimiento, ya que los elementos se eliminan del inicio de la lista. Para abordar esto, tenemos dos opciones. 1) iterar en orden inverso y eliminar elementos. 2) Utilice LinkedList en lugar de ArrayList. Debido a las preguntas sesgadas que se hacen en las entrevistas para eliminar los duplicados de la Lista sin usar ninguna otra colección, el ejemplo anterior es la respuesta. Sin embargo, en el mundo real, si tengo que lograr esto, pondré elementos de List en Set, ¡simple!

/**
     * Method to detect presence of duplicates in a generic list. 
     * Depends on the equals method of the concrete type. make sure to override it as required.
     */
    public static <T> boolean hasDuplicates(List<T> list){
        int count = list.size();
        T t1,t2;

        for(int i=0;i<count;i++){
            t1 = list.get(i);
            for(int j=i+1;j<count;j++){
                t2 = list.get(j);
                if(t2.equals(t1)){
                    return true;
                }
            }
        }
        return false;
    }

Un ejemplo de una clase concreta que se ha anulado equals():

public class Reminder{
    private long id;
    private int hour;
    private int minute;

    public Reminder(long id, int hour, int minute){
        this.id = id;
        this.hour = hour;
        this.minute = minute;
    }

    @Override
    public boolean equals(Object other){
        if(other == null) return false;
        if(this.getClass() != other.getClass()) return false;
        Reminder otherReminder = (Reminder) other;
        if(this.hour != otherReminder.hour) return false;
        if(this.minute != otherReminder.minute) return false;

        return true;
    }
}

    ArrayList<String> withDuplicates = new ArrayList<>();
    withDuplicates.add("1");
    withDuplicates.add("2");
    withDuplicates.add("1");
    withDuplicates.add("3");
    HashSet<String> set = new HashSet<>(withDuplicates);
    ArrayList<String> withoutDupicates = new ArrayList<>(set);

    ArrayList<String> duplicates = new ArrayList<String>();

    Iterator<String> dupIter = withDuplicates.iterator();
    while(dupIter.hasNext())
    {
    String dupWord = dupIter.next();
    if(withDuplicates.contains(dupWord))
    {
        duplicates.add(dupWord);
    }else{
        withoutDupicates.add(dupWord);
    }
    }
  System.out.println(duplicates);
  System.out.println(withoutDupicates);

Esta respuesta está escrita en Kotlin, pero se puede traducir fácilmente a Java.

Si el tamaño de su lista de arrays está dentro de un rango pequeño fijo, entonces esta es una gran solución.

var duplicateDetected = false
    if(arrList.size > 1){
        for(i in 0 until arrList.size){
            for(j in 0 until arrList.size){
                if(i != j && arrList.get(i) == arrList.get(j)){
                    duplicateDetected = true
                }
            }
        }
    }

private boolean isDuplicate() {
    for (int i = 0; i < arrayList.size(); i++) {
        for (int j = i + 1; j < arrayList.size(); j++) {
            if (arrayList.get(i).getName().trim().equalsIgnoreCase(arrayList.get(j).getName().trim())) {
                return true;
            }
        }
    }

    return false;
}