interger를 기반으로 해시 맵 정렬

Question

가장 긴 시간부터 내림차순으로 목록을 정렬하려고합니다. 이것은 내 방법입니다. 여기에서 몇 페이지를 사용하여 올바른 것으로 만들었지 만 코드에서 뭔가 잘못되어 잘못된 목록이 반환됩니다.

[team2, team1, team4, team3] 

하지만 다음과 같이해야한다 : 여기

public static ArrayList<String> winnerIs(List<HP> hp){ 
     //System.out.println("1"); 
     int size = hp.size(); 
     //System.out.println(size); 
     ArrayList<HP> listofWinner = new ArrayList<HP>(); 
     Map<String, Integer> map = new HashMap<String, Integer>(); 

     for(int i = 0; i < size; i++){ 
      listofWinner.add(hp.get(i)); 
      map.put(hp.get(i).getName(), hp.get(i).TD1()); 
      //System.out.println(hp.get(i).getName()+" "+hp.get(i).TD1()); 
     } 
     //sort based on time 
     ArrayList<String> keys = new ArrayList<String>(map.keySet()); 
     //System.out.println("---------------"); 
     /*for(int i = 0; i < keys.size(); i++){ 
      //wn.add(keys.get(i)); 
      System.out.println("here "+keys.get(i)); 
     }*/ 
     //System.out.println("---------------"); 


     ArrayList<String> wn = new ArrayList<String>(); 

     //System.out.println("---------------"); 
     for(int i = keys.size()-1; i >= 0; i--){  
      wn.add(keys.get(i)); 

     } 
     return wn; 
    } 

는 reurns 무엇

시간이 동일한 경우는 문제가되지 않습니다

[team4, team3, team2, team1] 

, 우리가 더 필요 시간, 나는 코드의 어떤 부분이 잘못된 것인지 잘 모르겠다.

here 2 
here 9 
here 0 
here 0 

그래서 난 stackoverflouw의 페이지 중 하나를 사용하고 난이 해결책을 발견 : 난 아직 여기에 수정되지 않은 본

ArrayList<Integer> s = new ArrayList<Integer>(map.values()); 
     Collections.sort(keys); 
     //System.out.println("---------------"); 
     for(int i = 0; i < s.size(); i++){ 
      //wn.add(keys.get(i)); 
      System.out.println("here "+s.get(i)); 
     } 

결과를 사용하는 경우에도

는 반환 것입니다 :

public static ArrayList<String> winnerIs(List<HumanPlayer> hp){ 
     //System.out.println("1"); 
     int size = hp.size(); 
     //System.out.println(size); 
     ArrayList<HumanPlayer> listofWinner = new ArrayList<HumanPlayer>(); 
     Map<String, Integer> map = new HashMap<String, Integer>(); 

     for(int i = 0; i < size; i++){ 
      listofWinner.add(hp.get(i)); 
      map.put(hp.get(i).getName(), hp.get(i).getTimeDriver1()); 
      //System.out.println(hp.get(i).getName()+" "+hp.get(i).getTimeDriver1()); 
     } 
     map.entrySet().stream() 
     .sorted(Map.Entry.<String, Integer>comparingByValue().reversed()) 
     .limit(1000) 
     .forEach(System.out::println); 

     return null; 
    } 

이 정확한 목록을 반환하지만이 무엇인지 확실하지 않다 : .limit(1000) 또한 어떻게 이것을 목록과 동일하게 할 수 있습니까?

Answer 1

같은 당신은지도의 값으로 편안한 정렬 자바 8을 사용할 수 있습니다 원한다고 생각

.collect(Collectors.toMap(Entry::getKey, Entry::getValue, (e1, e2) -> e1, LinkedHashMap::new)); 

명심해야 할 것은 개별지도가 유지 계약이다는 Collectors#toMap의 세번째 인수),하지만 당신은 방금 발견 된 첫 번째 키를 반환 할 수 있습니다. HashMap은 정렬되지 않은지도이며 반복 순서를 일치시키지 않으므로 (정렬은 효과가 없으므로) TreeMap은 SortedMap이지만 계약 상 이는 값이 아닌 키순으로 정렬됨을 의미합니다. LinkedHashMap은 일반적으로 삽입을 기반으로하는 반복 순서를 유지하므로 (대개 List과 비슷 함) 정렬 된 맵 출력이 필요할 때 일반적으로 원하는대로됩니다.

Answer 2

HP 클래스에서 TD1() 메서드를 정렬하려는 값으로 가정하고 맵을 사용하여 정렬하는 데 도움이된다고 가정합니다.

Map<String, Integer> sorted = /* your map */.entrySet().stream() 
     .sorted(Entry.comparingByValue()) //comparator for value, can reverse or use other 
     .collect(Collectors.toMap(Entry::getKey, Entry::getValue, 
       (e1, e2) -> { throw new IllegalArgumentException("Duplicate Key: " + e1.getKey()); }, 
       LinkedHashMap::new)); 

내가 (중복 키의 병합 기능을 예외를 던질 선택 : 나는 당신이

Map<Integer, List<String>> map = new HashMap<Integer, List<String>>(); 
for (HP h : hp) { 
    if (map.get(h.TD1() != null) { 
     map.get(h.TD1()).add(h.getName()); 
    } 
    else { 
     List temp = new ArrayList<String>(); 
     temp.add(h.getName()); 
     map.put(h.TD1(), temp); 
    } 
} 
ArrayList keys = Arrays.asList(map.getKeyset().toArray()); 
Collections.sort(keys); 

for (int i = keys.length() - 1; i >= 0; i--) { 
    List<String> names = map.get(i); 
    // print names 
} 

Answer 3

이 psuedo-code를 체크 아웃하면 전체적인 아이디어를 보게 될 것입니다.

Map<Integer,List<String> map = new HashMap<Integer,List<String>>(); 
for(HP hpObject:hp) { 
if(map.containsKey(hpObject.TD1())) { 
    map.get(hpObject.TD1()).add(hpObject.getName()); 
} else { 
    List<String> names = new ArrayList<String>(); 
    names.add(hpObject.getName()); 
    map.put(hpObject.TD1(),names); 
} 
} 

    // To sort by keys 
    TreeMap sortedByTD = new TreeMap(map); 

    // Iterate over TreeMap and create the list of winners you need 
    return result;enter code here