java - 按屬性排序自定義對象的ArrayList




sorting date (16)

JAVA 8 lambda表達式

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)

我閱讀了關於使用比較器對ArrayLists進行排序的方法,但在所有使用compareTo的例子中,根據某些研究,這是針對Strings的一種方法。

我想通過它們的一個屬性對自定義對象的ArrayList進行排序:Date對象( getStartDay() )。 通常我通過item1.getStartDate().before(item2.getStartDate())比較他們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);
    ...
}

2016年,您可以在德國斯圖加特的Java論壇上觀看此presentation

只有少數幻燈片使用德語,99%的內容是“基於英語的”Java源代碼; 喜歡

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

OurCustomComparator使用默認方法(以及其他有趣的想法)。 如圖所示,導致非常簡潔的代碼挑選一些getter方法進行排序; 和超級簡單的鏈接(或反向)排序標準。

如果你使用的是java8,你會發現很多資料讓你開始。


你可以使用java 8進行排序

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

or

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

你可以嘗試番石榴Ordering

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

使用Java 8可以使用Comparator.comparing()在一行中定義Comparator

使用以下任何一種方式:

選項1:

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

選項2:

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

使用Java 8,您可以使用比較器的方法引用:

import static java.util.Comparator.comparing;

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

對於Java 8:

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

要么

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

它似乎與字符串日期類型一起工作,如“2015-12-14T21:55:51Z”

另一種方法是

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



我更喜歡這個過程:

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 ,這意味著你需要一個compareToequalshashCode實現。

是的,它可能會更快......但是現在您不必為每種類型創建一個新的比較器。 如果你可以節省開發時間並放棄運行時間,那麼你可以使用這個。


是的你可以。 比較項目有兩個選項, Comparable界面和Comparator界面。

這兩個接口都允許不同的行為。 Comparable允許你使對象像你剛剛描述的Strings一樣行為(實際上,String implements Comparable)。 第二個比較器允許你做你要做的事情。 你會這樣做:

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

這將導致Collections.sort方法使用比較器來進行排序機制。 如果ArrayList中的對象實現可比性,則可以改為執行如下操作:

Collections.sort(myArrayList);

Collections類包含許多這些有用的常用工具。


是的,這是可能的,例如在這個答案中,我按類IndexValue的屬性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)並將它直接傳遞給類Arrayssort方法

你的對像也可以實現Comparable (這就是String和Java中的大多數核心庫),但是它會自己定義類的“自然排序順序”,並且不允許你插入新的類。


為了排序ArrayList你可以使用下面的代碼片段:

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

由於Date實現了Comparable ,因此它具有與String類似的compareTo方法。

所以你的自定義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());
    }
});

自java-8

您現在可以使用Comparator器的lambda表達式以較短的形式編寫最後一個示例:

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

List有一個sort(Comparator)方法,所以你可以進一步縮短:

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

這是一個常見的習慣用語,有一個內置的方法可以為Comparable類生成一個Comparable類:

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

所有這些都是等同的形式。


自1.8以來新增了一個List.sort()方法,而不是使用Collection.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);
}

} //結束Fruit類


這段代碼片段可能很有用。 如果你想對我的情況排序一個對象,我想按照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中使用它。





comparator