Saya membaca tentang sorting ArrayLists menggunakan Komparator tetapi dalam semua contoh-contoh yang digunakan orang compareTo
yang menurut beberapa penelitian adalah metode untuk String.
Saya ingin mengurutkan ArrayList benda-benda kustom dengan salah satu sifat mereka: Tanggal obyek
(getStartDay()
). Biasanya saya membandingkan mereka dengan item1.getStartDate().sebelum(item2.getStartDate())
jadi saya bertanya-tanya apakah aku 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 Date
mengimplementasikan Sebanding
, ia memiliki compareTo
metode seperti String
tidak.
Jadi kustom anda Pembanding
bisa terlihat seperti ini:
public class CustomComparator implements Comparator<MyObject> {
@Override
public int compare(MyObject o1, MyObject o2) {
return o1.getStartDate().compareTo(o2.getStartDate());
}
}
The membandingkan()
metode harus kembali int
, sehingga anda tidak't langsung kembali boolean
seperti yang anda berencana untuk pula.
Anda menyortir kode akan menjadi seperti yang anda tulis:
Collections.sort(Database.arrayList, new CustomComparator());
Sedikit lebih pendek cara untuk menulis semua ini, jika anda don't perlu untuk menggunakan kembali pembanding, adalah untuk menulis sebagai sebuah inline anonim kelas:
Collections.sort(Database.arrayList, new Comparator<MyObject>() {
@Override
public int compare(MyObject o1, MyObject o2) {
return o1.getStartDate().compareTo(o2.getStartDate());
}
});
Anda sekarang dapat menulis contoh terakhir dalam bentuk yang lebih pendek dengan menggunakan lambda expression untuk Pembanding
:
Collections.sort(Database.arrayList,
(o1, o2) -> o1.getStartDate().compareTo(o2.getStartDate()));
Dan Daftar
memiliki sort(Komparator)
metode, sehingga anda dapat mempersingkat ini bahkan lebih jauh:
Database.arrayList.sort((o1, o2) -> o1.getStartDate().compareTo(o2.getStartDate()));
Ini adalah suatu ungkapan umum yang ada's metode built-in untuk menghasilkan Pembanding
untuk kelas dengan Sebanding
kunci:
Database.arrayList.sort(Comparator.comparing(MyObject::getStartDate));
Semua ini adalah bentuk setara.
Kelas-kelas yang telah alami urutan (kelas Nomor, sebagai contoh) harus mengimplementasikan antarmuka Sebanding, sementara kelas yang tidak memiliki alami urutan (kelas Kursi, sebagai contoh) harus disediakan dengan Komparator (atau anonim Komparator 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();
}
}
Penggunaan:
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 menyortir sebuah ArrayList
anda bisa menggunakan potongan kode berikut:
Collections.sort(studList, new Comparator<Student>(){
public int compare(Student s1, Student s2) {
return s1.getFirstName().compareToIgnoreCase(s2.getFirstName());
}
});
Ya, anda bisa. Ada dua pilihan dengan membandingkan item, Sebanding
Kedua antarmuka ini memungkinkan untuk perilaku yang berbeda. Sebanding memungkinkan anda untuk membuat objek bertindak seperti anda hanya dijelaskan String (pada kenyataannya, String mengimplementasikan Sebanding). Kedua, Komparator, memungkinkan anda untuk melakukan apa yang anda minta untuk lakukan. Anda akan melakukannya seperti ini:
Collections.sort(myArrayList, new MyComparator());
Yang akan menyebabkan Koleksi.semacam metode untuk menggunakan komparator untuk itu's sorting mekanisme. Jika benda-benda di dalam ArrayList melaksanakan sebanding, anda malah bisa melakukan sesuatu seperti ini:
Collections.sort(myArrayList);
The Koleksi kelas berisi jumlah ini berguna, alat umum.
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)
Sejak teknologi yang muncul sehari-hari, jawabannya akan berubah dalam waktu. Aku mengambil melihat LambdaJ dan tampaknya sangat menarik.
Anda dapat mencoba memecahkan tugas-tugas ini dengan LambdaJ. Anda dapat menemukannya di sini: http://code.google.com/p/lambdaj/
Di sini anda memiliki sebuah contoh:
Urutkan Iteratif
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());
}
});
Urutkan dengan lambda
List<Person> sortedByAgePersons = sort(persons, on(Person.class).getAge());
Tentu saja, memiliki kecantikan jenis ini berdampak pada kinerja (rata-rata 2 kali), tapi anda dapat menemukan lebih banyak kode yang dapat 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());
}
}
}
Terbaik cara mudah dengan JAWA 8 untuk bahasa inggris semacam Abjad
Implementasi Kelas
public class NewspaperClass implements Comparable<NewspaperClass>{
public String name;
@Override
public int compareTo(NewspaperClass another) {
return name.compareTo(another.name);
}
}
Urutkan
Collections.sort(Your List);
Jika anda ingin mengurutkan untuk alfabet yang berisi karakter non inggris anda dapat menggunakan Lokal... kode di Bawah ini menggunakan bahasa turki karakter semacam...
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);
}
}
Urutkan
Collections.sort(your array list,new NewspaperClass());
The Koleksi.semacam
metode ini dapat mengurutkan klik disini
menggunakan Pembanding
anda lulus. Bahwa Pembanding
dapat diimplementasikan dengan menggunakan Komparator.membandingkan
metode di mana anda dapat melewati metode referensi seperti yang diperlukan Fungsi
. Untungnya, kode yang sebenarnya jauh lebih sederhana dan lebih pendek dari deskripsi ini.
Untuk Jawa 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 Jawa 8
dan seterusnya kita don't harus menggunakan Koleksi.sort()
secara langsung. Daftar
antarmuka memiliki default sort()
metode:
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.
Jawa 8 Lambda lebih pendek semacam itu.
Collections.sort(stdList, (o1, o2) -> o1.getName().compareTo(o2.getName()));
Anda dapat mencoba Jambu Pemesanan:
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);
Ya, itu's mungkin misalnya dalam jawaban saya urutkan berdasarkan properti v
kelas 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;
}
});
Jika anda perhatikan di sini saya'm menciptakan anonymous inner class ( yang merupakan pulau Jawa untuk penutupan ) dan menyerahkannya langsung ke semacam
metode dari kelas Array
Objek anda juga dapat menerapkan Sebanding
( yang's apa String dan yang paling inti perpustakaan di Java tidak ) tapi yang akan menentukan "alam urutan" dari kelas itu sendiri, dan doesn't membiarkan anda pasang yang baru.
Saya menemukan kebanyakan jika tidak semua dari jawaban-jawaban ini bergantung pada dasar kelas (Objek) untuk melaksanakan sebanding atau untuk memiliki pembantu sebanding antarmuka.
Tidak dengan solusi saya! Kode berikut memungkinkan anda membandingkan objek's lapangan dengan mengetahui mereka string nama. Anda bisa dengan mudah memodifikasi untuk tidak menggunakan nama, tapi kemudian anda perlu untuk mengekspos atau membangun salah satu dari benda-Benda yang anda ingin membandingkan terhadap.
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);
}
}
}
}
Ini potongan kode yang 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 dalam jsp.
Baru sejak 1.8 adalah Daftar.sort() metode, bukan menggunakan Koleksi.sort() jadi anda langsung menghubungi mylistcontainer.sort()
Berikut adalah potongan kode yang menunjukkan Daftar.sort() fitur:
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]
Buah kelas 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
Anda bisa melihat-lihat ke presentasi tahan di Jawa Forum di Stuttgart, Jerman pada tahun 2016.
Hanya beberapa slide menggunakan bahasa jerman, 99% dari konten adalah "bahasa inggris berdasarkan" Java source code; seperti
someCollection.sort(
OurCustomComparator
.comparing(Person::getName)
.thenComparing(Person::getId)
);
di mana OurCustomComparator
adalah menggunakan metode default (dan ide-ide menarik lainnya). Seperti yang ditunjukkan, yang mengarah ke sangat ringkas kode untuk memilih beberapa metode getter untuk menyortir; dan super sederhana chaining (atau mundur) dari kriteria semacam.
Jika anda ke java8, anda dapat menemukan banyak bahan yang ada untuk mendapatkan anda mulai.