Since java-8

Question

我读到的是使用比较器对ArrayLists进行分类,但在所有例子中,使用<代码>compare To ,根据一些研究,这种方法是用来衡量成绩的方法。

I wanted to sort an ArrayList of custom objects by one of their properties: a Date object (getStartDay()). Normally I compare them by item1.getStartDate().before(item2.getStartDate()) so I was wondering whether I could write something like:

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

Answer 1

自 rel=“noreferer”> 实施 rel=“noretinger”>Comparable <, 它有compare>。 To 仅如<代码>String。

因此,您的习惯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());
    }
});

Since java-8

您现在可以通过使用lambda expression,为Comparator:

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

sort(Comparator) 这种方法可以进一步缩短:

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

这是一种共同的区别,即有关键:

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

所有这些形式都是相当的。

Answer 2

具有自然秩序的班级(例如,班级数)应当采用可比较的接口,而没有自然秩序的班级(例如,班级主席)应当向比较员(或匿名比较班级)提供。

两个例子:

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

Answer 3

分类您可使用以下法典:

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

Answer 4

JAVA 8 lambda expression

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

OR

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

Answer 5

是的,你可以。比较项目有两个选择:Comparable接口和接口。

这两个接口都允许不同的行为。相比之下,你就能够使物体像你刚才描述的“强权”一样行事(事实上,可加以比较)。第二,比较法允许你做你要求做的事情。你们会这样做:

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

这将导致收集。采用哪一种方法利用你的比较机制进行分类。如果ArrayList的物体可作比较,你可以做这样的事情:

Collections.sort(myArrayList);

Collections。

Answer 6

如果是 Java8,你可以采用一种方法参照你的比较:

import static java.util.Comparator.comparing;

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

Answer 7

由于技术每天都在出现,答案将会改变。我看了LambdaJ,似乎非常有趣。

您可尝试通过<>Lambda J解决这些任务。 http://code.google.com/p/lambdaj/“rel=“noreferer”http://code.google.com/p/lambdaj/。

例如:

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

www.un.org/Depts/DGACM/index_spanish.htm Sort with lambda

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

当然,在业绩方面有这种美容影响(平均为2倍),但你能否找到一个更可读的法典?

Answer 8

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

}

}

Answer 9

Function & method reference

Collections.s或t 方法可以是 List ,使用>>>> > > >:Comparat或.comparing https://docs.或acle.com/javase/tut或ial/java/javaOO/methodviss.html” rel=“n或eferer”>method reference , as necessary , 幸运的是,实际守则比这一描述更加简单、更短。



 Java8:

Collections.s或t(list, comparing(ClassName::getName));


或

Collections.s或t(list, comparing(ClassName::getName).reversed());


另一种方式是:

Collections.s或t(list, comparing(ClassName::getName, Comparat或.nullsLast(Comparat或.naturalOrder())));

Answer 10

AAVA 8号卫星最容易使用英语

www.un.org/Depts/DGACM/index_spanish.htm 三级:

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

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

<>Sort

  Collections.sort(Your List);

如果你想对含有非英语特征的字母进行分类,你可以使用当地语。下面的代码使用土耳其特性。

www.un.org/Depts/DGACM/index_spanish.htm 三级:

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

<>Sort

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

Answer 11

www.un.org/Depts/DGACM/index_spanish.htm 页: 1

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

or

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

Answer 12

从<代码>Java 8,到此,我们不必直接使用<代码>。。

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

见 rel=“noretinger”http://visv.blogspot.in/2016/01/sorting-objects-in-java-8.html。

Answer 13

Java 8 Lambda缩短了这种时间。

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

Answer 14

您可使用Bean Comparativeator,对您的习俗类别中的任何财产进行分类。

Answer 15

是的,可在以下网站查阅:。类型<代码>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),并直接通过该栏的<代码>sort。

你的目标还可以执行<条码>可比较的(在 Java的藏书和大多数核心图书馆都做了些什么),但这将界定其自有的类别中的“自然秩序”,并且不会让你pl起新的功能。

Answer 16

我发现,大多数甚至所有答复都依赖基本类别(目标)来实施可比或具有比较的接口。

不是我的解决办法。下面的法典允许你通过了解其拼写名称来比较物体。你可以轻松地修改姓名,但你需要暴露姓名,或制造你想要比较的物体之一。

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

Answer 17

http://docs.guava-libraries.googlecode.com/git/javadoc/com/google/common/view/Ordering.html”rel=“noreferer”>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);

Answer 18

如果你使用 Java8或旧版这是最佳解决办法。

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

在这种情况下,它首先与Cegpa有关,而另一方面,它会与获得F.姓名和获得F.。同上。哪些领域属于波乔类。

Answer 19

your customComparator class must implement java.util.Comparator in order to be used. it must also overide compare() AND equals()

相比之下,必须回答问题: 目标1是否小于或大于目标2?

页: 1

Answer 20

This code snippets might be useful. If you want to sort an Object in my case I want to sort by 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;
}

这一工作。我用这个词。

Answer 21

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

Answer 22

http://2016.java-forum-stuttgart.de/_data/D4_Wiedeking.pdf”rel=“nofollow noreferer”>presentation。于2016年在德国斯塔特举行的 Java论坛上举行。

只有少数幻灯片使用德语,99%的内容是“以英语为基础的”。 Java源代码;如

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

<代码>OurCustomComparator>正在使用缺省方法(和其他有趣的想法)。正如所显示的那样,导致制定非常简明的法典,以采用一些更便的方法进行分类;以及采用简单的链条(或扭转)类型标准。

如果你被 j为 j,你会在那里找到大量材料,以便你开始。

Answer 23

New since 1.8 is a List.sort() method instead of using the Collection.sort() so you directly call mylistcontainer.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);
    }
} // end of Fruit class

Answer 24

利用java-8 溪流,你可以打上。 ArrayList by:

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

Answer 25

我倾向于这一进程:

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<>/code>的财产,请您随便使用。您甚至可以链接到<代码>。

这就要求您的物体为<代码>。比较,系指需要compareTo/code>、 Equals和hashCode 执行。



是的,可以更快...... 但现在,你不必为每一种类型的比较作新的比较。 如果你能够节省时间,放弃时间,你可以接手。

Answer 26

利用 Java8的用途,可在以下一行中使用<代码>Comparator:

采用以下任何方式:

<><>>

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

<><><>>

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

Answer 27

你的习俗阶层可以实施“可比较”的接口,这要求采用比较方法。在比较方法中,你可以界定其意思是什么,即物体为小于或大于其他物体。因此,在您的榜样中,它可以探讨这样的问题:

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

否定号表示,这一>小于标的。积极的数字表明,这一>大于标的,零意味着物体是平等的。

然后,你可以使用收集器(毛主义)对你的名单进行分类,而不必在比较器内输入。如果你使用像树木或树苗这样的分类收集数据结构,这种方法也具有自动分类的优势。
You can check this article if you would like to read more about the Comparable interface (disclosure: I am the author ;) ) https://nullbeans.com/the-java-comparable-interface-automatic-sort-of-collections/

Answer 28

您也可使用PropertyComparator 。如果你只是想把财产带往(冻结的)财产:

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

缺点是,该比较机构 silent然忽视了不存在或无法获得的财产,并将其作为“数值”加以比较。这意味着,你应仔细测试这种参照点,或确认存在某种财产途径。

Answer 29

我在互联网上尝试了许多不同的解决办法,但为我工作的解决办法可在以下链接查阅。

Since java-8

JAVA 8 lambda expression

OR

Function & method reference

友情链接