Как лучше всего удалить дубликаты в массиве в Java?

Я согласен с вашим подходом к переопределению hashCode() и equals() и использованию чего-то, что реализует Set.

Это также делает абсолютно ясным для всех других разработчиков, что требуется не дублирующая характеристика.

Еще одна причина - теперь вы можете выбрать реализацию, которая лучше всего соответствует вашим потребностям:

• HashSet
• TreeSet
• LinkedHashSet

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

Set определенно ваш лучший выбор. Единственный способ удалить что-либо из массива (без создания нового) - это обнулить их, а затем вы получите множество проверок на null позже.

Моей первой мыслью тоже было переопределение equals и hashCode и создание набора. В любом случае рекомендуется иметь в иерархии наследования некоторую переопределенную версию этих методов.

Я считать, что если вы используете LinkedHashSet, вы даже сохраните порядок уникальных элементов ...

Я нашел это в сети

Вот два метода, которые позволяют удалять дубликаты в ArrayList. removeDuplicate не поддерживает порядок, в то время как removeDuplicateWithOrder поддерживает порядок с некоторыми издержками производительности.

1. Метод removeDuplicate:

   /** List order not maintained **/
   public static void removeDuplicate(ArrayList arlList)
   {
    HashSet h = new HashSet(arlList);
    arlList.clear();
    arlList.addAll(h);
   }
   

2. Метод removeDuplicateWithOrder:

   /** List order maintained **/
   public static void removeDuplicateWithOrder(ArrayList arlList)
   {
      Set set = new HashSet();
      List newList = new ArrayList();
      for (Iterator iter = arlList.iterator(); iter.hasNext();) {
         Object element = iter.next();
         if (set.add(element))
            newList.add(element);
      }
      arlList.clear();
      arlList.addAll(newList);
   }
   

Исходя из общего стандарта программирования, вы всегда можете дважды перечислить коллекции, а затем сравнить источник и цель.

И если ваше внутреннее перечисление всегда начинается с одной записи после источника, это довольно эффективно (псевдокод для подражания)

foreach ( array as source )
{
    // keep track where we are in the array
    place++;
    // loop the array starting at the entry AFTER the current one we are comparing to
    for ( i=place+1; i < max(array); i++ )
    {
        if ( source === array[place] )
        {
            destroy(array[i]);
        }
    }
}

Возможно, вы могли бы добавить перерыв; после уничтожения, но тогда вы обнаружите только первый дубликат, но если это все, что у вас когда-либо будет, тогда это будет хорошая небольшая оптимизация.

Я хотел бы повторить мысль, высказанную Джейсоном в комментариях:

Зачем вообще ставить себя в эту точку?

Зачем использовать массив для структуры данных, в которой вообще не должно быть дубликатов?

Всегда используйте Set или SortedSet (когда элементы тоже имеют естественный порядок), чтобы удерживать элементы. Если вам нужно сохранить порядок вставки, вы можете использовать LinkedHashSet, как было указано.

Необходимость постобработки некоторой структуры данных часто является намеком на то, что вы должны были выбрать для начала другую.

Конечно, в исходном сообщении возникает вопрос: «Как вы вообще получили этот массив (который может содержать повторяющиеся записи)?»

Вам нужен массив (с дубликатами) для других целей, или вы могли бы просто использовать Set с самого начала?

В качестве альтернативы, если вам нужно знать количество появлений каждого значения, вы можете использовать Map<CustomObject, Integer> для отслеживания счетчиков. Также может оказаться полезным определение Коллекции Google классов Multimap.

По сути, вам нужна реализация LinkedHashSet<T>, которая поддерживает интерфейс List<T> для произвольного доступа. Следовательно, это то, что вам нужно:

public class LinkedHashSetList<T> extends LinkedHashSet<T> implements List<T> {

// Implementations for List<T> methods here...

}

Реализация методов List<T> будет обращаться к лежащему в основе LinkedHashSet<T> и манипулировать им. Хитрость заключается в том, чтобы этот класс вел себя правильно, когда кто-то пытается добавить дубликаты с помощью методов добавления List<T> (выбрасывание исключения или повторное добавление элемента в другой индекс будут вариантами: которые вы можете либо выбрать один из, либо сделать настраиваемым пользователями класса).

Используйте список distinctList для записи элемента, когда iterator впервые сталкивается с ним, возвращает отдельный список, поскольку список удаляет все дубликаты

 private List removeDups(List list) {
        Set tempSet = new HashSet();
        List distinctList = new ArrayList();
        for(Iterator  it = list.iterator(); it.hasNext();) {
            Object next = it.next();
            if (tempSet.add(next)) {
                distinctList.add(next);
            } 
        }
        return distinctList;
   }