Как проверить, совпадают ли два объекта в ArrayList? [Дубликат]

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

Чтобы знать дубликаты в списке, используйте следующий код: он даст вам набор, содержащий дубликаты.

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

лучший способ справиться с этой проблемой - использовать 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);

Просто напечатать результирующий арифметик и увидеть результат без дубликатов:)

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

Если ваши элементы каким-то образом сопоставимы (тот факт, что порядок имеет какой-либо реальный смысл, равнодушен - он просто должен соответствовать вашему определению равенства), самое быстрое решение для удаления дубликатов собирается сортировать список (0 ( n log (n))), затем выполнить один проход и искать повторяющиеся элементы (то есть равные элементы, которые следуют друг за другом) (это O (n)).

Общая сложность будет O (n log (n)), что примерно совпадает с тем, что вы получите с помощью Set (n times long (n)), но с гораздо меньшей константой. Это связано с тем, что константа в sort / dedup возникает из-за стоимости сравнения элементов, тогда как стоимость из набора, скорее всего, будет результатом вычисления хеша, плюс одно (возможно, несколько) хеш-сравнений. Если вы используете реализацию Set на основе хэша, то есть потому, что Tree based даст вам O (n log² (n)), что еще хуже.

Как я понимаю, однако вам не нужно удалить дубликаты, а просто проверить их существование. Таким образом, вы должны вручную скомпилировать алгоритм сортировки слияния или кучи в своем массиве, который просто выдает возвращаемое значение true (т. Е. «Есть дубликат»), если ваш компаратор возвращает 0 и в противном случае завершает сортировку и проходит проверку отсортированного массива для повторов , В случае слияния или кучи, действительно, когда сортировка будет завершена, вы будете сравнивать каждую повторяющуюся пару, если оба элемента уже не находятся в их конечных положениях (что маловероятно). Таким образом, алгоритм выборочной сортировки должен дать огромное повышение производительности (я должен был бы это доказать, но, я думаю, алгоритм с измененным алгоритмом должен быть в O (log (n)) на равномерно случайных данных)