Klasy, które mają naturalny porządek sortowania (przykładowy numer klasy) powinny zaimplementować porównywalny interfejs, podczas gdy klasy, które nie mają naturalnego porządku sortowania (przykładowy krzesło klasy) powinny być wyposażone w komparator (lub anonimową klasę komparatora).

Dwa przykłady:

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

Użycie:

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

Do sortowania ArrayList możesz użyć poniższego fragmentu kodu:

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

Tak, możesz. Istnieją dwie opcje porównywania elementów, interfejs porównywalny i Interfejs porównujący .

Oba te interfejsy pozwalają na różne zachowania. Comparable pozwala na to, aby obiekt zachowywał się tak, jak opisane ciągi znaków (w rzeczywistości String implementuje porównywalne). Drugi, komparator, pozwala Ci robić to, o co prosisz. Zrobiłbyś to tak:

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

To spowoduje zbiory.sort method to use your komparator do sortowania. Jeśli obiekty w ArrayList implementują porównywalne, możesz zamiast tego zrobić coś takiego:

Collections.sort(myArrayList);

Klasa Collections zawiera szereg tych użytecznych, powszechnych narzędzi.

Java 8 wyrażenie lambda

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

Lub

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

W Javie 8 możesz użyć referencji metody dla swojego komparatora:

import static java.util.Comparator.comparing;

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

Ponieważ technologie pojawiają się codziennie, odpowiedź zmieni się w czasie. Spojrzałam na Lambdaja i wydaje mi się bardzo interesująca.

Możesz spróbować rozwiązać te zadania za pomocą LambdaJ . Znajdziesz go tutaj: http://code.google.com/p/lambdaj/

Oto przykład:

Sort Iterative

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

Sortuj za pomocą lambda

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

Oczywiście, posiadanie tego rodzaju piękna wpływa na wydajność (średnio 2 razy), ale może znalazłeś bardziej czytelny kod?

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

}

}

Najlepszy łatwy sposób z JAVA 8 jest dla angielskiego alfabetycznego sortowania

Implementacja Klasy

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

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

Sortuj

  Collections.sort(Your List);

Jeśli chcesz sortować alfabet, który zawiera znaki inne niż angielskie, możesz użyć ustawień regionalnych... Poniżej kodu użyj sortowania znaków tureckich...

Implementacja Klasy

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

Sortuj

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

Function & method reference

The Collections.sort metoda może sortować List korzystanie z Comparator pasujesz. Że Comparator można zaimplementować za pomocą Comparator.comparing metoda, w której można przekazać odniesienie do metody jako niezbędne Function. Na szczęście rzeczywisty kod jest znacznie prostszy i krótszy niż ten opis.

Dla Javy 8:

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

Lub

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

Innym sposobem jest

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

Możesz sortować używając java 8

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

or

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

Od Java 8 i dalej nie musimy używać Collections.sort() bezpośrednio. List interfejs posiada domyślną metodę sort():

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

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

Java 8 Lambda skraca sort.

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

Możesz użyć komparatora Bean do sortowania na dowolnej właściwości w twojej klasie niestandardowej.

Tak, jest to możliwe na przykład w ta odpowiedź sortuję według właściwości v klasy 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;
        }
    });

Jeśli zauważysz tutaj, że tworzę anonimową klasę wewnętrzną (która jest Javą do zamykania ) i przekazuję ją bezpośrednio do metody sort klasy Arrays

Twój obiekt może również zaimplementować Comparable (tak robi String i większość podstawowych bibliotek w Javie), ale to definiowałoby "naturalny porządek sortowania" klasy it self, a nie pozwól podłączyć nowe.

Stwierdziłem, że większość, jeśli nie wszystkie z tych odpowiedzi, opiera się na podstawowej klasie (obiekcie), aby zaimplementować porównywalny lub mieć porównywalny interfejs helpera.

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

Możesz spróbować Guava zamawiając :

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

Twoja klasa customComparator musi zaimplementować Javę.util.Komparator w celu zastosowania. musi również nadpisać compare () i equals ()

Compare () musi odpowiedzieć na pytanie: czy obiekt 1 jest mniejszy, równy lub większy od obiektu 2?

Pełna dokumentacja: http://java.sun.com/j2se/1.5.0/docs/api/java/util/Comparator.html

Ten fragment kodu może być przydatny. Jeśli chcesz posortować obiekt w moim przypadku chcę sortować według 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;
}

Z tą biblioteką Tutaj {[3] } możesz sortować listę własnych obiektów na wielu kolumnach. Biblioteka korzysta z funkcji wersji 8.0. Próbka jest również dostępna tam. Oto przykład do zrobienia

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

Zapraszamy do zapoznania się z prezentacją , która odbędzie się na forum Java w Stuttgarcie w Niemczech w 2016 roku.

Tylko kilka slajdów używa języka niemieckiego, 99% zawartości to" angielski " kod źródłowy Javy; jak

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

Gdzie OurCustomComparator używa domyślnych metod (i innych ciekawych pomysłów). Jak pokazano, co prowadzi do bardzo zwięzłego kodu, aby wybrać jakąś metodę gettera do sortowania; i super proste łańcuchowanie (lub odwracanie) kryteriów sortowania.

Jeśli lubisz java8, znajdziesz wiele materiału na początek.

New since 1.8 is a List.metoda sort() zamiast używania kolekcji.Sortuj() więc dzwonisz bezpośrednio do mylistcontainer.sort ()

Oto fragment kodu, który pokazuje listę.funkcja 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]

Klasa owoców to:

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   

Wolę ten proces:

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

Jeśli lista obiektów ma właściwość o nazwie startDate, wywołujesz use this over and over. Możesz je nawet łańcuchować startDate.time.

To wymaga, aby twój obiekt był Comparable, co oznacza, że potrzebujesz compareTo, equals, i hashCode implementacja.

Cóż, jeśli używasz Java 8 lub starszej wersji tutaj jest najlepsze rozwiązanie.

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

W tym przypadku najpierw sortuje za pomocą 'getCgpa', a w drugiej części sortuje za pomocą getFname i getId. Czyli pole do klasy pojo.

Użycie Javy 8 może zdefiniować Comparator w jednej linii używając Comparator.comparing()

Użyj jednego z następujących sposobów:

Opcja 1:

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

Opcja 2:

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

Twoja klasa niestandardowa może zaimplementować interfejs" porównywalny", który wymaga implementacji metody CompareTo. W metodzie CompareTo można zdefiniować, co to znaczy, że obiekt jest mniejszy lub większy od innego obiektu. Więc w twoim przykładzie może to wyglądać mniej więcej tak:

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

Liczba ujemna oznacza, że Ten {[10] } jest mniejszy niż obiekt, z którym jest porównywany. Liczba dodatnia oznacza, że to jest większa niż w porównaniu do obiektu, a Zero oznacza, że obiekty są równe.

Możesz następnie użyć kolekcji.Sortuj (myList), aby posortować listę bez konieczności podawania w komparatorze. Ta metoda ma również tę zaletę, że rzeczy są sortowane automatycznie, jeśli używasz posortowanych struktur danych kolekcji, takich jak zestaw drzew lub Mapa drzew.

Możesz sprawdzić ten artykuł, jeśli chcesz przeczytać więcej o porównywalnym interfejsie (ujawnienie: jestem autorem ;) ) https://nullbeans.com/the-java-comparable-interface-automatic-sort-of-collections/

Możesz również użyć Springs PropertyComparator Jeśli masz tylko ścieżkę właściwości String do (zagnieżdżonej) właściwości, którą chcesz posortować:

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

Wadą jest to, że ten komparator po cichu ignoruje właściwości, które nie istnieją lub nie są dostępne i obsługuje to jako null wartość dla porównania. Oznacza to, że powinieneś dokładnie przetestować taki komparator lub jakoś zweryfikować istnienie ścieżki właściwości.

Używając API java-8 stream można sortować ArrayList Według:

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

Próbowałem wielu różnych rozwiązań dostępnych w Internecie, ale rozwiązanie, które działa dla mnie, jest dostępne pod poniższym linkiem.

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