Question

我有像这个名字，顺序，估计，实际

这样的数据

"Id1",4,230,350
"Id2",1,530,340
"Id3",4,530,150
"Id4",1,660,540
"Id5",2,530,540
"Id6",3,650,230
"Id7",4,530,120
"Id8",3,650,330

需要使用顺序，估计值和实际值对它们进行排序，输出应该看起来像

"Id2",1,530,340
"Id4",1,660,540
"Id5",2,530,540
"Id6",3,650,230
"Id8",3,650,330
"Id1",4,230,350
"Id7",4,530,120
"Id3",4,530,150

使用的最佳数据结构是什么，以及如何仅对整数值排序，估计，实际不在名称上

Answer 1

创建一个实现可比较的记录，然后将您的记录放入列表并调用：

Collections.sort(list);

记录是：

import java.util.Collections;
import org.apache.commons.lang.builder.CompareToBuilder;

public class Record implements Comparable<Record> {
String cad;
Integer x, y, z;

public int compareTo(final Record o) {
    return new CompareToBuilder().append(this.x, o.x).append(this.y, o.y).append(this.z, o.z).toComparison();
}

}

Answer 2

编写一个实现Comparable

的类

public class MyObject implements Comparable<MyObject>
{

private String id;
private  int order;
private int estimate;
private int actualValue;

@Override
public int compareTo(MyObject o)
{
    //Define your logic
    return 0;
}
}

您可以使用列表或设置（取决于您想要做什么）来存储这些对象并使用sort method对其进行排序

List<MyObject> list = new ArrayList<>();
    //list.add();
Collections.sort(list);

Answer 3

当您要排序并将其传递给Collections.sort(List, Comparator)

时，请使用接受比较器的方法

对于Eg：

class myClass implements Comparator<object> {

    @Override
    public int compare(object o1, object o2) {
        // write comparison logic here 
        return o1.getID().compareTo(o2.getID());
    }
}

然后将比较器用作

Collections.sort(objectData,new myClass());

您可以根据自己的要求修改逻辑。

Answer 4

您可以创建一个具有属性顺序，估计值和实际值的类

public class Data {
    private String name;
    private int order;
    private int estimate;
    private int actual;

}

对于排序，您可以将列表作为数据结构并使用Array List实现

List<Data> dataList=new ArrayList<Data>();

在类中实现Comparator接口，并在compare方法中编写排序逻辑

public int compare(Data data1, Data data2) {
//your sorting logic based on order,estimate,actual 
}

并在您要排序的类中使用：

Comparator<Data> dataComparator = new DataComparator();
 Collections.sort(dataList, dataComparator);

使用单独的比较器而不是可比较的比较器具有在单独的类中分离排序逻辑的优点。

Answer 5

我建议使用上一个答案中提到的其他类，但如果你无法避免，你可以使用这样的数据结构：

Map<String, List<Integer>> dataMap = new HashMap<String, List<Integer>>();

其中键是ID，列表将包含订单，估计值和实际值。记住该列表是一个有序集合，因此您应该以相同的顺序为Map.Eg：的所有条目添加值。 p>

        String key1 = "Id1";
        List<Integer> valueList1 = new ArrayList<Integer>();
        valueList1.add(4);     //order
        valueList1.add(230);   //estimate
        valueList1.add(350);   //actual
        dataMap.put(key1, valueList1); 

        String key2 = "Id2";
        List<Integer> valueList2 = new ArrayList<Integer>();
        valueList2.add(1);
        valueList2.add(530);
        valueList2.add(340);
        dataMap.put(key2, valueList2);

        //add all values similarly

您的dataMap将如下所示：

{Id4=[1, 660, 540], Id3=[4, 530, 150], Id6=[3, 650, 230], Id5=[2, 530, 540], Id8=[3, 650, 330], Id7=[4, 530, 120], Id2=[1, 530, 340], Id1=[4, 230, 350]}

你可能已经注意到这些值不是你输入的顺序。这是因为put方法不能保证元素放入Map的顺序。

现在你完成了数据结构部分。对于排序，你可以在你的类中实现这个方法

@SuppressWarnings({ "unchecked", "rawtypes" })
public Map sortByValue(Map map) {
    List list = new LinkedList(map.entrySet());
    Collections.sort(list, new Comparator() {
        public int compare(Object o1, Object o2) {
        //Your custom sorting logic 
            if (((List<Integer>) (((Map.Entry) (o1)).getValue())).get(0) > ((List<Integer>) (((Map.Entry) (o2))
                        .getValue())).get(0)) {
                    return 1;
                } else if (((List<Integer>) (((Map.Entry) (o1)).getValue()))
                        .get(0) < ((List<Integer>) (((Map.Entry) (o2))
                        .getValue())).get(0)) {
                    return -1;
                } else {
                    if (((List<Integer>) (((Map.Entry) (o1)).getValue()))
                            .get(1) > ((List<Integer>) (((Map.Entry) (o2))
                            .getValue())).get(1)) {
                        return 1;
                    } else if (((List<Integer>) (((Map.Entry) (o1)).getValue()))
                            .get(1) < ((List<Integer>) (((Map.Entry) (o2))
                            .getValue())).get(1)) {
                        return -1;
                    } else {
                        if (((List<Integer>) (((Map.Entry) (o1)).getValue()))
                                .get(2) > ((List<Integer>) (((Map.Entry) (o2))
                                .getValue())).get(2)) {
                            return 1;
                        } else if (((List<Integer>) (((Map.Entry) (o1))
                                .getValue())).get(2) > ((List<Integer>) (((Map.Entry) (o2))
                                .getValue())).get(2)) {
                            return -1;
                        } else {
                            return 0;
                        }
                    }
                }
            }
        });

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

结果将是：

{Id2=[1, 530, 340], Id4=[1, 660, 540], Id5=[2, 530, 540], Id6=[3, 650, 230], Id8=[3, 650, 330], Id1=[4, 230, 350], Id3=[4, 530, 150], Id7=[4, 530, 120]}

Answer 6

我总是使用比较器。如果您不想创建新类，可以这样做：

    ArrayList<Data> data = new ArrayList<Data>();
    // ....
    data.add(new Data("Id1", 4, 230, 350));
    data.add(new Data("Id2", 1, 530, 340));
    data.add(new Data("Id3", 3, 340, 340));
    data.add(new Data("Id4", 2, 300, 200));
    // ....
    System.out.println("Unsorted: " + data);
    data.sort(new Comparator<Data>() {

        @Override
        public int compare(Data o1, Data o2) {
            if(o1.x > o2.x)
            {
                return 1;
            }
            else
            {
                return -1;
            }
        }
    });
    System.out.println("Sorted by x: " + data);

给你希望的输出：

    Unsorted: [Id1, Id2, Id3, Id4]
    Sorted by x: [Id2, Id4, Id3, Id1]

假设您的数据存储如下：

public class Data {

        Data(String id, int x, int y, int z)
        {
            this.id = id;
            this.x = x;
            this.y = y;
            this.z = z;
        }
        String id;
        int x; // Sort by x
        int y;
        int z;

        @Override
        public String toString() {
            return id;
        }       
    }

Answer 7

我能够使用比较器并在Map＆gt;中获得数据。并找出解决方案

public class SortMapOnValueInteger {

    public static void main(String[] args) {

        Map<String, List<Integer>> unsortMap = new HashMap<String, List<Integer>>();
        unsortMap.put("z", new ArrayList(Arrays.asList( 3, 1, 56)));
        unsortMap.put("b", new ArrayList(Arrays.asList( 0, 2, 65)));
        unsortMap.put("x", new ArrayList(Arrays.asList( 0, 2, 35)));
        unsortMap.put("a", new ArrayList(Arrays.asList( 3, 3, 12)));
        unsortMap.put("c", new ArrayList(Arrays.asList( 1, 4, 65)));
        unsortMap.put("d", new ArrayList(Arrays.asList( 2, 4, 65)));
        unsortMap.put("e", new ArrayList(Arrays.asList( 4, 3, 34)));
        unsortMap.put("y", new ArrayList(Arrays.asList( 4, 2, 23)));
        unsortMap.put("n", new ArrayList(Arrays.asList( 3, 1, 23)));
        unsortMap.put("j", new ArrayList(Arrays.asList( 2, 2, 54)));
        unsortMap.put("m", new ArrayList(Arrays.asList( 1, 3, 96)));
        unsortMap.put("f", new ArrayList(Arrays.asList( 0, 4, 54)));

        System.out.println("Unsort Map......");
        printMap(unsortMap);

        System.out.println("\nSorted Map......");
        Map<String, List<Integer>> sortedMap = sortByComparator(unsortMap);
        printMap(sortedMap);

    }

    private static Map<String, List<Integer>> sortByComparator(Map<String, List<Integer>> unsortMap) {

        // Convert Map to List
        List<Map.Entry<String, List<Integer>>> list;
        list = new ArrayList<>(unsortMap.entrySet());


        // Sort list with comparator, to compare the Map values
        Collections.sort(list, new Comparator<Map.Entry<String, List<Integer>>>() {
            public int compare(Map.Entry<String, List<Integer>> o1,
                                           Map.Entry<String, List<Integer>> o2) {               
                int comparison = Integer.compare(o1.getValue().get(0), o2.getValue().get(0));
                if (comparison != 0) return comparison;
                    comparison = Integer.compare(o1.getValue().get(1), o2.getValue().get(1));
                if (comparison != 0) return comparison;
                    return Integer.compare(o1.getValue().get(2), o2.getValue().get(2));             
            }
        });         

        // Convert sorted map back to a Map
        Map<String, List<Integer>> sortedMap = new LinkedHashMap<String, List<Integer>>();
        for (Iterator<Map.Entry<String, List<Integer>>> it = list.iterator(); it.hasNext();) {
            Map.Entry<String, List<Integer>> entry = it.next();
            sortedMap.put(entry.getKey(), entry.getValue());
        }
        return sortedMap;
    }

    public static void printMap(Map<String, List<Integer>> map) {
        for (Map.Entry<String, List<Integer>> entry : map.entrySet()) {
            System.out.println("[Key] : " + entry.getKey() 
                                      + " [Value] : " + entry.getValue());
        }
    }

}

有序地图的输出是

Unsort Map......
[Key] : f [Value] : [0, 4, 54]
[Key] : d [Value] : [2, 4, 65]
[Key] : e [Value] : [4, 3, 34]
[Key] : b [Value] : [0, 2, 65]
[Key] : c [Value] : [1, 4, 65]
[Key] : a [Value] : [3, 3, 12]
[Key] : n [Value] : [3, 1, 23]
[Key] : m [Value] : [1, 3, 96]
[Key] : j [Value] : [2, 2, 54]
[Key] : z [Value] : [3, 1, 56]
[Key] : y [Value] : [4, 2, 23]
[Key] : x [Value] : [0, 2, 35]

Sorted Map......
[Key] : x [Value] : [0, 2, 35]
[Key] : b [Value] : [0, 2, 65]
[Key] : f [Value] : [0, 4, 54]
[Key] : m [Value] : [1, 3, 96]
[Key] : c [Value] : [1, 4, 65]
[Key] : j [Value] : [2, 2, 54]
[Key] : d [Value] : [2, 4, 65]
[Key] : n [Value] : [3, 1, 23]
[Key] : z [Value] : [3, 1, 56]
[Key] : a [Value] : [3, 3, 12]
[Key] : y [Value] : [4, 2, 23]
[Key] : e [Value] : [4, 3, 34]

使用java对具有多个列的对象列表进行排序

7 个答案: