根据首期还款日和分期数两个参数计算每期还款日期
根据首期还款日和分期数两个参数计算每期还款日期（及其他时间相关计算）
话不多说直接上代码
方便自己方便他人main方法中已备好调用方法操作。
如需扩展可自行修改。相关jar包一般项目都应该能找到。大部分jdk自带的！
package com.zeze.common.utils;
import org.apache.commons.lang3.time.DateFormatUtils;
import com.alibaba.druid.sql.ast.statement.SQLIfStatement.Else;
import com.zeze.common.DateUtil;
import com.zeze.common.StringUtil;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Scanner;
/**
* 时间计算工具类
*/
public class TimeUtils {
public static String toTimeString(long time) {
TimeUtils t = new TimeUtils(time);
int day = t.get(TimeUtils.DAY);
int hour = t.get(TimeUtils.HOUR);
int minute = t.get(TimeUtils.MINUTE);
int second = t.get(TimeUtils.SECOND);
StringBuilder sb = new StringBuilder();
if (day > 0){
sb.append(day).append("天");
}
if (hour > 0){
sb.append(hour).append("时");
}
if (minute > 0){
sb.append(minute).append("分");
}
if (second > 0){
sb.append(second).append("秒");
}
return sb.toString();
}
/**
* 时间字段常量，表示“秒”
*/
public final static int SECOND = 0;
/**
* 时间字段常量，表示“分”
*/
public final static int MINUTE = 1;
/**
* 时间字段常量，表示“时”
*/
public final static int HOUR = 2;
/**
* 时间字段常量，表示“天”
*/
public final static int DAY = 3;
/**
* 各常量允许的最大值
*/
private final int[] maxFields = { 59, 59, 23, Integer.MAX_VALUE - 1 };
/**
* 各常量允许的最小值
*/
private final int[] minFields = { 0, 0, 0, Integer.MIN_VALUE };
/**
* 默认的字符串格式时间分隔符
*/
private String timeSeparator = ":";
/**
* 时间数据容器
*/
private int[] fields = new int[4];
/**
* 无参构造，将各字段置为 0
*/
public TimeUtils() {
this(0, 0, 0, 0);
}
/**
* 使用时、分构造一个时间
* @param hour 小时
* @param minute 分钟
*/
public TimeUtils(int hour, int minute) {
this(0, hour, minute, 0);
}
/**
* 使用时、分、秒构造一个时间
* @param hour 小时
* @param minute 分钟
* @param second 秒
*/
public TimeUtils(int hour, int minute, int second) {
this(0, hour, minute, second);
}
/**
* 使用一个字符串构造时间
* Time time = new Time("14:22:23");
* @param time 字符串格式的时间，默认采用“:”作为分隔符
*/
public TimeUtils(String time) {
this(time, null);
}
/**
* 使用时间毫秒构建时间
* @param time
*/
public TimeUtils(long time){
this(new Date(time));
}
/**
* 使用日期对象构造时间
* @param date
*/
public TimeUtils(Date date){
this(DateFormatUtils.formatUTC(date, "HH:mm:ss"));
}
/**
* 使用天、时、分、秒构造时间，进行全字符的构造
* @param day 天
* @param hour 时
* @param minute 分
* @param second 秒
*/
public TimeUtils(int day, int hour, int minute, int second) {
initialize(day, hour, minute, second);
}
/**
* 使用一个字符串构造时间，指定分隔符
* Time time = new Time("14-22-23", "-");
* @param time 字符串格式的时间
*/
public TimeUtils(String time, String timeSeparator) {
if(timeSeparator != null) {
setTimeSeparator(timeSeparator);
}
parseTime(time);
}
/**
* 设置时间字段的值
* @param field 时间字段常量
* @param value 时间字段的值
*/
public void set(int field, int value) {
if(value < minFields[field]) {
throw new IllegalArgumentException(value + ", time value must be positive.");
}
fields[field] = value % (maxFields[field] + 1);
// 进行进位计算
int carry = value / (maxFields[field] + 1);
if(carry > 0) {
int upFieldValue = get(field + 1);
set(field + 1, upFieldValue + carry);
}
}
/**
* 获得时间字段的值
* @param field 时间字段常量
* @return 该时间字段的值
*/
public int get(int field) {
if(field < 0 || field > fields.length - 1) {
throw new IllegalArgumentException(field + ", field value is error.");
}
return fields[field];
}
/**
* 将时间进行“加”运算，即加上一个时间
* @param time 需要加的时间
* @return 运算后的时间
*/
public TimeUtils addTime(TimeUtils time) {
TimeUtils result = new TimeUtils();
int up = 0; // 进位标志
for (int i = 0; i < fields.length; i++) {
int sum = fields[i] + time.fields[i] + up;
up = sum / (maxFields[i] + 1);
result.fields[i] = sum % (maxFields[i] + 1);
}
return result;
}
/**
* 将时间进行“减”运算，即减去一个时间
* @param time 需要减的时间
* @return 运算后的时间
*/
public TimeUtils subtractTime(TimeUtils time) {
TimeUtils result = new TimeUtils();
int down = 0; // 退位标志
for (int i = 0, k = fields.length - 1; i < k; i++) {
int difference = fields[i] + down;
if (difference >= time.fields[i]) {
difference -= time.fields[i];
down = 0;
} else {
difference += maxFields[i] + 1 - time.fields[i];
down = -1;
}
result.fields[i] = difference;
}
result.fields[DAY] = fields[DAY] - time.fields[DAY] + down;
return result;
}
/**
* 获得时间字段的分隔符
* @return
*/
public String getTimeSeparator() {
return timeSeparator;
}
/**
* 设置时间字段的分隔符（用于字符串格式的时间）
* @param timeSeparator 分隔符字符串
*/
public void setTimeSeparator(String timeSeparator) {
this.timeSeparator = timeSeparator;
}
private void initialize(int day, int hour, int minute, int second) {
set(DAY, day);
set(HOUR, hour);
set(MINUTE, minute);
set(SECOND, second);
}
private void parseTime(String time) {
if(time == null) {
initialize(0, 0, 0, 0);
return;
}
String t = time;
int field = DAY;
set(field--, 0);
int p = -1;
while((p = t.indexOf(timeSeparator)) > -1) {
parseTimeField(time, t.substring(0, p), field--);
t = t.substring(p + timeSeparator.length());
}
parseTimeField(time, t, field--);
}
private void parseTimeField(String time, String t, int field) {
if(field < SECOND || t.length() < 1) {
parseTimeException(time);
}
char[] chs = t.toCharArray();
int n = 0;
for(int i = 0; i < chs.length; i++) {
if(chs[i] <= ' ') {
continue;
}
if(chs[i] >= '0' && chs[i] <= '9') {
n = n * 10 + chs[i] - '0';
continue;
}
parseTimeException(time);
}
set(field, n);
}
private void parseTimeException(String time) {
throw new IllegalArgumentException(time + ", time format error, HH"
+ this.timeSeparator + "mm" + this.timeSeparator + "ss");
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder(16);
sb.append(fields[DAY]).append(',').append(' ');
buildString(sb, HOUR).append(timeSeparator);
buildString(sb, MINUTE).append(timeSeparator);
buildString(sb, SECOND);
return sb.toString();
}
private StringBuilder buildString(StringBuilder sb, int field) {
if(fields[field] < 10) {
sb.append('0');
}
return sb.append(fields[field]);
}
public int hashCode() {
final int PRIME = 31;
int result = 1;
result = PRIME * result + Arrays.hashCode(fields);
return result;
}
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
final TimeUtils other = (TimeUtils) obj;
if (!Arrays.equals(fields, other.fields)) {
return false;
}
return true;
}
/**
*
* @Title: Dateofinstallment
* @Description: 根据分期期限数和首期还钱日期 计算每期具体还款日期
* @author xiecong
* @param recordDate 必要参数 首期还款日格式为：2020-03-30
* @param cycle 分期数
* @param type 1 为时间字符串 格式为“2020年02月02日” 2 时间戳
* 返回参数集为Map Key 为具体每期数 value 为 对应每期还钱日期
* @return
*/
public static Map<Integer,Object> Dateofinstallment(String recordDate,int cycle,String type){
int n = 1;
Map<Integer,Object> dateMap = new HashMap<Integer, Object>();
if(cycle<=0){
dateMap.put(222, "分期数必须大于0");
return dateMap;
}
if(StringUtil.isBlank(recordDate)){
dateMap.put(333, "首期日期不能为空");
return dateMap;
}
int yy=Integer.parseInt(recordDate.substring(0,4));
int mm=Integer.parseInt(recordDate.substring(5,7));
int dd=Integer.parseInt(recordDate.substring(8,10));
GregorianCalendar b =new GregorianCalendar();
for(int i=2;i<cycle+2;i++){
mm++;
b =new GregorianCalendar(yy,mm,dd);
int year= b.get(Calendar.YEAR);
int month= b.get(Calendar.MONDAY);
int day= b.get(Calendar.DAY_OF_MONTH);
if(month==0){
month =12;
year=year-1;
}
//日期超过每年二月份 最大天数的处理，包括对闰年的处理。
if(year%4==0&&year%100!=0||year%400==0){
if(dd >29 && month==2 && year>yy && n%2 !=0){
n =2;
month = 1;
day = dd;
}
if(dd >29 && year>yy && month==2 && n%2 ==0){
n =1;
month = 2;
day = 29;
}
}else{
if(dd >28 && month==2 && year>yy && n%2 !=0){
n =2;
month = 1;
day = dd;
}
if(dd >28 && year>yy && month==2 && n%2 ==0){
n =1;
month = 2;
day = 28;
}
}
String dateString = year+"年"+month+"月"+day+"日";
System.out.println(dateString);
if("1".equals(type)){
dateMap.put(i, dateString);
}else{
dateMap.put(i, DateUtil.StringToDate(dateString));
}
// System.out.println("第"+i+"期还款日期为："+year+"年"+month+"月"+day+"ri");
}
// System.out.println(dateMap.toString());
return dateMap;
}
public static void main(String[] args) {
// String dateString =DateUtil.dateToString(new Date(), "yyyy-MM-dd");
Dateofinstallment("2020-04-29", 12, "1");
}
}
注释也算写的比较详细了，好用请好评。