排序字符串數組

Question

我有值

List<String> list = new ArrayList<String>(); 
list = {'name1','10','name2','2','name3','15','name4','7'} 

我要對此列表進行排序和字符串數組輸出應該是

list = {'name3','15','name1','10','name4','7','name2','2'} 

我怎樣才能做到這一點？

Answer 1

你似乎也住在object denial。使用這個數據的列表（或至少一個字符串列表）只是使用錯誤的數據結構。

您顯然在該列表中有某種鍵值或值 - 值對，但並未明確表示該事實。這意味着對該數據結構的任何操作都將變得複雜和繁瑣，並且該語言或庫的所有默認功能都不會達到您期望的效果。

更好的解決方案是將名稱和數值（年齡？）存儲在某個對象中並保留這些對象的列表。

然後，該列表可以通過在該類中實現Comparable或通過提供Comparator來排序。

Answer 2

創建類

package org.life.java.stackoverflow.questions; 

import java.util.ArrayList; 
import java.util.Collections; 
import java.util.Comparator; 
import java.util.List; 

//class for your data representation 
class Data{ 
    private int no; 
    private String data; 

    public String getDaa() { 
     return data; 
    } 

    public void setData(String data) { 
     this.data = data; 
    } 

    public int getNo() { 
     return no; 
    } 

    public void setNo(int no) { 
     this.no = no; 
    } 

    public Data(int no, String data) { 
     this.no = no; 
     this.data = data; 
    } 

    public Data() { 
    } 


    @Override 
    public String toString() { 
     return "SortingDemo{" + "no=" + no + "data=" + data + '}'; 
    } 

} 

---

創建比較和排序列表

public class SortingDemo {  

    public static void main(String[] args) { 
    List<Data> listOfData = new ArrayList<Data>(); 
    listOfData.add(new Data(1,"DataFor one")); 
    listOfData.add(new Data(15,"DataFor 15")); 
    listOfData.add(new Data(10,"DataFor 10")); 
    //defincation of Comparator for your case , which compares object based on the `no` 
    Collections.sort(listOfData,new Comparator<Data>() { 

      @Override 
      public int compare(Data o1, Data o2) { 
       return o2.getNo() - o1.getNo(); 
      } 
     }); 
    } 
} 

Answer 3

首先，你需要把你的名字和值組合成一個對象，而不是連續的陣列位置。

然後使對象實現Comparable。

最後將這些對象放在一個List中，並使用Collections.sort對列表進行排序。

Answer 4

看一看TreeMap。我認爲這就是你想要的。

Answer 5

假設每namex（其中x = 1, 2, 3, ...）是獨一無二的，比你可以通過使用SortedMap

public static void main(String[] args) { 
    SortedMap<String, Integer> sortedMap = 
     new TreeMap<String, Integer>(); 
    sortedMap.put("name1", Integer.valueOf(10)); 
    sortedMap.put("name2", Integer.valueOf(2)); 
    sortedMap.put("name3", Integer.valueOf(15)); 
    sortedMap.put("name4", Integer.valueOf(7)); 
    for (String key : sortedMap.keySet()) 
     System.out.println(key + " - " + sortedMap.get(key)); 
} 

Answer 6

list = {'name3','15','name1','10','name4','7','name2','2'} 

解決您的問題，它是一個絕對的地圖，你所需要的。名稱和按鍵按降序排列。如果您不將鍵存儲爲int或至少將'7'表示爲'7'或​​'07'並將'2'表示爲'2'或'02'，則無法按降序排序。

Answer 7

我會建議你使用地圖，而不是一個列表，然後你可以做這樣的事情：

public static void main(String[] args) throws Exception{ 
     HashMap<String, Integer> map = new HashMap<String, Integer>(); 
     map.put("name10", 2); 
     map.put("name20", 1); 
     Map<String, Integer> sortedMap = sortByValue(map); 

     for (String key : sortedMap.keySet()) { 
       System.out.println("key/value: " + key + "/"+sortedMap.get(key)); 
      } 
     } 

    static Map sortByValue(Map map) { 
     LinkedList list = new LinkedList(map.entrySet()); 
     Collections.sort(list, new Comparator() { 
       public int compare(Object o1, Object o2) { 
        return ((Comparable) ((Map.Entry) (o1)).getValue()) 
        .compareTo(((Map.Entry) (o2)).getValue()); 
       } 
     }); 

     Map result = new LinkedHashMap(); 
     for (Iterator it = list.iterator(); it.hasNext();) { 
      Map.Entry entry = (Map.Entry)it.next(); 
      result.put(entry.getKey(), entry.getValue()); 
     } 
     return result; 
    } 

Sort a Map<Key, Value> by values (Java)

Answer 8

接受挑戰：

import java.util.*; 

class Test { 
    public static void main(String[] args) { 
     List<String> list = new ArrayList<String>(Arrays.asList("name1", "10", 
                   "name2", "2", 
                   "name3", "15", 
                   "name4", "7")); 

     List<NameNumPair> nps = new ArrayList<NameNumPair>(); 
     for (int i = 0; i < list.size(); i += 2) 
      nps.add(new NameNumPair(list.get(i), 
        Integer.parseInt(list.get(i+1)))); 

     Collections.sort(nps); 

     List<String> sortedList = new ArrayList<String>(); 
     for (NameNumPair np : nps) { 
      sortedList.add(np.name); 
      sortedList.add(np.num.toString()); 
     } 

     System.out.println(sortedList); 
    } 

} 

class NameNumPair implements Comparable<NameNumPair> { 
    String name; 
    Integer num; 

    public NameNumPair(String name, int num) { 
     this.name = name; 
     this.num = num; 
    } 

    @Override 
    public int compareTo(NameNumPair o) { 
     return o.num.compareTo(num); 
    } 
} 

輸出：

[name3, 15, name1, 10, name4, 7, name2, 2] 

Answer 9

正如幾個人所說，你可能不想這樣做。但是，如果你真的想這麼做，作爲Java對象封裝的練習，完全忽視效率和良好的編程習慣，這裏有一種方法儘可能地接近你在問題中寫的內容。

import java.util.*; 

public class CrazySort { 
    public static void main(String[] args) { 
     List<String> list = Arrays.asList(new String[] {"name1","10","name2","2","name3","15","name4","7"}); 
     crazySort(list); 
     System.out.println(list); 
    } 

    private static class StringPair implements Comparable<StringPair> { 
     String s1, s2; 
     StringPair(String p1, String p2) { s1 = p1; s2 = p2; } 
     public int compareTo(StringPair o) { return Integer.parseInt(o.s2) - Integer.parseInt(s2); } 
    } 

    static void crazySort(final List<String> list) { 
     List<StringPair> wrapper = new AbstractList<StringPair>() { 
      public StringPair get(int i) { return new StringPair(list.get(i*2), list.get(i*2+1)); } 
      public StringPair set(int i, StringPair p) { 
       StringPair r = get(i); 
       list.set(i*2, p.s1); 
       list.set(i*2+1, p.s2); 
       return r; 
      } 
      public int size() { return list.size()/2; } 
     }; 
     Collections.sort(wrapper); 
    } 
}