这是一个简短的教程，介绍在java中对对象数组进行排序的多种方法。
让我们来定义一个Employee.java 类。
public class Employee {
private Integer id;
private String name;
private Integer salary;
public Employee(Integer id, String name,Integer salary) {
this.id = id;
this.name = name;
this.salary=salary;
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getSalary() {
return salary;
}
public void setSalary(Integer salary) {
this.salary = salary;
}
@Override
public String toString() {
return "{" +
"id=" + id +
", name='" + name + '\'' +
", salary=" + salary +
'}';
}
}
Employee 类的字段 - , 和id name salary
让我们添加一些数据并显示ArrayList
import java.util.*;
public class Main {
public static void main(String[] args) {
ArrayList<Employee> list=new ArrayList<>();
Employee e1=new Employee(1,"Franc",5000);
Employee e2=new Employee(11,"John",8000);
Employee e3=new Employee(12,"Eric",4000);
Employee e4=new Employee(14,"Andrew",7000);
list.add(e1);
list.add(e2);
list.add(e3);
list.add(e4);
System.out.println(list);
}
}
输出:
[{id=1, name='Franc', salary=5000},
{id=11, name='John', salary=8000},
{id=12, name='Eric', salary=4000},
{id=14, name='Andrew', salary=7000}]
在上面的例子中:
- 创建了
List的Employee对象 - 用
employee的数据填充ArrayList - 最后，打印一个雇员对象的列表
- 列表对象默认以
insert顺序显示。
通过属性对对象的ArrayList进行排序 java
我们有多种方法可以按属性对对象进行排序 我们将看到多种方法对employee 对象的工资按ascending 或descending 顺序进行排序。
使用java.util.comparator
集合类提供了一个接受两个参数的排序方法。
- list参数是要排序的源数组列表
- 比较器对象，它有比较方法
Collections.sort(list, new Comparator<Employee>(){
public int compare(Employee e1, Employee e2){
return e1.getSalary().compareTo(e2.getSalary());
}
});
System.out.println(list);
输出:
[{id=12, name='Eric', salary=4000},
{id=1, name='Franc', salary=5000},
{id=14, name='Andrew', salary=7000},
{id=11, name='John', salary=8000}]
将列表中的Employee 对象按照工资字段descending 的顺序进行排序
Collections.sort(list, new Comparator<Employee>(){
public int compare(Employee e1, Employee e2){
return e2.getSalary().compareTo(e1.getSalary());
}
});
System.out.println(list);
输出
[{id=11, name='John', salary=8000},
{id=14, name='Andrew', salary=7000},
{id=1, name='Franc', salary=5000},
{id=12, name='Eric', salary=4000}]
下面的逻辑返回列表中的descending order
return e1.getSalary().compareTo(e2.getSalary());
为ascending order
return e2.getSalary().compareTo(e1.getSalary());
Java 8按字段排序对象列表
java 8 扩展了comparator 行为并添加了 comparing 静态方法。
Comparting的语法:
static <T,U extends Comparable<? super U>> Comparator<T> comparing(
Function<? super T,? extends U> keyExtractor)
static <T,U> Comparator<T> comparing(
Function<? super T,? extends U> keyExtractor,
Comparator<? super U> keyComparator)
比较方法有以下参数:
keyExtractor ：键函数来排序 。可选择添加自定义逻辑比较。keyComparator
这个comparator 可以应用于List 以及Collections 类。 下面是一个用List和Collections按字段升序排序的例子。
list.sort(Comparator.comparing(Employee::getSalary)); (or)
Collections.sort(list,Comparator.comparing(Employee::getSalary));
要进行降序排序
list.sort(Comparator.comparing(Employee::getSalary,(emp1, emp2) -> {
return emp2.compareTo(emp1);
}));
Collections.sort(list,Comparator.comparing(Employee::getSalary,(emp1, emp2) -> {
return emp2.compareTo(emp1);
}));
自定义对象与可比较类
这是一个用属性按字母顺序对对象列表进行排序的例子。
让我们在Employee对象中实现Comparable，用自定义逻辑覆盖compareTo ，这里需要根据雇员的名字进行排序，所以getName字段逻辑被添加到这个方法中。
public class Employee implements Comparable<Employee>{
private Integer id;
private String name;
private Integer salary;
public Employee(Integer id, String name,Integer salary) {
this.id = id;
this.name = name;
this.salary=salary;
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getSalary() {
return salary;
}
public void setSalary(Integer salary) {
this.salary = salary;
}
@Override
public String toString() {
return "{" +
"id=" + id +
", name='" + name + '\'' +
", salary=" + salary +
'}';
}
@Override
public int compareTo(Employee u) {
if (getName() == null || u.getName() == null) {
return 0;
}
return getName().compareTo(u.getName());
}
}
有名字的对象被排序为alphabetically ，即ascending 顺序
降序排列
Collections.sort(list);
Collections.reverse(list);
使用Java8 stream sorted进行排序
这种方法返回一个新的数组列表。
- 使用 stream() 迭代 ArrayList
- 使用sorted方法返回排序后的元素。
- 最后将集合返回到列表中
-
List<Employee> result = (ArrayList<Employee>) list .stream().sorted(Comparator.comparing(Employee::getName)) .collect(Collectors.toList());
### Sort ArrayList of Objects by multiple properties
Here is a sequence of steps
- First, create a `Comparator` using the `Comparator. comparing` method
- In this comparator, Sorting first `id`, next `name` and `salary`.
- Pass this `comparator` to `List` for soring using `List`.
- pass this `comparator` to `List` for sorting using `Collections`.
- Comparator returns a list in `ascending` order
- Comparator.` reverse` returns list in `descending` order
```java
Comparator<Employee> employeeComparator = Comparator.comparing(Employee::getId)
.thenComparing(Employee::getName)
.thenComparing(Employee::getSalary);
Collections.sort(list, employeeComparator);
用list 和collections 对多个字段进行排序的例子，顺序为ascending
Collections.sort(list, employeeComparator); // ascending
list.sort(employeeComparator);
使用list 和collections 对多个字段进行排序的例子，顺序为descending 。
Collections.sort(list, employeeComparator.reversed());
list.sort(employeeComparator.reversed());
