根据开始时间结束时间获取两个日期之间集合（日周月）的工具类：
import org.apache.commons.lang3.time.DateFormatUtils;
import org.apache.commons.lang3.time.DateUtils;
import java.text.ParseException;
import java.util.*;
public class TimeRangeUtil {
/**
* 获取两个日期字符串之间的日期集合
*
*/
public static List<String> getMonthDateRangeList(String startDate, String endDate){
List<String> dateRangeList=new ArrayList<>();
try {
Date start=DateUtils.parseDate(startDate,"MM-dd");
Date end=DateUtils.parseDate(endDate,"MM-dd");
while (start.before(end) || start.equals(end)){
dateRangeList.add(DateFormatUtils.format(start,"MM-dd"));
start=DateUtils.addDays(start,1);
}
} catch (ParseException e) {
e.printStackTrace();
}
return dateRangeList;
}
/**
* 获取两个日期字符串之间的日期集合
*
*/
public static List<String> getYearMonthRangeList(String format, String startDate, String endDate){
List<String> dateRangeList=new ArrayList<>();
try {
Date start=DateUtils.parseDate(startDate,"yyyy-MM-dd");
Date end=DateUtils.parseDate(endDate,"yyyy-MM-dd");
while (start.before(end) || start.equals(end)){
dateRangeList.add(DateFormatUtils.format(start,format));
start=DateUtils.addMonths(start,1);
}
} catch (ParseException e) {
e.printStackTrace();
}
return dateRangeList;
}
public static void main(String[] args) {
List<String> yearMonthRangeList = getYearMonthRangeList("yy-MM", "2023-01-01", "2023-12-31");
System.out.println(yearMonthRangeList);
}
/**
* 获取两个日期字符串之间的日期集合
*/
public static List<String> getDateRangeList(String startDate, String endDate){
List<String> dateRangeList=new ArrayList<>();
try {
Date start=DateUtils.parseDate(startDate,"yyyy-MM-dd");
Date end=DateUtils.parseDate(endDate,"yyyy-MM-dd");
while (start.before(end) || start.equals(end)){
dateRangeList.add(DateFormatUtils.format(start,"yyyy-MM-dd"));
start=DateUtils.addDays(start,1);
}
} catch (ParseException e) {
e.printStackTrace();
}
return dateRangeList;
}
/**
* 转为去掉年份的日期列表
*
*/
public static List<String> convertToShortDateRange(List<String> dateRangeList){
List<String> shortDateList=new ArrayList<>();
for (String s : dateRangeList) {
shortDateList.add(s.substring(5));
}
return shortDateList;
}
/**
* 获取两个时间字符串之间的小时集合
*/
public static List<String> getHourRangeList(String startTime, String endTime){
List<String> dateRangeList=new ArrayList<>();
try {
Date start=DateUtils.parseDate(startTime,"yyyy-MM-dd HH:mm:ss");
Date end=DateUtils.parseDate(endTime,"yyyy-MM-dd HH:mm:ss");
while (start.before(end) || start.equals(end)){
dateRangeList.add(DateFormatUtils.format(start,"yyyy-MM-dd HH"));
start=DateUtils.addHours(start,1);
}
} catch (ParseException e) {
e.printStackTrace();
}
return dateRangeList;
}
/**
* 获取两个时间字符串之间的小时集合
*/
public static List<String> getHourTimeRangeList(String startTime, String endTime){
List<String> dateRangeList=new ArrayList<>();
try {
Date start=DateUtils.parseDate(startTime,"yyyy-MM-dd HH:mm:ss");
Date end=DateUtils.parseDate(endTime,"yyyy-MM-dd HH:mm:ss");
while (start.before(end) || start.equals(end)){
dateRangeList.add(DateFormatUtils.format(start,"yyyy-MM-dd HH:00:00"));
start=DateUtils.addHours(start,1);
}
} catch (ParseException e) {
e.printStackTrace();
}
return dateRangeList;
}
/**
* 转为去掉日期的小时列表
*
*/
public static List<String> convertToShortHourRange(List<String> hourRangeList){
List<String> shortHourList=new ArrayList<>();
for (String s : hourRangeList) {
shortHourList.add(s.substring(11));
}
return shortHourList;
}
/**
* 获取两个日期字符串之间的月份集合
*/
public static List<String> getMonthRangeList(String startMonth, String endMonth){
List<String> dateRangeList=new ArrayList<>();
try {
Date start=DateUtils.parseDate(startMonth,"yyyy-MM");
Date end=DateUtils.parseDate(endMonth,"yyyy-MM");
while (start.before(end) || start.equals(end)){
dateRangeList.add(DateFormatUtils.format(start,"yyyy-MM"));
start=DateUtils.addMonths(start,1);
}
} catch (ParseException e) {
e.printStackTrace();
}
return dateRangeList;
}
/**
* 获取两个日期字符串之间的周次集合
*
*/
public static List<String> getWeekRangeList(String startMonth, String endMonth){
List<String> weekRangeList=new ArrayList<>();
try {
Date start=DateUtils.parseDate(startMonth,"yyyy-MM-dd");
Date end=DateUtils.parseDate(endMonth,"yyyy-MM-dd");
Calendar calendarStart = Calendar.getInstance();
calendarStart.setTime(start);
Integer startWeek=calendarStart.get(Calendar.WEEK_OF_YEAR);
Calendar calendarEnd = Calendar.getInstance();
calendarEnd.setTime(end);
Integer endWeek=calendarEnd.get(Calendar.WEEK_OF_YEAR);
for (Integer i = startWeek; i <= endWeek; i++) {
weekRangeList.add(i.toString());
}
} catch (ParseException e) {
e.printStackTrace();
}
return weekRangeList;
}
/**
* 获取年份集合
* @param startYear 开始年份
* @param endYear 结束年份
* @return
*/
public static List<String> getYearRangeList(String startYear, String endYear){
List<String> dateRangeList=new ArrayList<>();
try {
Date start=DateUtils.parseDate(startYear,"yyyy");
Date end=DateUtils.parseDate(endYear,"yyyy");
while (start.before(end) || start.equals(end)){
dateRangeList.add(DateFormatUtils.format(start,"yyyy"));
start=DateUtils.addYears(start,1);
}
} catch (ParseException e) {
e.printStackTrace();
}
return dateRangeList;
}
/**
* 转为去掉年份的月份列表
*/
public static List<String> convertToShortMonthRange(List<String> monthRangeList){
List<String> shortMonthList=new ArrayList<>();
for (String s : monthRangeList) {
shortMonthList.add(s.substring(5));
}
return shortMonthList;
}
/**
* 转为去掉年份的周次列表
*/
public static List<String> convertToShortWeekRange(List<String> weekRangeList){
List<String> shortWeekList=new ArrayList<>();
for (String s : weekRangeList) {
shortWeekList.add(s.substring(5));
}
return shortWeekList;
}
/**
* 转为去掉年份的月份列表（简写年份）
*/
public static List<String> convertToShortMonthRangeWithYear(List<String> monthRangeList){
List<String> shortMonthList=new ArrayList<>();
for (String s : monthRangeList) {
shortMonthList.add(s.substring(2));
}
return shortMonthList;
}
/**
* 转为去掉年份的年份列表
*/
public static List<String> convertToShortYearRange(List<String> yearRangeList){
List<String> shortYearList=new ArrayList<>();
for (String s : yearRangeList) {
shortYearList.add(s);
}
return shortYearList;
}
/**
* 获取某年第一天日期
* @param year 年份
* @return Date
*/
public static Date getFirstOfYear(int year){
Calendar calendar = Calendar.getInstance();
calendar.clear();
calendar.set(Calendar.YEAR, year);
return calendar.getTime();
}
/**
* 获取某年最后一天日期
* @param year 年份
* @return Date
*/
public static Date getLastOfYear(int year){
Calendar calendar = Calendar.getInstance();
calendar.clear();
calendar.set(Calendar.YEAR, year);
calendar.roll(Calendar.DAY_OF_YEAR, -1);
return calendar.getTime();
}
/**
* 获取某月第一天日期
* @param month 月份
* @return Date
*/
public static Date getFirstOfMonth(int month){
//获取当前月第一天：
Calendar c = Calendar.getInstance();
c.set(Calendar.MONTH, month-1);
c.set(Calendar.DAY_OF_MONTH,1);//设置为1号,当前日期既为本月第一天
return c.getTime();
}
/**
* 获取某月最后一天日期
* @param month 月份
* @return Date
*/
public static Date getLastOfMonth(int month){
//获取当前月最后一天
Calendar ca = Calendar.getInstance();
ca.set(Calendar.MONTH, month-1);
ca.set(Calendar.DAY_OF_MONTH, ca.getActualMaximum(Calendar.DAY_OF_MONTH));
return ca.getTime();
}
/**
* 获取两个日期字符串之间的日期集合
* 支持 日 ：yyyy-MM-dd
* 月 ：yyyy-MM
* 年： yyyy
*
* @param startDate the start date
* @param endDate the end date
*/
public static List<String> getRangeList(String startDate, String endDate, String format) {
List<String> dateRangeList = new ArrayList<>();
try {
Date start = DateUtils.parseDate(startDate, format);
Date end = DateUtils.parseDate(endDate, format);
while (start.before(end) || start.equals(end)) {
dateRangeList.add(DateFormatUtils.format(start, format));
switch (format) {
case "yyyy-MM-dd":
start = DateUtils.addDays(start, 1);
break;
case "yyyy-MM":
start = DateUtils.addMonths(start, 1);
break;
case "yyyy":
start = DateUtils.addYears(start, 1);
break;
}
}
} catch (ParseException e) {
e.printStackTrace();
}
return dateRangeList;
}
/**
* 获取两个日期字符串之间的周数集合
* 支持 日 ：yyyy-MM-dd
* 月 ：yyyy-MM
* 年： yyyy
*
* @param startDate the start date
* @param endDate the end date
*/
public static List<String> getDateRangeListByWeek(String startDate, String endDate){
Calendar calendar = Calendar.getInstance();
calendar.setFirstDayOfWeek(Calendar.SUNDAY);//设置星期天为一周开始的第一天
//calendar.setMinimalDaysInFirstWeek(4);//设置跨年第一周若小于4天则归为去年最后一周
String itemDate = endDate;
List<String> weeks = new ArrayList<>();
while (itemDate.compareTo(startDate)>=0){
try{
calendar.setTimeInMillis(DateUtils.parseDate(itemDate, "yyyy-MM-dd").getTime());//获得当前的时间戳
int week = calendar.get(Calendar.WEEK_OF_YEAR);
weeks.add(itemDate.substring(0,4)+"年第"+String.format("%02d",week)+"周");
itemDate = com.penghaisoft.ccr.common.etl.DateUtils.getDate(DateUtils.addWeeks(DateUtils.parseDate(itemDate, "yyyy-MM-dd"), -1));
}catch (Exception e){
System.out.println("日期范围内转换周数集合错误！ "+e);
}
}
//list从小到大排序
Collections.reverse(weeks);
return weeks;
}
}
时间区间统计通用类如下：
public class TimeValueModel {
//时间字符串（可以是年月日时任意类型）
String timeStr;
//统计值
Double value;
}
根据以上获取的时间区间和实际数据补全数据集合：
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class TimeRangeValueCompleteUtil {
/**
* 根据时间列表，返回相同长度的数据列表(null补0)
*/
public static List<Double> getCompleteValueList(List<String> timeStrList,List<TimeValueModel> dataList){
double[] result=new double[timeStrList.size()];
for (int i = 0; i < timeStrList.size(); i++) {
for (TimeValueModel data : dataList) {
if(data.getTimeStr().equals(timeStrList.get(i))){
result[i]=data.getValue()!=null?data.getValue():0;
break;
}
}
}
List<Double> dList = new ArrayList<>();
for(Double d:result){
dList.add(d);
}
return dList;
}
/**
* 根据时间列表，返回相同长度的数据列表(null补100)
*/
public static List<Double> getCompleteValueListRepair100(List<String> timeStrList,List<TimeValueModel> dataList){
double[] result=new double[timeStrList.size()];
for (int i = 0; i < timeStrList.size(); i++) {
result[i]=100;
for (TimeValueModel data : dataList) {
if(data.getTimeStr().equals(timeStrList.get(i))){
result[i]=data.getValue()!=null?data.getValue():0;
break;
}
}
}
List<Double> dList = new ArrayList<>();
for(Double d:result){
dList.add(d);
}
return dList;
}
/**
* 根据时间列表，返回相同长度的数据列表
*/
public static List<String> getCompleteStringValueList(List<String> timeStrList,List<TimeValueModel> dataList){
int[] dList = new int[timeStrList.size()];
for (int i = 0; i < timeStrList.size(); i++) {
for (TimeValueModel data : dataList) {
String s = timeStrList.get(i);
String timeStr = data.getTimeStr();
if(data.getTimeStr().equals(timeStrList.get(i))){
dList[i] = data.getValue()!=null? data.getValue().intValue() :0;
break;
}
}
}
ArrayList<String> strList = new ArrayList<>();
for (int v : dList) {
strList.add(String.valueOf(v));
}
return strList;
}
/**
* 根据时间列表，返回相同长度的数据列表
*/
public static List<String> getCompleteDoubleStringValueList(List<String> timeStrList,List<TimeValueModel> dataList){
double[] dList = new double[timeStrList.size()];
for (int i = 0; i < timeStrList.size(); i++) {
for (TimeValueModel data : dataList) {
if(data.getTimeStr().equals(timeStrList.get(i))){
dList[i] = data.getValue()!=null? data.getValue() :0.0;
break;
}
}
}
ArrayList<String> strList = new ArrayList<>();
for (double v : dList) {
strList.add(String.valueOf(v));
}
return strList;
}
/**
* 根据时间列表，去除空数据后，返回数据列表，并把空日期剔除
*/
public static List<Double> getNotNullValueList(List<String> timeStrList,List<TimeValueModel> dataList){
Double[] result=new Double[timeStrList.size()];
for (int i = 0; i < timeStrList.size(); i++) {
for (TimeValueModel data : dataList) {
if(data.getTimeStr().equals(timeStrList.get(i))){
result[i]=data.getValue();
break;
}
}
}
List<String> timeListResult=new ArrayList<>();
List<Double> dList = new ArrayList<>();
for (int i = 0; i < result.length; i++) {
if(result[i]!=null){
dList.add(result[i]);
timeListResult.add(timeStrList.get(i));
}
}
//修正日期列表
timeStrList.clear();
timeStrList.addAll(timeListResult);
return dList;
}
/**
* 将数字列表转为字符串列表
*
*/
public static List<String> getCompleteValueStringList(List<Double> doubleList,int digit){
return getCompleteValueStringList(doubleList,digit,"");
}
/**
* 将数字列表转为字符串列表，带单位
*/
public static List<String> getCompleteValueStringList(List<Double> doubleList,int digit,String unit){
List<String> stringList =new ArrayList<>();
String formatType="%."+digit+"f";
unit = unit==null?"":unit;
for (Double aDouble : doubleList) {
stringList.add(String.format(formatType,aDouble)+unit);
}
return stringList;
}
public static List<Double> getCompletionRate(List<Double> planList, List<Double> finishList, boolean isFinishDividePlan){
List<Double> result=new ArrayList<>();
for (int i = 0; i < planList.size(); i++) {
if(isFinishDividePlan){
result.add(planList.get(i)==0?100:finishList.get(i)/planList.get(i)*100);
}else{
result.add(finishList.get(i)==0?100:planList.get(i)/finishList.get(i)*100);
}
}
return result;
}
public static List<String> getStringCompletionRate(List<String> planList, List<String> finishList, String defaultValue){
List<String> result=new ArrayList<>();
for (int i = 0; i < planList.size(); i++) {
Double planNum = Double.parseDouble(planList.get(i));
Double finishNum = Double.parseDouble(finishList.get(i));
if (planNum==0){
result.add(defaultValue);
}else {
double rate = finishNum / planNum * 100;
String format = String.format("%.2f", rate);
result.add(format);
}
}
return result;
}
//给stringList的对应位置的数做除法,计算比例（%）
public static List<String> getStringListRate(List<String> planList, List<String> finishList, boolean isFinishDividePlan){
List<String> result=new ArrayList<>();
for (int i = 0; i < planList.size(); i++) {
Double planNum = Double.parseDouble(planList.get(i));
Double finishNum = Double.parseDouble(finishList.get(i));
if(isFinishDividePlan){
if (planNum==0){
result.add("100");
}else {
double rate = finishNum / planNum *100;
String format = String.format("%.2f", rate);
result.add(format);
}
}else{
if (finishNum==0){
result.add("100");
}else {
double rate = planNum / finishNum*100;
String format = String.format("%.2f", rate);
result.add(format);
}
}
}
return result;
}
//给stringList的对应位置的数做除法,计算数值
public static List<String> getStringListNum(List<String> planList, List<String> finishList, boolean isFinishDividePlan){
List<String> result=new ArrayList<>();
for (int i = 0; i < planList.size(); i++) {
Double planNum = Double.parseDouble(planList.get(i));
Double finishNum = Double.parseDouble(finishList.get(i));
if(isFinishDividePlan){
if (planNum==0){
result.add("0");
}else {
double rate = finishNum / planNum;
String format = String.format("%.2f", rate);
result.add(format);
}
}else{
if (finishNum==0){
result.add("0");
}else {
double rate = planNum / finishNum;
String format = String.format("%.2f", rate);
result.add(format);
}
}
}
return result;
}
/**
* 根据时间列表，返回相同长度的默认数据列表
*/
public static List<String> getCompleteDefaultStringValueList(List<String> timeStrList,String defaultValue){
ArrayList<String> strList = new ArrayList<>();
for (int i = 0; i < timeStrList.size(); i++) {
strList.add(defaultValue);
}
return strList;
}
}
扫一扫
1071
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
