Java 如何使用Comparator定义自定义排序顺序？

我想开发一个汽车清单排序演示。我使用数据表来显示汽车列表。现在我想按汽车颜色对列表进行排序。这里不是按字母顺序排序。我想使用我的自定义排序顺序，如红色汽车先来，然后是蓝色，等等

为此，我尝试使用Java，但它只允许按字母顺序排序

那么，有谁能指导我如何实现要使用的技术，从而加快排序速度呢

class Car implements Comparable<Car>
{
    private String name;
    private String color;

    public Car(String name, String color){
        this.name = name;
        this.color = color;
    }

    //Implement the natural order for this class
    public int compareTo(Car c) {
        return name.compareTo(c.name);
    }

    static class ColorComparator implements Comparator<Car> {
        public int compare(Car c1, Car c2) {
            String a1 = c1.color;
            String a2 = c2.color;
            return a1.compareTo(a2);
        }
    }

    public static void main(String[] args) {
        List<Car> carList = new ArrayList<>();
        List<String> sortOrder = new ArrayList<>();

        carList.add(new Car("Ford","Silver"));
        carList.add(new Car("Tes","Blue"));
        carList.add(new Car("Honda","Magenta"));

        sortOrder.add("Silver");
        sortOrder.add("Magenta");
        sortOrder.add("Blue");

        // Now here I am confuse how to implement my custom sort             
    }
}

class汽车实现可比性
{
私有字符串名称；
私有字符串颜色；
公共汽车（字符串名称、字符串颜色）{
this.name=名称；
这个颜色=颜色；
}
//实现该类的自然顺序
公共内部比较（c车）{
返回name.compareTo（c.name）；
}
静态类ColorComparator实现Comparator{
公共int比较（车辆c1、车辆c2）{
字符串a1=c1.5颜色；
字符串a2=c2.5颜色；
返回a1。比较（a2）；
}
}
公共静态void main（字符串[]args）{
List carList=new ArrayList（）；
List sortOrder=new ArrayList（）；
carList.add（新车（“福特”、“银色”）；
添加（新车（“Tes”、“蓝色”））；
添加（新车（“本田”、“洋红”）；
排序器。添加（“银”）；
添加（“洋红”）；
排序器。添加（“蓝色”）；
//现在我不知道如何实现自定义排序
}
}

我建议您为汽车颜色创建一个枚举，而不是使用字符串，枚举的自然顺序将是您声明常量的顺序

public enum PaintColors {
    SILVER, BLUE, MAGENTA, RED
}

及

---

我认为可以这样做：

class ColorComparator implements Comparator<CarSort>
{
    private List<String> sortOrder;
    public ColorComparator (List<String> sortOrder){
        this.sortOrder = sortOrder;
    }

    public int compare(CarSort c1, CarSort c2)
    {
        String a1 = c1.getColor();
        String a2 = c2.getColor();
        return sortOrder.indexOf(a1) - sortOrder.indexOf(a2);
     }
 }

package test;

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

public class CarSort implements Comparable<CarSort>{

    String name;
    Colors color;

    public CarSort(String name, Colors color){
        this.name = name;
        this.color = color;
    } 

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Colors getColor() {
        return color;
    }
    public void setColor(Colors color) {
        this.color = color;
    }

    //Implement the natural order for this class
    public int compareTo(CarSort c)
    {
        return getName().compareTo(c.getName());
    }

    static class ColorComparator implements Comparator<CarSort>
    {
        public int compare(CarSort c1, CarSort c2)
        {
            return c1.getColor().compareTo(c2.getColor());
        }
    }

    public enum Colors {
         BLUE, SILVER, MAGENTA, RED
    }

     public static void main(String[] args)
     {
         List<CarSort> carList = new ArrayList<CarSort>();
         List<String> sortOrder = new ArrayList<String>();

         carList.add(new CarSort("Ford Figo",Colors.SILVER));
         carList.add(new CarSort("Santro",Colors.BLUE));
         carList.add(new CarSort("Honda Jazz",Colors.MAGENTA));
         carList.add(new CarSort("Indigo V2",Colors.RED));
         Collections.sort(carList, new ColorComparator());

         ListIterator<CarSort> itr=carList.listIterator();
         while (itr.hasNext()) {
            CarSort carSort = (CarSort) itr.next();
            System.out.println("Car colors: "+carSort.getColor());
        }
     }
}

这个怎么样：

List<String> definedOrder = // define your custom order
    Arrays.asList("Red", "Green", "Magenta", "Silver");

Comparator<Car> comparator = new Comparator<Car>(){

    @Override
    public int compare(final Car o1, final Car o2){
        // let your comparator look up your car's color in the custom order
        return Integer.valueOf(
            definedOrder.indexOf(o1.getColor()))
            .compareTo(
                Integer.valueOf(
                    definedOrder.indexOf(o2.getColor())));
    }
};

这个版本没有那么冗长

---

再次更新

Java 8使比较器更加简洁：

Comparator<Car> carComparator = Comparator.comparing(
        c -> definedOrder.indexOf(c.getColor()));

Comparator carComparator=Comparator.comparating(
c->definedOrder.indexOf（c.getColor（））；

比较器在线路中

List<Object> objList = findObj(name);
Collections.sort(objList, new Comparator<Object>() {
    @Override
    public int compare(Object a1, Object a2) {
        return a1.getType().compareToIgnoreCase(a2.getType());
    }
});

List objList=findObj（名称）；
Collections.sort（objList，newcomparator（）{
@凌驾
公共整数比较（对象a1、对象a2）{
返回a1.getType（）.compareToIgnoreCase（a2.getType（））；
}
});

我不得不做一些类似肖恩和伊莱克斯的回答。
但是我有太多的选项来明确定义排序顺序，只需要将某些条目浮动到列表的前面。。。以指定的（非自然）顺序。
希望这对其他人有帮助

public class CarComparator implements Comparator<Car> {

    //sort these items in this order to the front of the list 
    private static List<String> ORDER = Arrays.asList("dd", "aa", "cc", "bb");

    public int compare(final Car o1, final Car o2) {
        int result = 0;
        int o1Index = ORDER.indexOf(o1.getName());
        int o2Index = ORDER.indexOf(o2.getName());
        //if neither are found in the order list, then do natural sort
        //if only one is found in the order list, float it above the other
        //if both are found in the order list, then do the index compare
        if (o1Index < 0 && o2Index < 0) result = o1.getName().compareTo(o2.getName());
        else if (o1Index < 0) result = 1;
        else if (o2Index < 0) result = -1;
        else result = o1Index - o2Index;
        return result;
    }

//Testing output: dd,aa,aa,cc,bb,bb,bb,a,aaa,ac,ac,ba,bd,ca,cb,cb,cd,da,db,dc,zz
}

公共类CarComparator实现Comparator{
//按此顺序将这些项目排序到列表的前面
私有静态列表顺序=Arrays.asList（“dd”、“aa”、“cc”、“bb”）；
公共int比较（最终车辆o1，最终车辆o2）{
int结果=0；
intO1Index=ORDER.indexOf（o1.getName（））；
intO2Index=ORDER.indexOf（o2.getName（））；
//如果在订单列表中找不到，则执行自然排序
//如果在订单列表中只找到一个，则将其浮动到另一个之上
//如果两者都在订单列表中，则进行索引比较
如果（o1Index<0&&o2Index<0）结果=o1.getName（）.compareTo（o2.getName（））；
如果（O1指数<0）结果=1，则为else；
如果（O2指数<0）结果=-1，则为else；
其他结果=O1指数-O2指数；
返回结果；
}
//测试输出：dd、aa、aa、cc、bb、bb、a、aaa、ac、ac、ba、bd、ca、cb、cb、cd、da、db、dc、zz
}

在Java 8中，您可以执行以下操作：

List<String> order = List.of("Red", "Green", "Magenta", "Silver");

Comparator.comparing(Car::getColor(), Comparator.comparingInt(c -> order.indexOf(c)))

您首先需要一个枚举：

public enum Color {
    BLUE, YELLOW, RED
}

车辆等级：

public class Car {

    Color color;

    ....

    public Color getColor() {
        return color;
    }

    public void setColor(Color color) {
        this.color = color;
    }
}

然后，使用您的汽车列表，您可以简单地执行以下操作：

Collections.sort(carList, Comparator:comparing(CarSort::getColor));

---

将一个枚举类型定义为

public enum Colors {
     BLUE, SILVER, MAGENTA, RED
}

将

color

的数据类型从

String

更改为

Colors

将color的getter和setter方法的返回类型和参数类型更改为

Colors

定义比较器类型如下

static class ColorComparator implements Comparator<CarSort>
{
    public int compare(CarSort c1, CarSort c2)
    {
        return c1.getColor().compareTo(c2.getColor());
    }
}

---

我会这样做：

List<String> order = List.of("Red", "Green", "Magenta", "Silver");

Comparator.comparing(Car::getColor(), Comparator.comparingInt(c -> order.indexOf(c)))

List order=List.of（“红色”、“绿色”、“洋红”、“银色”）；
Comparator.comparing（Car:：getColor（），Comparator.comparingInt（c->order.indexOf（c）））

---

所有的积分都归@Sean Patrick Floyd:）

使用简单的循环：

public static void compareSortOrder (List<String> sortOrder, List<String> listToCompare){
        int currentSortingLevel = 0;
        for (int i=0; i<listToCompare.size(); i++){
            System.out.println("Item from list: " + listToCompare.get(i));
            System.out.println("Sorting level: " + sortOrder.get(currentSortingLevel));
            if (listToCompare.get(i).equals(sortOrder.get(currentSortingLevel))){

            } else {
                try{
                    while (!listToCompare.get(i).equals(sortOrder.get(currentSortingLevel)))
                        currentSortingLevel++;
                    System.out.println("Changing sorting level to next value: " + sortOrder.get(currentSortingLevel));
                } catch (ArrayIndexOutOfBoundsException e){

                }

            }
        }
    }

publicstaticvoidcomparestorder（列表排序器、列表排序器）{
int currentSortingLevel=0；
对于（int i=0；i如何运行此示例。在ColorComparator中无法访问PaintColors。您能否说明主要方法的外观。输出是什么？它始终是银色的吗？@Deepak:是的，
enum
值的自然顺序是其值定义的顺序。@SeanPatrickFloyd我不认为依赖于枚举的自然排序是一种最佳做法。@mike我不同意，但这两种观点都有有效的参数。这不是自定义排序。此外，这不是一种“函数式”排序方式……这会产生副作用！！请您也研究一下这个问题。谢谢。
Comparator carComparator=Comparator.comparating（c->definedOrder.indexOf（c.getColor（））；
正在编译errors@SantosshKumhar下面是一个工作示例：
package test;

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

public class CarSort implements Comparable<CarSort>{

    String name;
    Colors color;

    public CarSort(String name, Colors color){
        this.name = name;
        this.color = color;
    } 

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Colors getColor() {
        return color;
    }
    public void setColor(Colors color) {
        this.color = color;
    }

    //Implement the natural order for this class
    public int compareTo(CarSort c)
    {
        return getName().compareTo(c.getName());
    }

    static class ColorComparator implements Comparator<CarSort>
    {
        public int compare(CarSort c1, CarSort c2)
        {
            return c1.getColor().compareTo(c2.getColor());
        }
    }

    public enum Colors {
         BLUE, SILVER, MAGENTA, RED
    }

     public static void main(String[] args)
     {
         List<CarSort> carList = new ArrayList<CarSort>();
         List<String> sortOrder = new ArrayList<String>();

         carList.add(new CarSort("Ford Figo",Colors.SILVER));
         carList.add(new CarSort("Santro",Colors.BLUE));
         carList.add(new CarSort("Honda Jazz",Colors.MAGENTA));
         carList.add(new CarSort("Indigo V2",Colors.RED));
         Collections.sort(carList, new ColorComparator());

         ListIterator<CarSort> itr=carList.listIterator();
         while (itr.hasNext()) {
            CarSort carSort = (CarSort) itr.next();
            System.out.println("Car colors: "+carSort.getColor());
        }
     }
}

List<String> order = List.of("Red", "Green", "Magenta", "Silver");

Comparator.comparing(Car::getColor(), Comparator.comparingInt(c -> order.indexOf(c)))

public static void compareSortOrder (List<String> sortOrder, List<String> listToCompare){
        int currentSortingLevel = 0;
        for (int i=0; i<listToCompare.size(); i++){
            System.out.println("Item from list: " + listToCompare.get(i));
            System.out.println("Sorting level: " + sortOrder.get(currentSortingLevel));
            if (listToCompare.get(i).equals(sortOrder.get(currentSortingLevel))){

            } else {
                try{
                    while (!listToCompare.get(i).equals(sortOrder.get(currentSortingLevel)))
                        currentSortingLevel++;
                    System.out.println("Changing sorting level to next value: " + sortOrder.get(currentSortingLevel));
                } catch (ArrayIndexOutOfBoundsException e){

                }

            }
        }
    }

public static List<String> ALARMS_LIST = Arrays.asList(
            "CRITICAL",
            "MAJOR",
            "MINOR",
            "WARNING",
            "GOOD",
            "N/A");