Sorting on list of objects with more than one column using java

Create a record that implements comparable and then put your records in a list and call:

Collections.sort(list);

Record is:

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

}

Write a class that implements 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;
}
}

You can use list or set (depends on what you want to do) to store these objects and sort them using sort method

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

Use the method that accepts a Comparator when you want to sort and pass it to Collections.sort(List, Comparator)

For Eg:

class myClass implements Comparator<object> {

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

Then use the Comparator as

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

You can modify the logic as per your requirements.

You can create a class with properties order,estimate and actual values something like this

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

}

For sorting you can have a list as data structure and use Array List implementation

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

Implement the Comparator interface in a class and write your sorting logic in the compare method

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

and in the class where you want to sort use:

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

Using a separate comparator instead of comparable has an advantage of segregating the sorting logic in a separate class.

I always use Comparator. If you don't want to create a new class you could do it like this:

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

Gives you the wished output:

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

Assuming you have the data stored like this:

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

I was able to use comparator and have the data in Map> and work out a solution

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

}

the output of sorted map is

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]