java 8 update вы можете использовать поток массива, как показано ниже:

Arrays.stream(yourArray).distinct()
                    .collect(Collectors.toList());

private void removeTheDuplicates(List<Customer>myList) {
    for(ListIterator<Customer>iterator = myList.listIterator(); iterator.hasNext();) {
        Customer customer = iterator.next();
        if(Collections.frequency(myList, customer) > 1) {
            iterator.remove();
        }
    }
    System.out.println(myList.toString());

}

Почти все приведенные выше ответы правильные, но я предлагаю использовать Map или Set при создании соответствующего списка, а не после получения производительности. Поскольку преобразование списка в Set или Map, а затем его повторное преобразование в список снова является тривиальной работой.

Пример кода:

Set<String> stringsSet = new LinkedHashSet<String>();//A Linked hash set 
//prevents the adding order of the elements
for (String string: stringsList) {
    stringsSet.add(string);
}
return new ArrayList<String>(stringsSet);

Список → Набор → Список (отдельный)

Просто добавьте все свои элементы в Set : он не позволяет повторять его элементы. Если вам понадобится список позже, используйте новый конструктор ArrayList(theSet) впоследствии (где theSet - ваш результирующий набор).

Class removeduplicates 
{
    public static void main(string args[[])
    {   
        int I;
        for(int =0;i'<10;I++)
        {
            system.out.println(+i);
            if([]I=[j])
            {
                system.out.println(1,2,3,1,1,1,2,2,2)
            }
        }
    }
}

ИМХО лучший способ, как это сделать в наши дни:

Предположим, у вас есть коллекция «dups», и вы хотите создать другую коллекцию, содержащую те же элементы, но со всеми дубликатами.

Collection<collectionType> noDups = new HashSet<collectionType>(dups);

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

На основе документа oracle doc.

Метод «содержит» проверяет, содержит ли список запись, возвращающую значение true из Customer.equals (Object o). Если вы не переопределили equals (Object) в Customer или один из его родителей, тогда он будет искать только существующее вхождение одного и того же объекта. Возможно, это было то, что вы хотели, и в этом случае ваш код должен работать. Но если вы искали не имеющие двух объектов, представляющих одного и того же клиента, тогда вам нужно переопределить equals (Object), чтобы вернуть true, когда это так.

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

Вы должны также переопределить hashCode (), когда вы переопределите equals ().

Правильный ответ для Java - это Установить . Если у вас уже есть List<Customer> и вы хотите его дублировать

Set<Customer> s = new HashSet<Customer>(listCustomer);

, используйте только функцию Set HashSet, TreeSet и пропустите фазу построения List.

Вам нужно будет переопределить hashCode() и equals() в ваших классах домена, которые помещены в Set, а также убедиться, что поведение, которое вы хотите на самом деле, получить. equals() может быть таким же простым, как сравнение уникальных идентификаторов объектов с такими сложными, как сравнение каждого поля. hashCode() может быть так же просто, как вернуть hashCode() уникального представления id 'String или hashCode().

Использование java 8 stream api.

    List<String> list = new ArrayList<>();
    list.add("one");
    list.add("one");
    list.add("two");
    System.out.println(list);
    Collection<String> c = list.stream().collect(Collectors.toSet());
    System.out.println(c);

Выход:

До значений: [один, один, два]

После значений: [один , два]

Два предложения:

• Используйте HashSet вместо ArrayList. Это значительно ускорит проверку contains (), если у вас длинный список
• Убедитесь, что Customer.equals () и Customer.hashCode () реализованы правильно, то есть они должны быть основаны на комбинированных значениях базовые поля в объекте клиента.

Я подозреваю, что у вас может быть неправильно реализовано Customer.equals() (или вообще).

List.contains() использует equals(), чтобы проверить, идентичен ли какой-либо из его элементов объекту, переданному как параметр. Тем не менее, реализация по умолчанию equals для физической идентичности, а не идентификатора ценности. Поэтому, если вы не перезаписали его в Customer, он вернет false для двух разных объектов Customer, имеющих идентичное состояние.

Ниже приведены подробные сведения о о том, как реализовать equals (и hashCode , который является его парой - вы должны практически всегда реализовывать оба варианта, если вам нужно реализовать любой из них). Поскольку вы не показали нам класс Customer, трудно дать более конкретные советы.

Как отмечали другие, вам лучше использовать Set вместо выполнения задания вручную, но даже для что вам все равно необходимо реализовать эти методы.

Выполняет ли клиент контракт equals()?

Если он не реализует equals() и hashCode(), тогда listCustomer.contains(customer) проверяет, существует ли уже такой же экземпляр в списке (например, I означает тот же самый объект - адрес памяти и т. д.). Если вы хотите проверить, есть ли в списке уже один и тот же Клиент (возможно, это тот же клиент, если у них есть то же имя клиента или номер клиента), тогда вам понадобится переопределить equals(), чтобы убедиться в том, соответствуют ли соответствующие поля (например, имена клиентов).

Примечание. Не забудьте переопределить hashCode(), если вы собираетесь переопределить equals()! В противном случае у вас могут возникнуть проблемы с вашими HashMaps и другими структурами данных. Чтобы получить хорошее представление о том, почему это так и в чем недостатки, избегайте взгляда на главы Effective Java Джоша Блоха equals() и hashCode() (ссылка содержит только информацию о том, почему вы должны реализовать hashCode(), когда вы реализуете equals(), но есть хорошее освещение о том, как переопределить equals() тоже.

Кстати, существует ли ограничение на упорядочение вашего набора? Если этого не происходит, немного проще решить эту проблему, используйте Set<Customer>, например:

Set<Customer> noDups = new HashSet<Customer>();
noDups.addAll(tmpListCustomer);
return new ArrayList<Customer>(noDups);

. Это позволит вам удалить дубликаты, поскольку наборы не позволяют дублировать. Тем не менее, это потеряет любое упорядочение, которое было применено к tmpListCustomer, так как HashSet не имеет явного упорядочения (вы можете обойти это с помощью TreeSet, но это не совсем связано с вашим вопросом). Это может немного упростить ваш код.

Предполагая, что вы хотите сохранить текущий порядок и не хотите Set, возможно, самый простой:

List<Customer> depdupeCustomers =
    new ArrayList<>(new LinkedHashSet<>(customers));

Если вы хотите изменить исходный список:

Set<Customer> depdupeCustomers = new LinkedHashSet<>(customers);
customers.clear();
customers.addAll(dedupeCustomers);

Как уже упоминалось, вы, вероятно, не правильно используете equals ().

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

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

Самый чистый способ:

List<XXX> lstConsultada = dao.findByPropertyList(YYY);
List<XXX> lstFinal = new ArrayList<XXX>(new LinkedHashSet<GrupoOrigen>(XXX));

и переопределить hascode и equals по свойствам Id каждого объекта