Java List对对象字段的常量值进行排序

Question

I have a enum representing severity level

public enum Severity {
    HIGH("H"), MEDIUM("M"), LOW("L");
}

Person one = new Person();
one.setSeverity(Severity.HIGH);

other fields ...

Person two = new Person();
two.setSeverity(Severity.LOW);

.....

Person three = new Person();
three.setSeverity(Severity.HIGH);

List<Person> persons = Lists.newArrayList();
persons.add(one);
persons.add(two);
persons.add(three);

I would like to sort persons list to sort by severity field (ie HIGH,MEDIUM then LOW).

My expected results after sorting the persons list should be in the order of HIGH,HIGH,LOW ?

can i know how i can achieve this ?

note : I am making use of com.google.common.collect

Answer 1

Try below code

Create an ENUM

package com.rais;

public enum Severity {
    HIGH("H"), MEDIUM("M"), LOW("L");

    private final String  value;

    private Severity(String value) {
        this.value = value;
    }



}

Now Create Person class according to your requirement eg.

package com.rais;

public class Person {

    private Severity severity;
    private String name;


    public Person(Severity severity, String name) {
        super();
        this.severity = severity;
        this.name = name;
    }

    public Severity getSeverity() {
        return severity;
    }

    public void setSeverity(Severity severity) {
        this.severity = severity;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }   

}

Finally create a Test Client and apply below logic.

package com.rais;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class TestClient {

    public static void main(String[] args) {

        Person one = new Person(Severity.HIGH, "shayam");
        Person two = new Person(Severity.MEDIUM, "mohan");
        Person three = new Person(Severity.LOW, "radha");
        Person four = new Person(Severity.HIGH, "rakesh");
        Person five = new Person(Severity.MEDIUM, "kailash");
        Person six = new Person(Severity.LOW, "rais");
        Person seven = new Person(Severity.LOW, "abhishek");

        List<Person> persons = new ArrayList<Person>();
        persons.add(one);
        persons.add(two);
        persons.add(three);
        persons.add(four);
        persons.add(five);
        persons.add(six);
        persons.add(seven);

        Collections.sort(persons, new Comparator<Person>() {

            @Override
            public int compare(Person person1, Person person2) {

                if(person1.getSeverity()==person2.getSeverity())
                {
                    return person1.getName().compareTo(person2.getName());
                }
                else{
                    return person1.getSeverity().compareTo(person2.getSeverity());
                }

            }
        });

        for (Person person : persons) {
            System.out.println(person.getName()+" "+ person.getSeverity());

        }

    }

}

I am sure you will get below output.

rakesh HIGH
shayam HIGH
kailash MEDIUM
mohan MEDIUM
abhishek LOW
radha LOW
rais LOW

Answer 2

Use Comparable or comparator and then apply Collection.sort() .

if using comparable interface you have to implement compareTo method and

Collection.sort(<list>)

and if using comparator then you have to override compareTo method and

Collection.sort(<list>, <comparator>)

and when to use comparatot or comparable read link:

http://iandjava.blogspot.in/2012/10/comparable-and-comparator.html

Answer 3

If you are using Google Collections, upgrade to Google Guava. Use its ComparisonChain class. Are you sure you want HIGH , MEDIUM , LOW in that order? The reverse fits Java comparisons better.

How do Person s have a severity level? Perhaps your class deserves a better name.

Answer 4

I would make Person implement Comparable , which makes the sorting code very simple and brief.

Note that enums are implicitly Comparable:

public enum Severity {
    HIGH("H"), MEDIUM("M"), LOW("L");

    private final String code;

    private Severity(String code) {
        this.code = code;
    }

    public String getCode() {
        return code;
    }
}

public class Person implements Comparable<Person> {

    private Severity severity;
    private final String name;

    public Person(Severity severity, String name) {
        this.severity = severity;
        this.name = name;
    }

    public Severity getSeverity() {
        return severity;
    }

    public void setSeverity(Severity severity) {
        this.severity = severity;
    }

    public String getName() {
        return name;
    }

    @Override
    public int compareTo(Person person) {
        return severity == person.severity ? name.compareTo(person.name)
                : severity.compareTo(person.severity);
    }

    @Override
    public String toString() {
        return name + "(" + severity +")";
    }
}

Now some test code:

Person one = new Person(Severity.HIGH, "one");
Person two = new Person(Severity.LOW, "two");
Person three = new Person(Severity.HIGH, "three");

List<Person> persons = new ArrayList<Person>();
persons.add(one);
persons.add(two);
persons.add(three);

Collections.sort(persons);

System.out.println(persons);

Output:

[one(HIGH), three(HIGH), two(LOW)]