순수 중복 제거 어레이

일반적으로, 배열 직접 HashSet의 반복 특성의 가장 간단하고 빠른 방법은 할 수없는, 또는 사용 목록은 중복 제거를 가로 지르는있을 것입니다 여부를 판단 포함입니다

객체 클래스 객체 및 요구의 배열은 동일한 hashCode 메소드를 다시 쓸 경우 ..

그러나 종종 경우 HashSet에 사용하지 않고, 질문을 질문의 중복 제거 어레이에 직면하고 목록이 방법을 어떻게 배열에 그물 무게를 포함?

당신은 할 수 있습니다 :

중복 된 위치를 식별하기위한 식별 요소 배열을 사용하면, 다음 디엠 퍼시스의 요소를 저장할 새 배열을 만들

　　　　 사용자 USER1 = 새 사용자 ( "zjamgs", 16,12); // 사용자需要重写동일和의 해시 코드方法의 
        사용자 USER2 = 새로운 사용자 ( "리시 ', 13,18); 
        사용자 사용자 3 = 새 사용자 ( "왕위전", 15,13); 
        사용자 USER4 = 새 사용자 ( "zhangsli", 23,10); 
        사용자 USER5 = 새 사용자 ( "zjamgs", 16,12); 

        사용자 user6 = 새 사용자 ( "zjamgs1", 16,12); 
        사용자 user7 = 새 사용자 ( "lisi2", 13,18); 
        사용자 user8 = 새 사용자 ( "zjamgs", 16,12); 
        사용자 사용자 9 = 새 사용자 ( "왕위전", 15,13); 
        사용자 user10 = 새 사용자 ( "zjamgs5", 16,12); 

        사용자 [] = {사용자 USER1, 사용자 9, user8, user7, user6, USER5, USER4, 사용자 3, USER2, user10}; 

        INT는 [] = userindex 새로운 INT [사용자.
        INT 반복 횟수 = 0;　　　　　　　　　　　　
            경우 (userindex [I] == 1) 계속; //非常重要
            대 (INT J = users.length-1; J> I, J -) { 
                경우 (사용자 [I] .equals (사용자 [J])) { 
                    userindex [J] = 1; 
                    반복 횟수 ++; 
                } 
            } 
        } 
        에서 System.out.println (Arrays.toString (userindex) 
        사용자 [] = 초보자들 새로운 사용자 [users.length - 반복 횟수] 

        난 userindex.length를 <; 위해 (ⅰ = 0 int로 난 ++) { 
            경우 (userindex [I] == 0) { 
                대 (INT의 J = 0; J <newUsers.length, J ++) { 
                    경우 (초보자들 [J] == NULL) {
                        초보자들 [J]를 사용자 [I]를 =; 
                        단절; 
                    }
                } 
            } 
        } 
        에서 System.out.println (Arrays.toString (초보자들));

　　사용자 클래스 :

클래스 사용자에 Comparable <사용자> {구현 
    개인 문자열 이름; 
    개인 INT 나이; 
    개인 INT 지수; 

    @Override 
    공공 메소드의 개요 boolean equals (Object o) { 
        (이 == 오)가 true를 반환하는 경우; 
        경우 false를 반환 ((O 사용자 instanceof를)!); 
        사용자 = 사용자 (사용자) O; 
        반환 getAge () == user.getAge () && 
                getIndex () == user.getIndex () && 
                Objects.equals (getName () user.getName ()); 
    } 

    @Override 
    공중 INT의 해시 코드 () { 
        반환 Objects.hash (getName () getAge () getIndex ()); 
    } 

    @Override 
    () {공공 문자열 toString을
        반환 "사용자 [이름 ="+ 이름 + ", 연령 ="+ 나이 + ", 인덱스 ="+ 인덱스 + "]"; 
    } 

    공공 사용자 (문자열 이름, INT 연령, 지능 지수) { 
        슈퍼 (); 
        this.name = 이름; 
        this.age = 나이; 
        this.index = 인덱스; 
    } 

    공공 INT getIndex () { 
        반환 인덱스; 
    } 

    공개 무효 setIndex (INT 인덱스) { 
        this.index = 인덱스; 
    } 

    공공 사용자 () { 
        슈퍼 (); 
    } 


    공공 INT getAge () { 
        반환 시대; 
    } 

    공공 무효 setAge (INT 세) { 
        this.age = 나이; 
    }

    공공 문자열 getName () { 
        반환 이름; 
    } 

    공공 무효에서는 setName (문자열 이름) { 
        this.name = 이름; 
    } 
    @Override 
    공개 INT은 compareTo (사용자 O) { 
        경우 (this.getAge () <o.getAge ()) { 
            -1을 리턴; 
        다른 경우} (this.getAge는 ()> o.getAge ()) { 
            1 리턴; 
        } 
        0을 반환; 
    } 
}

　　출력 :

[0, 0, 0, 0, 1, 0, 0, 1, 1, 0]

[사용자 [이름 = zjamgs, 연령 = 16, 인덱스 = 12],

사용자 [이름 = 리시, 연령 = 13, 인덱스 = 18],

USER [= 왕위전 이름, 나이 = 15, 인덱스 = 13]

사용자 [이름 = zhangsli, 연령 = 23, 인덱스 = 10],

사용자 [이름 = zjamgs1, 연령 = 16, 인덱스 = 12],

사용자 [이름 = lisi2, 연령 = 13, 인덱스 = 18],

사용자 [이름 = zjamgs5, 연령 = 16, 인덱스 = 12]]

세 가지 요소 요소를 반복하지 않는 일부 요소, 반복적 인 요소, 그리고 나머지 7이 이미이되어 있으며, 결과는 정확

순수 중복 제거 어레이

추천