我如何得到两个日期之间的区别在机器人? ，尝试了所有的事情和职位

我看了这里所有的帖子，还是不明白两个机器人的约会对象有什么不同。

这就是我的工作:

long diff = date1.getTime() - date2.getTime();
Date diffDate = new Date(diff);

我得到: 日期是1970年1月1日，时间总是在2小时内变大... ... 我来自以色列，所以2小时是时间偏移。

我怎样才能得到正常的差异? ? ？

128755 次浏览
小开
最佳答案

你接近正确答案了，你得到了这两个日期之间毫秒的差异，但是当你试图用这个差异来构造一个日期时，它假设你想创建一个新的 Date对象，用这个差异值作为它的纪元时间。如果你在寻找一个以小时为单位的时间，那么你只需要对这个 diff做一些基本的算术运算就可以得到不同的时间部分。

Java:

long diff = date1.getTime() - date2.getTime();
long seconds = diff / 1000;
long minutes = seconds / 60;
long hours = minutes / 60;
long days = hours / 24;

科特林:

val diff: Long = date1.getTime() - date2.getTime()
val seconds = diff / 1000
val minutes = seconds / 60
val hours = minutes / 60
val days = hours / 24

所有这些数学都只是做整数运算，所以它会截断任何小数点

小开

补充说明: 这里我将字符串转换为日期，然后比较当前时间。

String toyBornTime = "2014-06-18 12:56:50";
SimpleDateFormat dateFormat = new SimpleDateFormat(
"yyyy-MM-dd HH:mm:ss");


try {


Date oldDate = dateFormat.parse(toyBornTime);
System.out.println(oldDate);


Date currentDate = new Date();


long diff = currentDate.getTime() - oldDate.getTime();
long seconds = diff / 1000;
long minutes = seconds / 60;
long hours = minutes / 60;
long days = hours / 24;


if (oldDate.before(currentDate)) {


Log.e("oldDate", "is previous date");
Log.e("Difference: ", " seconds: " + seconds + " minutes: " + minutes
+ " hours: " + hours + " days: " + days);


}


// Log.e("toyBornTime", "" + toyBornTime);


} catch (ParseException e) {


e.printStackTrace();
}
小开 
    long diffInMillisec = date1.getTime() - date2.getTime();


long diffInDays = TimeUnit.MILLISECONDS.toDays(diffInMillisec);
long diffInHours = TimeUnit.MILLISECONDS.toHours(diffInMillisec);
long diffInMin = TimeUnit.MILLISECONDS.toMinutes(diffInMillisec);
long diffInSec = TimeUnit.MILLISECONDS.toSeconds(diffInMillisec);
小开

对我有效的最短答案。以毫秒为单位发送开始和结束日期。

public int GetDifference(long start,long end){
Calendar cal = Calendar.getInstance();
cal.setTimeInMillis(start);
int hour = cal.get(Calendar.HOUR_OF_DAY);
int min = cal.get(Calendar.MINUTE);
long t=(23-hour)*3600000+(59-min)*60000;


t=start+t;


int diff=0;
if(end>t){
diff=(int)((end-t)/ TimeUnit.DAYS.toMillis(1))+1;
}


return  diff;
}
小开

使用这些函数

    public static int getDateDifference(
int previousYear, int previousMonthOfYear, int previousDayOfMonth,
int nextYear, int nextMonthOfYear, int nextDayOfMonth,
int differenceToCount){
// int differenceToCount = can be any of the following
//  Calendar.MILLISECOND;
//  Calendar.SECOND;
//  Calendar.MINUTE;
//  Calendar.HOUR;
//  Calendar.DAY_OF_MONTH;
//  Calendar.MONTH;
//  Calendar.YEAR;
//  Calendar.----


Calendar previousDate = Calendar.getInstance();
previousDate.set(Calendar.DAY_OF_MONTH, previousDayOfMonth);
// month is zero indexed so month should be minus 1
previousDate.set(Calendar.MONTH, previousMonthOfYear);
previousDate.set(Calendar.YEAR, previousYear);


Calendar nextDate = Calendar.getInstance();
nextDate.set(Calendar.DAY_OF_MONTH, previousDayOfMonth);
// month is zero indexed so month should be minus 1
nextDate.set(Calendar.MONTH, previousMonthOfYear);
nextDate.set(Calendar.YEAR, previousYear);


return getDateDifference(previousDate,nextDate,differenceToCount);
}
public static int getDateDifference(Calendar previousDate,Calendar nextDate,int differenceToCount){
// int differenceToCount = can be any of the following
//  Calendar.MILLISECOND;
//  Calendar.SECOND;
//  Calendar.MINUTE;
//  Calendar.HOUR;
//  Calendar.DAY_OF_MONTH;
//  Calendar.MONTH;
//  Calendar.YEAR;
//  Calendar.----


//raise an exception if previous is greater than nextdate.
if(previousDate.compareTo(nextDate)>0){
throw new RuntimeException("Previous Date is later than Nextdate");
}


int difference=0;
while(previousDate.compareTo(nextDate)<=0){
difference++;
previousDate.add(differenceToCount,1);
}
return difference;
}
小开

Java.time 持续时间

使用 java.time.Duration:

    Duration diff = Duration.between(instant2, instant1);
System.out.println(diff);

这会打印出

PT109H27M21S

这意味着一段时间为109小时27分21秒。如果你想要一些更加人类可读的东西ーー我先给出 Java9版本，它最简单:

    String formattedDiff = String.format(Locale.ENGLISH,
"%d days %d hours %d minutes %d seconds",
diff.toDays(), diff.toHoursPart(), diff.toMinutesPart(), diff.toSecondsPart());
System.out.println(formattedDiff);

现在我们得到

4 days 13 hours 27 minutes 21 seconds

Duration类是现代 Java 日期和时间 API java.time的一部分。这是捆绑在新的 Android 设备上的。在较旧的设备上，获取 ThreeTenABP 并将其添加到项目中，并确保从同一个包中导入 org.threeten.bp.Duration和其他可能需要的日期时间类。

假设你还没有得到 Java9版本，你可以减去更大的单元来得到更小的单元:

    long days = diff.toDays();
diff = diff.minusDays(days);
long hours = diff.toHours();
diff = diff.minusHours(hours);
long minutes = diff.toMinutes();
diff = diff.minusMinutes(minutes);
long seconds = diff.toSeconds();

然后您可以像上面那样格式化这四个变量。

你做错了什么？

Date表示一个时间点。它从来就不是用来表示一个时间量，一个持续时间，而且它也不适合它。如果尝试这样做，充其量将导致混乱和难以维护的代码。你不想那样的，所以请不要。

问: java.time 不是需要 Android API 级别26吗？

Time 在旧的和新的 Android 设备上都能很好地工作，只是需要至少 爪哇6。

  • 在 Java8以及更新的 Android 设备上(从 API 级别26开始) ，现代的 API 是内置的。
  • 在非 Android 的 Java6和 Java7中获得 Three Ten Backport，这是现代类的 Backport (ThreeTen 用于 JSR 310; 请参阅底部的链接)。
  • 在(旧版本) Android 上使用安卓版本的 ThreeTen Backport。它叫做3TenABP。并确保从 org.threeten.bp导入带有子包的日期和时间类。

连结

小开

用的是格鲁吉亚火药筒

 public void dateDifferenceExample() {


// Set the date for both of the calendar instance
GregorianCalendar calDate = new GregorianCalendar(2012, 10, 02,5,23,43);
GregorianCalendar cal2 = new GregorianCalendar(2015, 04, 02);


// Get the represented date in milliseconds
long millis1 = calDate.getTimeInMillis();
long millis2 = cal2.getTimeInMillis();


// Calculate difference in milliseconds
long diff = millis2 - millis1;


// Calculate difference in seconds
long diffSeconds = diff / 1000;


// Calculate difference in minutes
long diffMinutes = diff / (60 * 1000);


// Calculate difference in hours
long diffHours = diff / (60 * 60 * 1000);


// Calculate difference in days
long diffDays = diff / (24 * 60 * 60 * 1000);
Toast.makeText(getContext(), ""+diffSeconds, Toast.LENGTH_SHORT).show();




}
小开

以下是我根据“ Ole V. V.”的回答给出的答案。

这也适用于 Singular。

private String getDuration(Date d1, Date d2) {
Duration diff = Duration.between(d1.toInstant(), d2.toInstant());




long days = diff.toDays();
diff = diff.minusDays(days);
long hours = diff.toHours();
diff = diff.minusHours(hours);
long minutes = diff.toMinutes();
diff = diff.minusMinutes(minutes);
long seconds = diff.toMillis();


StringBuilder formattedDiff = new StringBuilder();
if(days!=0){
if(days==1){
formattedDiff.append(days + " Day ");


}else {
formattedDiff.append(days + " Days ");
}
}if(hours!=0){
if(hours==1){
formattedDiff.append(hours + " hour ");
}else{
formattedDiff.append(hours + " hours ");
}
}if(minutes!=0){
if(minutes==1){
formattedDiff.append(minutes + " minute ");
}else{
formattedDiff.append(minutes + " minutes ");
}
}if(seconds!=0){
if(seconds==1){
formattedDiff.append(seconds + " second ");
}else{
formattedDiff.append(seconds + " seconds ");
}
}




return formattedDiff.toString();
}

它使用 StringBuilder 将所有内容附加在一起。

小开

返回文章页面 Kotlin: 如果你需要两个日期之间的差异，并且不关心日期本身(如果你需要在应用程序中做一些事情，基于保存在共享首选项中的其他操作时间的时间，例如，很好)。 第一次保存:

val firstTime:Long= System.currentTimeMillis()

第二次保存:

val now:Long= System.currentTimeMillis()

计算两次之间的毫秒:

val milisecondsSinceLastTime: Long =(now-lastScrollTime)
小开

如果你在 Android 开发中使用 Kotlin 语言，你可以在下面这些日子里得到不同的结果:

fun daysDiff(c1: Calendar, c2: Calendar): Long {
val diffInMillis = c1.timeInMillis - c2.timeInMillis
return diffInMillis.milliseconds.inWholeDays
}

或者如果你想得到不同类型的结果，你可以用 toInt(...)，toDouble(...)，toString(...)代替 inWholeDays。

如果您感兴趣的唯一日期差异是天(比方说作为一个 Double 类型的结果) ，您可以创建像下面这样的操作符扩展方法:

operator fun Calendar.minus(c: Calendar): Double {
val diffInMillis = timeInMillis - c.timeInMillis
return diffInMillis.milliseconds.toDouble(DurationUnit.DAYS)
}

然后像 calendar2 - calendar1这样的任何操作都会以双精度返回差值。

小开

我试过这种方法. . 但不知道为什么我没有得到适当的结果

long diff = date1.getTime() - date2.getTime();
long seconds = diff / 1000;
long minutes = seconds / 60;
long hours = minutes / 60;
long days = hours / 24;

但这个可以

long miliSeconds = date1.getTime() -date2.getTime();
long seconds = TimeUnit.MILLISECONDS.toSeconds(miliSeconds);
long minute = seconds/60;
long hour = minute/60;
long days = hour/24;
小开

使用 马上怎么样:

val instant1 = now()
val instant2 = now()
val diff: Duration = Duration.between(instant1, instant2)
val minutes = diff.toMinutes()

您甚至可以使用 inst1.toString ()保存 Instant，并使用 parse (string)解析该字符串。

如果您需要支持 Android API 级别 < 26，只需添加 Java8 + API 去糖化支持 你的项目。

小开

得到上午和下午之间的时间差

private int  getTimeDiff() {
SimpleDateFormat sdf = new SimpleDateFormat("hh:mm:ss aa");
Date systemDate = Calendar.getInstance().getTime();
String myDate = sdf.format(systemDate);
Date current = null;
Date Date2 = null;
try {
current = sdf.parse(myDate);
// current = sdf.parse("05:00:00 pm");
Date2 = sdf.parse("12:00:00 am");
} catch (ParseException e) {
e.printStackTrace();
}
long millse = Date2.getTime() - current.getTime();
long mills = Math.abs(millse);
int Hours = (int) (mills / (1000 * 60 * 60));
int Mins = (int) (mills / (1000 * 60)) % 60;
long Secs = (int) (mills / 1000) % 60;
String diff = Hours + ":" + Mins + ":" + Secs;
int min = 60-Mins;
if (Hours >= 12) {
String requiredTime = 24 - Hours + ":" + Mins + ":" + Secs;
int minutes= ((24-Hours)*60)-Mins;
return minutes;


} else {
int time = 12 - Hours;
int hours=time+12;
int res = (hours*60);
int minutes = res-Mins;
return minutes;
}
}
小开

当您试图根据该差异构造日期时，它假设您要创建一个新的 Date 对象，并将该差异值作为其纪元时间。

//get time in milliseconds
long diff = date1.getTime() - date2.getTime();
//get time in seconds
long seconds = diff / 1000;
//and so on
long minutes = seconds / 60;
long hours = minutes / 60;
long days = hours / 24;

如需更多资讯，请浏览以下连结:

Oracle 教程: Date Time ，解释如何使用 java.Time。

ThreeTen Backport 项目 ，Java.time 到 Java 的 Backport 6和7。

Three TenABP ，Three Ten Backport 的 Android 版本。

问题: 如何在 Android 项目中使用 ThreeTenABP，有一个非常详细的解释。


提交答案