@Data
public class Ticket {
    private String groupId;
    private String mallid;
    private String ticketId;
    private String ticketName;
    private String batchId;
    private String convertible;
    private String gradeLimit;
    private String batchAvailableNum;
    private String saleNum;
    private String exIntegral;
    private String exMoney;
    private String isSoldOut;
    private String isSpike;
    private Date exEndTime;
    private Date createDate;
     * 输出打印信息
     * @param list
    public static void printTickets(List<Ticket> list){
        System.out.println("[电子券名称]\t\t[isSoldOut]\t\t[convertible]\t\t[isSpike]\t\t[saleNum]\t\t[exIntegral]\t\t[exMoney]\t\t[exEndTime]\t\t[createDate]");
        System.out.println("-----------------------------------------------------------------------");
        list.forEach(u-> System.out.println(printValue(u)));
        System.out.println(" ");
     * 输出list结果集
     * @param ticket
     * @return
    public static String printValue(Ticket ticket){
        String str=String.format("%s\t\t\t\t%s\t\t\t\t%s\t\t\t\t\t%s\t\t\t\t%s\t\t\t%s\t\t\t%s\t\t\t%s\t\t\t%s",
                ticket.ticketName,ticket.isSoldOut,ticket.convertible.toString(),ticket.isSpike.toString(),ticket.saleNum.toString(),
                ticket.exIntegral.toString(),ticket.exMoney.toString(),ticket.exEndTime.toString(),ticket.createDate.toString());
        return str;
@Data
public class Student {
    private String id;
    private int nums;
    private int sums;
<!--Json工具类-->
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <optional>true</optional>
</dependency>
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.68</version>
</dependency>
1. List集合去重：使用distinct()函数
使用stream().map()提取List对象的某一列值及去重




    

public class ListDistinct {
    public static void main(String[] args) {
        //构建测试数据
        List<User> list = new ArrayList<User>();
        list.add(new User("张三","000001",26,true,1.76, LocalDate.of(1996,1,18)));
        list.add(new User("小莉","000002",21,false,1.61, LocalDate.of(2001,1,18)));
        list.add(new User("李四","000003",22,true,1.83, LocalDate.of(2000,1,18)));
        list.add(new User("程曦","000004",20,false,1.64, LocalDate.of(2002,1,18)));
        list.add(new User("喜喜","000005",20,false,1.67, LocalDate.of(2002,1,18)));
        //输出list列表
        User.printUsers(list);
        //1.提取某一列
        List<String> nameList = list.stream().map(User::getName).collect(Collectors.toList());
        System.out.println(JSON.toJSONString(nameList));
        System.out.println("#############################################################");
        //2.从列表中提取age并去重
        List<Integer>  ageList = list.stream().map(User::getAge).distinct().collect(Collectors.toList());
        System.out.println(JSON.toJSONString(ageList));
        System.out.println();
2.List集合过滤：使用filter方法可以过滤某些条件
public class ListFilter {
    public static void main(String[] args) {
        //构建测试数据
        List<User> list = new ArrayList<>();
        list.add(new User("张三","000001",26,true,1.76, LocalDate.of(1996,1,18)));
        list.add(new User("小莉","000002",21,false,1.61, LocalDate.of(2001,1,18)));
        list.add(new User("李四","000003",22,true,1.83, LocalDate.of(2000,1,18)));
        list.add(new User("程曦","000004",20,false,1.64, LocalDate.of(2002,1,18)));
        list.add(new User("喜喜","000005",20,false,1.67, LocalDate.of(2002,1,18)));
        //输出list列表
        User.printUsers(list);
        //示例3：使用filter()过滤list
        //查找身高在1.8米及以上的男生
        List<User> teacherList = list.stream().filter(user -> user.getGender()
                && user.getHeight() >= 1.8).collect(Collectors.toList());
        //输出查找结果
        User.printUsers(teacherList);
        //查找年龄在20以上的女生
        List<User> tList = list.stream().filter(user -> !user.getGender()
                && user.getAge() >= 20).collect(Collectors.toList());
        //输出查找结果
        User.printUsers(tList);
3.List集合获取第一条数据
使用 findAny() 和 findFirst() 获取第一条数据
public class ListFindAnyFindFirst {
    public static void main(String[] args) {
        //构建测试数据
        List<User> list = new ArrayList<User>();
        list.add(new User("张丹",11,new BigDecimal(11)));
        list.add(new User("刘大",13,new BigDecimal(13)));
        list.add(new User("飒飒",16,new BigDecimal(16)));
        list.add(new User("斯蒂芬",11,new BigDecimal(11)));
        //1. findAny():将返回集合中符合条件的任意一个元素。
        //findAny()Java Stream的方法为该流的某些元素返回一个Optional，如果该流为空，则返回一个空的Optional。在这里，Optional是一个容器对象，可以包含也可以不包含非null值
        Optional<User> userOptional = list.stream().findAny();
        System.out.println(userOptional.get());
        //1. findFirst():获取第一条数据
        //如果一个集合数据是有序的，而且你要查找符合条件的第一条数据。这时用findFirst是比较合适的
        Optional<User> userOptional1 = list.stream().findFirst();
        System.out.println(userOptional1.get());
         * 问题解答：findFirst和findAny如何选择？
         * （1）如果你不关心返回的是哪一个数据，只要符合条件的就行，那就用findAny。
         * 而且在并行流上，findAny限制更少。
         * （2）如果你关心集合的顺序，要返回符合条件的第一个元素，那就用findFirst。
4.List集合分组:通过Collectors.groupingBy可以分组指定字段
public class ListGrouping {
    public static void main(String[] args) {
        //构建测试数据
        List<User> list = new ArrayList<>();
        list.add(new User("张三","000001",26,true,1.76, LocalDate.of(1996,1,18)));
        list.add(new User("小莉","000002",21,false,1.61, LocalDate.of(2001,1,18)));
        list.add(new User("李四","000003",22,true,1.83, LocalDate.of(2000,1,18)));
        list.add(new User("程曦","000004",20,false,1.64, LocalDate.of(2002,1,18)));
        list.add(new User("喜喜","000005",20,false,1.67, LocalDate.of(2002,1,18)));
        //输出list列表
        User.printUsers(list);
        //示例2：list分组（通过groupingBy可以分组指定字段）
        System.out.println("###############################单字段分组##############################");
        //2.1单字段分组：按照gender分组
        Map<Boolean,List<User>> groupList = list.stream().collect(Collectors.groupingBy(User::getGender));
        //遍历结果集
        for(Map.Entry<Boolean,List<User>> entryUser :groupList.entrySet()){
            Boolean key = entryUser.getKey();
            List<User> entryUserList = entryUser.getValue();
            System.out.println("key："+key +",value:"+entryUserList.toString());
        System.out.println("#############################################################");
        //知道key值，可如下输出分组的结果
        groupList.get(true).forEach(e->{
            System.out.println("男："+e.toString());
        System.out.println("#############################################################");
        groupList.get(false).forEach(e->{
            System.out.println("女："+e.toString());
        System.out.println("#############################################################");
        //2.2多字段分组(多个字段，用下划线拼接)：按照年龄、gender分组
        Map<Object,List<User>> groupList2 = list.stream().collect(Collectors.groupingBy(o ->{
            StringBuffer bf = new StringBuffer();
            bf.append(o.getAge()).append("_");
            bf.append(o.getGender());
            return bf.toString();
        System.out.println(JSON.toJSONString(groupList2, SerializerFeature.PrettyFormat));
5.List集合最值：使用jdk8的Stream来获取list集合的最小值、最大值、总和、平均数
public class ListMaxMin {
    public static void main(String[] args) {
        //构建测试数据
        List<User> list = new ArrayList<User>();
        list.add(new User("张丹",11,new BigDecimal(11)));
        list.add(new User("刘大",13,new BigDecimal(13)));
        list.add(new User("飒飒",16,new BigDecimal(16)));
        list.add(new User("斯蒂芬",11,new BigDecimal(11)));
        //获取用户年龄的最大、最小、总和、平均值
        int max = list.stream().mapToInt(u->u.getAge()).max().getAsInt();
        int min = list.stream().mapToInt(u->u.getAge()).min().getAsInt();
        //求和：分基本类型和大数据类型，基本类型先mapToInt方法,然后调用sun方法；大数类型使用reduce调用BigDecimal::add方法
        //基本类型求和
        int sum = list.stream().mapToInt(u->u.getAge()).sum();
        //BigDecimal求和
        BigDecimal totalQuantity = list.stream().map(u->u.getFamilyMemberQuantity()).reduce(BigDecimal.ZERO,BigDecimal::add);
        double avg = list.stream().mapToInt(u->u.getAge()).average().getAsDouble();
        System.out.println("年龄最大值："+max+"\n年龄最小值："+min);
        System.out.println("年龄总和："+sum+"\n年龄平均值："+avg);
        System.out.println("成员数量总和："+totalQuantity);
6.List集合合并：合并两个list,并将userId相同的其它属性合并
public class ListMerge {
    public static void main(String[] args) {
        mergeList();
     * @Description: 合并两个list<map>,并将userId相同的其它属性合并
     * @Title: mergeList
     * @param: @return
     * @return: List<Map<String,Object>>
     * @throws
    public static List<Map<String,Object>> mergeList(){
        //构建list1集合数据
        List<Map<String,Object>> list1 = new ArrayList<>();
        Map<String,Object> data=new HashMap<>();
        data.put("userId","100001");
        data.put("userName","唐僧");
        list1.add(data);
        data=new HashMap<>();
        data.put("userId","100002");
        data.put("userName","八戒");
        list1.add(data);
        data=new HashMap<>();
        data.put("userId","100003");
        data.put("userName","悟空");
        list1.add(data);
        data=new HashMap<>();
        data.put("userId","100004");
        data.put("userName","沙僧");
        list1.add(data);
        //构建list2集合数据
        List<Map<String,Object>> list2 = new ArrayList<>();
        data=new HashMap<>();
        data.put("userId","100001");
        data.put("gender","男");
        data.put("age",20);
        list2.add(data);
        data=new HashMap<>();
        data.put("userId","100002");
        data.put("gender","雄");
        data.put("age",1000);
        list2.add(data);
        data=new HashMap<>();
        data.put("userId","100003");
        data.put("gender","雄");
        data.put("age",600);
        list2.add(data);
        data=new HashMap<>();
        data.put("userId","100004");
        data.put("gender","男");
        data.put("age",800);
        list2.add(data);
        //steam():把一个源数据，可以是集合，数组，I/O channel， 产生器generator 等，转化成流。
        //forEach():迭代流中的每个数据
        //map():用于映射每个元素到对应的结果
        //filter():用于通过设置的条件过滤出元素
        //Collectors(): 类实现了很多归约操作，例如将流转换成集合和聚合元素。Collectors 可用于返回列表或字符串：
        //属性合并：根据userId把list2合并到list1的结果集中
        List<Map<String, Object>> list = list1.stream().map(m -> {
            list2.stream().filter(m2-> Objects.equals(m.get("userId"),m2.get("userId"))).forEach(m2-> {
                m.put("gender",m2.get("gender"));
                m.put("age",m2.get("age"));
            return m;
        }).collect(Collectors.toList());
        //遍历输出合并后的结果集
        for(Map<String, Object> map:list){
            System.out.println(map.toString());
        return list;
7.List集合合并：合并两个list,并将ticketId相同的其它属性合并
public class ListMerge1 {
    public static void main(String[] args) {
        mergeList();
     * @Description: 合并两个list<Ticket>,并将ticketId相同的其它属性合并
     * @Title: mergeList
     * @param: @return
     * @return: List<Ticket>
     * @throws
    public static List<Ticket> mergeList(){
        List<Ticket> list1 = new ArrayList<>();
        Ticket data=new Ticket();
        data.setTicketId("100001");
        data.setTicketName("唐僧");
        list1.add(data);
        data=new Ticket();
        data.setTicketId("100002");
        data.setTicketName("八戒");
        list1.add(data);
        data=new Ticket();
        data.setTicketId("100003");
        data.setTicketName("悟空");
        list1.add(data);
        data=new Ticket();
        data.setTicketId("100004");
        data.setTicketName("沙僧");
        list1.add(data);
        List<Ticket> list2 = new ArrayList<>();
        data=new Ticket();
        data.setTicketId("100001");
        data.setSaleNum("20");
        data.setBatchAvailableNum("10");
        list2.add(data);
        data=new Ticket();
        data.setTicketId("100001");
        data.setSaleNum("20");
        data.setBatchAvailableNum("10");
        list2.add(data);
        data=new Ticket();
        data.setTicketId("100002");
        data.setSaleNum("1000");
        data.setBatchAvailableNum("600");
        list2.add(data);
        data=new Ticket();
        data.setTicketId("100003");
        data.setSaleNum("600");
        data.setBatchAvailableNum("100");
        list2.add(data);
        data=new Ticket();
        data.setTicketId("100004");
        data.setSaleNum("800");
        data.setBatchAvailableNum("300");
        list2.add(data);
        //使用stream流把list1和list2根据属性ticketId合并一个list集合
        List<Ticket> list = list1.stream().map(m -> {
            list2.stream().filter(m2-> Objects.equals(m.getTicketId(),m2.getTicketId())).forEach(m2-> {
                m.setSaleNum(m2.getSaleNum());
                m.setBatchAvailableNum(m2.getBatchAvailableNum());
            return m;
        }).collect(Collectors.toList());
        for(Ticket ticket:list){
            System.out.println(ticket.getTicketId()+","+ticket.getTicketName()+","+ticket.getSaleNum()+","+ticket.getBatchAvailableNum());
        return list;
8.List集合合并：合并两个list.list1合并到list2(list1的个数 < list2的个数)
public class ListMerge2 {
    public static void main(String[] args) {
        mergeList();
     * @Description: 合并两个list<map>,并将userId相同的其它属性合并
     * @Title: mergeList
     * @param: @return
     * @return: List<Map<String,Object>>
     * @throws
    public static List<Ticket> mergeList(){
        List<Ticket> list1 = new ArrayList<>();
        Ticket data=new Ticket();
        data.setTicketId("100001");
        data.setTicketName("唐僧");
        list1.add(data);
        data=new Ticket();
        data.setTicketId("100002");
        data.setTicketName("八戒");
        list1.add(data);
        List<Ticket> list2 = new ArrayList<>();
        data=new Ticket();
        data.setTicketId("100001");
        data.setBatchId("1");
        list2.add(data);
        data=new Ticket();
        data.setTicketId("100001");
        data.setBatchId("2");
        list2.add(data);
        data=new Ticket();
        data.setTicketId("100002");
        data.setBatchId("1");
        list2.add(data);
        data=new Ticket();
        data.setTicketId("100002");
        data.setBatchId("2");
        list2.add(data);
        data=new Ticket();
        data.setTicketId("100002");
        data.setBatchId("3");
        list2.add(data);
        //使用stream流把list1合并到list2集合中，根据ticketId属性
        List<Ticket> list = list2.stream().map(m -> {
            list1.stream().filter(m2-> Objects.equals(m.getTicketId(),m2.getTicketId())).forEach(m2-> {
                m.setTicketId(m2.getTicketId());
                m.setTicketName(m2.getTicketName());
            return m;
        }).collect(Collectors.toList());
        for(Ticket ticket:list){
            System.out.println(ticket.getTicketId()+","+ticket.getTicketName()+","+ticket.getBatchId());
        return list;
9.List集合合并：合并两个list.list1合并到list2(list1的个数 > list2的个数)
public class ListMerge3 {
    public static void main(String[] args) {
        mergeList();
     * @Description: 合并两个list<map>,并将userId相同的其它属性合并
     * @Title: mergeList
     * @param: @return
     * @return: List<Map<String,Object>>
     * @throws
    public static List<Ticket> mergeList(){
        List<Ticket> list1 = new ArrayList<>();
        Ticket data=new Ticket();
        data.setTicketId("100001");
        data.setTicketName("唐僧");
        list1.add(data);
        data=new Ticket();
        data.setTicketId("100002");
        data.setTicketName("八戒");
        list1.add(data);
        List<Ticket> list2 = new ArrayList<>();
        data=new Ticket();
        data.setTicketId("100001");
        data.setBatchId("1");
        list2.add(data);
        data=new Ticket();
        data.setTicketId("100001");
        data.setBatchId("2");
        list2.add(data);
//        data=new Ticket();
//        data.setTicketId("100002");
//        data.setBatchId("1");
//        list2.add(data);
//        data=new Ticket();
//        data.setTicketId("100002");
//        data.setBatchId("2");
//        list2.add(data);
//        data=new Ticket();
//        data.setTicketId("100002");
//        data.setBatchId("3");
//        list2.add(data);
        //使用stream流把list1合并到list2集合中，根据ticketId属性
        List<Ticket> list = list2.stream().map(m -> {
            list1.stream().filter(m2-> Objects.equals(m.getTicketId(),m2.getTicketId())).forEach(m2-> {
                m.setTicketId(m2.getTicketId());
                m.setTicketName(m2.getTicketName());
            return m;
        }).collect(Collectors.toList());
        for(Ticket ticket:list){
            System.out.println(ticket.getTicketId()+","+ticket.getTicketName()+","+ticket.getBatchId());
        return list;
10.一个list 集合合并去重求和
public class ListMerge4 {
    public static void main(String[] args) {
        List<Student> list = new ArrayList<>();
        Student s1 = new Student();
        s1.setId("s1");
        s1.setNums(1);
        s1.setSums(1);
        list.add(s1);
        s1 = new Student();
        s1.setId("s1");
        s1.setNums(2);
        s1.setSums(3);
        list.add(s1);
        s1 = new Student();
        s1.setId("s2");
        s1.setNums(3);
        s1.setSums(5);
        list.add(s1);
        //合并去重求和
        List<Student> result = merge(list);
        result.stream().forEach(e->{
            System.out.println("id:"+e.getId()+",nums:"+e.getNums()+",sums:"+e.getSums());
     * 将id进行合并nums, sums 相加道回合并后的集合使用Java8的流进行处理
     * @return
    public static List<Student> merge(List<Student> list){
        List<Student> result = list.stream()
                .collect(Collectors.toMap(Student::getId, a->a,(o1,o2)->{
                    o1.setNums(o1.getNums()+o2.getNums());
                    o1.setSums(o1.getSums()+o2.getSums());
                    return o1;
                })).values().stream().collect(Collectors.toList());
        return result;
11.List集合排序：单字段排序1
public class ListSort {
    public static void main(String[] args) {
        List<Ticket> list = new ArrayList<Ticket>();
        Ticket data = new Ticket();
        data.setGroupId("8a8480487c96d58f017c9b7bab7d0020");
        data.setMallid("8a8481f57cca9442017ce026ddd40049");
        data.setTicketId("1b82899c065d4474b85cfb809a99396a");
        data.setTicketName("金卡");
        data.setBatchId("7ed298bd08104cfe9ece16621c5e51ce");
        data.setConvertible("0");
        data.setGradeLimit("金卡");
        data.setBatchAvailableNum("100");
        data.setSaleNum("10");
        list.add(data);
        data = new Ticket();
        data.setGroupId("8a8480487c96d58f017c9b7bab7d0020");
        data.setMallid("8a8481f57cca9442017ce026ddd40049");
        data.setTicketId("5ecd6634026c45edaca8b4ebfdf3964c");
        data.setTicketName("电子券001");
        data.setBatchId("2d29984f938b446b9174a24233b64b39");
        data.setConvertible("1");
        data.setGradeLimit("都可");
        data.setBatchAvailableNum("100");
        data.setSaleNum("30");
        list.add(data);
        data = new Ticket();
        data.setGroupId("8a8480487c96d58f017c9b7bab7d0020");
        data.setMallid("8a8481f57cca9442017ce026ddd40049");
        data.setTicketId("5ecd6634026c45edaca8b4ebfdf3964c");
        data.setTicketName("电子券001");
        data.setBatchId("2d29984f938b446b9174a24233b64b39");
        data.setConvertible("0");
        data.setGradeLimit("都可");
        data.setBatchAvailableNum("100");
        data.setSaleNum("3");
        list.add(data);
        data = new Ticket();
        data.setGroupId("8a8480487c96d58f017c9b7bab7d0020");
        data.setMallid("8a8481f57cca9442017ce026ddd40049");
        data.setTicketId("5ecd6634026c45edaca8b4ebfdf3964c");
        data.setTicketName("电子券001");
        data.setBatchId("2d29984f938b446b9174a24233b64b39");
        data.setConvertible("0");
        data.setGradeLimit("都可");
        data.setBatchAvailableNum("100");
        data.setSaleNum("6");
        list.add(data);
        data = new Ticket();
        data.setGroupId("8a8480487c96d58f017c9b7bab7d0020");
        data.setMallid("8a8481f57cca9442017ce026ddd40049");
        data.setTicketId("5ecd6634026c45edaca8b4ebfdf3964c");
        data.setTicketName("电子券001");
        data.setBatchId("2d29984f938b446b9174a24233b64b39");
        data.setConvertible("0");
        data.setGradeLimit("都可");
        data.setBatchAvailableNum("100");
        data.setSaleNum("11");
        list.add(data);
        data = new Ticket();
        data.setGroupId("8a8480487c96d58f017c9b7bab7d0020");
        data.setMallid("8a8481f57cca9442017ce026ddd40049");
        data.setTicketId("96c166ce59894cf0a4f8fc14a5c94fb2");
        data.setTicketName("普卡");
        data.setBatchId("1c332332b0d64d729a3521ea253fe621");
        data.setConvertible("1");
        data.setGradeLimit("普卡");
        data.setBatchAvailableNum("90");
        data.setSaleNum("33");
        list.add(data);
        data = new Ticket();
        data.setGroupId("8a8480487c96d58f017c9b7bab7d0020");
        data.setMallid("8a8481f57cca9442017ce026ddd40049");
        data.setTicketId("b3826676e6e14168b58a1342b049723c");
        data.setTicketName("银卡");
        data.setBatchId("6d32889f9ab7450fb48fedad5efcaf85");
        data.setConvertible("0");
        data.setGradeLimit("银卡");
        data.setBatchAvailableNum("30");
        data.setSaleNum("33");
        list.add(data);
        //根据ticketId字段进行分组
        Map<String, List<Ticket>> map = list.stream().collect(Collectors.groupingBy(Ticket::getTicketId));
        List<Ticket> newList = new ArrayList<Ticket>();
        //取每组的第一条数据
        map.forEach((s, tickets) -> {
            newList.add(tickets.get(0));
        for(Ticket ticket:newList){
            System.out.println(ticket.getTicketName()+","+ticket.getConvertible()+","+ticket.getSaleNum()+","+ticket.getBatchAvailableNum());
        System.out.println("--------------------------------------list------------------------------------");
        // 根据SaleNum降序
        newList.sort(Comparator.comparing(Ticket::getSaleNum).reversed());
       //BatchAvailableNum降序
        newList.sort(Comparator.comparing(Ticket::getBatchAvailableNum).reversed());
        for(Ticket ticket:newList){
            System.out.println("ticketName："+ticket.getTicketName()+",convertible："+ticket.getConvertible()+",saleNum："+ticket.getSaleNum()+",batchAvailableNum："+ticket.getBatchAvailableNum());
12.List集合排序：单字段排序2
public class ListSortMultiple {
    public static void main(String[] args) throws ParseException {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        List<Ticket> list = new ArrayList<Ticket>();
        Ticket data = new Ticket();
        data.setTicketName("测试券1");
        data.setConvertible("0");
        data.setCreateDate(sdf.parse("2022-01-05 22:56:03"));
        data.setExEndTime(sdf.parse("2022-01-31 23:59:59"));
        data.setExIntegral("1");
        data.setExMoney("0");
        data.setIsSoldOut("1");
        data.setIsSpike("0");
        data.setSaleNum("11");
        list.add(data);
        data = new Ticket();
        data.setTicketName("测试券2");
        data.setConvertible("1");
        data.setCreateDate(sdf.parse("2022-01-05 22:54:11"));
        data.setExEndTime(sdf.parse("2022-01-31 23:59:59"));
        data.setExIntegral("1");
        data.setExMoney("0");
        data.setIsSoldOut("1");
        data.setIsSpike("0");
        data.setSaleNum("31");
        list.add(data);
        data = new Ticket();
        data.setTicketName("测试券3");
        data.setConvertible("1");
        data.setCreateDate(sdf.parse("2022-01-05 22:52:06"));
        data.setExEndTime(sdf.parse("2022-01-31 23:59:59"));
        data.setExIntegral("1");
        data.setExMoney("0");
        data.setIsSoldOut("1");
        data.setIsSpike("0");
        data.setSaleNum("41");
        list.add(data);
        data = new Ticket();
        data.setTicketName("测试券4");
        data.setConvertible("1");
        data.setCreateDate(sdf.parse("2022-01-07 17:03:42"));
        data.setExEndTime(sdf.parse("2022-01-31 23:59:59"));
        data.setExIntegral("10");
        data.setExMoney("0");
        data.setIsSoldOut("1");
        data.setIsSpike("0");
        data.setSaleNum("12");
        list.add(data);
        data = new Ticket();
        data.setTicketName("测试券5");
        data.setConvertible("1");
        data.setCreateDate(sdf.parse("2022-01-05 14:10:09"));
        data.setExEndTime(sdf.parse("2022-01-15 23:59:59"));
        data.setExIntegral("0");
        data.setExMoney("0");
        data.setIsSoldOut("1");
        data.setIsSpike("0");
        data.setSaleNum("11");
        list.add(data);
        data = new Ticket();
        data.setTicketName("测试券6");
        data.setConvertible("1");
        data.setCreateDate(sdf.parse("2022-01-05 09:48:43"));
        data.setExEndTime(sdf.parse("2022-01-12 23:59:59"));
        data.setExIntegral("0");
        data.setExMoney("0");
        data.setIsSoldOut("1");
        data.setIsSpike("0");
        data.setSaleNum("8");
        list.add(data);
        data = new Ticket();
        data.setTicketName("测试券7");
        data.setConvertible("1");
        data.setCreateDate(sdf.parse("2022-01-05 22:58:27"));
        data.setExEndTime(sdf.parse("2022-01-31 23:59:59"));
        data.setExIntegral("1200");
        data.setExMoney("0");
        data.setIsSoldOut("1");
        data.setIsSpike("0");
        data.setSaleNum("16");
        list.add(data);
        data = new Ticket();
        data.setTicketName("测试券8");
        data.setConvertible("1");
        data.setCreateDate(sdf.parse("2022-01-10 17:56:44"));
        data.setExEndTime(sdf.parse("2022-01-31 23:59:59"));
        data.setExIntegral("1000");
        data.setExMoney("0");
        data.setIsSoldOut("1");
        data.setIsSpike("0");
        data.setSaleNum("21");
        list.add(data);
        data = new Ticket();
        data.setTicketName("测试券9");
        data.setConvertible("1");
        data.setCreateDate(sdf.parse("2022-01-05 21:54:37"));
        data.setExEndTime(sdf.parse("2022-01-12 23:59:59"));
        data.setExIntegral("9");
        data.setExMoney("0");
        data.setIsSoldOut("1");
        data.setIsSpike("0");
        data.setSaleNum("2");
        list.add(data);
        data = new Ticket();
        data.setTicketName("测试1券");
        data.setConvertible("1");
        data.setCreateDate(sdf.parse("2022-01-11 11:27:11"));
        data.setExEndTime(sdf.parse("2022-01-12 23:59:59"));
        data.setExIntegral("1000");
        data.setExMoney("0.01");
        data.setIsSoldOut("1");
        data.setIsSpike("0");
        data.setSaleNum("1");
        list.add(data);
        data = new Ticket();
        data.setTicketName("测试2券");
        data.setConvertible("1");
        data.setCreateDate(sdf.parse("2021-12-23 14:35:57"));
        data.setExEndTime(sdf.parse("2022-01-13 23:59:59"));
        data.setExIntegral("50");
        data.setExMoney("0");
        data.setIsSoldOut("1");
        data.setIsSpike("0");
        data.setSaleNum("2");
        list.add(data);
        for(Ticket ticket:list){
            System.out.println(ticket.getTicketName()+","+ticket.getConvertible()+","+ticket.getSaleNum()+","+ticket.getBatchAvailableNum());
        System.out.println("--------------------------------------list------------------------------------");
        //jdk8 组合降序排序
        //isSoldOut desc,convertible desc,isSpike desc,saleNum desc,exIntegral desc,exMoney desc,exEndTime asc,createDate desc
        //Comparator.reverseOrder():降序 Comparator.naturalOrder()：升序
        //方式一：多个字段排序（多余两个）
        //先以属性SaleNum降序,再进行属性BatchAvailableNum升序 多个字段 后面追加即可
//        List<Ticket> sortList =  list.stream()
//                .sorted(Comparator.comparing(Ticket::getSaleNum,Comparator.reverseOrder())
//                        .thenComparing(e->{
//                            return Integer.valueOf(e.getBatchAvailableNum());
//                        },Comparator.naturalOrder())
//                        .thenComparing(e->{
//                            return Integer.valueOf(e.getConvertible());
//                        },Comparator.reverseOrder())
//                )
//                .collect(Collectors.toList());
        //方式二：多个字段排序（多余两个）
        Collections.sort(list, Comparator.comparing(Ticket::getIsSoldOut,Comparator.reverseOrder())
                .thenComparing(Ticket::getConvertible,Comparator.reverseOrder())
                .thenComparing(Ticket::getIsSpike,Comparator.reverseOrder())
                .thenComparing(t->Integer.parseInt(t.getSaleNum()),Comparator.reverseOrder())
                .thenComparing(t->Double.valueOf(t.getExIntegral()),Comparator.reverseOrder())
                .thenComparing(t->Double.valueOf(t.getExMoney()),Comparator.reverseOrder())
                .thenComparing(Ticket::getExEndTime,Comparator.naturalOrder())
                .thenComparing(Ticket::getCreateDate,Comparator.reverseOrder())
        Ticket.printTickets(list);
13.List集合：skip(long n) 方法用于跳过前n条数据
public class ListSpike {
    public static void main(String[] args) {
        skip(7);
    public static void skip(long n){
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
        list.add(6);
        list.stream().skip(n).forEach(integer -> System.out.println("integer = " + integer));
14.List集合遍历
public class ListTraverse {
    public static void main(String[] args) {
        //构建测试数据
        List<User> list = new ArrayList<>();
        list.add(new User("张三","000001",26,true,1.76, LocalDate.of(1996,1,18)));
        list.add(new User("小莉","000002",21,false,1.61, LocalDate.of(2001,1,18)));
        list.add(new User("李四","000003",22,true,1.83, LocalDate.of(2000,1,18)));
        list.add(new User("程曦","000004",20,false,1.64, LocalDate.of(2002,1,18)));
        //输出list列表
        User.printUsers(list);
        //示例1：list遍历
        System.out.println("###############################方式一##############################");
        // 方式一：for循环遍历
        for(int i=0;i<list.size();i++){
            User user = list.get(i);
            System.out.println("姓名："+list.get(i).getName());
        System.out.println("###############################方式二##############################");
        // 方式二：for
        for(User user:list){
            System.out.println("姓名："+user.getName());
        System.out.println("###############################方式三#############################");
        // 方式三：iterator
        Iterator<User> it = list.iterator();
        while(it.hasNext()){
            System.out.println("姓名："+it.next().getName());
        System.out.println("###############################方式四##############################");
        // 方式四：foreach（jdk1.8之后）
        list.forEach(u->{
            System.out.println("姓名："+u.getName());
我是南国以南i记录点滴每天成长一点点，学习是永无止境的！转载请附原文链接！！！
参考链接、参考链接