java - 삭제 iterator ArrayList에서 반복되는 요소를 제거하려면 어떻게해야합니까?



15 Answers

ArrayListHashSet 변환하면 중복을 효과적으로 제거 할 수 있지만 삽입 순서를 유지해야하는 경우이 변형을 사용하는 것이 좋습니다.

// list is some List of Strings
Set<String> s = new LinkedHashSet<>(list);

그런 다음 List 참조를 다시 가져와야하는 경우 변환 생성자를 다시 사용할 수 있습니다.

arraylist 객체 삭제

ArrayList<String> 있는데 반복 된 문자열을 제거하고 싶습니다. 어떻게해야합니까?




중복을 원하지 않으면 List 대신 Set 사용 Set . ListSet 변환하려면 다음 코드를 사용할 수 있습니다.

// list is some List of Strings
Set<String> s = new HashSet<String>(list);

정말 필요한 경우 같은 구조를 사용하여 Set List 다시 변환 할 수 있습니다.




목록 순서에 영향을 미치지 않는 방법은 다음과 같습니다.

ArrayList l1 = new ArrayList();
ArrayList l2 = new ArrayList();

Iterator iterator = l1.iterator();

        while (iterator.hasNext())
        {
            YourClass o = (YourClass) iterator.next();
            if(!l2.contains(o)) l2.add(o);
        }

l1은 원래 목록이고 l2는 반복되는 항목이없는 목록입니다 (YourClass에 평등을 유지하려는 것과 동일한 방법으로 equals 메서드가 있는지 확인하십시오)




Java 8 스트림은 목록에서 중복 요소를 제거하는 매우 간단한 방법을 제공합니다. 고유 한 방법 사용. 우리가 도시 목록을 가지고 있고 그 목록에서 중복을 제거하고자한다면 그것은 한 줄로 할 수 있습니다 -

 List<String> cityList = new ArrayList<>();
 cityList.add("Delhi");
 cityList.add("Mumbai");
 cityList.add("Bangalore");
 cityList.add("Chennai");
 cityList.add("Kolkata");
 cityList.add("Mumbai");

 cityList = cityList.stream().distinct().collect(Collectors.toList());

arraylist에서 중복 요소를 제거하는 방법




HashSet 이나 하나 이상의 arraylist를 사용하지 않고 arraylist에서 중복을 제거 할 수 있습니다.

이 코드를 사용해보십시오 ..

    ArrayList<String> lst = new ArrayList<String>();
    lst.add("ABC");
    lst.add("ABC");
    lst.add("ABCD");
    lst.add("ABCD");
    lst.add("ABCE");

    System.out.println("Duplicates List "+lst);

    Object[] st = lst.toArray();
      for (Object s : st) {
        if (lst.indexOf(s) != lst.lastIndexOf(s)) {
            lst.remove(lst.lastIndexOf(s));
         }
      }

    System.out.println("Distinct List "+lst);

출력

Duplicates List [ABC, ABC, ABCD, ABCD, ABCE]
Distinct List [ABC, ABCD, ABCE]



이 문제를 해결할 수 있습니다.

private List<SomeClass> clearListFromDuplicateFirstName(List<SomeClass> list1) {

Map<String, SomeClass> cleanMap = new LinkedHashMap<String, SomeClass>();
for (int i = 0; i < list1.size(); i++) {
     cleanMap.put(list1.get(i).getFirstName(), list1.get(i));
}
List<SomeClass> list = new ArrayList<SomeClass>(cleanMap.values());
return list;
}



써드 파티 라이브러리를 사용하고자한다면, Eclipse Collections (이전의 GS Collections)에서 distinct() 메소드를 사용할 수있다.

ListIterable<Integer> integers = FastList.newListWith(1, 3, 1, 2, 2, 1);
Assert.assertEquals(
    FastList.newListWith(1, 3, 2),
    integers.distinct());

Set으로 변환 한 다음 List로 돌아가는 대신 distinct() 를 사용하면 distinct() 가 각 요소의 첫 번째 항목을 유지하면서 원래 List의 순서를 유지한다는 장점이 있습니다. 집합과 목록을 사용하여 구현됩니다.

MutableSet<T> seenSoFar = UnifiedSet.newSet();
int size = list.size();
for (int i = 0; i < size; i++)
{
    T item = list.get(i);
    if (seenSoFar.add(item))
    {
        targetCollection.add(item);
    }
}
return targetCollection;

원본 목록을 Eclipse Collections 유형으로 변환 할 수없는 경우 ListAdapter를 사용하여 동일한 API를 가져올 수 있습니다.

MutableList<Integer> distinct = ListAdapter.adapt(integers).distinct();

참고 : 저는 Eclipse Collections에 대한 커미터입니다.




ArrayList를 채울 때 각 요소에 조건을 사용하십시오. 예 :

    ArrayList< Integer > al = new ArrayList< Integer >(); 

    // fill 1 
    for ( int i = 0; i <= 5; i++ ) 
        if ( !al.contains( i ) ) 
            al.add( i ); 

    // fill 2 
    for (int i = 0; i <= 10; i++ ) 
        if ( !al.contains( i ) ) 
            al.add( i ); 

    for( Integer i: al )
    {
        System.out.print( i + " ");     
    }

배열 {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}




암호:

List<String> duplicatList = new ArrayList<String>();
duplicatList = Arrays.asList("AA","BB","CC","DD","DD","EE","AA","FF");
//above AA and DD are duplicate
Set<String> uniqueList = new HashSet<String>(duplicatList);
duplicatList = new ArrayList<String>(uniqueList); //let GC will doing free memory
System.out.println("Removed Duplicate : "+duplicatList);

참고 : 확실히, 메모리 오버 헤드가있을 것입니다.




LinkedHashSet이 트릭을 수행합니다.

String[] arr2 = {"5","1","2","3","3","4","1","2"};
Set<String> set = new LinkedHashSet<String>(Arrays.asList(arr2));
for(String s1 : set)
    System.out.println(s1);

System.out.println( "------------------------" );
String[] arr3 = set.toArray(new String[0]);
for(int i = 0; i < arr3.length; i++)
     System.out.println(arr3[i].toString());

// 출력 : 5,1,2,3,4




이것은 사용자 지정 개체 목록에 사용됩니다.

   public List<Contact> removeDuplicates(List<Contact> list) {
    // Set set1 = new LinkedHashSet(list);
    Set set = new TreeSet(new Comparator() {

        @Override
        public int compare(Object o1, Object o2) {
            if (((Contact) o1).getId().equalsIgnoreCase(((Contact) o2).getId()) /*&&
                    ((Contact)o1).getName().equalsIgnoreCase(((Contact)o2).getName())*/) {
                return 0;
            }
            return 1;
        }
    });
    set.addAll(list);

    final List newList = new ArrayList(set);
    return newList;
}



모델 유형 List <T> / ArrayList <T>를 사용하는 경우. 희망, 도움이됩니다.

다음은 set 또는 hashmap과 같은 다른 데이터 구조를 사용하지 않고 코드입니다.

for(int i = 0; i < Models.size(); i++) {
     for(int j = i + 1; j < Models.size(); j++) {                                
       if(Models.get(i).getName().equals(Models.get(j).getName())){    
                                Models.remove(j);

                                j--;
                            }
                        }
                    }



for(int a=0;a<myArray.size();a++){
        for(int b=a+1;b<myArray.size();b++){
            if(myArray.get(a).equalsIgnoreCase(myArray.get(b))){
                myArray.remove(b); 
                dups++;
                b--;
            }
        }
}



public Set<Object> findDuplicates(List<Object> list) {
        Set<Object> items = new HashSet<Object>();
        Set<Object> duplicates = new HashSet<Object>();
        for (Object item : list) {
            if (items.contains(item)) {
                duplicates.add(item);
                } else { 
                    items.add(item);
                    } 
            } 
        return duplicates;
        }



ArrayList에서 중복을 제거하려면 다음 논리를 찾으십시오.

public static Object[] removeDuplicate(Object[] inputArray)
{
    long startTime = System.nanoTime();
    int totalSize = inputArray.length;
    Object[] resultArray = new Object[totalSize];
    int newSize = 0;
    for(int i=0; i<totalSize; i++)
    {
        Object value = inputArray[i];
        if(value == null)
        {
            continue;
        }

        for(int j=i+1; j<totalSize; j++)
        {
            if(value.equals(inputArray[j]))
            {
                inputArray[j] = null;
            }
        }
        resultArray[newSize++] = value;
    }

    long endTime = System.nanoTime()-startTime;
    System.out.println("Total Time-B:"+endTime);
    return resultArray;
}



Related