java8前后对Collections集合排序操作对比，以及java8版本后的使用lambda对集合Collections操作

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