登录
当前位置： 首页 > 工具软件 > JAVE > 使用案例 >

Jave-Date(DateUtil)

陶超
2023-12-01

DateUtil

1.检查格式是否正确

校验传入的字符串日期格式是否正确

    public static final String FORMAT = "yyyy-MM-dd HH:mm:ss";

    /**
     * 格式化
     */
    private static final SimpleDateFormat format = new SimpleDateFormat(FORMAT);

    /**
     * 检查格式是否正确
     * @param dateStr
     * @return
     */
    public static boolean isRightDateString(String dateStr) {
        try {
            return format.parse(dateStr) != null;
        } catch (ParseException e) {
            return false;
        }
    }

2.字符串转日期

将字符串日期转换成Date日期

   /**
     * String转Date
     * @param dateStr
     * @return
     */
SimpleDateFormat(FORMAT);
    
    public static  Date toDate(String dateStr) {
        if(StringUtils.isBlank(dateStr)) {
            return null;
        }
        try {
            return format.parse(dateStr);
        } catch (ParseException e) {
            throw new IllegalArgumentException("日期字符串：" + dateStr + " 格式不正确，请使用如下日期格式："
                + FORMAT, e);
        }
    }

3.日期转字符串

将Date类型日期转换成字符串

    /**
     * 转换为日期字符串
     * @param date
     * @return
     */
    public static String toString(Date date) {
        if(null == date) {
            return null;
        }

        return format.format(date);
    }

4.获取固定日期后几天

获取固定日期的后几天

    /**
     * 获取指定日期的后几天
     * @param dateTime
     * @param days
     * @return
     */
    public static String getNextDay(String dateTime,int days){

        SimpleDateFormat simpleDateFormat=new SimpleDateFormat(FORMAT);
        Date date = null;
        try{
            date=simpleDateFormat.parse(dateTime);
        }catch (ParseException e){
            log.error("String转Date日期失败:",e);
        }
        Calendar calendar=Calendar.getInstance();
        calendar.setTime(date);
        //往后几天
        calendar.add(Calendar.DAY_OF_MONTH,days);
        return simpleDateFormat.format(calendar.getTime());
    }

5.日期比较大小

日期为String类型
值相等返回0，前者小于后者返回负数，前者大于后者返回正数。

public class DateDemo {
    public static void main(String[] args) {
        String start = new String("2022-09-19 14:23:20");
        String end=new String("2022-09-20 14:03:20");

        int i = start.compareTo(end);
        System.out.println(i);
    }
}

使用Date自带方法before()方法和after()方法。

public class DateDemo {
    public static void main(String[] args) {
        String start = new String("2022-09-19 14:23:20");
        String end=new String("2022-09-20 14:03:20");
        SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        try {
            Date startDate = sdf.parse(start);
            Date endDate = sdf.parse(end);
            boolean r1=startDate.before(endDate);
            boolean r2=startDate.after(endDate);
            System.out.println(r1);
            System.out.println(r2);
        } catch (ParseException e) {
            e.printStackTrace();
        }
    }
}

转换date格式换成秒数比较秒数大小，getTime()方法。

public class DateDemo {
    public static void main(String[] args) {
        String start = new String("2022-09-19 14:23:20");
        String end=new String("2022-09-20 14:03:20");
        SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        try {
            Date startDate = sdf.parse(start);
            Date endDate = sdf.parse(end);

            long t1 = startDate.getTime();
            System.out.println(t1);
            long t2 = endDate.getTime();
            System.out.println(t2);
        } catch (ParseException e) {
            e.printStackTrace();
        }
    }
}

6.Java8日期和时间

如今，一些应用程序仍在使用java.util.Date和java.util.Calendar API，包括使我们的生活更轻松地使用这些类型的库，例如JodaTime。 但是，Java 8引入了新的API来处理日期和时间，这使我们可以对日期和时间表示进行更精细的控制，为我们提供不可变的datetime对象，更流畅的API以及在大多数情况下提高性能，而无需使用其他库。 让我们看一下基础知识。

1.Clock

抽象类，使用时区提供对当前即时，日期和时间的访问的时钟。

该类的实例用于查找当前时刻，可以使用存储的时区来解释当前时刻（当前时间戳转成时区时间的表示）。

Clock有四个内部子类，这些子类只有包内可见。

  1. FixedClock: 始终返回同一时刻，常用于测试。
  2. OffsetClock: 为基础时钟添加偏移量，构造方法第一个参数为基础时钟，第二个参数为Duration的偏移量。
  3. TickClock: 为基础时钟添加偏移量，构造方法第一个参数为基础时钟，第二个参数为long型的纳秒偏移量。
  4. SystemClock:调用System.currentTimeMillis()返回最新时间。
public class DateDemo {
    public static void main(String[] args) {

        //UTC时间戳
        System.out.println(Clock.systemUTC().millis());
        //当前时区时间戳
        System.out.println(Clock.systemDefaultZone().millis());
        //当前时间戳+1小时
        System.out.println(Clock.offset(Clock.systemDefaultZone(), Duration.of(1, ChronoUnit.HOURS)).millis());

    }
}
2.Duration

代表一段时间。
该类以秒和纳秒为单位建立数量或时间量。 它可以使用其他基于持续时间的单位进行访问，例如毫秒、秒、分钟、小时和天。天被视为完全等于24小时。 一般用于小时间单位的一段时间，Period常用于大时间单位。

public class DateDemo {
    public static void main(String[] args) {

        //获取秒数
        System.out.println(Duration.ofDays(1).getSeconds());
        System.out.println(Duration.ofHours(1).getSeconds());
        System.out.println(Duration.ofMinutes(1).getSeconds());
        //获取纳秒数
        System.out.println(Duration.ofMillis(1).getNano());
        System.out.println(Duration.ofNanos(1).getNano());
        //两个时间的差值
        System.out.println(Duration.between(LocalDateTime.now(),
                LocalDateTime.parse("2022-12-12 12:12:12",
                        DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")))
                .getSeconds());
        //1天+1小时
        System.out.println(Duration.ofDays(1).plus(Duration.ofHours(1)).getSeconds());
        //1天-1小时
        System.out.println(Duration.ofDays(1).minus(Duration.ofHours(1)).getSeconds());
    }
}
3.Instant

时刻，是时间线上的瞬间点。

该类在时间线上建立单个瞬时点。 这可能用于在程序中记录事件时间戳。
实际上，这一瞬间存在一些限制。 可测量的时间线受限于long的大小，这大于当前估计的宇宙年龄， 该瞬间单位为纳秒。
瞬间的范围需要存储大于long 。为了实现这一点，类存储一个long表示纪元秒和一个int表示纳秒，这将始终为0和999,999,999之间。纪元秒数是从标准的Java纪元1970-01-01T00:00:00Z开始测量，其中纪元之后的时刻具有正值，较早的时刻具有负值

public class DateDemo {
    public static void main(String[] args) {

        //纪元开始的时刻
        System.out.println(Instant.EPOCH);
        //获取UTC时间的纪元秒数
        System.out.println(Instant.now().getEpochSecond());
        //是否支持给定的时间单位
        System.out.println(Instant.now().isSupported(ChronoUnit.HOURS));
        //UTC+8，东八区的当前时刻
        System.out.println(Instant.now().atOffset(ZoneOffset.of("+8")));
        //+12小时的时刻
        System.out.println(Instant.now().plus(12,ChronoUnit.HOURS));
        //-12小时的时刻
        System.out.println(Instant.now().minus(12,ChronoUnit.HOURS));
        //比较两个时刻的先后
        System.out.println(Instant.now().isAfter(LocalDateTime.now().toInstant(ZoneOffset.of("+8"))));

    }
}
4.LocalDate

LocalDate是一个不可变的日期时间对象，表示日期，通常被视为年月日，也可以获取其他信息，例如日期，星期几和星期。
该类不存储或表示时间或时区，它是日期的描述，它不能代表时间线上的即时信息，没有偏移或时区

public class DateDemo {
    public static void main(String[] args) {
        
        // 2022-10-12是星期几
        System.out.println(LocalDate.of(2022, 10, 12).getDayOfWeek());
        //当前日期
        System.out.println(LocalDate.now());
        //获取纪元，CE是公元 BCE是公元前
        System.out.println(LocalDate.now().getEra());
        //是否闰年
        System.out.println(LocalDate.now().isLeapYear());
        //+3周
        System.out.println(LocalDate.now().plus(3,ChronoUnit.WEEKS));
        //-3个月
        System.out.println(LocalDate.now().minus(3,ChronoUnit.MONTHS));

    }
}
5.LocalDateTime

LocalDateTime是一个不可变的日期时间对象，代表日期时间，通常被视为年 - 月 - 日 - 时 - 分 - 秒。 也可以获取日期，星期几和星期。 时间表示为纳秒精度。
该类不存储或表示时区。 相反，它是对日期的描述。它不能代表时间线上的即时信息，没有偏移或时区。

public class DateDemo {
    public static void main(String[] args) {
       //当前日期时间
        System.out.println(LocalDateTime.now());
        //用给定的日期时间格式化器 格式化 当前日期时间
        System.out.println(LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy/MM/dd HH:mm:ss")));
        //获取日期
        System.out.println(LocalDateTime.now().toLocalDate());
        //获取时间
        System.out.println(LocalDateTime.now().toLocalTime());
        //当前日期时间是否在给定日期时间之后
        System.out.println(LocalDateTime.now()
                .isAfter(LocalDateTime
                        .of(2022, 10, 12,16,20,55)));
        //当前日期时间是否在给定日期时间之前
        System.out.println(LocalDateTime.now()
                .isBefore(LocalDateTime
                        .of(2022, 10, 12,16,20,55)));
        //+3小时
        System.out.println(LocalDateTime.now().plus(3,ChronoUnit.HOURS));
        //-3秒
        System.out.println(LocalDateTime.now().minus(3,ChronoUnit.SECONDS));
        
    }
}
6.LocalTime

LocalTime是一个不可变的日期时间对象，代表一个时间，通常表示小时 - 分钟 - 秒。 时间表示为纳秒精度。

该类不存储或表示时区。它是对日期的描述。它不能代表时间线上的即时信息，没有偏移或时区。

public class DateDemo {
    public static void main(String[] args) {
        //当前时间
        System.out.println(LocalTime.now());
        //获取当前时间的 小时
        System.out.println(LocalTime.now().getHour());
        //当前时间到17:00:00还有多少分钟
        System.out.println(LocalTime.now()
                .until(LocalTime.of(17,0,0),ChronoUnit.MINUTES));
        //当前时间的分钟部分替换成10
        System.out.println(LocalTime.now().withMinute(10));

    }
}
7.LocalDate/LocalDateTime/LocalTime互转
public class DateDemo {
    public static void main(String[] args) {
        // LocalDate to LocalDateTime
        LocalDateTime dateTime = LocalDate.parse("2022-09-11").atTime(LocalTime.parse("06:30"));
        System.out.println(dateTime);

        // LocalTime to LocalDateTime
        LocalDateTime dateTime2 = LocalTime.parse("06:30").atDate(LocalDate.parse("2022-09-11"));
        System.out.println(dateTime2);

        // LocalDateTime to LocalDate
        LocalDate date = LocalDateTime.parse("2022-09-11T06:30").toLocalDate();
        System.out.println(date);

        // LocalDateTime to LocalTime
        LocalTime time = LocalDateTime.parse("2022-09-11T06:30").toLocalTime();
        System.out.println(time);

    }
}
 类似资料：

相关阅读

Oracle在DATE使用LIKE'％'SQL MAX（DATE）订单号date（）返回1970-01-01new Date（new Date（）。getTime（）-25 * 24 * 60 * 60 * 1000）获得了意外日期从DATE和TIME创建DATETIME

相关文章

2.4.2 Date & Time组件(上)JavaScript之Date类型（引用类型）

相关问答

仅在groovy中以date数据类型传递date输入type=“date”thymeleaf带时区的PostgreSQL date（）基于max Date的Spark java DataFrame Date过滤器另一个DataFrame共享/类和war文件下的Jave类-在tomcat中加载的优先级
快捷导航： 新手教程 算法原理 架构设计 Java进阶 数据库进阶 大厂专栏 面试经验 编程笔记 编程问答 所有专题 文档资料 工具软件 电子书籍 小牛导航
在线工具： 房贷计算器 个税计算器 Linux命令查询 Json格式化 正则表达式 颜色转换 AES加解密 SHA1加密 MD5加密 毒鸡汤 字数统计 随机密码生成 进制转换 Base64编解码 励志句子
Copyright © 2019-2024 小牛知识库@xnip.cn. All Rights Reserved.