在java8之前的排序,Collections.sort()中的对象要实现Comparable接口,或者匿名内部类的方式,有些繁琐,如下
public class SortTest {
public static void main(String[] args) {
List<String> lists = new ArrayList<String>();
lists.add("5");
lists.add("2");
lists.add("9");
//lists中的对象String本身含有compareTo方法,所以可以直接调用sort方法,按自然顺序排序,即升 序排序
Collections.sort(lists);
}
当list中存放的是对象时,对象要实现Comparable接口或者匿名内部类的方式
定义A和B两个对象,其中A对象用实现接口方式,B对象匿名内部类方式
class A implements Comparable<A>{
private String name;
private Integer order;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getOrder() {
return order;
}
public void setOrder(Integer order) {
this.order = order;
}
@Override
public String toString() {
return "name is "+name+" order is "+order;
}
@Override
public int compareTo(A a) {
return this.order.compareTo(a.getOrder());
}
}
class B{
private String name;
private String order;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getOrder() {
return order;
}
public void setOrder(String order) {
this.order = order;
}
@Override
public String toString() {
return "name is "+name+" order is "+order;
}
}
对A对象的集合进行排序
A aa = new A();
aa.setName("aa");
aa.setOrder(1);
A bb = new A();
bb.setName("bb");
bb.setOrder(2);
list.add(bb);
list.add(aa);
//list中的对象A要实现Comparable接口
Collections.sort(list);
对B对象的集合排序
B ab = new B();
ab.setName("ab");
ab.setOrder("1");
B ba = new B();
ba.setName("ba");
ba.setOrder("2");
listB.add(ba);
listB.add(ab);
//listB中的对象如果没有实现Comparable接口,根据Collections.sort重载方法实现
Collections.sort(listB, new Comparable<B>()) {
@Override
public int compare(B b1, B b2) {
return b1.getOrder().compareTo(b2.getOrder);
}
};
System.out.println(lists);
System.out.println(list);
System.out.println(listB);
打印结果:
[2, 5, 9]
[name is aa order is 1, name is bb order is 2]
[name is ab order is 1, name is ba order is 2]
以上就是在java8之前的简单排序,是不是有些繁琐,后面来看下与之对应的排序在java8中如何实现,其实很简单只有几行代码
//在java8中可以使用Lanbda表达式
Collections.sort(lists, (String a, String b)->{
return b.compareTo(a);
})
//或者
Collections.sort(lists, (String a, String b) -> b.compareTo(b));
//或者
Collections.sort(names, (a, b) -> b.compareTo(a));
是不是简单了很多,java8最大的特点就是使用Lambda表达式,具体什么事Lambda这里就不在细说了,只是简单说下如何使用,() ->最简单的理解:()就是你方法中的(),比如setName() ,-> 就是你具体的方法, 如果方法有参数,就把参数加上即可(a, b) -> b.compareTo(a)
下面主要说下,在java8中排序
ok切入正题,重新写一个user对象:
public class User {
public User() {
}
public User(String name, int age) {
this.name = name;
this.age = age;
}
private String name;
private Integer age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
@Override
public String toString() {
return "name=" + this.name + " " + "age" + this.age;
}
}
下面直接上代码,下面的代码是我写的一些java8中集合的常用操作,基本可以满足日常的操作,其中可能涉及到lambda,如果没有接触过的话,建议先了解下。但是代码的意思很简单,都可以看的明白,只是涉及到一些用法,不懂的可能要先了解下了,好,上代码
package java8;
import java8.bean.User;
import org.junit.Test;
import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;
/**
* java8中集合操作
* @author wp
* @since 2018/12/28 11:25
*/
public class CollectionsTest {
@Test
public void testFilter() {
//获取年龄为30的集合
List<User> userList = Arrays.asList(new User("nihao", 20), new User("haoni", 30));
userList = userList.stream().filter(user -> user.getAge() == 30).collect(Collectors.toList());
System.out.println(userList.get(0).getAge());
}
@Test
public void testDistinctGroupBy() {
//对集合去重,分组操作
List<User> userList = Arrays.asList(new User("nihao", 20), new User("haoni", 30), new User("haobuhao", 30));
// List<Integer> integerList = userList.stream().map(User::getAge).distinct().sorted(Comparator.reverseOrder()).collect(Collectors.toList());//降序
// userList.forEach(user -> System.out.println(user.toString()));
// integerList.forEach(i -> System.out.println(i));
// 按年龄分组
Map<Integer, List<User>> userMap = userList.stream().collect(Collectors.groupingBy(User::getAge));
System.out.println(userMap.get(20).size());
System.out.println(userMap.get(30).size());
Map<String, User> userNameMap = userList.stream().collect(Collectors.toMap(User::getName, Function.identity()));
System.out.println(userNameMap.get("nihao").getName());
System.out.println(userNameMap.get("haoni").getName());
System.out.println(userNameMap.get("haobuhao").getName());
}
@Test
public void testMapForeach() {
//Map 循环
List<User> userList = Arrays.asList(new User("nihao", 20), new User("haoni", 30), new User("haobuhao", 30));
Map<String, User> userMap = userList.stream().collect(Collectors.toMap(User::getName, Function.identity()));
userMap.forEach((name, user) -> {
System.out.println(name + "===" + user.getAge());
});
}
@Test
public void testSorted() {
//排序
List<User> userList = Arrays.asList(new User("nihao", 20), new User("haoni", 30), new User("haobuhao", 30));
userList = userList.stream().sorted(Comparator.comparing(User::getAge)).collect(Collectors.toList());//按照年龄排序
userList.forEach(user -> {
System.out.println(user.getAge());
});
userList.sort((user1, user2) -> user2.getAge().compareTo(user1.getAge()));//按年龄倒叙排
userList.forEach(user -> {
System.out.println(user.getAge());
});
Collections.sort(userList, Comparator.comparing(User::getName));// 利用Collections工具来排序
userList.forEach(user -> {
System.out.println(user.getName());
});
//如果想要写一些复杂逻辑
Collections.sort(userList, (a, b) -> {
if (a.getAge() == b.getAge()) {
return a.getName().compareTo(b.getName());
} else {
return a.getAge() - b.getAge();
}
});
userList.forEach(user -> {
System.out.println(user.toString());
});
}
@Test
public void testSorted2() {
//多条件的排序两种写法 先根据年龄排序后姓名排序
//1 编写复杂的lambda表达式
List<User> userList = Arrays.asList(new User("nihao", 20), new User("haoni", 30), new User("haobuhao", 30));
userList.sort((user1, user2) -> {
if (user1.getAge() == user2.getAge()) {
return user1.getName().compareTo(user2.getName());
} else {
return user1.getAge() - user2.getAge();
}
});
System.out.println("list1 =======");
userList.forEach(user -> {
System.out.println(user.toString());
});
//2 通过Comparator新的组合支持来实现。把多个Comparator链在一起(chain together)去建造更复杂的比较逻辑:
List<User> user2List = Arrays.asList(new User("nihao", 20), new User("haoni", 30), new User("haobuhao", 30));
user2List.sort(Comparator.comparing(User::getAge).thenComparing(User::getName));
System.out.println("list2 =======");
userList.forEach(user -> {
System.out.println(user.toString());
});
}
}