자바 에서 List 집합 재 활용 방법 및 효율 대비

List 집합 은 모두 가 개발 과정 에서 거의 사용 할 것 이 라 고 믿는다.집합 에 있 는 데이터 가 중복 되 는 것 을 피하 기 어렵 고 제거 가 필요 하 다.그러나 무 거 운 방식 은 여러 가지 방법 이 있 습 니 다.당신 은 어떤 방식 을 사용 합 니까?탈 중 방식 의 효율 이 가장 효율 적 이 고 가장 좋 은 것 입 니까?오늘 은 List 집합 에서 흔히 볼 수 있 고 자주 사용 하 는 네 가지 방식 을 설명해 드 리 겠 습 니 다.
01
실현 사고:두 개의 for 순환 을 사용 하여 모든 요 소 를 집합 한 다음 에 같은 요소 가 있 는 지 판단 하고 있 으 면 제거 합 니 다.이런 방식 은 대부분 가장 먼저 생각 하 는 것 이자 가장 간단 한 실현 방식 이다.그 중에서 이런 방식 은 List 집합 원래 의 순서 가 변 하지 않 는 다 는 것 을 보증 할 수 있다.
코드 구현:

/**
* notes:    for    List  
* @param list
* @return
*/
public static List repeatListWayOne(List<String> list){
 for(int i = 0;i < list.size();i++){
  for(int j = i+1;j < list.size();j++){
   if(list.get(i).equals(list.get(j))){
    list.remove(j);
   }
  }
 }
 return list;
}

02
실현 사고:우 리 는 HashSet 이 Set 인 터 페 이 스 를 실현 하고 중복 요소 가 나타 나 는 것 을 허락 하지 않 는 다 는 것 을 알 고 있다.이 생각 을 바탕 으로 List 를 모든 요 소 를 HashSet 대상 에 집합 시 킨 다음 에 List 집합 요 소 를 모두 비우 고 마지막 으로 HashSet 대상 요 소 를 모두 List 집합 에 추가 하면 중복 요소 가 나타 나 지 않도록 할 수 있 습 니 다.HashSet 는 초기 화 할 때 원 소 를 직접 추가 할 수 있 는 구조 함수 가 있 습 니 다.그 중에서 HashSet 은 순서 가 변 하지 않 는 다 는 것 을 보증 할 수 없 기 때문에 이 방식 은 List 집합 원래 의 순서 가 변 하지 않 는 다 는 것 을 보증 할 수 없다.
코드 구현:

/**
* notes:  HashSet  List  
* @param list
* @return
*/
public static List repeatListWayTwo(List<String> list){
 //   HashSet  ，  list       HashSet  
 HashSet set = new HashSet(list);
 // List        
 list.clear();
 // HashSet     List  
 list.addAll(set);
 return list;
}

03
실현 사고:TreeSet 집합 도 Set 인 터 페 이 스 를 실현 하고 질서 가 있 으 며 중복 요소 가 없 는 집합 이다.마찬가지 로 우 리 는 위의 방식 2 의 사상 에 따라 중시 할 수 있다.그 중에서 도 무 거 운 리스트 집합 은 원래 의 순서 와 일치 하도록 보장 할 수 있다.
코드 구현:

/**
* notes:  TreeSet  List  
* @param list
* @return
*/
public static List repeatListWayThird(List<String> list){
 //   TreeSet  ，  list       TreeSet  
 TreeSet set = new TreeSet(list);
 // List        
 list.clear();
 // TreeSet     List  
 list.addAll(set);
 return list;
}

04
실현 사고:List 집합 contains 방법 으로 순환 적 으로 옮 겨 다 니 며 새로운 List 집합 을 만 들 고 그 다음 에 원래 의 List 집합 을 순환 적 으로 옮 겨 다 니 며 새로운 집합 에 오래된 집합 이 포함 되 어 있 는 지 판단 합 니 다.있 으 면 새로운 집합 에 추가 하지 않 습 니 다.그렇지 않 으 면 추가 합 니 다.마지막 으로 낡은 집합 을 비우 고 새로운 집합 원 소 를 낡은 집합 에 할당 합 니 다.
코드 구현:

/**
* notes:  List  contains        
* @param list
* @return
*/
public static List repeatListWayFourth(List<String> list){
  //   List  ，          
  List<String> newList = new ArrayList<String>();
  //         
  for(int i = 0; i < list.size(); i++ ){
    //          ，      ，       
    boolean isContains = newList.contains(list.get(i));
    if(!isContains){
      newList.add(list.get(i));
    }
  }
  // List        
  list.clear();
  //         List  
  list.addAll(newList);
  return list;
}

위 에 서 는 모두 에 게 네 가지 List 집합 재 활용 방식 을 소개 하 였 다.그렇다면 어떤 방식 이 효율 이 가장 좋 을 까?다음은 대 비 를 보 여 드 리 겠 습 니 다.
프 리 젠 테 이 션 방식 을 위해 0-500 사이 의 20000 개의 정수 문자열 을 무 작위 로 생 성하 고 List 집합 에 저장 하 며 해당 코드 인쇄 와 관련 된 시간 을 비교 합 니 다.그 중에서 List 집합 코드 를 무 작위 로 생 성 하 는 것 은 다음 과 같다.

/**
*     0-500   20000      ，   List  
* @return
*/
public static List<String> getRandomList(){
  List<String> list = new ArrayList<String>();
  //    20000      
  for(int i = 1; i <= 20000; i++){
    //   [0,500)    ，  0    ，500   
    int number = new Random().nextInt(500);
    String number_str = "geshan"+number;
    list.add(number_str);
  }
  return list;
}

List 집합 요소 가 일치 하도록 네 개의 List 집합 을 만 들 고 각각 List 제거 방식 에 대응 합 니 다.효율 대비 코드 는 다음 과 같다.

public static void main(String[] args){
  //    0-500   1000      List  
  List<String> list = getRandomList();
 
  //          ，    List  ，  List      
  //   List  
  List<String> oneList = new ArrayList<>();
  oneList.addAll(list);
  //   List  
  List<String> twoList = new ArrayList<>();
  twoList.addAll(list);
  //   List  
  List<String> thirdList = new ArrayList<>();
  thirdList.addAll(list);
  //   List  
  List<String> fourthList = new ArrayList<>();
  fourthList.addAll(list);
 
  System.out.println("   ：    for    List  ");
  System.out.println("      :"+oneList.size()+"，    >>"+oneList);
  Date oneDateBegin = new Date();
  repeatListWayOne(oneList);
  System.out.println("      :"+oneList.size()+"，    >>"+oneList);
  Date oneDateEnd = new Date();
  System.out.println("      :"+(oneDateEnd.getTime()-oneDateBegin.getTime())+"  ");
 
  System.out.println("   ：  HashSet  List  ");
  System.out.println("      :"+twoList.size()+"，    >>"+twoList);
  Date twoDateBegin = new Date();
  repeatListWayTwo(twoList);
  System.out.println("      :"+twoList.size()+"，    >>"+twoList);
  Date twoDateEnd = new Date();
  System.out.println("      :"+(twoDateEnd.getTime()-twoDateBegin.getTime())+"  ");
 
  System.out.println("   ：  TreeSet  List  ");
  System.out.println("      :"+thirdList.size()+"，    >>"+thirdList);
  Date thirdDateBegin = new Date();
  repeatListWayThird(thirdList);
  System.out.println("      :"+thirdList.size()+"，    >>"+thirdList);
  Date thirdDateEnd = new Date();
  System.out.println("      :"+(thirdDateEnd.getTime()-thirdDateBegin.getTime())+"  ");
 
  System.out.println("   ：  List  contains        ");
  System.out.println("      :"+fourthList.size()+"，    >>"+fourthList);
  Date fourthDateBegin = new Date();
  repeatListWayFourth(fourthList);
  System.out.println("      :"+fourthList.size()+"，    >>"+fourthList);
  Date fourthDateEnd = new Date();
  System.out.println("      :"+(fourthDateEnd.getTime()-fourthDateBegin.getTime())+"  ");
}

여러 번 실행 한 결 과 는 다음 과 같 습 니 다.
첫 번 째 네 가지 방식 의 운행 시간 은 다음 과 같다.223,10,16,30.
두 번 째 네 가지 방식 의 운행 시간 은 다음 과 같다.164,10,17,43.
세 번 째 네 가지 방식 의 운행 시간 은 다음 과 같다.164,9,16,37.
종합 코드 와 운행 시간 을 비교 하면 방식 두 번 째 는 가장 좋 은 무 게 를 제거 하 는 방식 이다.코드 가 가장 간결 하고 시간 이 가장 짧 지만 순서 가 어 지 러 울 수 있다.만약 에 원래 의 순서에 따라 야 한다 면 방식 세 번 째 가 비교적 좋다.너 는 평소에 List 집합 을 다시 하 는데 방식 이 맞 니?
총결산
자바 에 있 는 List 집합 중 방법 및 효율 대비 에 관 한 이 글 은 여기까지 소개 되 었 습 니 다.더 많은 자바 List 집합 중 효율 적 인 내용 은 우리 의 이전 글 을 검색 하거나 아래 의 관련 글 을 계속 조회 하 시기 바 랍 니 다.앞으로 많은 응원 바 랍 니 다!