Comparator를 사용하여 ArrayLists를 정렬하는 것에 대해 읽었지만 모든 예제에서 사람들이 사용한 compareTo연구에 따르면 Strings에 대한 방법입니다.

속성 중 하나 인 Date 객체 ( getStartDay()) 로 사용자 정의 객체의 ArrayList를 정렬하려고했습니다 . 일반적으로 나는 그것들을 비교하여 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);
    ...
}

때문에 Date구현 Comparable, 그것은이 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());
    }
});

이후 자바 -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()));

이것은 키가 있는 클래스 를 생성하는 내장 메소드 가있는 일반적인 관용구입니다 .ComparatorComparable

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을 사용하면 방금 설명한 String (사실 String이 Comparable을 구현 함)처럼 객체를 작동시킬 수 있습니다. 두 번째 인 Comparator를 사용하면 원하는 작업을 수행 할 수 있습니다. 당신은 이것을 이렇게 할 것입니다 :

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

그러면 Collections.sort 메소드가 정렬 메커니즘으로 비교기를 사용하게됩니다. ArrayList의 객체가 비슷한 것을 구현하면 대신 다음과 같이 할 수 있습니다.

Collections.sort(myArrayList);

컬렉션 클래스는이 유용한 일반적인 도구를 포함하고 있습니다.

자바 8 람다 식

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

또는

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 배) 더 읽기 쉬운 코드를 찾을 수 있습니까?

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<Person> {
        @Override
        public int compare(Person arg0, Person arg1) {
            return arg0.id - arg1.id;
        }
    }

    public static class CompDate implements Comparator<Person> {
        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<Person> people;
    people = new ArrayList<Person>();
    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());
    }

}

}

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

영어 이외의 문자가 포함 된 알파벳을 정렬하려면 로케일을 사용할 수 있습니다. 아래 코드는 터키어 문자 정렬을 사용합니다.

클래스 구현

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

기능 및 방법 참조

이 Collections.sort방법은 패스를 List사용하여 정렬 할 수 있습니다 Comparator. 즉 Comparator사용하여 구현 될 수있는 Comparator.comparing사용자가 전달할 수있는 방법 에있어서의 참조 필요한 등을 Function. 다행히도 실제 코드는이 설명보다 훨씬 간단하고 짧습니다.

자바 8 :

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

또는

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

다른 방법은

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

에서 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있지만 (Java의 String 및 대부분의 핵심 라이브러리가 수행하는 작업) 자체 클래스의 "자연 정렬 순서"를 정의하므로 새로운 플러그를 연결할 수 없습니다.

나는이 답변이 모두 기본 클래스 (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);
            }
        }
    }
}

당신은 구아바 주문을 시도 할 수 있습니다 :

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

당신은 자바 8을 사용하여 정렬 할 수 있습니다

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

or

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

이 코드 스 니펫이 유용 할 수 있습니다. 필자의 경우 객체를 정렬하려면 VolumeName으로 정렬하고 싶습니다.

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

2016 년 슈투트가르트 독일의 Java 포럼 에서이 프레젠테이션 자료를 살펴볼 수 있습니다 .

소수의 슬라이드 만 독일어를 사용하며, 내용의 99 %가 "영어 기반"Java 소스 코드입니다. 처럼

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

OurCustomComparator사용하는 기본 방법 (및 기타 흥미로운 아이디어). 그림과 같이 정렬을 위해 getter 메소드를 선택하는 매우 간결한 코드로 이어집니다. 정렬 기준의 매우 간단한 연결 (또는 역전).

당신이 java8에 있다면, 시작하기 위해 많은 자료를 찾을 수 있습니다.

1.8 이후의 새로운 기능은 Collection.sort ()를 사용하는 대신 List.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]

과일 수업은 다음과 같습니다.

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   

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 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을 사용하면 다음을 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;
    }
}

음의 수는 것을 나타낸다 이 비교되는 오브젝트보다 작다. 양수 것을 나타낸다 이 물체와 비교하고, 오브젝트가 동일한 것을 제로 수단보다 크다.

그런 다음 collections.sort (myList)를 사용하여 비교기를 입력하지 않고도 목록을 정렬 할 수 있습니다. 이 메소드는 TreeSet 또는 TreeMap과 같은 정렬 된 콜렉션 데이터 구조를 사용하는 경우 사물을 자동으로 정렬하는 이점도 있습니다.

Comparable 인터페이스에 대한 자세한 내용을 보려면이 기사를 확인하십시오 (공개 : 나는 저자입니다;) https://nullbeans.com/the-java-comparable-interface-automatic-sort-of-collections/

정렬하려는 (중첩) 속성에 대한 문자열 속성 경로가있는 경우 Springs PropertyComparator를 사용할 수도 있습니다 .

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

단점은이 비교기가 존재하지 않거나 액세스 할 수없는 속성을 자동으로 무시하고이를 비교하기 위해 null 값 으로 처리한다는 것입니다. 즉, 이러한 비교기를주의 깊게 테스트하거나 속성 경로가 존재하는지 확인해야합니다.

java-8 스트림 API를 사용하면 다음을 기준으로 정렬 할 수 있습니다 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