Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
com.github.dennisit.vplus.data.utils.DateTimeUtils Maven / Gradle / Ivy
/*--------------------------------------------------------------------------
* Copyright (c) 2010-2020, Elon.su All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* Neither the name of the elon developer nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
* Author: Elon.su, you can also mail [email protected]
*--------------------------------------------------------------------------
*/
package com.github.dennisit.vplus.data.utils;
import org.joda.time.DateTime;
import java.text.SimpleDateFormat;
import java.time.Instant;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.time.format.DateTimeFormatter;
import java.time.temporal.ChronoUnit;
import java.util.Calendar;
import java.util.Date;
import java.util.List;
import java.util.Locale;
import java.util.stream.Collectors;
import java.util.stream.Stream;
/**
* Created by Elon.su on 17/9/16.
*/
public class DateTimeUtils {
public static final String[] ASTROLOGY_NAMES = {
"白羊座", "金牛座", "双子座", "巨蟹座", "狮子座", "处女座", "天秤座", "天蝎座", "射手座", "摩羯座", "水瓶座", "双鱼座"
};
private static String[] ZODIAC_NAMES = {
"鼠", "猪", "狗", "鸡", "猴", "羊", "马", "蛇", "龙", "兔", "虎", "牛"
};
public static Date now(){
return new Date();
}
/**
* 获取星座信息
* @param date 日期
* @return 星座描述
*/
public static String getAstrologyName(Date date) {
int index = getAstrologyByDate(date);
if (index < 0 || index > 11) {
return "未知";
} else {
return ASTROLOGY_NAMES[index];
}
}
/**
* 根据日期返回所属星座的 index
* 0 - 白羊座
* 1 - 金牛座
* 2 - 双子座
* 3 - 巨蟹座
* 4 - 狮子座
* 5 - 处女座
* 6 - 天秤座
* 7 - 天蝎座
* 8 - 射手座
* 9 - 摩羯座
* 10 - 水瓶座
* 11 - 双鱼座
* -1 - 不知道啥星座（不应当发生）
*
* @param date 日期
* @return 星座描述
*/
private static int getAstrologyByDate(Date date) {
DateTime dateTime = new DateTime(date);
int month = dateTime.getMonthOfYear();
int day = dateTime.getDayOfMonth();
if (month == 3 && day >= 21 || month == 4 && day <= 20) {
return 0;
} else if (month == 4 && day >= 21 || month == 5 && day <= 21) {
return 1;
} else if (month == 5 && day >= 22 || month == 6 && day <= 21) {
return 2;
} else if (month == 6 && day >= 22 || month == 7 && day <= 22) {
return 3;
} else if (month == 7 && day >= 23 || month == 8 && day <= 23) {
return 4;
} else if (month == 8 && day >= 24 || month == 9 && day <= 23) {
return 5;
} else if (month == 9 && day >= 24 || month == 10 && day <= 23) {
return 6;
} else if (month == 10 && day >= 24 || month == 11 && day <= 22) {
return 7;
} else if (month == 11 && day >= 23 || month == 12 && day <= 21) {
return 8;
} else if (month == 12 && day >= 22 || month == 1 && day <= 20) {
return 9;
} else if (month == 1 && day >= 21 || month == 2 && day <= 19) {
return 10;
} else if (month == 2 && day >= 20 || month == 3 && day <= 20) {
return 11;
} else {
return -1;
}
}
/**
* 获取生肖
* @param year 年份
* @return 生效描述
*/
public static String getChineseZodiac(int year) {
Calendar ca = Calendar.getInstance();
int now = ca.get(Calendar.YEAR);
int index = (now - year - 1) % 12 - 1;
if (index > 0) {
return ZODIAC_NAMES[index];
} else if (index == 0) {
return ZODIAC_NAMES[11];
} else {
return ZODIAC_NAMES[12 - (-index)];
}
}
/**
* 将 {@link LocalDateTime} 转换成 {@link Date}
* @param localDateTime {@link LocalDateTime} 待转换的日期
* @return 转换成Date结果
*/
public static Date from(LocalDateTime localDateTime){
Instant instant = localDateTime.atZone(ZoneId.systemDefault()).toInstant();
return Date.from(instant);
}
/**
* 将 {@link Date} 转换成 {@link LocalDateTime}
* @param date {@link Date} 待转换的日期
* @return 转换成 {@link LocalDateTime} 结果
*/
public static LocalDateTime from(Date date){
return LocalDateTime.ofInstant(date.toInstant(), ZoneId.systemDefault());
}
/**
* 获取{@link Date}在开始时间和结束时间内的日期时间段{@link Date}集合
* @param start 开始时间
* @param end 结束时间
* @return 时间天数集合
*/
public static List dateZones(Date start, Date end){
return dateZones(from(start), from(end));
}
/**
* 获取 {@link LocalDate} 在开始时间和结束时间内的日期时间段 {@link LocalDate} 集合
* @param start 开始时间
* @param end 结束时间
* @return 时间集合
*/
public static List dateZones(LocalDate start, LocalDate end){
return Stream.iterate(start, x -> x.plusDays(1))
.limit(ChronoUnit.DAYS.between(start, end) + 1)
.map(e -> Date.from(e.atStartOfDay().atZone(ZoneId.systemDefault()).toInstant()))
.collect(Collectors.toList());
}
/**
* 获取{@link LocalDateTime} 在开始时间和结束时间内的日期时间段{@link Date}集合
* @param start 开始时间
* @param end 结束时间
* @return 时间天数集合
*/
public static List dateZones(LocalDateTime start, LocalDateTime end){
// 用起始时间作为流的源头，按照每次加一天的方式创建一个无限流
return Stream.iterate(start.toLocalDate(), x -> x.plusDays(1))
// 截断无限流，长度为起始时间和结束时间的差+1个
.limit(ChronoUnit.DAYS.between(start, end) + 1)
// 由于最后要的是字符串，所以map转换一下
.map(e -> Date.from(e.atStartOfDay().atZone(ZoneId.systemDefault()).toInstant()))
// 把流收集为List
.collect(Collectors.toList());
}
/**
* 获取{@link Date}在开始时间和结束时间内的日期时间段{@link LocalDate}集合
* @param start 开始时间
* @param end 结束时间
* @return 时间集合
*/
public static List localDateZones(Date start, Date end){
return localDateZones(from(start), from(end));
}
/**
* 获取 {@link LocalDate} 在开始时间和结束时间内的日期时间段 {@link LocalDate} 集合
* @param start 开始时间
* @param end 结束时间
* @return 时间集合
*/
public static List localDateZones(LocalDate start, LocalDate end){
return Stream.iterate(start, x -> x.plusDays(1))
.limit(ChronoUnit.DAYS.between(start, end) + 1)
.collect(Collectors.toList());
}
/**
* 获取 {@link LocalDateTime} 在开始时间和结束时间内的日期时间段 {@link LocalDate} 集合
* @param start 开始时间
* @param end 结束时间
* @return 时间集合
*/
public static List localDateZones(LocalDateTime start, LocalDateTime end){
// 用起始时间作为流的源头，按照每次加一天的方式创建一个无限流
return Stream.iterate(start.toLocalDate(), x -> x.plusDays(1))
// 截断无限流，长度为起始时间和结束时间的差+1个
.limit(ChronoUnit.DAYS.between(start, end) + 1)
.map(e -> e.atStartOfDay().toLocalDate())
// 把流收集为List
.collect(Collectors.toList());
}
/**
* 格式化日期
* @param date 待格式化的日期
* @param pattern 格式化正则
* @return 格式化结果串
*/
public static String format(Date date, String pattern){
return new SimpleDateFormat(pattern).format(date);
}
/**
* 格式化日期
* @param localDateTime 待格式化的日期
* @param pattern 格式化正式
* @return 格式化结果串
*/
public static String format(LocalDateTime localDateTime, String pattern){
return format(localDateTime, DateTimeFormatter.ofPattern(pattern));
}
/**
* 格式化日期
* @param localDateTime 待格式化的日期
* @param dateTimeFormatter 格式化形式
* @return 格式化结果串
*/
public static String format(LocalDateTime localDateTime, DateTimeFormatter dateTimeFormatter){
return localDateTime.format(dateTimeFormatter);
}
/**
* 格式化日期
* @param localDate 待格式化的日期
* @param pattern 格式化正则, 这里使用的类型 {@link LocalDate}, 所以正则只能设定到天
* @return 格式化结果串
*/
public static String format(LocalDate localDate, String pattern){
return format(localDate, DateTimeFormatter.ofPattern(pattern));
}
/**
* 格式化日期
* @param localDate 待格式化的日期
* @param dateTimeFormatter 格式化正则, 这里使用的类型 {@link LocalDate}, 所以正则只能设定到天
* @return 格式化结果串
*/
public static String format(LocalDate localDate, DateTimeFormatter dateTimeFormatter){
return localDate.format(dateTimeFormatter);
}
/**
* 当前时间格式化
* @param formatter 格式化形式
* @return 格式化后的字符串
*/
public static String nowFormat(DateTimeFormatter formatter){
return format(LocalDateTime.now(), formatter);
}
/**
* 当前时间格式化
* @param pattern 格式化形式
* @return 格式化后的字符串
*/
public static String nowFormat(String pattern){
return nowFormat(DateTimeFormatter.ofPattern(pattern, Locale.getDefault()));
}
}
