Saya membaca tentang menyortir ArrayLists menggunakan Comparator tetapi dalam semua contoh yang digunakan orang compareToyang menurut beberapa penelitian adalah metode untuk Strings.

Saya ingin mengurutkan ArrayList objek kustom berdasarkan salah satu propertinya: objek Date ( getStartDay()). Biasanya saya membandingkannya dengan item1.getStartDate().before(item2.getStartDate())begitu saya bertanya-tanya apakah saya bisa menulis sesuatu seperti:

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

Sejak Datediterapkan Comparable, ia memiliki compareTometode seperti Stringhalnya.

Jadi kebiasaan Anda Comparatordapat terlihat seperti ini:

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

The compare()Metode harus mengembalikan int, sehingga Anda tidak bisa langsung mengembalikan booleanseperti Anda berencana untuk tetap.

Kode sortir Anda hampir sama dengan yang Anda tulis:

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

Cara yang sedikit lebih pendek untuk menulis semua ini, jika Anda tidak perlu menggunakan kembali komparator Anda, adalah menuliskannya sebagai kelas anonim sebaris:

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

Sejak java-8

Anda sekarang dapat menulis contoh terakhir dalam bentuk yang lebih pendek dengan menggunakan ekspresi lambda untuk Comparator:

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

Dan Listmemiliki sort(Comparator)metode, sehingga Anda dapat mempersingkat ini lebih jauh:

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

Ini adalah idiom umum sehingga ada metode bawaan untuk menghasilkan a Comparatoruntuk kelas dengan Comparablekunci:

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

Semua ini adalah bentuk yang setara.

Kelas-kelas yang memiliki urutan penyortiran alami (nomor kelas, sebagai contoh) harus mengimplementasikan antarmuka yang sebanding, sementara kelas-kelas yang tidak memiliki urutan penyortiran alami (ketua kelas, sebagai contoh) harus disediakan dengan pembanding (atau pembanding anonim) kelas).

Dua contoh:

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

Pemakaian:

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

Untuk mengurutkan, ArrayListAnda dapat menggunakan cuplikan kode berikut:

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

Ya kamu bisa. Ada dua opsi dengan membandingkan item, antarmuka yang sebanding , dan antarmuka komparator .

Kedua antarmuka ini memungkinkan untuk perilaku yang berbeda. Sebanding memungkinkan Anda untuk membuat objek bertindak seperti Anda baru saja dijelaskan Strings (pada kenyataannya, String mengimplementasikan Sebanding). Yang kedua, Pembanding, memungkinkan Anda untuk melakukan apa yang Anda minta. Anda akan melakukannya seperti ini:

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

Itu akan menyebabkan metode Collections.sort menggunakan komparator Anda untuk mekanisme penyortirannya. Jika objek dalam mengimplementasikan ArrayList sebanding, Anda bisa melakukan sesuatu seperti ini:

Collections.sort(myArrayList);

Kelas Koleksi berisi sejumlah alat yang berguna dan umum ini.

Ekspresi lambda JAVA 8

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

ATAU

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

Dengan Java 8 Anda dapat menggunakan referensi metode untuk komparator Anda:

import static java.util.Comparator.comparing;

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

Karena teknologi muncul setiap hari, jawabannya akan berubah seiring waktu. Saya melihat LambdaJ dan tampaknya sangat menarik.

Anda dapat mencoba menyelesaikan tugas ini dengan LambdaJ . Anda dapat menemukannya di sini: http://code.google.com/p/lambdaj/

Di sini Anda memiliki contoh:

Urutkan berulang

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

Sortir dengan lambda

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

Tentu saja, memiliki keindahan semacam ini berdampak pada kinerja (rata-rata 2 kali), tetapi dapatkah Anda menemukan kode yang lebih mudah dibaca?

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

}

}

Cara mudah terbaik dengan JAVA 8 adalah untuk jenis Alfabet Bahasa Inggris

Implementasi Kelas

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

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

Menyortir

  Collections.sort(Your List);

Jika Anda ingin mengurutkan untuk alfabet yang mengandung karakter bukan bahasa Inggris, Anda dapat menggunakan Lokal ... Di bawah kode ini menggunakan pengurutan karakter Turki ...

Implementasi Kelas

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

Menyortir

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

Referensi fungsi & metode

The Collections.sortMetode dapat mengurutkan Listmenggunakan ComparatorAnda lulus. Itu Comparatordapat diimplementasikan menggunakan Comparator.comparingmetode di mana Anda dapat melewati referensi metode yang diperlukan Function. Untungnya, kode yang sebenarnya jauh lebih sederhana dan lebih pendek dari deskripsi ini.

Untuk Java 8:

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

atau

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

Cara lain adalah

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

Dari Java 8dan selanjutnya kita tidak harus menggunakan Collections.sort()secara langsung. Listantarmuka memiliki sort()metode default :

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

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

Java 8 Lambda mempersingkat semacam itu.

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

Anda dapat menggunakan Bean Comparator untuk mengurutkan properti apa pun di kelas khusus Anda.

Ya, itu mungkin misalnya dalam jawaban ini saya urutkan berdasarkan properti vkelasIndexValue

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

Jika Anda perhatikan di sini saya membuat kelas dalam anonim (yang merupakan Java untuk penutupan) dan meneruskannya langsung ke sortmetode kelasArrays

Objek Anda juga dapat mengimplementasikan Comparable(itulah yang dilakukan oleh String dan sebagian besar pustaka inti di Jawa) tetapi itu akan menentukan "susunan urutan alami" dari kelas itu sendiri, dan tidak membiarkan Anda memasang yang baru.

Saya menemukan sebagian besar jika tidak semua jawaban ini bergantung pada kelas yang mendasari (Obyek) untuk mengimplementasikan sebanding atau memiliki antarmuka yang sebanding pembantu.

Tidak dengan solusi saya! Kode berikut memungkinkan Anda membandingkan bidang objek dengan mengetahui nama string mereka. Anda dapat dengan mudah memodifikasinya untuk tidak menggunakan nama, tetapi kemudian Anda perlu memaparkannya atau membuat salah satu Objek yang ingin Anda bandingkan.

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

Anda dapat mencoba Pemesanan Jambu :

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

Anda dapat Mengurutkan menggunakan java 8

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

or

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

Cuplikan kode ini mungkin berguna. Jika Anda ingin mengurutkan Objek dalam kasus saya, saya ingin mengurutkan berdasarkan 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;
}

Ini bekerja. Saya menggunakannya di jsp saya.

Dengan perpustakaan ini di sini Anda dapat mengurutkan daftar objek khusus pada banyak kolom. Perpustakaan menggunakan fitur versi 8.0. Sampel juga tersedia di sana. Berikut adalah contoh yang harus dilakukan

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

Anda dapat melihat ke dalam presentasi ini di Java Forum di Stuttgart Germany pada tahun 2016.

Hanya beberapa slide yang menggunakan bahasa Jerman, 99% kontennya adalah kode sumber Java "Berbasis Bahasa Inggris"; Suka

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

dimana OurCustomComparator menggunakan metode default (dan ide menarik lainnya). Seperti yang ditunjukkan, mengarah ke kode yang sangat ringkas untuk memilih beberapa metode pengambil untuk menyortir; dan rantai super sederhana (atau membalikkan) kriteria semacam.

Jika Anda tertarik dengan java8, Anda akan menemukan banyak materi untuk memulai.

Yang baru sejak 1.8 adalah metode List.sort () alih-alih menggunakan Collection.sort () sehingga Anda langsung memanggil mylistcontainer.sort ()

Berikut ini cuplikan kode yang menunjukkan fitur 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]

Kelas Buah adalah:

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   

kelas customComparator Anda harus mengimplementasikan java.util.Comparator agar dapat digunakan. itu juga harus mengungguli bandingkan () DAN sama dengan ()

bandingkan () harus menjawab pertanyaan: Apakah objek 1 kurang dari, sama dengan atau lebih besar dari objek 2?

dokumen lengkap: http://java.sun.com/j2se/1.5.0/docs/api/java/util/Comparator.html

Saya lebih suka proses ini:

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

Jika Anda daftar objek memiliki properti yang dipanggil startDate, Anda dapat menelepon menggunakan ini berulang-ulang. Anda bahkan dapat merantai mereka startDate.time.

Hal ini memerlukan objek Anda untuk menjadi Comparableyang berarti Anda membutuhkan compareTo, equalsdan hashCodeimplementasi.

Ya, itu bisa lebih cepat ... Tapi sekarang Anda tidak perlu membuat Pembanding baru untuk setiap jenis pengurutan. Jika Anda dapat menghemat waktu dev dan menyerah saat runtime, Anda bisa menggunakan yang ini.

Menggunakan Java 8, penggunaan dapat menentukan penggunaan Comparatordalam satu barisComparator.comparing()

Gunakan salah satu dari cara berikut:

Pilihan 1:

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

Pilihan 2:

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

Kelas khusus Anda dapat mengimplementasikan antarmuka "Sebanding", yang membutuhkan implementasi metode CompareTo. Dalam metode CompareTo, Anda kemudian dapat mendefinisikan apa artinya suatu objek kurang dari atau lebih dari objek lainnya. Jadi dalam contoh Anda, ini dapat terlihat seperti ini:

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

Angka negatif menunjukkan bahwa ini lebih kecil dari objek yang dibandingkan. Angka positif menunjukkan bahwa ini lebih besar daripada yang dibandingkan dengan objek dan Nol berarti bahwa objek tersebut sama.

Anda kemudian dapat menggunakan collections.sort (myList) untuk mengurutkan daftar Anda tanpa harus memberi makan di pembanding. Metode ini juga memiliki keuntungan memiliki hal-hal yang diurutkan secara otomatis jika Anda menggunakan struktur data koleksi yang diurutkan seperti TreeSet atau TreeMap.

Anda dapat memeriksa artikel ini jika Anda ingin membaca lebih lanjut tentang antarmuka Sebanding (pengungkapan: Saya penulis;)) https://nullbeans.com/the-java-comparable-interface-automatic-sort-of-collections/

Anda juga bisa menggunakan Springs PropertyComparator jika Anda hanya memiliki jalur properti String ke properti (bersarang) yang ingin Anda urutkan:

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

Kekurangannya adalah, pembanding ini secara diam-diam mengabaikan properti yang tidak ada atau tidak dapat diakses dan menangani ini sebagai nilai nol untuk perbandingan. Ini berarti, Anda harus dengan hati-hati menguji pembanding tersebut atau memvalidasi keberadaan jalur properti.

menggunakan api streaming java-8 Anda dapat mengurutkan ArrayListberdasarkan:

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

Saya telah mencoba banyak solusi berbeda yang tersedia di internet tetapi solusi yang berfungsi untuk saya tersedia di tautan di bawah ini.

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