Сортировка ArrayList пользовательских объектов по свойствам

Я читал о сортировке ArrayLists с помощью Comparator, но во всех примерах люди использовали compareTo, который, согласно некоторым исследованиям, является методом для строк.

Я хотел отсортировать ArrayList пользовательских объектов по одному из их свойств: объекту Date (getStartDay()). Обычно я сравниваю их по принципу item1.getStartDate().before(item2.getStartDate()), поэтому мне стало интересно, могу ли я написать что-то вроде:

public class CustomComparator {
    public boolean compare(Object object1, Object object2) {
        return object1.getStartDate().before(object2.getStartDate());
    }
}

public class RandomName {
    ...
    Collections.sort(Database.arrayList, new CustomComparator);
    ...
}
james.garriss
Редактировал вопрос 27-го января 2016 в 5:18
Программирование
sorting java date comparator
6-го мая 2010 в 9:09
29 просмотров
Комментарии к вопросу (2)
Решение

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

Поэтому ваш пользовательский Comparator может выглядеть следующим образом:

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

Since [tag:java-8]

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

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

А у List есть метод sort(Comparator), так что вы можете сократить его еще больше:

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

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

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

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

Michael Myers
Редактировал ответ 2-го июня 2016 в 4:46
Комментарии (12)

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

Два примера:

public class Number implements Comparable {
    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 {
    public int compare(Chair chair1, Chair chair2) {
        return chair1.getWeight() - chair2.getWeight();
    }
}
class ChairHeightComparator implements Comparator {
    public int compare(Chair chair1, Chair chair2) {
        return chair1.getHeight() - chair2.getHeight();
    }
}

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

List numbers = new ArrayList();
...
Collections.sort(numbers);

List chairs = new ArrayList();
// 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() {
    public int compare(Chair chair1, Chair chair2) {
        ...
    }
});
Комментарии (4)

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

Collections.sort(studList, new Comparator(){
    public int compare(Student s1, Student s2) {
        return s1.getFirstName().compareToIgnoreCase(s2.getFirstName());
    }
});
Комментарии (2)

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

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

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

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

Collections.sort(myArrayList);

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

Комментарии (0)

<Н2>Java 8 лямбда-выражения</Н2>

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

<Н3 и GT;или</Н3>

Comparator c = (s1, s2) -> s1.firstName.compareTo(s2.firstName);
studList.sort(c)
Комментарии (3)

С Java 8 вы можете использовать эталонный метод для компаратора:

import static java.util.Comparator.comparing;

Collections.sort(list, comparing(MyObject::getStartDate));
Комментарии (1)

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

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

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

Сортировка Итерационный

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

Сортировка с лямда

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

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

Комментарии (3)
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;

public class test {

public static class Person {
    public String name;
    public int id;
    public Date hireDate;

    public Person(String iname, int iid, Date ihireDate) {
        name = iname;
        id = iid;
        hireDate = ihireDate;
    }

    public String toString() {
        return name + " " + id + " " + hireDate.toString();
    }

    // Comparator
    public static class CompId implements Comparator {
        @Override
        public int compare(Person arg0, Person arg1) {
            return arg0.id - arg1.id;
        }
    }

    public static class CompDate implements Comparator {
        private int mod = 1;
        public CompDate(boolean desc) {
            if (desc) mod =-1;
        }
        @Override
        public int compare(Person arg0, Person arg1) {
            return mod*arg0.hireDate.compareTo(arg1.hireDate);
        }
    }
}

public static void main(String[] args) {
    // TODO Auto-generated method stub
    SimpleDateFormat df = new SimpleDateFormat("mm-dd-yyyy");
    ArrayList people;
    people = new ArrayList();
    try {
        people.add(new Person("Joe", 92422, df.parse("12-12-2010")));
        people.add(new Person("Joef", 24122, df.parse("1-12-2010")));
        people.add(new Person("Joee", 24922, df.parse("12-2-2010")));
    } catch (ParseException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }

    Collections.sort(people, new Person.CompId());
    System.out.println("BY ID");
    for (Person p : people) {
        System.out.println(p.toString());
    }

    Collections.sort(people, new Person.CompDate(false));
    System.out.println("BY Date asc");
    for (Person p : people) {
        System.out.println(p.toString());
    }
    Collections.sort(people, new Person.CompDate(true));
    System.out.println("BY Date desc");
    for (Person p : people) {
        System.out.println(p.toString());
    }

}

}
Комментарии (3)

Лучший простой способ с Java 8 для английской алфавитной сортировки

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

public class NewspaperClass implements Comparable{
   public String name;

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

**Род *

  Collections.sort(Your List);

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

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

public class NewspaperClass implements Comparator {
   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());
Beyaz
Редактировал ответ 26-го июня 2016 в 9:57
Комментарии (0)

Функция &ампер; базовый способ

Коллекции .сорт метод сортировки "Список" с помощью компаратор вы проходите. Что компаратор может быть реализован с помощью компаратора в .сравнивая способ, где можно пройти метод использования как надо функция. К счастью, фактический код намного проще и короче, чем это описание.

Для Java 8:

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

или

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

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

Collections.sort(list, comparing(ClassName::getName, Comparator.nullsLast(Comparator.naturalOrder())));
Basil Bourque
Редактировал ответ 28-го декабря 2018 в 9:22
Комментарии (1)

От Java версии 8 и далее мы не'т придется использовать коллекции.сортировать () напрямую. Список интерфейс по умолчанию сортировки () метод:

List 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.

Комментарии (0)

Java 8 лямбда сокращает сортировки.

Collections.sort(stdList, (o1, o2) -> o1.getName().compareTo(o2.getName()));
Pshemo
Редактировал ответ 31-го мая 2016 в 11:06
Комментарии (1)

Вы можете использовать компаратора фасоли Сортировать по любое свойство в пользовательском классе.

Комментарии (0)

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

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

List orderedItems = Ordering.natural().onResultOf(getStartDate).
                          sortedCopy(items);
Комментарии (0)

Да, что's возможно, например, в этот ответ я Сортировать по недвижимость В класса IndexValue 

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

Если вы заметили здесь, я'м создание анонимный внутренний класс ( Что такое Java для укупорочных средств ) и передает его непосредственно на "сортировка" метод класса массивы

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

Community
Редактировал ответ 23-го мая 2017 в 12:10
Комментарии (1)

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

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

or

yourList.stream().forEach(a -> a.getBObjects().sort(Comparator.comparing(Classname::getValue)));
Комментарии (0)

Я нашел большинство, если не все эти ответы опираются на базовый класс (объект) для осуществления сопоставимо или есть помощник comparable интерфейс.

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

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

public class ReflectiveComparator {
    public class FieldComparator implements Comparator {
        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 {
        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);
            }
        }
    }
}
Комментарии (0)

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

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

Это работает. Я использую это в моей JSP-страницы.

Комментарии (0)

Новый с 1.8-это список.метода sort() вместо использования коллекции.сортировать() так вы напрямую звоните mylistcontainer.сортировать()

Вот фрагмент кода, который демонстрирует список.сортировать() функция:

List fruits = new ArrayList();
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]

Плод класс:

public class Fruit implements Comparable
{
    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
TylerH
Редактировал ответ 7-го января 2019 в 5:01
Комментарии (0)

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

Только несколько слайдов использовать немецкий язык, 99% контента является "английский и" в исходный Java-код; как

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

где OurCustomComparator является использование методов по умолчанию (и другие интересные идеи). Как показано, приводит к очень лаконичный код, чтобы выбрать какой-то метод GET для сортировки и супер простых цепочек (или реверсивный) критериев сортировки.

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

Комментарии (0)