背景：管理后台添加节日规则，前端展示节日
实现方案设计
将所有节日分类，每类节日对应一个时间计算规则，添加节日时生成该节日近50年的时间，前端查询节日时，根据传入时间戳，即可查询最近节日。
代码：
@Getter
@AllArgsConstructor
public enum FestivalCreateTypeEnum {
SOLAR_DAY(1,"阳历的某月某天"),
LUNAR_DAY(2,"阴历的某月某天"),
TWENTY_FOUR(3,"二十四节气"),
WEEK_DAY(4,"每年某月某周周几"),
LAST_WEEK_DAY(6,"每年某月最后一周周几"),
F_BEFORE(5,"某个节日的前几天");
private final int code;
private final String desc;
private static final Map<Integer, FestivalCreateTypeEnum> map = new HashMap<>();
static {
for (FestivalCreateTypeEnum typeEnum: FestivalCreateTypeEnum.values()) {
map.put(typeEnum.getCode(), typeEnum);
}
}
public static FestivalCreateTypeEnum getEnum(int code){
return map.get(code);
}
}
//添加节日入参
@Data
public class AddCalendarDto implements Serializable {
/**
* 创建类型 1-阳历每年某月某天，2-农历每年某与某天，
* 3-二十四节气，4-每年某月某周 周几，5-某个节日的前几天or后几天
* */
private Integer createType;
/**
* 节日类型
* */
private Integer typeId;
/**
* 节日名称
* */
private String name;
/**
* 第几月
* */
private Integer monthNum;
/**
* 第几天
* */
private Integer dayNum;
/**
* 第几周
* */
private Integer weekCount;
/**
* 周几
* */
private Integer weekNum;
/**
* 二十四节气对应C值
* */
private Double c;
/**
* 时间
* */
private Long date;
/**
* 状态 0无效 1有效
* */
private Integer status;
/**
* 每个节气对应的顺序 0-小寒 1大寒 2立春 3雨水 4惊蛰 5春分 6清明 7谷雨 8立夏 9小满 10芒种 11夏至
* 12小暑 13大暑 14立秋 15处暑 16白露 17秋分 18寒露 19霜降 20立冬 21小雪 22大雪 23冬至
*/
private Integer sort;
/**
* 时间类型 0非规律时间 1规律时间
* */
private Integer timeType;
private String alias;
private String desc;
private String displayName;
private String imageUrl;
private String keyWords;
private Integer festivalId;
private List<Long> dateList;
}
//添加节日方法
public ServerResponse addFestival(AddCalendarDto param) {
if (param.getTimeType() == null || StringUtils.isBlank(param.getName())) {
return ServerResponse.createByError(-1,"参数错误");
}
//判断是否已经有该节日
FestivalDo festivalDo = festivalDao.selectByName(param.getName());
if (!Objects.isNull(festivalDo)) {
return ServerResponse.createByError(-2,"该节日已存在");
}
//自定义节日
if (param.getTimeType() == 0) {
if (CollectionUtils.isEmpty(param.getDateList())) {
return ServerResponse.createByError(-1,"参数错误");
}
CustomizeFestivalDto customizeFestivalDto = new CustomizeFestivalDto();
customizeFestivalDto = (CustomizeFestivalDto)convertFesDto(customizeFestivalDto, param);
customizeFestivalDto.setDateList(param.getDateList());
customizeFestivalFactory.createFestival(customizeFestivalDto);
return ServerResponse.createBySuccess();
}
//已有规律性节日
FestivalCreateTypeEnum fTypeEnum = FestivalCreateTypeEnum.getEnum(param.getCreateType());
if (Objects.isNull(fTypeEnum)) {
return ServerResponse.createByError(-3,"节日创建类型错误");
}
boolean isSuccess = false;
switch (fTypeEnum) {
case F_BEFORE://依附于某个节日-寒食
if (param.getFestivalId() == null || param.getDayNum()==0) {
break;
}
BeforeFestivalDto beforeFestivalDto = new BeforeFestivalDto();
beforeFestivalDto = (BeforeFestivalDto)convertFesDto(beforeFestivalDto, param);
beforeFestivalDto.setFestivalId(param.getFestivalId());
beforeFestivalDto.setDayCount(param.getDayNum());
isSuccess = beforeFestivalFactory.createFestival(beforeFestivalDto);
break;
case WEEK_DAY://周几的节日-母亲节
if (param.getMonthNum()<0 || param.getWeekCount()<0 || param.getWeekNum()<0) {
break;
}
WeekFestivalDto weekFestivalDto = new WeekFestivalDto();
weekFestivalDto = (WeekFestivalDto)convertFesDto(weekFestivalDto, param);
weekFestivalDto.setMonthNum(param.getMonthNum());
weekFestivalDto.setWeekCount(param.getWeekCount());
weekFestivalDto.setWeekNum(param.getWeekNum());
isSuccess = weekFestivalFactory.createFestival(weekFestivalDto);
break;
case LUNAR_DAY://农历的节日-春节
if (param.getMonthNum()<0 || param.getDayNum()<0) {
break;
}
LunarFestivalDto lFestivalDto = new LunarFestivalDto();
lFestivalDto = (LunarFestivalDto)convertFesDto(lFestivalDto, param);
lFestivalDto.setMonthNum(param.getMonthNum());
lFestivalDto.setDayNum(param.getDayNum());
isSuccess = lunarFestivalFactory.createFestival(lFestivalDto);
break;
case SOLAR_DAY://阳历的节日-劳动节
if (param.getMonthNum() < 0 || param.getDayNum() < 0) {
break;
}
SolarFestivalDto sFestivalDto = new SolarFestivalDto();
sFestivalDto = (SolarFestivalDto)convertFesDto(sFestivalDto, param);
sFestivalDto.setMonthNum(param.getMonthNum());
sFestivalDto.setDayNum(param.getDayNum());
isSuccess = solarFestivalFactory.createFestival(sFestivalDto);
break;
case TWENTY_FOUR://二十四节气
if (param.getSort() < 0 || param.getC() < 0) {
break;
}
TwentyFourFestivalDto tfParam = new TwentyFourFestivalDto();
tfParam = (TwentyFourFestivalDto)convertFesDto(tfParam, param);
tfParam.setC(param.getC());
tfParam.setSort(param.getSort());
tfParam.setName(tfParam.getName());
isSuccess = twentyFourFestivalFactory.createFestival(tfParam);
break;
case LAST_WEEK_DAY://最后一周的周几-地球一小时
if (param.getMonthNum() < 0 || param.getWeekNum() < 0) {
break;
}
LastWeekFestivalDto lastWeekFestivalDto = new LastWeekFestivalDto();
lastWeekFestivalDto = (LastWeekFestivalDto)convertFesDto(lastWeekFestivalDto, param);
lastWeekFestivalDto.setMonthNum(param.getMonthNum());
lastWeekFestivalDto.setWeekNum(param.getWeekNum());
isSuccess = lastWeekFestivalFactory.createFestival(lastWeekFestivalDto);
break;
default:
break;
}
if (isSuccess) {
return ServerResponse.createBySuccess();
}
return ServerResponse.createByError(-10,"创建节日失败");
}
//阳历节日
@Service
@Slf4j
public class SolarFestivalFactoryImpl implements FestivalFactory {
@Autowired
private FestivalDao festivalDao;
@Autowired
private FestivalTimeDao festivalTimeDao;
@Override
public boolean createFestival(FestivalDto festivalDto) {
//创建近3年的节日
SolarFestivalDto solarFestivalDto = (SolarFestivalDto)festivalDto;
FestivalDo festivalDo = new FestivalDo();
festivalDo = DomainConvertUtils.festivalConvertDo(solarFestivalDto,festivalDo);
festivalDo.setMonthNum(solarFestivalDto.getMonthNum());
festivalDo.setDayNum(solarFestivalDto.getDayNum());
festivalDao.insertSelective(festivalDo);
FestivalDo fDo = festivalDao.selectByName(solarFestivalDto.getName());
if (Objects.isNull(fDo)) {
return false;
}
List<FestivalTimeDo> festivalTimeDos = Lists.newArrayList();
//获取当前年
Calendar rightNow = Calendar.getInstance();
int year = rightNow.get(Calendar.YEAR);// 获取当前年份
for (int i=0;i<50;i++) {
FestivalTimeDo festivalTimeDo = new FestivalTimeDo();
festivalTimeDo.setStatus(1);
festivalTimeDo.setFestivalId(fDo.getId());
String str = year+i+"-"+solarFestivalDto.getMonthNum()+"-"+solarFestivalDto.getDayNum();
try {
Date date = DateUtils.parseDate(str, "yyyy-MM-dd");
festivalTimeDo.setTime(date);
festivalTimeDos.add(festivalTimeDo);
} catch (Exception e) {}
}
log.info("[SolarFestivalFactoryImpl]festivalTimeDos:{}", JSON.toJSONString(festivalTimeDos));
if (CollectionUtils.isNotEmpty(festivalTimeDos)) {
festivalTimeDao.batchInsert(festivalTimeDos);
}
return true;
}
}
//农历节日
@Service
@Slf4j
public class LunarFestivalFactoryImpl implements FestivalFactory {
@Autowired
private FestivalDao festivalDao;
@Autowired
private FestivalTimeDao festivalTimeDao;
@Override
public boolean createFestival(FestivalDto festivalDto) {
//创建近3年的节日
LunarFestivalDto lunarFestivalDto = (LunarFestivalDto)festivalDto;
FestivalDo festivalDo = new FestivalDo();
festivalDo = DomainConvertUtils.festivalConvertDo(lunarFestivalDto,festivalDo);
festivalDo.setMonthNum(lunarFestivalDto.getMonthNum());
festivalDo.setDayNum(lunarFestivalDto.getDayNum());
festivalDao.insertSelective(festivalDo);
FestivalDo fDo = festivalDao.selectByName(lunarFestivalDto.getName());
if (Objects.isNull(fDo)) {
return false;
}
List<FestivalTimeDo> festivalTimeDos = Lists.newArrayList();
//获取当前年
Calendar rightNow = Calendar.getInstance();
int year = rightNow.get(Calendar.YEAR);// 获取当前年份
for (int i=0;i<50;i++) {
FestivalTimeDo festivalTimeDo = new FestivalTimeDo();
festivalTimeDo.setFestivalId(fDo.getId());
festivalTimeDo.setStatus(1);
//指定阴历的某一天
Lunar luDate = new Lunar(year+i,lunarFestivalDto.getMonthNum(),lunarFestivalDto.getDayNum());
festivalTimeDo.setTime(luDate.getSolar().getCalendar().getTime());
festivalTimeDos.add(festivalTimeDo);
}
//批量添加
festivalTimeDao.batchInsert(festivalTimeDos);
return true;
}
}
//二十四节气
@Service
@Slf4j
public class TwentyFourFestivalFactoryImpl implements FestivalFactory {
@Autowired
private FestivalDao festivalDao;
@Autowired
private FestivalTimeDao festivalTimeDao;
//二十四节气日期偏移度
private static final double D = 0.2422;
//特殊年份节气日期偏移
private final static Map<Integer, Integer[]> INCREASE_OFFSETMAP = new HashMap<Integer, Integer[]>();//+1偏移
private final static Map<Integer, Integer[]> DECREASE_OFFSETMAP = new HashMap<Integer, Integer[]>();//-1偏移
@Override
public boolean createFestival(FestivalDto festivalDto) {
TwentyFourFestivalDto tfFestivalDto = (TwentyFourFestivalDto) festivalDto;
FestivalDo festivalDo = new FestivalDo();
festivalDo = DomainConvertUtils.festivalConvertDo(tfFestivalDto,festivalDo);
festivalDao.insertSelective(festivalDo);
FestivalDo fDo = festivalDao.selectByName(tfFestivalDto.getName());
if (Objects.isNull(fDo)) {
return false;
}
List<FestivalTimeDo> festivalTimeDos = Lists.newArrayList();
log.info("[TwentyFourFestivalFactoryImpl]tfFestivalDto:{}",tfFestivalDto);
//获取当前年
Calendar rightNow = Calendar.getInstance();
int year = rightNow.get(Calendar.YEAR);
for (int i=0;i<50;i++) {
Date date = sTerm(year + i, tfFestivalDto.getSort(), tfFestivalDto.getC());
if (date == null) {
break;
}
FestivalTimeDo festivalTimeDo = new FestivalTimeDo();
festivalTimeDo.setFestivalId(fDo.getId());
festivalTimeDo.setStatus(1);
festivalTimeDo.setTime(date);
festivalTimeDos.add(festivalTimeDo);
}
log.info("[TwentyFourFestivalFactoryImpl]festivalTimeDos:{}", JSON.toJSONString(festivalTimeDos));
if (CollectionUtils.isNotEmpty(festivalTimeDos)) {
festivalTimeDao.batchInsert(festivalTimeDos);
}
return true;
}
/**
* 获取某年的第n个节气为几日(从0小寒起算)
*
* @param year
* @param n
* @param centuryValue 气的21世纪C值，每个节气的世纪值都不同
* @return
*/
private Date sTerm(int year, int n,double centuryValue) {
int dateNum = 0;
int y = year % 100;//步骤1:取年分的后两位数
if (year % 4 == 0 && year % 100 != 0 || year % 400 == 0) {//闰年
if (n == 0 || n == 1 || n == 2 || n == 3) {
//注意：凡闰年3月1日前闰年数要减一，即：L=[(Y-1)/4],因为小寒、大寒、立春、雨水这两个节气都小于3月1日,所以 y = y-1
y = y - 1;//步骤2
}
}
//获取月份
int month = getFesMonth(n);
dateNum = (int) (y * D + centuryValue) - (int) (y / 4);//步骤3，使用公式[Y*D+C]-L计算
dateNum += specialYearOffset(year, n);//步骤4，加上特殊的年分的节气偏移量
//获取当前年的第一天
String dateStr = year+"-"+month+"-"+01;
try {
Date date = DateUtils.parseDate(dateStr, "yyyy-MM-dd");
Date date1 = DateUtils.addDays(date, dateNum-1);
return date1;
} catch (Exception e) {
}
return null;
}
//获取每个节气对应的月份
private int getFesMonth(int sort) {
if (sort>24 || sort<0) {
return 0;
}
if (sort < 2) {//0 1
return 1;
} else if (1 < sort && sort < 4) {//2 3
return 2;
} else if (sort>3 && sort<6) {// 4 5
return 3;
} else if (sort>5 && sort<8) {//6 7
return 4;
} else if (sort>7 && sort<10) {//8 9
return 5;
} else if (sort>9 && sort<12) {//10 11
return 6;
} else if (sort>11 && sort<14) {//12 13
return 7;
} else if (sort>13 && sort<16) {//14 15
return 8;
} else if (sort>15 && sort<18) {//16 17
return 9;
} else if (sort>17 && sort<20) {//18 19
return 10;
} else if (sort>19 && sort<22) {//20 21
return 11;
} else if (sort>21 && sort<24) {//22 23
return 12;
}
return 0;
}
/**
* 特例,特殊的年分的节气偏移量,由于公式并不完善，所以算出的个别节气的第几天数并不准确，在此返回其偏移量
*
* @param year 年份
* @param n 节气编号
* @return 返回其偏移量
*/
private int specialYearOffset(int year, int n) {
int offset = 0;
offset += getOffset(DECREASE_OFFSETMAP, year, n, -1);
offset += getOffset(INCREASE_OFFSETMAP, year, n, 1);
return offset;
}
/**
* 节气偏移量计算
*
* @param map
* @param year
* @param n
* @param offset
* @return
*/
private int getOffset(Map<Integer, Integer[]> map, int year, int n, int offset) {
int off = 0;
Integer[] years = map.get(n);
if (null != years) {
for (int i : years) {
if (i == year) {
off = offset;
break;
}
}
}
return off;
}
}
//周几的节日-母亲节
@Service("weekFestivalFactory")
@Slf4j
public class WeekFestivalFactoryImpl implements FestivalFactory {
@Autowired
private FestivalTimeDao festivalTimeDao;
@Autowired
private FestivalDao festivalDao;
@DubboReference
TemplateService templateService;
@Override
public boolean createFestival(FestivalDto festivalDto) {
//创建50年的节日
WeekFestivalDto weekFestivalDto = (WeekFestivalDto) festivalDto;
FestivalDo festivalDo = new FestivalDo();
festivalDo = DomainConvertUtils.festivalConvertDo(weekFestivalDto,festivalDo);
festivalDo.setMonthNum(weekFestivalDto.getMonthNum());
festivalDo.setWeekCount(weekFestivalDto.getWeekCount());
festivalDo.setWeekNum(weekFestivalDto.getWeekNum());
festivalDao.insertSelective(festivalDo);
FestivalDo fDo = festivalDao.selectByName(weekFestivalDto.getName());
if (Objects.isNull(fDo)) {
return false;
}
log.info("[WeekFestivalFactoryImpl]fDo:{}",fDo);
List<FestivalTimeDo> festivalTimeDos = Lists.newArrayList();
//获取当前年
Calendar rightNow = Calendar.getInstance();
int year = rightNow.get(Calendar.YEAR);// 获取当前年份
for (int i = 0; i < 50; i++) {
Date date = getSundayFestival(year + i, weekFestivalDto.getMonthNum(), weekFestivalDto.getWeekCount(), weekFestivalDto.getWeekNum());
if (date == null) {
break;
}
FestivalTimeDo festivalTimeDo = new FestivalTimeDo();
festivalTimeDo.setTime(date);
festivalTimeDo.setFestivalId(fDo.getId());
festivalTimeDo.setStatus(1);
festivalTimeDos.add(festivalTimeDo);
}
log.info("[WeekFestivalFactoryImpl]festivalTimeDos:{}", JSON.toJSONString(festivalTimeDos));
if (CollectionUtils.isNotEmpty(festivalTimeDos)) {
festivalTimeDao.batchInsert(festivalTimeDos);
}
return true;
}
/**
* 周日的节日
*
* @param year
* @param month
* @param weekCount 第几个周
* @param weekNum 周几
*/
private Date getSundayFestival(int year, int month, int weekCount, int weekNum) {
//获取当前年的第一天
String dateStr = year + "-" + month + "-" + 01;
Date date = null;
try {
date = DateUtils.parseDate(dateStr, "yyyy-MM-dd");
} catch (Exception e) {
return null;
}
Calendar cal = Calendar.getInstance();
cal.setTime(date);
int dayCount = cal.getActualMaximum(Calendar.DAY_OF_MONTH);
cal.set(Calendar.YEAR, year);
cal.set(Calendar.MONTH, month - 1);
int sundays = 0;
int mondays = 0;
int tuesdays = 0;
int wednesdays = 0;
int thursdays = 0;
int fridays = 0;
int saturdays = 0;
for (int i = 1; i <= dayCount; i++) {
cal.set(Calendar.DATE, i);
switch (weekNum) {
case 7://周日
if (cal.get(Calendar.DAY_OF_WEEK) == Calendar.SUNDAY) {
sundays++;
if (sundays == weekCount) {
String fDateStr = year + "-" + month + "-" + i;
try {
Date fDate = DateUtils.parseDate(fDateStr, "yyyy-MM-dd");
return fDate;
} catch (Exception e) {
return null;
}
}
}
break;
case 1://周一
if (cal.get(Calendar.DAY_OF_WEEK) == Calendar.MONDAY) {
mondays++;
if (mondays == weekCount) {
String fDateStr = year + "-" + month + "-" + i;
try {
Date fDate = DateUtils.parseDate(fDateStr, "yyyy-MM-dd");
return fDate;
} catch (Exception e) {
return null;
}
}
}
break;
case 2://周二
if (cal.get(Calendar.DAY_OF_WEEK) == Calendar.TUESDAY) {
tuesdays++;
if (tuesdays == weekCount) {
String fDateStr = year + "-" + month + "-" + i;
try {
Date fDate = DateUtils.parseDate(fDateStr, "yyyy-MM-dd");
return fDate;
} catch (Exception e) {
return null;
}
}
}
break;
case 3://周三
if (cal.get(Calendar.DAY_OF_WEEK) == Calendar.WEDNESDAY) {
wednesdays++;
if (wednesdays == weekCount) {
String fDateStr = year + "-" + month + "-" + i;
try {
Date fDate = DateUtils.parseDate(fDateStr, "yyyy-MM-dd");
return fDate;
} catch (Exception e) {
return null;
}
}
}
break;
case 4://周四
if (cal.get(Calendar.DAY_OF_WEEK) == Calendar.THURSDAY) {
thursdays++;
if (thursdays == weekCount) {
String fDateStr = year + "-" + month + "-" + i;
try {
Date fDate = DateUtils.parseDate(fDateStr, "yyyy-MM-dd");
return fDate;
} catch (Exception e) {
return null;
}
}
}
break;
case 5://周五
if (cal.get(Calendar.DAY_OF_WEEK) == Calendar.FRIDAY) {
fridays++;
if (fridays == weekCount) {
String fDateStr = year + "-" + month + "-" + i;
try {
Date fDate = DateUtils.parseDate(fDateStr, "yyyy-MM-dd");
return fDate;
} catch (Exception e) {
return null;
}
}
}
break;
case 6://周六
if (cal.get(Calendar.DAY_OF_WEEK) == Calendar.SATURDAY) {
saturdays++;
if (saturdays == weekCount) {
String fDateStr = year + "-" + month + "-" + i;
try {
Date fDate = DateUtils.parseDate(fDateStr, "yyyy-MM-dd");
return fDate;
} catch (Exception e) {
return null;
}
}
}
break;
default:
break;
}
}
return null;
}
}
//最后一周周几的节日
@Service
@Slf4j
public class LastWeekFestivalFactoryImpl implements FestivalFactory {
@Autowired
private FestivalDao festivalDao;
@Autowired
private FestivalTimeDao festivalTimeDao;
@Override
public boolean createFestival(FestivalDto festivalDto) {
//创建近3年的节日
LastWeekFestivalDto lastWeekDto = (LastWeekFestivalDto)festivalDto;
FestivalDo festivalDo = new FestivalDo();
festivalDo = DomainConvertUtils.festivalConvertDo(lastWeekDto,festivalDo);
festivalDo.setMonthNum(lastWeekDto.getMonthNum());
festivalDo.setWeekNum(lastWeekDto.getWeekNum());
festivalDao.insertSelective(festivalDo);
FestivalDo fDo = festivalDao.selectByName(lastWeekDto.getName());
if (Objects.isNull(fDo)) {
return false;
}
List<FestivalTimeDo> festivalTimeDos = Lists.newArrayList();
//获取当前年
Calendar rightNow = Calendar.getInstance();
int year = rightNow.get(Calendar.YEAR);// 获取当前年份
for (int i=0;i<50;i++) {
Date result = getSundayFestival(year + i, lastWeekDto.getMonthNum() - 1, lastWeekDto.getWeekNum());
if (result == null) {
break;
}
FestivalTimeDo festivalTimeDo = new FestivalTimeDo();
festivalTimeDo.setFestivalId(fDo.getId());
festivalTimeDo.setStatus(1);
festivalTimeDo.setTime(result);
festivalTimeDos.add(festivalTimeDo);
}
log.info("[LastWeekFestivalFactoryImpl]festivalTimeDos:{}", JSON.toJSONString(festivalTimeDos));
if (CollectionUtils.isNotEmpty(festivalTimeDos)) {
festivalTimeDao.batchInsert(festivalTimeDos);
}
return true;
}
/**
* 最后一周周几的节日
* @param year
* @param month
* @param weekNum 周几
*/
private Date getSundayFestival(int year, int month, int weekNum) {
//获取当前年的第一天
String dateStr = year+"-"+month+"-"+01;
Date date = null;
Date result = null;
try {
date = DateUtils.parseDate(dateStr, "yyyy-MM-dd");
} catch (Exception e) {
return date;
}
Calendar d = Calendar.getInstance();
d.setTime(date);
d.set(d.MONTH, month);
switch (weekNum) {
case 7://周日
d.set(d.DAY_OF_WEEK, d.SUNDAY);
d.set(d.WEEK_OF_MONTH, d.getActualMaximum(d.WEEK_OF_MONTH));
while (d.get(d.MONTH) > month || d.get(d.MONTH) < month) {
d.add(d.WEEK_OF_MONTH, -1);
}
result = d.getTime();
break;
case 1://周一
d.set(d.DAY_OF_WEEK, d.MONDAY);
d.set(d.WEEK_OF_MONTH, d.getActualMaximum(d.WEEK_OF_MONTH));
while (d.get(d.MONTH) > month || d.get(d.MONTH) < month) {
d.add(d.WEEK_OF_MONTH, -1);
}
result = d.getTime();
break;
case 2://周二
d.set(d.DAY_OF_WEEK, d.TUESDAY);
d.set(d.WEEK_OF_MONTH, d.getActualMaximum(d.WEEK_OF_MONTH));
while (d.get(d.MONTH) > month || d.get(d.MONTH) < month) {
d.add(d.WEEK_OF_MONTH, -1);
}
result = d.getTime();
break;
case 3://周三
d.set(d.DAY_OF_WEEK, d.WEDNESDAY);
d.set(d.WEEK_OF_MONTH, d.getActualMaximum(d.WEEK_OF_MONTH));
while (d.get(d.MONTH) > month || d.get(d.MONTH) < month) {
d.add(d.WEEK_OF_MONTH, -1);
}
result = d.getTime();
break;
case 4://周四
d.set(d.DAY_OF_WEEK, d.THURSDAY);
d.set(d.WEEK_OF_MONTH, d.getActualMaximum(d.WEEK_OF_MONTH));
while (d.get(d.MONTH) > month || d.get(d.MONTH) < month) {
d.add(d.WEEK_OF_MONTH, -1);
}
result = d.getTime();
break;
case 5://周五
d.set(d.DAY_OF_WEEK, d.FRIDAY);
d.set(d.WEEK_OF_MONTH, d.getActualMaximum(d.WEEK_OF_MONTH));
while (d.get(d.MONTH) > month || d.get(d.MONTH) < month) {
d.add(d.WEEK_OF_MONTH, -1);
}
result = d.getTime();
break;
case 6://周六
d.set(d.DAY_OF_WEEK, d.SATURDAY);
d.set(d.WEEK_OF_MONTH, d.getActualMaximum(d.WEEK_OF_MONTH));
while (d.get(d.MONTH) > month || d.get(d.MONTH) < month) {
d.add(d.WEEK_OF_MONTH, -1);
}
result = d.getTime();
break;
default:
break;
}
return result;
}
}
最终效果
有问题私信。。。。。
446
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
