工具类，Java转换

import com.tax.cloud.core.exception.DateException;
import com.tax.cloud.core.model.DateModel;
import com.tax.cloud.core.model.Rest;
import com.tax.cloud.core.util.StringUtils;
import java.math.BigDecimal;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;

public class DateUtils {
    public static final String YYYY_MM_DD = "yyyy-MM-dd";
    public static final String YYYY_MM_DD_SLASH = "yyyy/MM/dd";
    public static final String YYYY_MM_DD_HH_MM_DD_SLASH = "yyyy/MM/dd HH:mm:ss";
    public static final String YYYY_MM_DD_HH_MM_SS = "yyyy-MM-dd HH:mm:ss";
    public static final String YYYYMMDD = "yyyyMMdd";
    public static final String YYYYMMDDHHMMSS = "yyyyMMddHHmmss";
    private static final String[] WEEK_DAYS = new String[]{"星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六"};

    public DateUtils() {
    }

    public static String DateToStringFormat(Date date, String format) {
        if(StringUtils.isNull(date)) {
            return null;
        } else {
            SimpleDateFormat sdf = new SimpleDateFormat(format);
            return sdf.format(date);
        }
    }

    public static Date StringToDateFormat(String date, String format) {
        if(StringUtils.isNull(date)) {
            return null;
        } else {
            Date d = null;

            try {
                SimpleDateFormat e = new SimpleDateFormat(format);
                d = e.parse(date);
            } catch (ParseException var4) {
                var4.printStackTrace();
            }

            return d;
        }
    }

    public static String getYYmm() {
        String year = DateToStringFormat(getSystemDate(), "yyyy");
        String month = DateToStringFormat(getSystemDate(), "MM");
        return StringUtils.concat("", new String[]{StringUtils.substring(year, year.length() - 2), month});
    }

    public static Date getSystemDate() {
        return new Date();
    }

    public static long getSystemDateDifference(Date date) {
        if(StringUtils.isNull(date)) {
            return 0L;
        } else {
            Date systemDate = getSystemDate();
            long days = (systemDate.getTime() - date.getTime()) / 86400000L;
            return days;
        }
    }

    public static long getDifference(Date startDate, Date endDate) throws DateException {
        if(endDate.compareTo(startDate) == -1) {
            throw new DateException("开始时间不能小于结束时间");
        } else {
            BigDecimal days = (new BigDecimal(endDate.getTime() - startDate.getTime())).divide(new BigDecimal(86400000), 0, 4);
            System.out.println(days);
            return days.longValue();
        }
    }

    public static String getWeek(Date date) {
        if(StringUtils.isNull(date)) {
            return null;
        } else {
            Calendar cal = Calendar.getInstance();
            cal.setTime(date);
            int w = cal.get(7) - 1;
            return WEEK_DAYS[w];
        }
    }

    public static Date getEndDate(Date startDate, int days) {
        Calendar cal = Calendar.getInstance();
        cal.setTime(startDate);
        cal.add(5, days);
        return cal.getTime();
    }

    public static String timePass(Date date, int level) {
        if(date == null) {
            return null;
        } else {
            String result = null;
            String res = DateToStringFormat(date, "yyyy-MM-dd");
            if(level == 0) {
                return res;
            } else {
                long time = 0L;
                time = System.currentTimeMillis() - date.getTime();
                if(time <= 0L) {
                    return "刚才";
                } else {
                    if(time < 60000L) {
                        result = time / 1000L + "秒前";
                        if(level < 1) {
                            return res;
                        }
                    } else if(time < 3600000L) {
                        result = time / 1000L / 60L + "分钟前";
                        if(level < 2) {
                            return res;
                        }
                    } else if(time < 86400000L) {
                        result = time / 1000L / 60L / 60L + "小时前";
                        if(level < 3) {
                            return res;
                        }
                    } else if(time < 1296000000L) {
                        result = time / 1000L / 60L / 60L / 24L + "天前";
                        if(level < 3) {
                            return res;
                        }
                    } else {
                        result = res;
                    }

                    return result;
                }
            }
        }
    }

    public static BigDecimal calculationDays(Rest rest, Date startTime, Date endTime, DateUtils.RestType restType) throws DateException {
        BigDecimal total = new BigDecimal(0);
        if(StringUtils.isEquals(DateUtils.RestType.LEAVE.getType(), restType.getType())) {
            DateModel startModel = getRestDate(rest, startTime);
            DateModel endModel = getRestDate(rest, endTime);
            Calendar calendar = Calendar.getInstance();
            if(startTime.compareTo(startModel.getEndMorningTime()) >= 0 && startTime.compareTo(startModel.getStartAfternoonTime()) <= 0) {
                startTime = startModel.getStartAfternoonTime();
            }

            if(endTime.compareTo(endModel.getEndMorningTime()) >= 0 && endTime.compareTo(endModel.getStartAfternoonTime()) <= 0) {
                endTime = endModel.getEndMorningTime();
            }

            if(startTime.compareTo(startModel.getStartMorningTime()) == -1) {
                startTime = startModel.getStartMorningTime();
            }

            if(startTime.compareTo(startModel.getEndAfternoonTime()) == 1) {
                calendar.setTime(startModel.getStartMorningTime());
                calendar.add(5, 1);
                startTime = calendar.getTime();
            }

            if(endTime.compareTo(endModel.getEndAfternoonTime()) == 1) {
                endTime = endModel.getEndAfternoonTime();
            }

            if(endTime.compareTo(endModel.getStartMorningTime()) == -1) {
                calendar.setTime(endModel.getEndAfternoonTime());
                calendar.add(5, -1);
                endTime = calendar.getTime();
            }

            long days = getDifference(startTime, endTime);
            total = BigDecimal.valueOf(endTime.getTime() - startTime.getTime()).divide(BigDecimal.valueOf(3600000L), 1, 1);
            total = total.subtract((new BigDecimal(24)).subtract(rest.getWorkHour()).multiply(new BigDecimal(days)));
            startModel = getRestDate(rest, startTime);
            endModel = getRestDate(rest, endTime);
            if(startTime.compareTo(startModel.getEndMorningTime()) == -1 && endTime.compareTo(endModel.getStartAfternoonTime()) == 1) {
                total = total.subtract(rest.getNoonHour());
            }
        } else if(StringUtils.isEquals(DateUtils.RestType.OVERTIME.getType(), restType.getType())) {
            if(endTime.compareTo(startTime) == -1) {
                throw new DateException("开始时间不能小于结束时间");
            }

            total = BigDecimal.valueOf(endTime.getTime() - startTime.getTime()).divide(BigDecimal.valueOf(3600000L), 1, 1);
        }

        return total;
    }

    public static void main(String[] args) {
        Rest rest = new Rest("08:30", "11:30", "13:00", "17:30");

        try {
            BigDecimal e = calculationDays(rest, StringToDateFormat("2017-11-13 08:30:00", "yyyy-MM-dd HH:mm:ss"), StringToDateFormat("2017-11-13 17:30:00", "yyyy-MM-dd HH:mm:ss"), DateUtils.RestType.LEAVE);
            System.out.println(e);
        } catch (DateException var3) {
            var3.printStackTrace();
        }

    }

    private static DateModel getRestDate(Rest rest, Date date) {
        Date startMorningTime = StringToDateFormat(DateToStringFormat(date, "yyyy-MM-dd") + " " + rest.getStartMorningTime() + ":00", "yyyy-MM-dd HH:mm:ss");
        Date endMorningTime = StringToDateFormat(DateToStringFormat(date, "yyyy-MM-dd") + " " + rest.getEndMorningTime() + ":00", "yyyy-MM-dd HH:mm:ss");
        Date startAfternoonTime = StringToDateFormat(DateToStringFormat(date, "yyyy-MM-dd") + " " + rest.getStartAfternoonTime() + ":00", "yyyy-MM-dd HH:mm:ss");
        Date endAfternoonTime = StringToDateFormat(DateToStringFormat(date, "yyyy-MM-dd") + " " + rest.getEndAfternoonTime() + ":00", "yyyy-MM-dd HH:mm:ss");
        return new DateModel(startMorningTime, endMorningTime, startAfternoonTime, endAfternoonTime);
    }

    public static enum RestType {
        LEAVE("0"),
        OVERTIME("1");

        private String type;

        private RestType() {
        }

        private RestType(String type) {
            this.type = type;
        }

        public String getType() {
            return this.type;
        }

        public void setType(String type) {
            this.type = type;
        }
    }

public class DateException extends Exception {
    private static final long serialVersionUID = 5004274153680922246L;

    public DateException(String msg) {
        super(msg);
    }

    public DateException() {
    }
}

import java.util.Date;

public class DateModel {
    private Date startMorningTime;
    private Date endMorningTime;
    private Date startAfternoonTime;
    private Date endAfternoonTime;

    DateModel() {
    }

    public DateModel(Date startMorningTime, Date endMorningTime, Date startAfternoonTime, Date endAfternoonTime) {
        this.startMorningTime = startMorningTime;
        this.endMorningTime = endMorningTime;
        this.startAfternoonTime = startAfternoonTime;
        this.endAfternoonTime = endAfternoonTime;
    }

    public Date getStartMorningTime() {
        return this.startMorningTime;
    }

    public void setStartMorningTime(Date startMorningTime) {
        this.startMorningTime = startMorningTime;
    }

    public Date getEndMorningTime() {
        return this.endMorningTime;
    }

    public void setEndMorningTime(Date endMorningTime) {
        this.endMorningTime = endMorningTime;
    }

    public Date getStartAfternoonTime() {
        return this.startAfternoonTime;
    }

    public void setStartAfternoonTime(Date startAfternoonTime) {
        this.startAfternoonTime = startAfternoonTime;
    }

    public Date getEndAfternoonTime() {
        return this.endAfternoonTime;
    }

    public void setEndAfternoonTime(Date endAfternoonTime) {
        this.endAfternoonTime = endAfternoonTime;
    }

import java.math.BigDecimal;

public class Rest {
    private String startMorningTime;
    private String endMorningTime;
    private String startAfternoonTime;
    private String endAfternoonTime;
    private BigDecimal workHour = new BigDecimal(8);
    private BigDecimal noonHour = new BigDecimal(1);

    public Rest(String startMorningTime, String endMorningTime, String startAfternoonTime, String endAfternoonTime, BigDecimal workHour, BigDecimal noonHour) {
        this.startMorningTime = startMorningTime;
        this.endMorningTime = endMorningTime;
        this.startAfternoonTime = startAfternoonTime;
        this.endAfternoonTime = endAfternoonTime;
        this.workHour = workHour;
        this.noonHour = noonHour;
    }

    public Rest(String startMorningTime, String endMorningTime, String startAfternoonTime, String endAfternoonTime) {
        this.startMorningTime = startMorningTime;
        this.endMorningTime = endMorningTime;
        this.startAfternoonTime = startAfternoonTime;
        this.endAfternoonTime = endAfternoonTime;
    }

    Rest() {
    }

    public String getStartMorningTime() {
        return this.startMorningTime;
    }

    public void setStartMorningTime(String startMorningTime) {
        this.startMorningTime = startMorningTime;
    }

    public String getEndMorningTime() {
        return this.endMorningTime;
    }

    public void setEndMorningTime(String endMorningTime) {
        this.endMorningTime = endMorningTime;
    }

    public String getStartAfternoonTime() {
        return this.startAfternoonTime;
    }

    public void setStartAfternoonTime(String startAfternoonTime) {
        this.startAfternoonTime = startAfternoonTime;
    }

    public String getEndAfternoonTime() {
        return this.endAfternoonTime;
    }

    public void setEndAfternoonTime(String endAfternoonTime) {
        this.endAfternoonTime = endAfternoonTime;
    }

    public BigDecimal getWorkHour() {
        return this.workHour;
    }

    public void setWorkHour(BigDecimal workHour) {
        this.workHour = workHour;
    }

    public BigDecimal getNoonHour() {
        return this.noonHour;
    }

    public void setNoonHour(BigDecimal noonHour) {
        this.noonHour = noonHour;
    }
}

import com.google.gson.GsonBuilder;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

public class StringUtils {
    public StringUtils() {
    }

    public static boolean isNull(Object obj) {
        return !(obj instanceof String)?obj == null:null == obj || "".equals(obj);
    }

    public static boolean isNotNull(Object object) {
        return !isNull(object);
    }

    public static boolean isEquals(String str1, String str2) {
        return str1 == null?false:str1.equals(str2);
    }

    public static String substring(String str, int sLength) {
        return isNull(str)?null:str.substring(sLength);
    }

    public static String substring(String str, int sLength, int eLength) {
        return isNull(str)?null:str.substring(sLength, eLength);
    }

    public static String[] split(String str, String regex) {
        return isNull(str)?null:str.split(regex);
    }

    public static List<String> splitToList(String str, String regex) {
        if(isNull(str)) {
            return null;
        } else {
            ArrayList resultList = new ArrayList();
            List resultObject = arrayToList(str.split(regex));
            Iterator i$ = resultObject.iterator();

            while(i$.hasNext()) {
                Object obj = i$.next();
                resultList.add(obj.toString());
            }

            return resultList;
        }
    }

    public static List<Object> arrayToList(Object[] strArray) {
        return isNull(strArray)?null:new ArrayList(Arrays.asList(strArray));
    }

    public static String join(Object[] arrays, String regex) {
        if(isNull(arrays)) {
            return null;
        } else {
            StringBuffer str = new StringBuffer();

            for(int i = 0; i < arrays.length; ++i) {
                str = arrays.length - 1 == i?str.append(arrays[i]):str.append(arrays[i] + regex);
            }

            return str.toString();
        }
    }

    public static String concat(String regex, String... str) {
        Object[] object = new Object[str.length];

        for(int i = 0; i < str.length; ++i) {
            object[i] = str[i];
        }

        return join(object, regex);
    }

    public static <T> T stringToBena(String json, Class<T> bean) {
        return isNull(json)?null:(new GsonBuilder()).create().fromJson(json, bean);
    }

    /** @deprecated */
    @Deprecated
    public static String arrayToString(Object[] arrays, String regex) {
        String str = "";

        for(int i = 0; i < arrays.length; ++i) {
            str = str + concat(regex, new String[]{arrays[i].toString()});
        }

        return str;
    }

    public static void beanCopy(Object obj1, Object obj2) {
        Class cls1 = obj1.getClass();
        Class cls2 = obj2.getClass();
        Field[] fields1 = cls1.getDeclaredFields();
        ArrayList fieldList = new ArrayList(Arrays.asList(fields1));
        Field[] fields2;
        if(isNotNull(cls1.getSuperclass())) {
            fields2 = cls1.getSuperclass().getDeclaredFields();
            Field[] i$ = fields2;
            int field1 = fields2.length;

            for(int arr$ = 0; arr$ < field1; ++arr$) {
                Field len$ = i$[arr$];
                fieldList.add(len$);
            }
        }

        fields2 = cls2.getDeclaredFields();
        Iterator var15 = fieldList.iterator();

        while(var15.hasNext()) {
            Field var16 = (Field)var15.next();
            var16.setAccessible(true);
            Field[] var17 = fields2;
            int var18 = fields2.length;

            for(int i$1 = 0; i$1 < var18; ++i$1) {
                Field field2 = var17[i$1];
                field2.setAccessible(true);
                if(isEquals(var16.getName(), field2.getName()) && isEquals(var16.getType().getName(), field2.getType().getName())) {
                    try {
                        field2.set(obj2, var16.get(obj1));
                    } catch (IllegalAccessException var14) {
                        var14.printStackTrace();
                    }
                }
            }
        }

    }

    public static Map<String, String> transBean2Map(Object obj) {
        HashMap returnMap = new HashMap();
        Class cls = obj.getClass();
        Field[] fields = cls.getDeclaredFields();
        ArrayList fieldList = new ArrayList(Arrays.asList(fields));
        if(isNotNull(cls.getSuperclass())) {
            Field[] i$ = cls.getSuperclass().getDeclaredFields();
            Field[] field = i$;
            int e = i$.length;

            for(int i$1 = 0; i$1 < e; ++i$1) {
                Field field1 = field[i$1];
                fieldList.add(field1);
            }
        }

        Iterator var11 = fieldList.iterator();

        while(var11.hasNext()) {
            Field var12 = (Field)var11.next();
            var12.setAccessible(true);

            try {
                String var13 = var12.getType().getName();
                byte var14 = -1;
                switch(var13.hashCode()) {
                case 1195259493:
                    if(var13.equals("java.lang.String")) {
                        var14 = 0;
                    }
                default:
                    switch(var14) {
                    case 0:
                        if(isNotNull(var12.get(obj))) {
                            returnMap.put(var12.getName().toString(), var12.get(obj).toString());
                        }
                    }
                }
            } catch (IllegalAccessException var10) {
                var10.printStackTrace();
            }
        }

        return returnMap;
    }

    public static String listToString(List<String> stringList, String regex) {
        if(isNull(stringList)) {
            return null;
        } else {
            Object result = null;
            Object[] object = new Object[stringList.size()];

            for(int i = 0; i < stringList.size(); ++i) {
                object[i] = stringList.get(i);
            }

            return join(object, regex);
        }
    }