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

接受挑战：

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 5

看看TreeMap。我认为这就是你要找的东西。

Answer 6

假设每个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 7

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

它绝对是您需要的地图。按键按降序排列的名称和键。如果您不将密钥存储为int或至少代表＆＃39; 7＆＃39;您将无法按降序排序。作为＆＃39; 7＆＃39;或者＆＃39; 07＆＃39;和＆＃39; 2＆＃39;作为＆＃39; 2＆＃39;或者＆＃39; 02＆＃39;。

Answer 8

我建议您使用地图而不是列表，然后您可以执行以下操作：

 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 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);
    }
}

排序字符串数组

9 个答案: