版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/ymaini/article/details/81750633
摘要
本文主要介绍利用Collections.sort方法对list, map和自定义的class进行排序。
基本方法
方法1
利用
public static <T extends Comparable<? super T>> void sort(List<T> list)排序方法，则List中的元素对应的class需要implements Comparable接口，实现public int compareTo(T o)方法方法2
利用
public static <T> void sort(List<T> list, Comparator<? super T> c)排序方法，则需要新建一个Comparator类，重写compare方法。
具体操作
List排序
直接构造单测样例，List元素分别使用Integer和String为例进行验证，其中Integer和String均实现 Comparable接口的public int compareTo(T o)方法。样例通过新建Comparator类，实现了Integer正序和逆序排列，字符串根据长度排序。
package hello.core.sort;
import org.junit.Test;
import java.util.*;
/**
* 排序测试
*
* Created on 2018/8/16.
*
* @author [email protected]
*/
public class SortUtilsTest {
/**
* List元素类型为Integer测试
*
* @throws Exception 异常出现
*/
@Test
public void testIntegerListSort() throws Exception {
// number
Integer [] numbers = {1, 3, 5, 7, 11, 13, 14, 31};
List<Integer> list = Arrays.asList(numbers);
// 正序
Collections.sort(list);
System.out.println(list);
// 逆序
Collections.sort(list, new Comparator<Integer>() {
// 构造逆序的compare
@Override
public int compare(Integer o1, Integer o2) {
return o2.compareTo(o1);
}
});
System.out.println(list);
}
/**
* List元素类型为String测试
*
* @throws Exception 异常出现
*/
@Test
public void testStringListSort() throws Exception {
// number
String [] strings = {"Hello", "China", "HangZhou"};
List<String> list = Arrays.asList(strings);
// 正序
Collections.sort(list);
System.out.println(list);
// 根据字符串的长度正序
Collections.sort(list, new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
int l1 = o1 == null? 0: o1.length();
int l2 = o2 == null? 0: o2.length();
return (l1 < l2)? -1: ((l1 == l2)?0:1);
}
});
System.out.println(list);
}
}结果输出
// 正序
[1, 3, 5, 7, 11, 13, 14, 31]
// 逆序
[31, 14, 13, 11, 7, 5, 3, 1]
// 字符串正序，compareTo方法依次比较字符串中的每个字符
[China, HangZhou, Hello]
// 字符串长度正序
[China, Hello, HangZhou]Map排序
构造单测样例，其中Map的Key和Value均为Integer类型。样例通过新建Comparator类，实现了Map根据Key的正序和逆序，根据Value的正序和逆序排列。示例如下：
@Test
public void testIntegerMapSort() throws Exception {
// 构造HashMap
Map<Integer, Integer> map = new HashMap<Integer, Integer>() {{
put(1, 23);
put(2, 20);
put(3, 21);
}};
// 根据key正序
List<Map.Entry<Integer, Integer>> entries = new ArrayList<>(map.entrySet());
Collections.sort(entries, new Comparator<Map.Entry<Integer, Integer>>() {
@Override
public int compare(Map.Entry<Integer, Integer> o1, Map.Entry<Integer, Integer> o2) {
return o1.getKey().compareTo(o2.getKey());
}
});
System.out.println(entries);
// 根据key逆序
Collections.sort(entries, new Comparator<Map.Entry<Integer, Integer>>() {
@Override
public int compare(Map.Entry<Integer, Integer> o1, Map.Entry<Integer, Integer> o2) {
return o2.getKey().compareTo(o1.getKey());
}
});
System.out.println(entries);
// 根据value正序
Collections.sort(entries, new Comparator<Map.Entry<Integer, Integer>>() {
@Override
public int compare(Map.Entry<Integer, Integer> o1, Map.Entry<Integer, Integer> o2) {
return o1.getValue().compareTo(o2.getValue());
}
});
System.out.println(entries);
// 根据value逆序
Collections.sort(entries, new Comparator<Map.Entry<Integer, Integer>>() {
@Override
public int compare(Map.Entry<Integer, Integer> o1, Map.Entry<Integer, Integer> o2) {
return o2.getValue().compareTo(o1.getValue());
}
});
System.out.println(entries);
}结果输出
// key正序
[1=23, 2=20, 3=21]
// key逆序
[3=21, 2=20, 1=23]
// value正序
[2=20, 3=21, 1=23]
// value逆序
[1=23, 3=21, 2=20]自定义class排序
最后我们自定义class，implements Comparable接口，实现public int compareTo(T o)方法。自定义User如下：
package hello.core.sort;
/**
* Created on 2018/8/16.
*
* @author [email protected]
*/
public class User implements Comparable<User> {
public User(String name, int age) {
this.name = name;
this.age = age;
}
// User根据年龄大小排序
@Override
public int compareTo(User o) {
return (this.age < o.age) ? -1 : ((this.age == o.age) ? 0 : 1);
}
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
private String name;
private int age;
}
接下来我们构建单测样例实现自定义class的排序，实现了List和Map
@Test
public void testUserSort() throws Exception {
// list User
User marvin = new User("Marvin", 28);
User james = new User("James", 33);
User ai = new User("ai", 22);
List<User> users = new ArrayList<>();
users.add(marvin);
users.add(james);
users.add(ai);
// User根据年龄正序排列
Collections.sort(users);
System.out.println(users);
// map User: 依据value排序
Map<Integer, User> map = new HashMap<Integer, User>() {{
put(32, marvin);
put(23, james);
put(3, ai);
}};
List<Map.Entry<Integer, User>> entries = new ArrayList<>(map.entrySet());
Collections.sort(entries, new Comparator<Map.Entry<Integer, User>>() {
@Override
public int compare(Map.Entry<Integer, User> o1, Map.Entry<Integer, User> o2) {
return o1.getValue().compareTo(o2.getValue());
}
});
System.out.println(entries);
}输出结果：
# List User: 年龄正序
[User{name='ai', age=22}, User{name='Marvin', age=28}, User{name='James', age=33}]
# Map User: Value-年龄正序
[3=User{name='ai', age=22}, 32=User{name='Marvin', age=28}, 23=User{name='James', age=33}]参考文献
JDK
Comparable<T>,Collections,Comparator<T>