Sort multiple variable lists with Java 8 thread

Question

I have a list of objects with multiple variables. I want to sort this list according to a specific execution sequence. I am using the following code that looks inefficient at all. For example, what happens if the variable is not 3, but 10 or 30? Can anyone suggest a better way to do this?

import java.util.List;
import java.util.function.Function;
import static java.util.Comparator.*;
import static java.util.stream.Collectors.*;

public class SortXYZ {
    double x;
    String y;
    double z;

public double getX() {return x; }
public String getY() {return y; }
public double getZ() {return z; }

 public static void main(String[] arg)   {
    Function<SortXYZ, Double> f1 = SortXYZ::getX;
    Function<SortXYZ, String> f2 = SortXYZ::getY;
    Function<SortXYZ, Double> f3 = SortXYZ::getZ;
    //could have f4, f5 etc.

    List<SortXYZ> list = getList(); //get a list of SortXYZ objects 

    String sortSeq = arg[0];
    if (sortSeq.equals("XYZ")) {
        list = list.stream().sorted(comparing(f1).thenComparing(f2).thenComparing(f3)).collect(toList());
    } else if (sortSeq.equals("XZY")) {
        list = list.stream().sorted(comparing(f1).thenComparing(f3).thenComparing(f2)).collect(toList());
    } else if (sortSeq.equals("YXZ")) {
        list = list.stream().sorted(comparing(f2).thenComparing(f1).thenComparing(f3)).collect(toList());
    } else if (sortSeq.equals("YZX")) {
        list = list.stream().sorted(comparing(f2).thenComparing(f3).thenComparing(f1)).collect(toList());
    } else if (sortSeq.equals("ZXY")) {
        list = list.stream().sorted(comparing(f3).thenComparing(f1).thenComparing(f2)).collect(toList());
    } else if (sortSeq.equals("ZYX")) {
        list = list.stream().sorted(comparing(f3).thenComparing(f2).thenComparing(f1)).collect(toList());
    } 


}
 }

Answer 1

You can use a loop to iterate over the characters and create a comparator - see the code below.

, comparator " ", , . , , , , , , , , , .

import java.util.Comparator;
import java.util.List;
import java.util.function.Function;

import static java.util.Arrays.asList;
import static java.util.Comparator.comparing;
import static java.util.stream.Collectors.toList;

public class SortXYZ {

    private final double x;
    private final String y;
    private final double z;

    public SortXYZ(double x, String y, double z) {
        this.x = x;
        this.y = y;
        this.z = z;
    }

    public double getX() {
        return x;
    }

    public String getY() {
        return y;
    }

    public double getZ() {
        return z;
    }

    @Override
    public String toString() {
        return "SortXYZ{x=" + x + ", y=" + y + ", z=" + z + "}";
    }

    private static Comparator<SortXYZ> comparator;

    public static void main(String[] arg) {
        List<SortXYZ> list = asList(new SortXYZ(1, "A", 2), new SortXYZ(1, "A", 0), new SortXYZ(2, "B", 1));

        String sortSeq = "YXZ";

        comparator = comparing(function(sortSeq.charAt(0)));
        sortSeq.chars().skip(1).forEach(c -> comparator = comparator.thenComparing(function((char) c)));

        List<SortXYZ> sortedList = list.stream().sorted(comparator).collect(toList());

        System.out.println(sortedList);
    }

    public static Function<SortXYZ, ? extends Comparable> function(char c) {
        switch (c) {
            case 'X': return SortXYZ::getX;
            case 'Y': return SortXYZ::getY;
            case 'Z': return SortXYZ::getZ;
            default:  throw new IllegalArgumentException("" + c);
        }
    }

}

Answer 2

rawtypes Comparator. .

---

, , . , (f1 f2..) ,

@SuppressWarnings("rawtypes") 
static Map<String, Function<SortXYZ, Comparable>> gettersMap = new HashMap<>();
static {
    gettersMap.put("x", SortXYZ::getX);
    gettersMap.put("y", SortXYZ::getY);
    gettersMap.put("z", SortXYZ::getZ);
}

,

@SuppressWarnings("unchecked")
static Comparator<SortXYZ> getComparator(String order){
    String[] keys = order.toLowerCase().split("");
    Comparator<SortXYZ> result = Comparator.comparing(gettersMap.get(keys[0]));
    for (int i = 1; i<keys.length; i++){
        result = result.thenComparing(gettersMap.get(keys[i]));
    }
    return result;
}

BTW: :

list = list.stream().sorted(Comparator.comparing(f3).thenComparing(f2).thenComparing(f1)).collect(toList());

, list. ,

list.sort(yourComparator);

, :

List<SortXYZ> list = getList(); //get a list of SortXYZ objects 

String sortSeq = arg[0];
list.sort(getComparator(sortSeq));