根据日期排序 List＜Date＞、List＜Map＜String,Object＞＞、List＜Object＞排序之选择排序

已于 2022-05-23 18:22:31 修改
阅读量2.8k 收藏 8
点赞数 1
分类专栏： java 文章标签： list java 排序算法
于 2022-03-03 01:14:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dj1955/article/details/123244329
版权 
package com.jt.dto;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

/**
 * User: ldj
 * Date: 2022/3/2
 * Time: 22:48
 * Description: No Description
 */
public class DateListSort {

    public static void main(String[] args) {
        ArrayList<Date> dates = new ArrayList<>();
        dates.add(stringToDate("20230215"));
        dates.add(stringToDate("20220302"));
        dates.add(stringToDate("19951109"));
        dates.add(stringToDate("20501123"));

        ArrayList<String> beforeDateStrList = new ArrayList<>();
        dates.forEach(date -> beforeDateStrList.add(dateToString(date)));
        System.out.println("排序前：" + beforeDateStrList);

        ArrayList<String> afterDateStrList = new ArrayList<>();
        testSort(dates);//倒序
        dates.forEach(date -> afterDateStrList.add(dateToString(date)));
        System.out.println("排序后：" + afterDateStrList);
    }


    //String -> Date
    public static Date stringToDate(String dateStr) {
        Date date = null;
        try {
            SimpleDateFormat ft = new SimpleDateFormat("yyyyMMdd");
            date = ft.parse(dateStr);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return date;
    }

    //Date -> String
    public static String dateToString(Date date) {
        SimpleDateFormat ft = new SimpleDateFormat("yyyyMMdd");
        return ft.format(date);
    }

  
    public static void testSort(List<Date> list) {
        for (int i = 0; i < list.size() - 1; i++) {
            for (int j = 1; j < list.size() - i; j++) {
                if (list.get(i).before(list.get(i + j))) {
                    Date empty;
                    empty = list.get(i);
                    list.set(i, list.get(i + j));
                    list.set(i + j, empty);
                }
            }
        }
    }
}

续更。。 

package com.jt.dto;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;

/**
 * User: ldj
 * Date: 2022/3/5
 * Time: 18:36
 * Description: 根据日期对对象进行倒序
 */
public class ObjectSort {

    private static final String NAME = "name";
    private static final String AGE = "age";
    private static final String BIRTHDAY = "birthday";

    public static void main(String[] args) throws JsonProcessingException {

        Map<String, Object> linkedHashMap1 = new LinkedHashMap<>();
        Map<String, Object> linkedHashMap2 = new LinkedHashMap<>();
        Map<String, Object> linkedHashMap3 = new LinkedHashMap<>();

        linkedHashMap1.put(NAME, "lili");
        linkedHashMap1.put(AGE, 18);
        linkedHashMap1.put(BIRTHDAY, "20220329");

        linkedHashMap2.put(NAME, "liLei");
        linkedHashMap2.put(AGE, 17);
        linkedHashMap2.put(BIRTHDAY, "20210329");

        linkedHashMap3.put(NAME, "ldj");
        linkedHashMap3.put(AGE, 19);
        linkedHashMap3.put(BIRTHDAY, "19951109");

        //模拟返回数据list
        List<Map<String, Object>> objectList = new ArrayList<>();
        objectList.add(linkedHashMap3);
        objectList.add(linkedHashMap2);
        objectList.add(linkedHashMap1);

        System.out.println("倒序前：" + new ObjectMapper().writeValueAsString(objectList));

        //方法1 ==> 倒序
        desSort(objectList);
        System.out.println("倒序后：" + new ObjectMapper().writeValueAsString(objectList));

        //方法2 ==> 升序
        Collections.sort(objectList, new Comparator<Map<String, Object>>() {
            @Override
            public int compare(Map<String, Object> o1, Map<String, Object> o2) {
                Date date1 = stringToDate((String) o1.get(BIRTHDAY));
                Date date2 = stringToDate((String) o2.get(BIRTHDAY));
                return date1.compareTo(date2);   //升序
                //return date2.compareTo(date1); //降序
            }
        });
        System.out.println("升序后：" + new ObjectMapper().writeValueAsString(objectList));

        //函数式接口 lomda表达式写法 ==> 降序
        Collections.sort(objectList, (map1, map2) -> {
            Date date1 = stringToDate((String) map1.get(BIRTHDAY));
            Date date2 = stringToDate((String) map2.get(BIRTHDAY));
            return date2.compareTo(date1);
        });
        System.out.println("降序后：" + new ObjectMapper().writeValueAsString(objectList));
    }

    //String -> Date
    public static Date stringToDate(String dateStr) {
        Date date = null;
        try {
            SimpleDateFormat ft = new SimpleDateFormat("yyyyMMdd");
            date = ft.parse(dateStr);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return date;
    }

    //选择排序算法 <before倒序 after升序>
    public static void desSort(List<Map<String, Object>> list) {
        for (int i = 0; i < list.size() - 1; i++) {
            for (int j = 1; j < list.size() - i; j++) {
                if (stringToDate((String) list.get(i).get(BIRTHDAY)).before(stringToDate((String) list.get(i + j).get(BIRTHDAY)))) {
                    Map<String, Object> empty;
                    empty = list.get(i);
                    list.set(i, list.get(i + j));
                    list.set(i + j, empty);
                }
            }
        }
    }
}

参数换成实体类List＜Object＞同理  

package com.jt.dto;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

/**
 * User: ldj
 * Date: 2022/3/6
 * Time: 17:42
 * Description: No Description
 */
public class ObjectSortByField {

    public static void main(String[] args) throws JsonProcessingException {

        Users ldj = new Users("ldj", 15, "20220523");

        Users zhangHao = Users.builder()
                .name("ZhangHao")
                .age(18)
                .birthday("20220315")
                .build();

        List<Users> objectList = new ArrayList<>();
        objectList.add(ldj);
        objectList.add(zhangHao);

        System.out.println("排序前："+new ObjectMapper().writeValueAsString(objectList));
        desSort(objectList);
        System.out.println("排序后："+new ObjectMapper().writeValueAsString(objectList));
    }

    //选择排序算法 <before倒序 after升序>
    public static void desSort(List<Users> list) {
        for (int i = 0; i < list.size() - 1; i++) {
            for (int j = 1; j < list.size() - i; j++) {
                if (list.get(i).getAge() < list.get(i + j).getAge()) {
                    Object empty = list.get(i);
                    list.set(i, list.get(i + j));
                    list.set(i + j, (Users) empty);
                }
            }
        }
    }

    //String -> Date
    public static Date stringToDate(String dateStr) {
        Date date = null;
        try {
            SimpleDateFormat ft = new SimpleDateFormat("yyyyMMdd");
            date = ft.parse(dateStr);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return date;
    }
}

@Data
@Builder
@AllArgsConstructor
class Users {
    private String name;
    private Integer age;
    private String birthday;
}

续更。。。

package com.jt.test;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.stream.Collectors;

/**
 * @Author: ldj
 * @Date: 2022/03/02/20:18
 * @Description:
 */
public class SortDate {
    private static final String NAME = "name";
    private static final String AGE = "age";
    private static final String BIRTHDAY = "birthday";

    public static void main(String[] args) {
        Map<String, Object> linkedHashMap1 = new LinkedHashMap<>();
        Map<String, Object> linkedHashMap2 = new LinkedHashMap<>();
        Map<String, Object> linkedHashMap3 = new LinkedHashMap<>();

        linkedHashMap1.put(NAME, "lili");
        linkedHashMap1.put(AGE, 18);
        linkedHashMap1.put(BIRTHDAY, "20220329");

        linkedHashMap2.put(NAME, "liLei");
        linkedHashMap2.put(AGE, 17);
        linkedHashMap2.put(BIRTHDAY, "20210329");

        linkedHashMap3.put(NAME, "ldj");
        linkedHashMap3.put(AGE, 19);
        linkedHashMap3.put(BIRTHDAY, "19951109");

        //模拟返回数据list
        List<Map<String, Object>> objectList = new ArrayList<>();
        objectList.add(linkedHashMap3);
        objectList.add(linkedHashMap2);
        objectList.add(linkedHashMap1);

        System.out.println("排序前：" + objectList);

        List<Map<String, Object>> newList = sortBySteam(objectList);
        System.out.print("排序后：" +newList);
    }

    //流方式排序
    public static List<Map<String, Object>> sortBySteam(List<Map<String, Object>> objectList) {
        List<Map<String, Object>> newList = objectList.stream().sorted((e1, e2) -> {
            Date date1 = stringToDate((String) e1.get(BIRTHDAY));
            Date date2 = stringToDate((String) e2.get(BIRTHDAY));
            //return date1.compareTo(date2); //升序
            return date2.compareTo(date1);   //降序
        }).collect(Collectors.toList());
        return newList;
    }

    //String -> Date
    public static Date stringToDate(String dateStr) {
        Date date = null;
        try {
            SimpleDateFormat ft = new SimpleDateFormat("yyyyMMdd");
            date = ft.parse(dateStr);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return date;
    }
}
续更。。。。

package com.jt.test;

import lombok.AllArgsConstructor;
import lombok.Data;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.Date;
import java.util.List;
import java.util.stream.Collectors;

/**
 * @Author: ldj
 * @Date: 2022/05/23/17:32
 * @Description:
 */
public class ObjectSort {
    public static void main(String[] args) {
        User lina = new User("lina", 18, new Date());//小
        for (int i = 0; i < 100000000; i++) {
            i++;
        }
        User lili = new User("ldj", 17, new Date()); //中

        for (int i = 0; i < 100000000; i++) {
            i++;
        }
        User ldj = new User("lili", 15, new Date()); //大

        List<User> userList = new ArrayList<>();
        userList.add(lina);
        userList.add(ldj);
        userList.add(lili);

        List<User> userList1 = sortBySteam2(userList);
        System.out.println(userList1.toString());
    }

    //流方排序式
    public static List<User> sortBySteam1(List<User> objectList) {
        List<User> newList = objectList.stream().sorted(((o1, o2) -> {
            Date birthday1 = o1.getBirthday();
            Date birthday2 = o2.getBirthday();
            return birthday2.compareTo(birthday1);
        })).collect(Collectors.toList());
        return newList;
    }

    //流方排序式
    public static List<User> sortBySteam2(List<User> objectList) {
        List<User> newList = objectList.stream().sorted(Comparator.comparing(User::getBirthday).reversed()).collect(Collectors.toList());
        return newList;
    }
}

@Data
@AllArgsConstructor
class User {
    private String name;
    private Integer age;
    private Date birthday;
}

ldj2020
关注
专栏目录
java 中List按照date排序的实现
08-30
主要介绍了java 中List按照date排序的实现的相关资料,需要的朋友可以参考下
Java集合List按日期升序或降序四种方法
s_156的博客
07-03 8154
总结Java集合List按日期升序或降序常见的四种方法如下
java中list集合筛选出本月数据
最新发布
边走、边悟、迟早变好
07-28 694
在Java中筛选出本月的数据，你可以使用java.time包中的类来处理日期和时间。假设你有一个包含日期字段的List对象集合，你可以利用StreamAPI来筛选出本月的数据。
List按照date排序
热门推荐
一个普本码农奋斗史
06-01 1万+
今天开发需要对一个list进行排序，要求对里面的date类型的属性进行排序，不多说，直接上代码。 Leavecalendar这个bean类里面有属性date； private Date Date;有get/set方法； public Date getDate() { return Date; } public void setDate(Date lc
根据List中元素的Date属性或多元素对List进行排序
a_2436的博客
08-09 452
private void doSort(List<LoanOrderDTO> list) { if (list == null || list.size() == 0) { return; } Collections.sort(list, new Comparator<LoanOrderDTO>() { @Override ...
List 存取date排序
java
12-10 452
主要利用 Comparator这个接口来实现，我这里是排序list里面的时间 分别取到最大的时间和最小的时间。 要实现里面的函数 int compare(Object o1, Object o2) 返回一个基本类型的整型，返回负数表示o1 小于o2，返回0 表示o1和o2相等，返回正数表示o1大于o2。 [code="java"] public class ComparatorDateT...
List＜Map＜String,Object＞＞ 转 List＜T＞
12程序猿的博客
09-06 1997
java实现List<Map<String,Object>> 到 List的数据转换 一、java代码实现 1.Product实体类： package com.example.easypoiexceldemo.entity; import com.baomidou.mybatisplus.annotation.*; import com.fasterxml.jackson.annotation.JsonFormat; import io.swagger.annotations.Ap
List＜Map＜String, Object＞＞排序 根据Map的某个value排序
Pace_mondiale的博客
08-24 666
List< Map< String,Object > >根据Map的某个value排序 不废话 上代码 上一个测试类，可直接运行试试 package com.mybatisPlus; import org.junit.Test; import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.*; public class ListMapSort { /**
List＜Map＜String, Object＞＞排序
weixin_47140716的博客
03-29 4651
List<Map<String, Object>>获取到该字段后进行排序 //正序 1.使用自己的集合.sort进行排序里面定义参数后，get后去到自己的字段进行排序 listByCondition.sort(Comparator.comparing(o -> String.valueOf(o.get("retire_date")))); //倒序 2.使用自己的集合.sort后把自己的集合放进去后使用比较器进行排序,如果值有null的话使用下面的判断，如果没有的话.
利用java反射机制实现List<Map<String, Object>>转化为List<JavaBean>
weixin_30443731的博客
02-11 1519
最近在用mybatis做项目，遇到将date格式化显示到easyui的问题，需要将List<Map<String, Object>>转化为List<JavaBean>，研究好久，终于在网上找到了一个方法： 核心方法如下： [java]view plaincopy /** *根据List<Map<St...
Java小技能：字符串【List＜T＞ 转 String】
iOS逆向与安全
02-17 1357
sun建议：重写equals方法时，保证两个相同内容的对象作比较的结果为true,来达到equals方法比较对象的内容，都是动态字符序列(采用动态数组的算法，来实现动态存储数据方式，完成字符串的动态存储，采用变长数组存储。1））ss和ss1作比较时，是把数组中的对象作比较，在对象作比较时需要调用equals方法，注：如果equals方法的值为TRUE，那么对象的hashCode必须一致。（因为hashCode方法返回的值是唯一标识当前对象的内容，而非它的地址）
对List中的日期进行排序
wsfengye的博客
09-16 1246
[code="java"]import java.text.SimpleDateFormat; import java.util.ArrayList; import java.util.Collections; import java.util.Comparator; import java.util.Date; import java.util.List; /** * @au...
根据list对象集合中的Date时间属性进行排序
qq_43163943的博客
06-08 3477
1）HourAirQualityRankVo2这个类里的时间字段为Date 2）方法 /** * 根据list集合对象中的时间进行排序 * * @param list */ private static void ListSort(List<HourAirQualityRankVo2> list) { Iterator<HourAirQualityRankVo2> iterator = list.iterator
日期集合排序，List＜Date＞，Set＜Date＞
weixin_46053707的博客
09-10 2699
如何对日期类型的集合排序？ List 根据sonarLint提示点点点可以发现新大陆！其实java8已经内置了许多比较器，可以点进去看看 List<Date> list = new ArrayList<>(); list.sort(new Comparator<Date>() { @Override public int compare(Date o1, Date o2) { return o1.compareTo
List＜Map＜String, Object＞＞根据时间排序
weixin_43096562的博客
02-06 564
List根据时间排序
List中对象根据日期排序
hsc从容的博客
12-08 1596
List中对象根据日期排序
list集合中 按照日期排序
maxiaole_z的博客
06-03 6872
private void ListSort(List<FitnessProCourse> list) { { //排序方法 Collections.sort(list, new Comparator<FitnessProCourse>() { @Override ...
stream流 对List<Map<String, Object>>对象 日期排序
07-15
List<Map<String, Object>> sortedList = list.stream() .sorted(Comparator.comparing(m -> (Date) m.get("date"))) .collect(Collectors.toList()); ``` 在这个例子中，我们使用 `Comparator.comparing` 方法来...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值