Як використовувати порівняльник для визначення користувацького порядку сортування?


91

Я хочу розробити демонстраційне сортування списку автомобілів. Я використовую таблицю даних для відображення списку автомобілів. Зараз насправді я хочу відсортувати список за кольором автомобіля. Тут це не сортується за алфавітом. Я хочу скористатися своїм замовленням на сортування, наприклад, насамперед червоний автомобіль, потім синій тощо.

Для цього я намагаюся використовувати Java Comparatorі Comparableале він дозволяє сортувати в алфавітному порядку тільки.

Отже, чи може хто-небудь навести мене на шлях впровадження техніки, щоб сортування стало швидшим.

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

Відповіді:


101

Я рекомендую вам створити перелік кольорів вашого автомобіля замість того, щоб використовувати рядки, і природне впорядкування переліку буде таким, в якому ви оголошуєте константи.

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

і

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

Ви змінюєте String на PaintColor, і в основному ваш список автомобілів стає:

carList.add(new CarSort("Ford Figo",PaintColor.SILVER));

...

Collections.sort(carList, new ColorComparator());

як мені запустити цей приклад. PaintColors не доступний у ColorComparator. не могли б ви проілюструвати, як би виглядав основний метод.
Діпак

який результат? це завжди СРІБНИЙ перший?
Діпак

@Deepak: так, природний порядок enumзначень - це порядок, у якому визначаються його значення.
Йоахім Зауер

1
@SeanPatrickFloyd Я не думаю, що покладання на природне впорядкування перелічень є найкращою практикою.
mike

1
@mike Я не згоден, але є вагомі аргументи з обох точок зору
Шон Патрік Флойд

57

Як щодо цього:

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

В принципі, я згоден, що використання an enum- ще кращий підхід, але ця версія є більш гнучкою, оскільки дозволяє визначати різні порядки сортування.

Оновлення

Гуава має цю функціональність, включену у свій Orderingклас:

List<String> colorOrder = ImmutableList.of("red","green","blue","yellow");
final Ordering<String> colorOrdering = Ordering.explicit(colorOrder);
Comparator<Car> comp = new Comparator<Car>() {
    @Override
    public int compare(Car o1, Car o2) {
        return colorOrdering.compare(o1.getColor(),o2.getColor());
    }
}; 

Ця версія трохи менш багатослівна.


Оновіть ще раз

Java 8 робить компаратор ще менш багатослівним:

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

Чи можете ви, будь ласка, також розглянути це питання. Дякую тобі. stackoverflow.com/questions/61934313 / ...
user2048204

25

Компаратор в рядку ...

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

11

Я думаю, це можна зробити наступним чином:

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

Для сортування використовуйте це:

Collections.sort(carList, new ColorComparator(sortOrder));

7

Мені довелося зробити щось подібне до відповіді Шона та Ілалекса.
Але у мене було занадто багато варіантів, щоб чітко визначити порядок сортування, і мені потрібно було лише розмістити певні записи на початку списку ... у вказаному (неприродному) порядку.
Сподіваємось, це корисно комусь іншому.

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
}

4

Я зроблю щось подібне:

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

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

Усі кредити надходять @Sean Patrick Floyd :)


3

У Java 8 ви можете зробити щось подібне:

Спочатку потрібно Enum:

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

Це не є спеціальним сортуванням.
zygimantus

До того ж це не "функціональний" спосіб зробити це ... це має побічні наслідки !!
TriCore

2

Визначте один тип Enum як

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

Змінити тип даних colorз Stringна Colors Змінити тип повернення та тип аргументу геттера та методу встановлення кольору наColors

Визначте тип компаратора наступним чином

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

після додавання елементів до списку викличте метод сортування Collection, передавши об'єкти списку та компаратора як аргументи

тобто Collections.sort(carList, new ColorComparator()); друкуйте за допомогою ListIterator.

Повна реалізація класу така:

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

0

Використання простих циклів:

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");
Використовуючи наш веб-сайт, ви визнаєте, що прочитали та зрозуміли наші Політику щодо файлів cookie та Політику конфіденційності.
Licensed under cc by-sa 3.0 with attribution required.