Поскольку Date реализует _ 2_, у него есть метод compareTo, как и у String.

Итак, ваш пользовательский Comparator может выглядеть так:

public class CustomComparator implements Comparator<MyObject> {
    @Override
    public int compare(MyObject o1, MyObject o2) {
        return o1.getStartDate().compareTo(o2.getStartDate());
    }
}

Метод compare() должен возвращать int, поэтому вы не можете напрямую вернуть boolean, как вы планировали.

Ваш код сортировки будет примерно таким, как вы написали:

Collections.sort(Database.arrayList, new CustomComparator());

Немного более короткий способ записать все это, если вам не нужно повторно использовать свой компаратор, - это записать его как встроенный анонимный класс:

Collections.sort(Database.arrayList, new Comparator<MyObject>() {
    @Override
    public int compare(MyObject o1, MyObject o2) {
        return o1.getStartDate().compareTo(o2.getStartDate());
    }
});

Поскольку java-8

Теперь вы можете написать последний пример в более короткой форме, используя лямбда-выражение для Comparator:

Collections.sort(Database.arrayList, 
                        (o1, o2) -> o1.getStartDate().compareTo(o2.getStartDate()));

И List имеет sort(Comparator) < / a>, так что вы можете сократить его еще больше:

Database.arrayList.sort((o1, o2) -> o1.getStartDate().compareTo(o2.getStartDate()));

Это настолько распространенная идиома, что существует встроенный метод для создания Comparator для класса с Comparable ключом:

Database.arrayList.sort(Comparator.comparing(MyObject::getStartDate));

Все это эквивалентные формы.

Классы, которые имеют естественный порядок сортировки (например, номер класса), должны реализовывать интерфейс Comparable, в то время как классы, которые не имеют естественного порядка сортировки (например, класс Chair), должны быть снабжены Comparator (или анонимным Comparator). класс).

Два примера:

public class Number implements Comparable<Number> {
    private int value;

    public Number(int value) { this.value = value; }
    public int compareTo(Number anotherInstance) {
        return this.value - anotherInstance.value;
    }
}

public class Chair {
    private int weight;
    private int height;

    public Chair(int weight, int height) {
        this.weight = weight;
        this.height = height;
    }
    /* Omitting getters and setters */
}
class ChairWeightComparator implements Comparator<Chair> {
    public int compare(Chair chair1, Chair chair2) {
        return chair1.getWeight() - chair2.getWeight();
    }
}
class ChairHeightComparator implements Comparator<Chair> {
    public int compare(Chair chair1, Chair chair2) {
        return chair1.getHeight() - chair2.getHeight();
    }
}

Использование:

List<Number> numbers = new ArrayList<Number>();
...
Collections.sort(numbers);

List<Chair> chairs = new ArrayList<Chair>();
// Sort by weight:
Collections.sort(chairs, new ChairWeightComparator());
// Sort by height:
Collections.sort(chairs, new ChairHeightComparator());

// You can also create anonymous comparators;
// Sort by color:
Collections.sort(chairs, new Comparator<Chair>() {
    public int compare(Chair chair1, Chair chair2) {
        ...
    }
});

Для сортировки ArrayList вы можете использовать следующий фрагмент кода:

Collections.sort(studList, new Comparator<Student>(){
    public int compare(Student s1, Student s2) {
        return s1.getFirstName().compareToIgnoreCase(s2.getFirstName());
    }
});

Да, ты можешь. Есть два варианта сравнения элементов: Comparable интерфейс и интерфейс Comparator.

Оба этих интерфейса допускают различное поведение. Comparable позволяет вам заставить объект действовать так, как вы только что описали Strings (фактически, String реализует Comparable). Второй, Comparator, позволяет делать то, что вы просите. Вы бы сделали это так:

Collections.sort(myArrayList, new MyComparator());

Это заставит метод Collections.sort использовать ваш компаратор для механизма сортировки. Если объекты в ArrayList реализуют сопоставимые, вы можете вместо этого сделать что-то вроде этого:

Collections.sort(myArrayList);

Класс Collections содержит ряд таких полезных , общие инструменты.

Лямбда-выражение JAVA 8

Collections.sort(studList, (Student s1, Student s2) ->{
        return s1.getFirstName().compareToIgnoreCase(s2.getFirstName());
});

OR

Comparator<Student> c = (s1, s2) -> s1.firstName.compareTo(s2.firstName);
studList.sort(c)

В Java 8 вы можете использовать ссылку на метод для вашего компаратора:

import static java.util.Comparator.comparing;

Collections.sort(list, comparing(MyObject::getStartDate));

Поскольку технологии появляются каждый день, ответ со временем изменится. Я взглянул на LambdaJ и мне показался очень интересным.

Вы можете попробовать решить эти задачи с помощью LambdaJ. Вы можете найти его здесь: http://code.google.com/p/lambdaj/

Вот вам пример:

Итерационная сортировка

List<Person> sortedByAgePersons = new ArrayList<Person>(persons);
Collections.sort(sortedByAgePersons, new Comparator<Person>() {
        public int compare(Person p1, Person p2) {
           return Integer.valueOf(p1.getAge()).compareTo(p2.getAge());
        }
});

Сортировка с использованием лямбды

List<Person> sortedByAgePersons = sort(persons, on(Person.class).getAge()); 

Конечно, такая красота сказывается на производительности (в среднем в 2 раза), но можно ли найти более читаемый код?

Лучший простой способ с JAVA 8 - сортировка по английскому алфавиту

Реализация класса

public class NewspaperClass implements Comparable<NewspaperClass>{
   public String name;

   @Override
   public int compareTo(NewspaperClass another) {
      return name.compareTo(another.name);
   }
}

Сортировать

  Collections.sort(Your List);

Если вы хотите выполнить сортировку по алфавиту, содержащему неанглийские символы, вы можете использовать Locale ... Ниже кода используйте турецкую сортировку символов ...

Реализация класса

public class NewspaperClass implements Comparator<NewspaperClass> {
   public String name;
   public Boolean isUserNewspaper=false;
   private Collator trCollator = Collator.getInstance(new Locale("tr_TR"));



   @Override
   public int compare(NewspaperClass lhs, NewspaperClass rhs) {
      trCollator.setStrength(Collator.PRIMARY);
      return trCollator.compare(lhs.name,rhs.name);
   }
}

Сортировать

Collections.sort(your array list,new NewspaperClass());

Справочник по функциям и методам

_ 1_ может сортировать _ 2_ с использованием _ 3_ вы пройдете. Это Comparator можно реализовать с помощью _ 5_, в котором вы можете передать ссылку на метод в качестве необходимого _ 6_. К счастью, реальный код намного проще и короче, чем это описание.

Для Java 8:

Collections.sort(list, comparing(ClassName::getName));

or

Collections.sort(list, comparing(ClassName::getName).reversed());

Другой способ

Collections.sort(list, comparing(ClassName::getName, Comparator.nullsLast(Comparator.naturalOrder())));

Вы можете сортировать с помощью java 8

yourList.sort(Comparator.comparing(Classname::getName));

or

yourList.stream().forEach(a -> a.getBObjects().sort(Comparator.comparing(Classname::getValue)));

Начиная с Java 8 и далее нам не нужно использовать Collections.sort() напрямую. List интерфейс имеет sort() метод по умолчанию:

List<User> users = Arrays.asList(user1,user2,user3);
users.sort( (u1, u2) -> { 
return u1.getFirstName.compareTo(u2.getFirstName());}); 

См. http://visvv.blogspot.in/2016/01/sorting-objects-in-java-8.html.

Java 8 Lambda сокращает сортировку.

Collections.sort(stdList, (o1, o2) -> o1.getName().compareTo(o2.getName()));

Вы можете использовать Bean Comparator для сортировки по любому свойству в вашем пользовательском класс.

Да, это возможно, например, в этом ответе Сортирую по свойству v класса IndexValue

    // Sorting by property v using a custom comparator.
    Arrays.sort( array, new Comparator<IndexValue>(){
        public int compare( IndexValue a, IndexValue b ){
            return a.v - b.v;
        }
    });

Если вы заметили здесь, я создаю анонимный внутренний класс (который является Java для замыканий) и передаю его непосредственно методу sort класса Arrays

Ваш объект может также реализовывать Comparable (это то, что делает String и большинство базовых библиотек в Java), но это определит «естественный порядок сортировки» самого класса и не позволит вам подключать новые.

Я обнаружил, что большинство, если не все, из этих ответов полагаются на базовый класс (Object) для реализации сопоставимого или вспомогательного сопоставимого интерфейса.

Не с моим решением! Следующий код позволяет сравнивать поля объекта, зная их строковое имя. Вы можете легко изменить его, чтобы не использовать имя, но тогда вам нужно раскрыть его или создать один из объектов, с которыми вы хотите сравнивать.

Collections.sort(anArrayListOfSomeObjectPerhapsUsersOrSomething, new ReflectiveComparator(). new ListComparator("name"));

public class ReflectiveComparator {
    public class FieldComparator implements Comparator<Object> {
        private String fieldName;

        public FieldComparator(String fieldName){
            this.fieldName = fieldName;
        }

        @SuppressWarnings({ "unchecked", "rawtypes" })
        @Override
        public int compare(Object object1, Object object2) {
            try {
                Field field = object1.getClass().getDeclaredField(fieldName);
                field.setAccessible(true);

                Comparable object1FieldValue = (Comparable) field.get(object1);
                Comparable object2FieldValue = (Comparable) field.get(object2);

                return object1FieldValue.compareTo(object2FieldValue);
            }catch (Exception e){}

            return 0;
        }
    }

    public class ListComparator implements Comparator<Object> {
        private String fieldName;

        public ListComparator(String fieldName) {
            this.fieldName = fieldName;
        }

        @SuppressWarnings({ "unchecked", "rawtypes" })
        @Override
        public int compare(Object object1, Object object2) {
            try {
                Field field = object1.getClass().getDeclaredField(fieldName);
                field.setAccessible(true);
                Comparable o1FieldValue = (Comparable) field.get(object1);
                Comparable o2FieldValue = (Comparable) field.get(object2);

                if (o1FieldValue == null){ return -1;}
                if (o2FieldValue == null){ return 1;}
                return o1FieldValue.compareTo(o2FieldValue);
            } catch (NoSuchFieldException e) {
                throw new IllegalStateException("Field doesn't exist", e);
            } catch (IllegalAccessException e) {
                throw new IllegalStateException("Field inaccessible", e);
            }
        }
    }
}

Вы можете попробовать заказ Guava. :

Function<Item, Date> getStartDate = new Function<Item, Date>() {
    public Date apply(Item item) {
        return item.getStartDate();
    }
};

List<Item> orderedItems = Ordering.natural().onResultOf(getStartDate).
                          sortedCopy(items);

ваш класс customComparator должен реализовывать java.util.Comparator, чтобы его можно было использовать. он также должен перекрывать compare () AND equals ()

compare () должен ответить на вопрос: действительно ли объект 1 меньше, равен или больше объекта 2?

полные документы: http://java.sun.com/j2se/1.5.0/docs/api/java/util/Comparator.html.

Эти фрагменты кода могут быть полезны. Если вы хотите отсортировать объект, в моем случае я хочу отсортировать по имени тома:

public List<Volume> getSortedVolumes() throws SystemException {
    List<Volume> volumes = VolumeLocalServiceUtil.getAllVolumes();
    Collections.sort(volumes, new Comparator<Volume>() {
        public int compare(Volume o1, Volume o2) {
            Volume p1 = (Volume) o1;
            Volume p2 = (Volume) o2;
            return p1.getVolumeName().compareToIgnoreCase(
                    p2.getVolumeName());
        }
    });
    return volumes;
}

Это работает. Я использую его в своем jsp.

С помощью этой библиотеки здесь вы можете отсортировать список настраиваемых объектов в нескольких столбцах. Библиотека использует возможности версии 8.0. Образец также доступен там. Вот образец, который нужно сделать

SortKeys sortKeys = new SortKeys();
sortKeys.addField("firstName")
            .addField("age", true); // This (true) will sort the age descending

// Other ways to specify a property to the sorter are
//      .addField("lastName", String.class);
//      .addField("dob", Date.class, true);

// Instantiate a ListSorter
ListSorter listSorter = new ListSorter();

// Pass the data to sort (listToSort) and the "by keys" to sort (sortKeys)
List sortedList = (List<Person>) listSorter.sortList(listToSort, sortKeys);

Вы можете ознакомиться с этой презентацией на форуме Java в Штутгарт Германия в 2016 году.

Лишь в нескольких слайдах используется немецкий язык, 99% содержимого - это исходный код Java на «английском»; нравиться

someCollection.sort(
  OurCustomComparator
    .comparing(Person::getName)
    .thenComparing(Person::getId)
);

где OurCustomComparator использует методы по умолчанию (и другие интересные идеи). Как показано, это приводит к очень сжатому коду для выбора некоторого метода получения для сортировки; и сверхпростое объединение (или обращение) критериев сортировки.

Если вы занимаетесь java8, вы найдете там много материала для начала.

Новым с версии 1.8 является метод List.sort () вместо использования Collection.sort (), поэтому вы напрямую вызываете mylistcontainer.sort ()

Вот фрагмент кода, демонстрирующий функцию List.sort ():

List<Fruit> fruits = new ArrayList<Fruit>();
fruits.add(new Fruit("Kiwi","green",40));
fruits.add(new Fruit("Banana","yellow",100));
fruits.add(new Fruit("Apple","mixed green,red",120));
fruits.add(new Fruit("Cherry","red",10));

// a) using an existing compareto() method
fruits.sort((Fruit f1,Fruit f2) -> f1.getFruitName().compareTo(f2.getFruitName()));
System.out.println("Using String.compareTo(): " + fruits);
//Using String.compareTo(): [Apple is: mixed green,red, Banana is: yellow, Cherry is: red, Kiwi is: green]

// b) Using a comparable class
fruits.sort((Fruit f1,Fruit f2) -> f1.compareTo(f2));  
System.out.println("Using a Comparable Fruit class (sort by color): " + fruits);
// Using a Comparable Fruit class (sort by color): [Kiwi is green, Apple is: mixed green,red, Cherry is: red, Banana is: yellow]

Класс Fruit:

public class Fruit implements Comparable<Fruit>
{
    private String name;
    private String color;
    private int quantity;

    public Fruit(String name,String color,int quantity)
    { this.name = name; this.color = color; this.quantity = quantity; }

    public String getFruitName() { return name; }        
    public String getColor() { return color; }  
    public int getQuantity() { return quantity; }

    @Override public final int compareTo(Fruit f) // sorting the color
    {
        return this.color.compareTo(f.color);
    }     
    @Override public String toString()
    {   
        return (name + " is: " + color);
    }
} // end of Fruit class   

Я предпочитаю этот процесс:

public class SortUtil
{    
    public static <T> List<T> sort(List<T> list, String sortByProperty)
    {
            Collections.sort(list, new BeanComparator(sortByProperty));
            return list;
    }
}

List<T> sortedList = SortUtil<T>.sort(unsortedList, "startDate");

Если у вашего списка объектов есть свойство с именем startDate, вы вызываете его снова и снова. Вы даже можете связать их startDate.time.

Для этого требуется, чтобы ваш объект был Comparable, что означает, что вам нужна реализация compareTo, equals и hashCode.

Да, это могло бы быть быстрее ... Но теперь вам не нужно создавать новый компаратор для каждого типа сортировки. Если вы можете сэкономить время разработки и отказаться от времени выполнения, вы можете пойти с этим.

Что ж, если вы используете Java 8 или более старую версию, вот лучшее решение.

Collections.sort(studentList, Comparator.comparing(Student::getCgpa).reversed().thenComparing(Student:: getFname).thenComparing(Student::getId));

В этом случае сначала выполняется сортировка с помощью getCgpa, а во второй части выполняется сортировка с помощью getFname и getId. Это поле в классе pojo.

Использование Java 8 позволяет определить Comparator в одной строке с помощью Comparator.comparing()

Используйте любой из следующих способов:

Вариант 1:

listToBeSorted.sort(Comparator.comparing(CustomObject::getStartDate));

Вариант 2:

Collections.sort(listToBeSorted, Comparator.comparing(CustomObject::getStartDate));

Ваш настраиваемый класс может реализовать интерфейс «Comparable», для которого требуется реализация метода CompareTo. Затем в методе CompareTo можно определить, что означает, что объект меньше или больше другого объекта. Итак, в вашем примере это может выглядеть примерно так:

public class MyCustomClass implements Comparable<MyCustomClass>{

..........

 @Override
public int compareTo(MyCustomClass a) {
    if(this.getStartDate().before(a.getStartDate())){
        return -1;
    }else if(a.getStartDate().before(this.getStartDate())){
        return 1;
    }else {
        return 0;
    }
}

Отрицательное число означает, что this меньше сравниваемого объекта. Положительное число означает, что this больше, чем по сравнению с объектом, а ноль означает, что объекты равны.

Затем вы можете использовать collections.sort (myList) для сортировки списка без необходимости использовать компаратор. Этот метод также имеет преимущество в том, что вещи сортируются автоматически, если вы используете отсортированные структуры данных коллекции, такие как TreeSet или TreeMap.

Вы можете проверить эту статью, если хотите узнать больше об интерфейсе Comparable (раскрытие: я являюсь автором;)) https://nullbeans.com/the-java-comparable-interface-automatic-sort-of-collections/

Вы также можете использовать Springs PropertyComparator, если у вас есть только путь свойства String к (вложенному) свойству, которое вы хотите отсортировать:

List<SomeObject> list = ...;
PropertyComparator<HitWithInfo> propertyComparator = new PropertyComparator<>(
    "property.nested.myProperty", false, true);
list.sort(propertyComparator);

Недостатком является то, что этот компаратор молча игнорирует свойства, которые не существуют или недоступны, и обрабатывает это как значение null для сравнения. Это означает, что вам следует тщательно протестировать такой компаратор или как-то проверить существование пути к свойствам.

используя api потока java-8, вы можете отсортировать ArrayList по:

 Comparator<Person> birthdayComparator = Comparator.comparing(Person::getBirthday);
 List<Person> sortedList = list.stream().sorted(birthdayComparator).collect(toList());

Я пробовал множество различных решений, доступных в Интернете, но решение, которое мне подходит, доступно по ссылке ниже.

https://www.java67.com/2017/07/how-to-sort-arraylist-of-objects-using.html