获取两个对象相同字段的不同值，并返回不同值的信息

 java通过反射获取对象的所有的字段名称和值，判断值是否相等，不相等就打印出来。

/**
 * 获取2个对象相同字段不同值
 * @param obj1
 * @param obj2
 * @return
 */
public String getDiff(Object obj1, Object obj2) {
    if(ObjectUtils.isNull(obj1) || ObjectUtils.isNull(obj2)){
        return "";
    }
    StringBuffer sb = new StringBuffer();
    try {
        //获取对象所有字段
        List fieldList1 = Arrays.stream(obj1.getClass().getDeclaredFields()).collect(Collectors.toList());
        List fieldList2 = Arrays.stream(obj2.getClass().getDeclaredFields()).collect(Collectors.toList());
        for (Field field1 : fieldList1) {
            //获取相同字段
            Field field2 = fieldList2.stream()
                    .filter(p -> p.getName().equals(field1.getName())
                            && p.getType().getName().equals(field1.getType().getName())
                    )
                    .findFirst().orElse(null);
            //存在相同字段，才比较值
            if(ObjectUtils.isNull(field2)){
                continue;
            }
            field1.setAccessible(true);
            field2.setAccessible(true);
            //得到值
            Object value1 = field1.get(obj1);
            Object value2 = field2.get(obj2);

            //转成字符比较
            String valueString1 = getStringValue(value1,field1.getType().getName());
            String valueString2 = getStringValue(value2,field2.getType().getName());
            String columnName = "";
            //值不相等
            if(!valueString1.equals(valueString2)){
                // 是否引用ApiModelProperty注解
                boolean bool = field1.isAnnotationPresent(ApiModelProperty.class);
                if (bool) {
                    columnName = field1.getAnnotation(ApiModelProperty.class).value();//获取注解值
                } else {
                    columnName = field1.getName();//没有写注解
                }
                sb.append(columnName).append(":").append(valueString1).append("(").append(valueString2).append(");");
            }
        };
    }catch (Exception e){
        LOG.info("获取2个对象相同字段不同值失败:"+e.getMessage());
    }
    return sb.toString();
}

/**
 * 获取字段的值
 * @param value
 * @param type
 * @return
 */
private String getStringValue(Object value,String type){
    String stringValue = "";
    if(ObjectUtils.isNull(value)){
        return stringValue;
    }
    if("java.util.Date".equalsIgnoreCase(type)){
        stringValue = DatetimeUtil.threadSafeFormatDate((Date) value);
    } else {
        stringValue = String.valueOf(value);
    }

    return stringValue;
}

日期工具类：

package com.hhgz.core.utils;

import org.apache.commons.lang3.StringUtils;

import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;

/**
 * 日期工具类
 * @author 
 *
 */
@SuppressWarnings("unused")
public class DatetimeUtil {

    /**
     * 不允许被创建
     */
    private DatetimeUtil() {
        throw new IllegalStateException("Utility class");
    }

    private static final String DEFAULT_FORMAT1 = "yyyy-MM-dd HH:mm:ss";
    // 默认时间格式1 年-月-日 时:分:秒
    private static final String DEFAULT_FORMAT2 = "yyyy-MM-dd";
    // 默认时间格式2 年-月-日

    private static final String DEFAULT_FORMAT3 = "HH:mm:ss";
    // 默认时间格式3 时:分:秒
    public static final long DAY_TIME_MILLIS = 24 * 60 * 60 * 1000;

    // 工作台报表时间格式1 月.日 举例：8.1
    private static final String REPORT_CHECKING_DEFAULT_FORMAT2 = "MM.dd";

    //小程序打卡时间
    private static final SimpleDateFormat wechatPunchTime = new SimpleDateFormat("HH:mm");

    /**
     * 默认的格式
     */
    private static final SimpleDateFormat simpleDateFormat = new SimpleDateFormat(DEFAULT_FORMAT1);

    private static final SimpleDateFormat simpleDateFormat2 = new SimpleDateFormat(DEFAULT_FORMAT2);

    private static final SimpleDateFormat reportCheckDateFormat = new SimpleDateFormat(REPORT_CHECKING_DEFAULT_FORMAT2);

    /**
     * 设备时间
     */
    private static final SimpleDateFormat timeLogSimpleDateFormat = new SimpleDateFormat("yyyy-MM-dd-'T'HH:mm:ss'Z'");

    // 一天的毫秒数
    /**
     * 获得当前时间的字符串
     *
     * @param format 格式化字符串，如"yyyy-MM-dd HH:mm:ss"
     * @return String类型的当前日期时间
     */
    public static String getCurrentDatetime(String format) {
        String currentDateTime = null;
        if (null == format || "".equals(format)) {
            return null;
        }
        try {
            SimpleDateFormat simpleDateFormat = new SimpleDateFormat(format);
            Calendar calendar = new GregorianCalendar();
            currentDateTime = simpleDateFormat.format(calendar.getTime());
        } catch (Exception e) {
            e.printStackTrace();
        }
        return currentDateTime;
    }

    /**
     * 得到当前时间的格式化时间
     *
     * @return 年-月-日 时:分:秒 格式的当前时间
     */
    public static String getCurrentDatetime() {
        return getCurrentDatetime(DEFAULT_FORMAT1);
    }

    /**
     * 获得指定时间的date格式
     *
     * @param date   指定时间Date类型
     * @param format 格式化字符串
     * @return 格式化完后的时间
     */
    public static String getDate(Date date, String format) {
        String currentDate = null;
        try {
            SimpleDateFormat formatter = new SimpleDateFormat(format);
            currentDate = formatter.format(date);
        } catch (Exception e) {
            e.printStackTrace();
        }

        return currentDate;

    }

    /**
     * 获得指定毫秒数，指定格式的格式化时间
     *
     * @param time   毫秒数
     * @param format 格式化字符串
     * @return 格式化后的时间
     */
    public static String getDate(long time, String format) {
        Date date = new Date(time);
        return getDate(date, format);
    }

    /**
     * 获得指定Date类型的格式化时间(yyyy-MM-dd)
     *
     * @param date 时间Date
     * @return 格式化后的时间
     */
    public static String getDate(Date date) {
        if(date == null){
            return "";
        }
        return getDate(date, DEFAULT_FORMAT2);
    }

    /**
     * 字符(yyyy-MM-dd)日期转为Date类型
     * @param date
     * @return
     */
    public static Date string2Date(String date){
        if(StringUtils.isEmpty(date)){
            return null;
        }
        try{
            return simpleDateFormat.parse(date);
        } catch (Exception e){
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 字符(yyyy-MM-dd)日期转为Date类型
     * @param date
     * @return
     */
    public static Date string2Datetime(String date){
        if(StringUtils.isEmpty(date)){
            return null;
        }
        try{
            return simpleDateFormat2.parse(date);
        } catch (Exception e){
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 获得指定毫秒数的格式化时间
     *
     * @param time 毫秒数
     * @return 格式化后的时间
     */
    public static String getDate(long time) {
        return getDate(time, DEFAULT_FORMAT2);
    }

    /**
     * 获得当前时间指定格式化字符串的格式化时间
     *
     * @param format 格式化字符串
     * @return 格式化后的时间
     */
    public static String getCurrentDate(String format) {
        return getDate(System.currentTimeMillis(), format);
    }

    /**
     * 获得当前时间的格式化时间
     *
     * @return 格式化后的时间
     */
    public static String getCurrentDate() {
        return getDate(System.currentTimeMillis(), DEFAULT_FORMAT2);
    }

    /**
     * 获取当前时间
     * @return
     */
    public static String getDatetime() {
        return getDatetime(new Date());
    }

    /**
     * 获得指定Date类型的毫秒数
     *
     * @param date 指定的Date
     * @return 指定Date类型的毫秒数
     */
    public static long getTimeMillis(Date date) {
        return date.getTime();
    }

    /**
     * 获得当前时间的毫秒数
     *
     * @return 当前时间的毫秒数
     */
    public static long getCurrentDayTimeMillis() {
        return System.currentTimeMillis();
    }

    /**
     * 得到当前时间后一天的TimeMillis
     *
     * @return 当前时间后一天的TimeMillis
     */
    public static long getNextDayTimeMillis() {
        return getCurrentDayTimeMillis() + DAY_TIME_MILLIS;
    }

    /**
     * 得到当前时间前一天的TimeMillis
     *
     * @return 当前时间前一天的TimeMillis
     */
    public static long getPreDayTimeMillis() {
        return getCurrentDayTimeMillis() - DAY_TIME_MILLIS;
    }

    /**
     * 根据输入的String 例如 2013-03-07， 返回周四
     *
     * @param strDate
     * @return
     */
    public static String getDayOfweek(String strDate) {
        Calendar calendar = Calendar.getInstance();
        if (strDate == null) {
            return null;
        }

        String[] dateSlipt = strDate.split("-");
        if (dateSlipt.length != 3 | dateSlipt.length == 0) {
            return null;
        }

        calendar.set(Calendar.YEAR, Integer.valueOf(dateSlipt[0]));
        calendar.set(Calendar.MONTH, Integer.valueOf(dateSlipt[1]) - 1);
        calendar.set(Calendar.DAY_OF_MONTH, Integer.valueOf(dateSlipt[2]));

        int dayOfWeek = calendar.get(Calendar.DAY_OF_WEEK);

        return getSimpleDateOfWeek(dayOfWeek);

    }

    /**
     * 根据输入的i,i 为 calendar的星期索引,返回星期几
     *
     * @param i calendar的星期索引
     * @return 星期几
     */

    public static String getDateOfWeek(int i) {
        String date = null;
        switch (i) {
            case Calendar.SUNDAY:
                date = "星期日";
                break;
            case Calendar.MONDAY:
                date = "星期一";
                break;
            case Calendar.TUESDAY:
                date = "星期二";
                break;
            case Calendar.WEDNESDAY:
                date = "星期三";
                break;
            case Calendar.THURSDAY:
                date = "星期四";
                break;
            case Calendar.FRIDAY:
                date = "星期五";
                break;
            case Calendar.SATURDAY:
                date = "星期六";
                break;
            default:
                break;
        }
        return date;
    }

    /**
     * 根据输入的i,i 为 calendar的星期索引,返回星期几
     *
     * @param i calendar的星期索引
     * @return 周几
     */
    public static String getSimpleDateOfWeek(int i) {
        String date = null;
        switch (i) {
            case Calendar.SUNDAY:
                date = "周日";
                break;
            case Calendar.MONDAY:
                date = "周一";
                break;
            case Calendar.TUESDAY:
                date = "周二";
                break;
            case Calendar.WEDNESDAY:
                date = "周三";
                break;
            case Calendar.THURSDAY:
                date = "周四";
                break;
            case Calendar.FRIDAY:
                date = "周五";
                break;
            case Calendar.SATURDAY:
                date = "周六";
                break;
            default:
                break;
        }
        return date;
    }

    /**
     * 将格式化过的时间串转换成毫秒
     *
     * @param day    将格式化过的时间
     * @param format 格式化字符串
     * @return 毫秒
     */
    public static long convertMillisecond(String day, String format) {
        if (day == null || format == null)
            return 0;
        SimpleDateFormat formatter = new SimpleDateFormat(format);
        try {
            Date dt = formatter.parse(day);
            return dt.getTime();
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return 0;
    }

    /**
     * 得到两个日期的天数
     *
     * @param beginDate
     * @param endDate
     * @return 天数
     */
    public static int getDateInterval(String beginDate, String endDate) {
        Date date1 = null;
        Date date2 = null;
        long betweenDays = 0;

        try {
            date1 = new SimpleDateFormat("yyyy-MM-dd").parse(beginDate);
            date2 = new SimpleDateFormat("yyyy-MM-dd").parse(endDate);

            long beginTime = date1.getTime();
            long endTime = date2.getTime();
            betweenDays = (long) ((endTime - beginTime) / (1000 * 60 * 60 * 24));

        } catch (ParseException e) {
            e.printStackTrace();
        }

        return (int) betweenDays;
    }

    /**
     * 得到两个日期的天数
     *
     * @param beginDate
     * @param endDate
     * @return 天数
     */
    public static int getDateInterval(Date beginDate, Date endDate) {
        long betweenDays = 0;

        long beginTime = beginDate.getTime();
        long endTime = endDate.getTime();
        betweenDays = (endTime - beginTime) / (1000 * 60 * 60 * 24);

        return (int) betweenDays;
    }

    /**
     * 得到两个日期的小时数
     *
     * @param beginDate
     * @param endDate
     * @return 天数
     */
    public static int getHourInterval(Date beginDate, Date endDate) {
        long betweenHours = 0;

        long beginTime = beginDate.getTime();
        long endTime = endDate.getTime();
        betweenHours = (endTime - beginTime) / (1000 * 60 * 60);

        return (int) betweenHours;
    }

    /**
     * 得到两个日期的小时数
     *
     * @param beginDate
     * @param endDate
     * @return 天数
     */
    public static int getMinuteInterval(Date beginDate, Date endDate) {
        long betweenMinutes = 0;

        long beginTime = beginDate.getTime();
        long endTime = endDate.getTime();
        betweenMinutes = (endTime - beginTime) / (1000 * 60);

        return (int) betweenMinutes;
    }

    /**
     * 时间比较
     *
     * @param format 格式化字符串
     * @param time1  时间1
     * @param time2  时间2
     * @return time1比time2早返回-1,time1与time2相同返回0,time1比time2晚返回1
     */
    public static int compareTime(String format, String time1, String time2) {
        if (format == null || time1 == null || time2 == null)
            return 0;
        SimpleDateFormat formatter = new SimpleDateFormat(format);
        Calendar c1 = Calendar.getInstance();
        Calendar c2 = Calendar.getInstance();

        try {
            c1.setTime(formatter.parse(time1));
            c2.setTime(formatter.parse(time2));
        } catch (ParseException e) {
            e.printStackTrace();
        }

        return c1.compareTo(c2);
    }

    /**
     * 标准时间格式转换成date
     * @param dateStr
     * @return
     */
    public static Date toDate(String dateStr) {
        if(StringUtils.isEmpty(dateStr)) {
            return new Date();
        }

        try {
            return simpleDateFormat.parse(dateStr);
        } catch (ParseException e) {
            // TODO Auto-generated catch block
            return new Date();
        }
    }

    /**
     * 格式化日期
     * @param datetime
     * @return
     */
    public static String getDatetime(Date datetime) {
        return ObjectUtils.isNull(datetime) ? null : simpleDateFormat.format(datetime);
    }

    /**
     * 获取当前的日期 时分秒毫秒为0
     * @return
     */
    public static Date getCurrentDateTime(){
        Calendar calendar = Calendar.getInstance();
        calendar.set(Calendar.HOUR_OF_DAY,0);
        calendar.set(Calendar.MINUTE,0);
        calendar.set(Calendar.SECOND,0);
        calendar.set(Calendar.MILLISECOND,0);
        return calendar.getTime();
    }

    /**
     * 获取星期 从0开始星期天，老外的第一天是从星期日开始的
     * @param date
     * @return
     */
    public static int getDayOfWeek(Date date){
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        return calendar.get(Calendar.DAY_OF_WEEK);
    }

    /**
     * 出勤率日期格式
     * @param date
     * @return
     */
    public static String getReportCheckingDate(Date date){
        if(date == null){
            return "";
        }
        return reportCheckDateFormat.format(date);
    }

    /**
     * 根据时间返回当天的Date对象 如：8:00 变成 2019年9月7日08:00:00
     * @param time
     * @return
     */
    public static Date getTime(String time){
        Calendar calendar = Calendar.getInstance();
        calendar.set(Calendar.SECOND,0);
        calendar.set(Calendar.MILLISECOND,0);
        try{
        String[] hourAndMinute = time.split(":");
        if(hourAndMinute.length >= 1){
            calendar.set(Calendar.HOUR_OF_DAY, Integer.parseInt(hourAndMinute[0]));
        }
        if(hourAndMinute.length >= 2){
            calendar.set(Calendar.MINUTE, Integer.parseInt(hourAndMinute[1]));
        }
        }catch (Exception e){
            e.printStackTrace();
        }
        return calendar.getTime();
    }

    /**
     * 返回小程序打卡时间
     * @param date
     * @return
     */
    public static String getWechatPunchTime(Date date){
        return wechatPunchTime.format(date);
    }

    /**
     * 计算两个时间差 返回分钟(结束时间 - 开始时间)
     * @param startTime
     * @param endTime
     * @return
     */
    public static int getDiffMinute(Date startTime, Date endTime){
        long diffMillisecond = endTime.getTime() - startTime.getTime();//相差的毫秒数
        return (int)(diffMillisecond / 1000 / 60);
    }

    /**
     * 获取设备打卡时间
     * @param timeStr
     * @return
     */
    public static Date getTimeLogTime(String timeStr){
        try {
            return timeLogSimpleDateFormat.parse(timeStr);
        } catch (ParseException e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 清空时分秒
     * @param date
     * @return
     */
    public static Date cleanHourMinuteSecond(Date date){
        if(ObjectUtils.isNull(date)){
            return null;
        }

        try {
            return simpleDateFormat2.parse(simpleDateFormat2.format(date));
        } catch (ParseException e) {
            e.printStackTrace();
            return date;
        }
    }

    /**
     * 日期格式化(线程安全)
     */
    private static ThreadLocal sdfThreadLocal =  new ThreadLocal(){
        @Override
        public SimpleDateFormat initialValue(){
            return  new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        }
    };

    /**
     * 日期转成字符串(线程安全)
     * @param date
     * @return yyyy-MM-dd HH:mm:ss
     */
    public static String threadSafeFormatDate(Date date) {
        return date == null ? "" : sdfThreadLocal.get().format(date);
    }

    /**
     * 字符串转成日期(线程安全)
     * @param strDate yyyy-MM-dd HH:mm:ss
     * @return
     */
    public static Date threadSafeParse(String strDate) throws ParseException{
        return StringUtils.isEmpty(strDate) ? null : sdfThreadLocal.get().parse(strDate);
    }

    /**
     * 结束时间默认为当天23:59:59
     * @param time
     * @return
     */
    public static Date getEndTime(Date time){
        if(ObjectUtils.isNull(time)){
            return null;
        }
        String strDate = simpleDateFormat2.format(time) + " 23:59:59";
        try{
            return threadSafeParse(strDate);
        } catch (Exception e){
            return null;
        }
    }

}