중복을 허용하는 TreeSet 또는 TreeMap

Question

Collection은 요소를 정렬하지만 중복을 제거하지 않아야합니다.

나는 TreeSet으로 갔다.

public boolean add(E e) { return m.put(e, PRESENT)==null; }

그리고 TreeMap에 내가 쓴

Comparatorscompare 논리를 사용하여 중복을 제거합니다 TreeSet 이후

실제로 백업 TreeMap에 값을 추가합니다 Comparator은 요소가 같은 경우 0 대신 1을 반환합니다. 따라서 동일한 요소의 경우 TreeSet이이 Comparator 인 경우 중복을 덮어 쓰지 않고 정렬 만합니다.

간단한 String 개체를 테스트했지만 맞춤 개체 집합이 필요합니다.

public static void main(String[] args) 
{  
     List<String> strList = Arrays.asList(new String[]{"d","b","c","z","s","b","d","a"});  
     Set<String> strSet = new TreeSet<String>(new StringComparator());  
     strSet.addAll(strList);  
     System.out.println(strSet); 
} 

class StringComparator implements Comparator<String> 
{ 
    @Override 
    public int compare(String s1, String s2) 
    { 
     if(s1.compareTo(s2) == 0){ 
      return 1; 
     } 
     else{ 
      return s1.compareTo(s2); 
     } 
    } 
} 

이렇게 접근하는 것이 좋습니까? 아니면 더 좋은 방법입니까?

사실 나는 다음과 같은 클래스의 ArrayList를하는 데 문제

편집 :

class Fund 
{ 
    String fundCode; 
    BigDecimal fundValue; 
    ..... 

    public boolean equals(Object obj) { 
    // uses fundCode for equality 
    } 
} 

나는 모든이 fundCode

Answer 1

내가 가장 fundValue

당신은 내가 전혀 분류하지 않는 것이 좋습니다 정렬 할 이유가 유일한 이유라면과 함께 모든 fundCode이 필요합니다. 정렬은 대부분 O (n log (n))의 복잡도로 이루어집니다. 최대 찾기 O (N)의 복잡도를 가지고을하고리스트를 단순 반복에서 구현됩니다

List<Fund> maxFunds = new ArrayList<Fund>(); 
int max = 0; 
for (Fund fund : funds) { 
    if (fund.getFundValue() > max) { 
     maxFunds.clear(); 
     max = fund.getFundValue(); 

    } 
    if (fund.getFundValue() == max) { 
     maxFunds.add(fund); 

    } 
} 

당신은 Guava 같은 세 번째 수준의 라이브러리를 사용하여 해당 코드를 방지 할 수 있습니다. 참조 : How to get max() element from List in Guava

Answer 2

fundValue 가장 높은 당신이 Collections.sort를 사용하여 목록을 정렬 할 수 있습니다 필요합니다.

주어진 당신의 Fund :

List<Fund> sortMe = new ArrayList(...); 
Collections.sort(sortMe, new Comparator<Fund>() { 
    @Override 
    public int compare(Fund left, Fund right) { 
    return left.fundValue.compareTo(right.fundValue); 
    } 
}); 
// sortMe is now sorted 

Answer 3

TreeSet의 경우 Comparator 또는 Comparable를 사용하여 객체를 비교하고 저장할 수 있습니다. 등호가 호출되지 않아 중복 된 것을 인식하지 못합니다.

Answer 4

TreeSet 대신 List를 사용하고 Comparable 인터페이스를 구현할 수 있습니다.

public class Fund implements Comparable<Fund> { 

    String fundCode; 
    int fundValue; 

    public Fund(String fundCode, int fundValue) { 
     super(); 
     this.fundCode = fundCode; 
     this.fundValue = fundValue; 
    } 

    public String getFundCode() { 
     return fundCode; 
    } 

    public void setFundCode(String fundCode) { 
     this.fundCode = fundCode; 
    } 

    public int getFundValue() { 
     return fundValue; 
    } 

    public void setFundValue(int fundValue) { 
     this.fundValue = fundValue; 
    } 

    public int compareTo(Fund compareFund) { 

     int compare = ((Fund) compareFund).getFundValue(); 
     return compare - this.fundValue; 
    } 

    public static void main(String args[]){ 

     List<Fund> funds = new ArrayList<Fund>(); 

     Fund fund1 = new Fund("a",100); 
     Fund fund2 = new Fund("b",20); 
     Fund fund3 = new Fund("c",70); 
     Fund fund4 = new Fund("a",100); 
     funds.add(fund1); 
     funds.add(fund2); 
     funds.add(fund3); 
     funds.add(fund4); 

     Collections.sort(funds); 

     for(Fund fund : funds){ 
      System.out.println("Fund code: " + fund.getFundCode() + " Fund value : " + fund.getFundValue()); 
     } 
    } 
} 

Answer 5

요소를 arraylist에 추가 한 다음 유틸리티 Collections.sort를 사용하여 요소를 정렬하십시오. 비교할 수있는 것을 구현하고 자신의 키에 따라 자신의 compareTo 메소드를 작성하십시오.

않을뿐만 아니라 중복 제거도 정렬 할 수 있습니다 :

List<Integer> list = new ArrayList<>(); 

Collections.sort(list,new Comparator<Integer>() 
{ 

    @Override 


    public int compare(List left, List right) { 


**your logic** 

    return ''; 

    } 

} 

) 
;