Java 在Android中计算两次之间的差异

我有两个字符串变量，比如StartTime和EndTime。我需要用StartTime减去EndTime来计算总时间

开始时间和结束时间的格式如下：

StartTime = "08:00 AM";
EndTime = "04:00 PM";

以小时和分钟为单位的总时间。如何在Android中计算此值？

请尝试下面的代码

//假设时间格式为（“hh:mm a”）格式

SimpleDateFormat simpleDateFormat = new SimpleDateFormat("hh:mm a");

date1 = simpleDateFormat.parse("08:00 AM");
date2 = simpleDateFormat.parse("04:00 PM");

long difference = date2.getTime() - date1.getTime(); 
days = (int) (difference / (1000*60*60*24));  
hours = (int) ((difference - (1000*60*60*24*days)) / (1000*60*60)); 
min = (int) (difference - (1000*60*60*24*days) - (1000*60*60*hours)) / (1000*60);
hours = (hours < 0 ? -hours : hours);
Log.i("======= Hours"," :: "+hours);

SimpleDateFormat SimpleDateFormat=新的SimpleDateFormat（“hh:mm a”）；
date1=SimpleDataFormat.parse（“上午8:00”）；
date2=SimpleDataFormat.parse（“04:00pm”）；
长差=date2.getTime（）-date1.getTime（）；
天数=（整数）（差值/（1000*60*60*24））；
小时=（整数）（（差-（1000*60*60*24*天））/（1000*60*60））；
最小值=（整数）（差值-（1000*60*60*24*天）-（1000*60*60*小时）/（1000*60）；
小时数=（小时数<0？-小时数：小时）；
Log.i（“==========Hours”，”：“+Hours）；

输出-Hours:：8

看一看，您可以使用它使用parse（String source）方法解析字符串，并且您可以轻松地操作two Dates对象以获得所需内容

DateFormat df = DateFormat.getInstance();
Date date1 = df.parse(string1);
Date date2 = df.parse(string2);
long difference = date1.getTime() - date2.getTime();

days = (int) (difference / (1000*60*60*24));  
hours = (int) ((difference - (1000*60*60*24*days)) / (1000*60*60)); 
min = (int) (difference - (1000*60*60*24*days) - (1000*60*60*hours)) / (1000*60);

String diffHours = df.format(hours);

日期差

Date myDate = new Date(difference);

要显示日期，请执行以下操作：

String diff = df.format(myDate);

请试试这个

SimpleDateFormat simpleDateFormat = new SimpleDateFormat("HH:mm");

    try {
        date1 = simpleDateFormat.parse("08:00 AM");
    } catch (ParseException e) {
        e.printStackTrace();
    }

    try {
        date2 = simpleDateFormat.parse("04:00 PM");
    } catch (ParseException e) {
        e.printStackTrace();
    }

    long difference = date2.getTime() - date1.getTime();
    int days = (int) (difference / (1000 * 60 * 60 * 24));
    int hours = (int) ((difference - (1000 * 60 * 60 * 24 * days)) / (1000 * 60 * 60));
    int min = (int) (difference - (1000 * 60 * 60 * 24 * days) - (1000 * 60 * 60 * hours))
            / (1000 * 60);
    hours = (hours < 0 ? -hours : hours);
    Log.i("======= Hours", " :: " + hours);

SimpleDateFormat SimpleDateFormat=新的SimpleDateFormat（“HH:mm”）；
试一试{
date1=SimpleDataFormat.parse（“上午8:00”）；
}捕获（解析异常）{
e、 printStackTrace（）；
}
试一试{
date2=SimpleDataFormat.parse（“04:00pm”）；
}捕获（解析异常）{
e、 printStackTrace（）；
}
长差=date2.getTime（）-date1.getTime（）；
整数天=（整数）（差额/（1000*60*60*24））；
整数小时=（整数）（（差值-（1000*60*60*24*天））/（1000*60*60））；
最小整数=（整数）（差值-（1000*60*60*24*天）-（1000*60*60*小时））
/ (1000 * 60);
小时数=（小时数<0？-小时数：小时）；
Log.i（“==========Hours”，”：“+Hours）；

注意：更正了Chirag Raval提供的以下代码，因为Chirag提供的代码在我们试图从22:00到07:00查找时间时出现了一些问题

SimpleDateFormat simpleDateFormat = new SimpleDateFormat("HH:mm");
Date startDate = simpleDateFormat.parse("22:00");
Date endDate = simpleDateFormat.parse("07:00");

long difference = endDate.getTime() - startDate.getTime(); 
if(difference<0)
{
    Date dateMax = simpleDateFormat.parse("24:00");
    Date dateMin = simpleDateFormat.parse("00:00");
    difference=(dateMax.getTime() -startDate.getTime() )+(endDate.getTime()-dateMin.getTime());
}
int days = (int) (difference / (1000*60*60*24));  
int hours = (int) ((difference - (1000*60*60*24*days)) / (1000*60*60)); 
int min = (int) (difference - (1000*60*60*24*days) - (1000*60*60*hours)) / (1000*60);
Log.i("log_tag","Hours: "+hours+", Mins: "+min); 

SimpleDateFormat SimpleDateFormat=新的SimpleDateFormat（“HH:mm”）；
Date startDate=simpleDateFormat.parse（“22:00”）；
Date endDate=simpleDateFormat.parse（“07:00”）；
长差=endDate.getTime（）-startDate.getTime（）；
如果（差异
String mStrDifferenceTime=comparetwortimempm（“11:06 PM”，“05:07 AM”）；
Log.e（“应用程序时间”，mStrDifferenceTime+“分钟”）；
公共静态字符串getCurrentDateUsingCalendar（）{
Date mDate=new Date（）；//获取日期
@SuppressLint（“SimpleDateFormat”）SimpleDateFormat mSimpleDateFormat=新SimpleDateFormat（“dd MM yyyy”）；//获取此格式的日期
返回mSimpleDateFormat.format（mDate.getTime（））；
}
公共静态字符串getNextDateUsingCalendar（）{
Calendar mCalendar=Calendar.getInstance（）；
mCalendar.add（日历年的第1天）；
Date mstrtomory=mCalendar.getTime（）；
@SuppressLint（“SimpleDataFormat”）DateFormat mDateFormat=新的SimpleDataFormat（“dd-MM-yyyy”）；
返回mDateFormat.format（mstr）；
}
公共静态字符串CompareTowitMeamPM（字符串mStrStartTime、字符串mStrEndTime）{
字符串mStrCompareStartTime[]=mStrStartTime.split（“”）；
字符串mStrCompareEndTime[]=mStrEndTime.split（“”）；
int-mistartime=Integer.parseInt（mStrCompareStartTime[0]。替换（“：”，”）；
int mIEndTime=Integer.parseInt（mStrCompareEndTime[0]。替换（“：”，”）；
字符串mStrToday=“”；
字符串MSTRMOTORY=“”；
if（mIStartTimemIEndTime&&mStrCompareStartTime[1]。等于（“PM”）&&mStrCompareEndTime[1]。等于（“PM”））{
字符串mStrTime12[]=mStrCompareStartTime[0]。拆分（“：”；
if（mStrTime12[0]。等于（“12”））{
mStrToday=getNextDateUsingCalendar（）；
mstrtomory=getNextDateUsingCalendar（）；
}否则{
mStrToday=getCurrentDateUsingCalendar（）；
mstrtomory=getNextDateUsingCalendar（）；
}
}否则如果（mIStartTime>mIEndTime&&mStrCompareStartTime[1]。等于（“AM”）&&mStrCompareEndTime[1]。等于（“AM”））{
字符串mStrTime12[]=mStrCompareStartTime[0]。拆分（“：”；
if（mStrTime12[0]。等于（“12”））{
mStrToday=getNextDateUsingCalendar（）；
mstrtomory=getNextDateUsingCalendar（）；
}否则{
mStrToday=getCurrentDateUsingCalendar（）；
mstrtomory=getNextDateUsingCalendar（）；
}
}else if（mStrCompareStartTime[1].equals（“PM”）和&mStrCompareEndTime[1].equals（“AM”））{
mStrToday=getCurrentDateUsingCalendar（）；
mstrtomory=getNextDateUsingCalendar（）；
}else if（mStrCompareStartTime[1].equals（“AM”）和&mStrCompareEndTime[1].equals（“PM”））{
mStrToday=getCurrentDateUsingCalendar（）；
mstrtomory=getCurrentDateUsingCalendar（）；
}
@SuppressLint（“SimpleDataFormat”）SimpleDataFormat SimpleDataFormat=新的SimpleDataFormat（“dd-MM-yyyy-hh:MM-aa”）；
字符串mStrDifference=“”；
试一试{
Date date1=simpleDateFormat.parse（mStrToday+“”+mStrStartTime）；
Date date2=simpleDateFormat.parse（MSTRMOTORY+“”+mStrEndTime）；
mStrDifference=不同的日期和时间（日期1、日期2）；
}捕获（解析异常）{
e、 printStackTrace（）；
}
返回mStrDifference；
}
公共静态字符串DifferenceDate和Time（日期mDateStart、日期MDATEND）{
long different=mDateEnd.getTime（）-mDateStart.getTime（）；
长二次罪
Try simple piece of code using For 24 hour time
StartTime = "10:00";
EndTime = "13:00";
here starthour=10 and end hour=13 
if(TextUtils.isEmpty(txtDate.getText().toString())||TextUtils.isEmpty(txtDate1.getText().toString())||TextUtils.isEmpty(txtTime.getText().toString())||TextUtils.isEmpty(txtTime1.getText().toString()))
    {
        Toast.makeText(getApplicationContext(), "Date/Time fields cannot be blank", Toast.LENGTH_SHORT).show();
    }
    else {
        if (starthour > endhour) {
            Toast.makeText(getApplicationContext(), "Start Time Should Be Less Than End Time", Toast.LENGTH_SHORT).show();
        } else if (starthour == endhour) {
            if (startmin > endmin) {
                Toast.makeText(getApplicationContext(), "Start Time Should Be Less Than End Time", Toast.LENGTH_SHORT).show();
            }
            else{
                tvalid = "True";
            }
        } else {
            // Toast.makeText(getApplicationContext(),"Sucess"+(endhour-starthour)+(endmin-startmin),Toast.LENGTH_SHORT).show();
            tvalid = "True";
        }
    }
same for date also

String mStrDifferenceTime =compareTwoTimeAMPM("11:06 PM","05:07 AM");
Log.e("App---Time ", mStrDifferenceTime+" Minutes");

public static String getCurrentDateUsingCalendar() {
    Date mDate = new Date();  // to get the date
    @SuppressLint("SimpleDateFormat") SimpleDateFormat mSimpleDateFormat = new SimpleDateFormat("dd-MM-yyyy"); // getting date in this format
    return mSimpleDateFormat.format(mDate.getTime());
}

public static String getNextDateUsingCalendar() {
    Calendar mCalendar = Calendar.getInstance();
    mCalendar.add(Calendar.DAY_OF_YEAR, 1);
    Date mStrTomorrow = mCalendar.getTime();
    @SuppressLint("SimpleDateFormat") DateFormat mDateFormat = new SimpleDateFormat("dd-MM-yyyy");
    return mDateFormat.format(mStrTomorrow);

}

public static String compareTwoTimeAMPM(String mStrStartTime, String mStrEndTime) {
    String mStrCompareStartTime[] = mStrStartTime.split(" ");
    String mStrCompareEndTime[] = mStrEndTime.split(" ");
    int mIStartTime = Integer.parseInt(mStrCompareStartTime[0].replace(":", ""));
    int mIEndTime = Integer.parseInt(mStrCompareEndTime[0].replace(":", ""));
    String mStrToday = "";
    String mStrTomorrow = "";
    if (mIStartTime < mIEndTime && mStrCompareStartTime[1].equals("PM") && mStrCompareEndTime[1].equals("PM")) {
        mStrToday = getCurrentDateUsingCalendar();
        mStrTomorrow = getCurrentDateUsingCalendar();
    } else if (mIStartTime < mIEndTime && mStrCompareStartTime[1].equals("AM") && mStrCompareEndTime[1].equals("AM")) {
        mStrToday = getCurrentDateUsingCalendar();
        mStrTomorrow = getCurrentDateUsingCalendar();
    } else if (mIStartTime > mIEndTime && mStrCompareStartTime[1].equals("PM") && mStrCompareEndTime[1].equals("PM")) {
        String mStrTime12[] = mStrCompareStartTime[0].split(":");
        if (mStrTime12[0].equals("12")) {
            mStrToday = getNextDateUsingCalendar();
            mStrTomorrow = getNextDateUsingCalendar();
        } else {
            mStrToday = getCurrentDateUsingCalendar();
            mStrTomorrow = getNextDateUsingCalendar();
        }
    } else if (mIStartTime > mIEndTime && mStrCompareStartTime[1].equals("AM") && mStrCompareEndTime[1].equals("AM")) {
        String mStrTime12[] = mStrCompareStartTime[0].split(":");
        if (mStrTime12[0].equals("12")) {
            mStrToday = getNextDateUsingCalendar();
            mStrTomorrow = getNextDateUsingCalendar();
        } else {
            mStrToday = getCurrentDateUsingCalendar();
            mStrTomorrow = getNextDateUsingCalendar();
        }
    } else if (mStrCompareStartTime[1].equals("PM") && mStrCompareEndTime[1].equals("AM")) {
        mStrToday = getCurrentDateUsingCalendar();
        mStrTomorrow = getNextDateUsingCalendar();
    } else if (mStrCompareStartTime[1].equals("AM") && mStrCompareEndTime[1].equals("PM")) {
        mStrToday = getCurrentDateUsingCalendar();
        mStrTomorrow = getCurrentDateUsingCalendar();
    }
    @SuppressLint("SimpleDateFormat") SimpleDateFormat simpleDateFormat = new SimpleDateFormat("dd-MM-yyyy hh:mm aa");
    String mStrDifference = "";
    try {
        Date date1 = simpleDateFormat.parse(mStrToday + " " + mStrStartTime);
        Date date2 = simpleDateFormat.parse(mStrTomorrow + " " + mStrEndTime);
        mStrDifference = differenceDatesAndTime(date1, date2);
    } catch (ParseException e) {
        e.printStackTrace();
    }

    return mStrDifference;

}


public static String differenceDatesAndTime(Date mDateStart, Date mDateEnd) {

    long different = mDateEnd.getTime() - mDateStart.getTime();
    long secondsInMilli = 1000;
    long minutesInMilli = secondsInMilli * 60;
    long hoursInMilli = minutesInMilli * 60;
    long daysInMilli = hoursInMilli * 24;

    long elapsedDays = different / daysInMilli;
    different = different % daysInMilli;

    long elapsedHours = different / hoursInMilli;
    different = different % hoursInMilli;

    long elapsedMinutes = different / minutesInMilli;

    long minutes = elapsedHours * 60 + elapsedMinutes;
    long result = elapsedDays * 24 * 60 + minutes;
    if (0 > result) {
        result = result + 720;  //result is minus then add 12*60 minutes
    }

    return result + "";
}

    DateTimeFormatter timeFormatter = DateTimeFormatter.ofPattern("hh:mm a", Locale.ENGLISH);

    String startTime = "08:00 AM";
    String endTime = "04:00 PM";

    LocalTime start = LocalTime.parse(startTime, timeFormatter);
    LocalTime end = LocalTime.parse(endTime, timeFormatter);

    Duration diff = Duration.between(start, end);

    long hours = diff.toHours();
    long minutes = diff.minusHours(hours).toMinutes();
    String totalTimeString = String.format("%02d:%02d", hours, minutes);
    System.out.println("TotalTime in Hours and Mins Format is " + totalTimeString);