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

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

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

你可以尝试番石榴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最简单的方法是英文字母排序

课程实施

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

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

分类

  Collections.sort(Your List);

如果您想对包含非英文字符的字母进行排序,则可以使用Locale ...下面的代码使用土耳其字符排序...

课程实施

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

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

import static java.util.Comparator.comparing;

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

具有自然排序顺序的类(例如类Number)应该实现Comparable接口,而没有自然排序顺序的类(例如,Chair类)应该随比较器(或匿名比较器类)。

两个例子:

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

您可以使用Bean比较器对自定义类中的任何属性进行排序。



我更喜欢这个过程:

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类包含许多这些有用的常用工具。


有了这个库here您可以在多列上对自定义对象列表进行排序。 该库使用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);

由于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类,其中包含一个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