Android / Java-日付の日数の違い


80

以下のコードを使用して、現在の日付(1999年12月31日、つまりmm / dd / yyyyの形式)を取得しています。

Textview txtViewData;
txtViewDate.setText("Today is " +
        android.text.format.DateFormat.getDateFormat(this).format(new Date()));

そして私は次のような形式で別の日付を持っています:2010-08-25(すなわち、yyyy / mm / dd)、

日付の日数の違いを見つけたいのですが、どうすれば日数の違いを見つけることができますか?

(つまり、現在の日付-yyyy / mm / dd形式の日付の違いを見つけたい)


このコードは、現在java.timeクラスに取って代わられている厄介な古い日時クラスを使用しています。古いJavaおよびAndroidについては、ThreeTen-BackportおよびThreeTenABPプロジェクトを参照してください。
バジルバーク2017年

同様の質問ですが、日付
BasilBourque18年

回答:


126

本当に信頼できる方法ではなく、JodaTimeを使用する方が良い

  Calendar thatDay = Calendar.getInstance();
  thatDay.set(Calendar.DAY_OF_MONTH,25);
  thatDay.set(Calendar.MONTH,7); // 0-11 so 1 less
  thatDay.set(Calendar.YEAR, 1985);

  Calendar today = Calendar.getInstance();

  long diff = today.getTimeInMillis() - thatDay.getTimeInMillis(); //result in millis

これが概算です...

long days = diff / (24 * 60 * 60 * 1000);

文字列から日付を解析するには、次を使用できます

  String strThatDay = "1985/08/25";
  SimpleDateFormat formatter = new SimpleDateFormat("yyyy/MM/dd");
  Date d = null;
  try {
   d = formatter.parse(strThatDay);//catch exception
  } catch (ParseException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  } 


  Calendar thatDay = Calendar.getInstance();
  thatDay.setTime(d); //rest is the same....

ただし、日付の形式がわかっているので...Integer.parseInt()部分文字列を使用して、数値を取得することもできます。


@stOleありがとう、しかし私は両方の日付を文字列で持っているので、どうすればいいですか、plsは私に詳細を知らせます、pls
Paresh Mayani 2010年

1
@stOleが正確な答えを取得していない、コードに小さな間違いがある可能性があります。StringstrThatDay= "2010/10/03";を設定しても、274日のギャップが発生します。サポートに感謝します
Pareshマヤニ2010年

@Paresh、申し訳ありませんが、月は大文字のM、分は小文字に("yyyy/mm/dd");置き換える必要があります("yyyy/MM/dd");。修正しました。
st0le 2010年

1
@Gevorg、私はそれをお勧めしました。:)私GUSTA JodaTime
st0le

3
ミリ秒を除算するときの丸めの問題(その欠如)のために、このコードが休日になることがあります。これは私にとってはMath.round(millisBetweenDates * 1f / TimeUnit.MILLISECONDS.convert(1, TimeUnit.DAYS));
うまくいき

83

これは私の仕事ではありません、ここで答えを見つけました。将来的に壊れたリンクを望んでいませんでした:)。

重要なのは、日光の設定を考慮に入れるためのこの行です。フルコードを参照してください。

TimeZone.setDefault(TimeZone.getTimeZone("Europe/London"));

または合格してみてくださいTimeZone へのパラメータとしてdaysBetween()、コールsetTimeZone()sDateし、eDateオブジェクト。

だからここに行く:

public static Calendar getDatePart(Date date){
    Calendar cal = Calendar.getInstance();       // get calendar instance
    cal.setTime(date);      
    cal.set(Calendar.HOUR_OF_DAY, 0);            // set hour to midnight
    cal.set(Calendar.MINUTE, 0);                 // set minute in hour
    cal.set(Calendar.SECOND, 0);                 // set second in minute
    cal.set(Calendar.MILLISECOND, 0);            // set millisecond in second
    
    return cal;                                  // return the date part
}

ここから取得したgetDatePart()

/**
 * This method also assumes endDate >= startDate
**/
public static long daysBetween(Date startDate, Date endDate) {
  Calendar sDate = getDatePart(startDate);
  Calendar eDate = getDatePart(endDate);

  long daysBetween = 0;
  while (sDate.before(eDate)) {
      sDate.add(Calendar.DAY_OF_MONTH, 1);
      daysBetween++;
  }
  return daysBetween;
}

ニュアンス: 2つの日付の違いを見つけることは、2つの日付を減算し、結果を(24 * 60 * 60 * 1000)で割るほど簡単ではありません。実際、その誤りです!

例えば: 2007年3月24日と2007年3月25日の2つの日付の差は1日である必要があります。ただし、上記の方法を使用すると、英国では0日が発生します。

自分の目で確かめてください(以下のコード)。ミリ秒単位で進むと、エラーが四捨五入されます。夏時間のような小さなことがわかったら、エラーが最も顕著になります。

完全なコード:

import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.TimeZone;

public class DateTest {

public class DateTest {

static SimpleDateFormat sdf = new SimpleDateFormat("dd-MMM-yyyy");

public static void main(String[] args) {

  TimeZone.setDefault(TimeZone.getTimeZone("Europe/London"));

  //diff between these 2 dates should be 1
  Date d1 = new Date("01/01/2007 12:00:00");
  Date d2 = new Date("01/02/2007 12:00:00");

  //diff between these 2 dates should be 1
  Date d3 = new Date("03/24/2007 12:00:00");
  Date d4 = new Date("03/25/2007 12:00:00");

  Calendar cal1 = Calendar.getInstance();cal1.setTime(d1);
  Calendar cal2 = Calendar.getInstance();cal2.setTime(d2);
  Calendar cal3 = Calendar.getInstance();cal3.setTime(d3);
  Calendar cal4 = Calendar.getInstance();cal4.setTime(d4);

  printOutput("Manual   ", d1, d2, calculateDays(d1, d2));
  printOutput("Calendar ", d1, d2, daysBetween(cal1, cal2));
  System.out.println("---");
  printOutput("Manual   ", d3, d4, calculateDays(d3, d4));
  printOutput("Calendar ", d3, d4, daysBetween(cal3, cal4));
}


private static void printOutput(String type, Date d1, Date d2, long result) {
  System.out.println(type+ "- Days between: " + sdf.format(d1)
                    + " and " + sdf.format(d2) + " is: " + result);
}

/** Manual Method - YIELDS INCORRECT RESULTS - DO NOT USE**/
/* This method is used to find the no of days between the given dates */
public static long calculateDays(Date dateEarly, Date dateLater) {
  return (dateLater.getTime() - dateEarly.getTime()) / (24 * 60 * 60 * 1000);
}

/** Using Calendar - THE CORRECT WAY**/
public static long daysBetween(Date startDate, Date endDate) {
  ...
}

出力:

マニュアル-2007年1月1日から2007年1月2日までの日数:1

カレンダー-2007年1月1日から2007年1月2日までの日数:1


手動-2007年3月24日から2007年3月25日までの日数:0

カレンダー-2007年3月24日から2007年3月25日までの日数:1


同意します。トップレベルの方法を使用するより信頼性が高くエレガントなソリューションを手に入れています。ありがとう!
ロジャーエイリアン

メソッドの場合:daysBetween日付が2012年7月24日の15:00でendDateが2012年7月24日の16:00の場合、日付はendDateより前ですが、1日ではなく、1時間だけです。私は何かが足りないのですか、それともdaysBetweenの結果はこの場合間違っていますか(期待される結果はゼロですが、与えられた計算ではゼロではなく1になるはずです)?
AgentKnopf 2012

@Zainodis、頭のてっぺんに、コードを更新しました。これで問題は解決したと思います。
サミュエル

@SamQuest更新していただきありがとうございます!私はもっ​​と素朴なアプローチを取りました。開始と終了が同じ日、月、年の場合、sDate.before(eDate)のwhileループが停止し、結果が返されます。これにより、最初の反復で開始と終了が同じ日/月/年にある場合(時間的に開始が終了前であるにもかかわらず)、ゼロが正しく返されることも保証されます。
AgentKnopf 2012

あなたは、ベルに値する!
marienke 2014年

38

答えのほとんどはあなたの問題に対して良くて正しいものでした

日付の日数の違いを見つけたいのですが、日数の違いを見つけるにはどうすればよいですか?

この非常にシンプルでわかりやすいアプローチをお勧めします。これにより、どのタイムゾーンでも正しい違いが得られることが保証されます。

int difference= 
((int)((startDate.getTime()/(24*60*60*1000))
-(int)(endDate.getTime()/(24*60*60*1000))));

以上です!


これも私にとってはうまくいきました..他のものはあまりにも複雑で正確にする方法でした:)
Siddharth 2016

1
2回に分割されないように、最初に減算して後で分割するとよいでしょう。
ravindu1024 2017年

@ ravindu1024これを行うと、startDateがendDateよりも小さい場合に+1の差が生じます。この場合、+ 1の違いがあります。答えに-1を追加することで解決できます。
sHOLE 2017

@sHOLEどうやって?私が言っているのは、t1 / C-t2 / Cの代わりに(t1-t2)/ Cを実行する必要があるということです。t1 / Cもt2 / Cもゼロにならないので、それが答えにどのように影響するかわかりません。
ravindu1024 2017

@ ravindu1024私はあなたが何を言おうとしているのか理解し、この答えを読んだときに同じことを疑問に思いました。実装して初めて、なぜそれがそのように行われなかったのか(私が上で述べた理由)に気づきました。
sHOLE 2017

25

使用jodatimeのAPI

Days.daysBetween(start.toDateMidnight() , end.toDateMidnight() ).getDays() 

ここで、「start」と「end」はDateTimeオブジェクトです。日付文字をDateTimeオブジェクトに解析するには、parseDateTimeメソッドを使用します

Android固有のJodaTimeライブラリもあります


3
サポートに
感謝し

2
ジョーダは+1。Java Calendar APIはひどい混乱であり、Jodaはクリーンで美しいです。
LuxuryMode 2012

JodaTimeはAndroidのいくつかのデバイスでいくつかのバグを出します、理由はわかりません、私はそれにいくつかの問題があります
josemwarrior 2015年

1
Jodaタイムライブラリは、プロジェクトに4744メソッドを追加します。65Kメソッドの制限を回避したい場合は、賢明に選択してください。
Lior Iluz 2015

14

このフラグメントは夏時間を考慮しており、O(1)です。

private final static long MILLISECS_PER_DAY = 24 * 60 * 60 * 1000;

private static long getDateToLong(Date date) {
    return Date.UTC(date.getYear(), date.getMonth(), date.getDate(), 0, 0, 0);
}

public static int getSignedDiffInDays(Date beginDate, Date endDate) {
    long beginMS = getDateToLong(beginDate);
    long endMS = getDateToLong(endDate);
    long diff = (endMS - beginMS) / (MILLISECS_PER_DAY);
    return (int)diff;
}

public static int getUnsignedDiffInDays(Date beginDate, Date endDate) {
    return Math.abs(getSignedDiffInDays(beginDate, endDate));
}

6

これは私にとってシンプルで最良の計算であり、あなたのためかもしれません。

       try {
            /// String CurrDate=  "10/6/2013";
            /// String PrvvDate=  "10/7/2013";
            Date date1 = null;
            Date date2 = null;
            SimpleDateFormat df = new SimpleDateFormat("M/dd/yyyy");
            date1 = df.parse(CurrDate);
            date2 = df.parse(PrvvDate);
            long diff = Math.abs(date1.getTime() - date2.getTime());
            long diffDays = diff / (24 * 60 * 60 * 1000);


            System.out.println(diffDays);

        } catch (Exception e1) {
            System.out.println("exception " + e1);
        }

@PareshMayaniがログキャットをチェックインしています
Rishi Gautam

3

Correct Way最初の日付が第二よりも前である場合、サムクエストの答えからのみ動作します。さらに、2つの日付が1日以内の場合は、1を返します。

これは私にとって最も効果的なソリューションです。他のほとんどのソリューションと同様に、夏時間のオフセットが間違っているため、1年に2日でも誤った結果が表示されます。

private final static long MILLISECS_PER_DAY = 24 * 60 * 60 * 1000;

long calculateDeltaInDays(Calendar a, Calendar b) {

    // Optional: avoid cloning objects if it is the same day
    if(a.get(Calendar.ERA) == b.get(Calendar.ERA) 
            && a.get(Calendar.YEAR) == b.get(Calendar.YEAR)
            && a.get(Calendar.DAY_OF_YEAR) == b.get(Calendar.DAY_OF_YEAR)) {
        return 0;
    }
    Calendar a2 = (Calendar) a.clone();
    Calendar b2 = (Calendar) b.clone();
    a2.set(Calendar.HOUR_OF_DAY, 0);
    a2.set(Calendar.MINUTE, 0);
    a2.set(Calendar.SECOND, 0);
    a2.set(Calendar.MILLISECOND, 0);
    b2.set(Calendar.HOUR_OF_DAY, 0);
    b2.set(Calendar.MINUTE, 0);
    b2.set(Calendar.SECOND, 0);
    b2.set(Calendar.MILLISECOND, 0);
    long diff = a2.getTimeInMillis() - b2.getTimeInMillis();
    long days = diff / MILLISECS_PER_DAY;
    return Math.abs(days);
}

3

これを行うための最良かつ最も簡単な方法

  public int getDays(String begin) throws ParseException {
     long MILLIS_PER_DAY = 24 * 60 * 60 * 1000;
     SimpleDateFormat dateFormat = new SimpleDateFormat("dd-MM-yyyy", Locale.ENGLISH);

    long begin = dateFormat.parse(begin).getTime();
    long end = new Date().getTime(); // 2nd date want to compare
    long diff = (end - begin) / (MILLIS_PER_DAY);
    return (int) diff;
}

3

tl; dr

ChronoUnit.DAYS.between( 
    LocalDate.parse( "1999-12-28" ) , 
    LocalDate.parse( "12/31/1999" , DateTimeFormatter.ofPattern( "MM/dd/yyyy" ) ) 
)

詳細

他の答えは時代遅れです。初期のバージョンのJavaにバンドルされている古い日時クラスは、設計が不十分で、混乱し、面倒であることが証明されています。それらを避けてください。

java.time

Joda-Timeプロジェクトは、これらの古いクラスの代わりとして大成功を収めました。これらのクラスは、Java8以降に 組み込まれたjava.timeフレームワークにインスピレーションを与えました。

java.time機能の多くはThreeTen-BackportJava6および7にバックポートされ、ThreeTenABPでAndroidにさらに適合されています

LocalDate

ザ・ LocalDateクラスは、時刻やタイムゾーンのない日付のみの値を表します。

文字列の解析

入力文字列が標準のISO8601形式の場合、LocalDateクラスは文字列を直接解析できます。

LocalDate start = LocalDate.parse( "1999-12-28" );

ISO 8601形式でない場合は、でフォーマットパターンを定義しDateTimeFormatterます。

String input = "12/31/1999";
DateTimeFormatter formatter = DateTimeFormatter.ofPattern( "MM/dd/yyyy" );
LocalDate stop = LocalDate.parse( input , formatter );

経由日数 ChronoUnit

次に、そのLocalDateオブジェクトのペア間で経過した日数を取得します。ChronoUnit列挙型の計算には時間が経過しました。

long totalDays = ChronoUnit.DAYS.between( start , stop ) ; 

Java列挙型に慣れていない場合は、他のほとんどのプログラミング言語の従来の列挙型よりもはるかに強力で便利であることを知っておいてください。詳細については、Enumクラスドキュメント、Oracleチュートリアル、およびWikipediaを参照してください。


java.timeについて

java.timeフレームワークは、Java8以降に組み込まれています。これらのクラスは面倒古い取って代わるレガシーのような日付時刻クラスjava.util.DateCalendar&を、SimpleDateFormat

ジョダタイムプロジェクトは、今でメンテナンスモードへの移行をアドバイスjava.timeのクラス。

詳細については、Oracleチュートリアルを参照してください。そして、StackOverflowで多くの例と説明を検索してください。仕様はJSR310です。

java.timeクラスはどこで入手できますか?

ThreeTen-エクストラプロジェクトでは、追加のクラスでjava.timeを拡張します。このプロジェクトは、java.timeへの将来の追加の可能性の証明の場です。あなたはここにいくつかの有用なクラスのような見つけることがIntervalYearWeekYearQuarter、および多くを


java.time.LocalDateはAndroidではサポートされていません
Mahdi Astanei 2016

1
@MahdiAstaneiAndroid用のThreeTenABPライブラリに関する私の3番目の段落を読み直してください。古い日時クラスは本当にひどいので、アプリに追加する価値は十分にあります。
バジルバーク2016

2

次の関数を使用します。

   /**
     * Returns the number of days between two dates. The time part of the
     * days is ignored in this calculation, so 2007-01-01 13:00 and 2007-01-02 05:00
     * have one day inbetween.
     */
    public static long daysBetween(Date firstDate, Date secondDate) {
        // We only use the date part of the given dates
        long firstSeconds = truncateToDate(firstDate).getTime()/1000;
        long secondSeconds = truncateToDate(secondDate).getTime()/1000;
        // Just taking the difference of the millis.
        // These will not be exactly multiples of 24*60*60, since there
        // might be daylight saving time somewhere inbetween. However, we can
        // say that by adding a half day and rounding down afterwards, we always
        // get the full days.
        long difference = secondSeconds-firstSeconds;
        // Adding half a day
        if( difference >= 0 ) {
            difference += SECONDS_PER_DAY/2; // plus half a day in seconds
        } else {
            difference -= SECONDS_PER_DAY/2; // minus half a day in seconds
        }
        // Rounding down to days
        difference /= SECONDS_PER_DAY;

        return difference;
    }

    /**
     * Truncates a date to the date part alone.
     */
    @SuppressWarnings("deprecation")
    public static Date truncateToDate(Date d) {
        if( d instanceof java.sql.Date ) {
            return d; // java.sql.Date is already truncated to date. And raises an
                      // Exception if we try to set hours, minutes or seconds.
        }
        d = (Date)d.clone();
        d.setHours(0);
        d.setMinutes(0);
        d.setSeconds(0);
        d.setTime(((d.getTime()/1000)*1000));
        return d;
    }

2

単純な解決策がありますが、少なくとも私にとっては、実行可能な唯一の解決策です。

問題は、Joda、Calendar、Dateなどを使用して、私が見ているすべての答えがミリ秒単位しか考慮されていないことです。最終的には、実際の日数ではなく、2つの日付間の24時間サイクルの数をカウントします。したがって、1月1日午後11時から1月2日午前1時までの何かは0日を返します。

startDateとの間の実際の日数を数えるにはendDate、次のようにします。

// Find the sequential day from a date, essentially resetting time to start of the day
long startDay = startDate.getTime() / 1000 / 60 / 60 / 24;
long endDay = endDate.getTime() / 1000 / 60 / 60 / 24;

// Find the difference, duh
long daysBetween = endDay - startDay;

これにより、1月2日から1月1日までの間に「1」が返されます。終了日をカウントする必要がある場合は、に1を追加するだけdaysBetweenです(範囲内の合計日数をカウントしたかったので、コードでこれを行う必要がありました)。

これはダニエルが提案したものと多少似ていますが、私が思うより小さなコードです。


2

これらのソリューションはすべて、2つの問題のうちの1つに悩まされています。丸め誤差、うるう日と秒などが原因でソリューションが完全に正確でないか、2つの不明な日付の間の日数をループすることになります。

このソリューションは最初の問題を解決し、2番目の問題を約365倍改善します。これは、最大範囲がわかっている場合に適しています。

/**
 * @param thisDate
 * @param thatDate
 * @param maxDays
 *            set to -1 to not set a max
 * @returns number of days covered between thisDate and thatDate, inclusive, i.e., counting both
 *          thisDate and thatDate as an entire day. Will short out if the number of days exceeds
 *          or meets maxDays
 */
public static int daysCoveredByDates(Date thisDate, Date thatDate, int maxDays) {
    //Check inputs
    if (thisDate == null || thatDate == null) {
        return -1;
    }

    //Set calendar objects
    Calendar startCal = Calendar.getInstance();
    Calendar endCal = Calendar.getInstance();
    if (thisDate.before(thatDate)) {
        startCal.setTime(thisDate);
        endCal.setTime(thatDate);
    }
    else {
        startCal.setTime(thatDate);
        endCal.setTime(thisDate);
    }

    //Get years and dates of our times.
    int startYear = startCal.get(Calendar.YEAR);
    int endYear = endCal.get(Calendar.YEAR);
    int startDay = startCal.get(Calendar.DAY_OF_YEAR);
    int endDay = endCal.get(Calendar.DAY_OF_YEAR);

    //Calculate the number of days between dates.  Add up each year going by until we catch up to endDate.
    while (startYear < endYear && maxDays >= 0 && endDay - startDay + 1 < maxDays) {
        endDay += startCal.getActualMaximum(Calendar.DAY_OF_YEAR); //adds the number of days in the year startDate is currently in
        ++startYear;
        startCal.set(Calendar.YEAR, startYear); //reup the year
    }
    int days = endDay - startDay + 1;

    //Honor the maximum, if set
    if (maxDays >= 0) {
        days = Math.min(days, maxDays);
    }
    return days;
}

日付の間に日数が必要な場合(後者の日付を除く)、が表示されたら削除+ 1してくださいendDay - startDay + 1


1

もう1つの方法:

public static int numberOfDaysBetweenDates(Calendar fromDay, Calendar toDay) {
        fromDay = calendarStartOfDay(fromDay);
        toDay = calendarStartOfDay(toDay);
        long from = fromDay.getTimeInMillis();
        long to = toDay.getTimeInMillis();
        return (int) TimeUnit.MILLISECONDS.toDays(to - from);
    }

提供したコードについてコメントしてください。だから人々はあなたのコードの意味を理解します。
AbedPutra20年

1

これらの機能を使用する

    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およびAndroidについては、ThreeTen-BackportおよびThreeTenABPプロジェクトを参照してください。
バジルバーク2017年

カレンダークラスは古い日時クラスですか?
neal zedlav 2017

はい、java.timeパッケージの外部で見つかった日時関連のクラスは現在レガシーであり、避ける必要があります。これにはDate、とCalendar、およびjava.sqlクラスが含まれます。Oracleチュートリアルを参照してください。
バジルバーク2017

1
        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();


}

0

私はこれを行うための非常に簡単な方法を見つけました、そしてそれは私が私のアプリで使用しているものです。

Timeオブジェクトに日付があるとしましょう(または何でも、ミリ秒が必要です):

Time date1 = initializeDate1(); //get the date from somewhere
Time date2 = initializeDate2(); //get the date from somewhere

long millis1 = date1.toMillis(true);
long millis2 = date2.toMillis(true);

long difference = millis2 - millis1 ;

//now get the days from the difference and that's it
long days = TimeUnit.MILLISECONDS.toDays(difference);

//now you can do something like
if(days == 7)
{
    //do whatever when there's a week of difference
}

if(days >= 30)
{
    //do whatever when it's been a month or more
}

0

ジョーダタイム

最善の方法は、プロジェクトに追加する非常に成功したオープンソースライブラリであるJoda-Timeを使用することです。

String date1 = "2015-11-11";
String date2 = "2013-11-11";
DateTimeFormatter formatter = new DateTimeFormat.forPattern("yyyy-MM-dd");
DateTime d1 = formatter.parseDateTime(date1);
DateTime d2 = formatter.parseDateTime(date2);
long diffInMillis = d2.getMillis() - d1.getMillis();

Duration duration = new Duration(d1, d2);
int days = duration.getStandardDays();
int hours = duration.getStandardHours();
int minutes = duration.getStandardMinutes();

Android Studioを使用している場合は、joda-timeを簡単に追加できます。build.gradle(アプリ)内:

dependencies {
  compile 'joda-time:joda-time:2.4'
  compile 'joda-time:joda-time:2.4'
  compile 'joda-time:joda-time:2.2'
}

いい答えです。toStringonを呼び出すDurationと、ISO8601標準形式の1つで文字列表現が生成されることに注意してくださいPnYnMnDTnHnMnS Pマーク始まり、しばらくT時間-分-秒から離れる年-月-日。つまりP3D、3日であり、3日P3DT12H半です。
バジルバーク2015

2
Jodaタイムライブラリは、プロジェクトに4744メソッドを追加します。65Kメソッドの制限を回避したい場合は、賢明に選択してください。
Lior Iluz 2015

これは、DateTimeFormatter formatter = DateTimeFormat.forPattern( "yyyy-MM-dd")
sb_269 2016年

0
        Date userDob = new SimpleDateFormat("yyyy-MM-dd").parse(dob);
        Date today = new Date();
        long diff =  today.getTime() - userDob.getTime();
        int numOfDays = (int) (diff / (1000 * 60 * 60 * 24));
        int hours = (int) (diff / (1000 * 60 * 60));
        int minutes = (int) (diff / (1000 * 60));
        int seconds = (int) (diff / (1000));
弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.