반응형
Java로 "time above"를 알려주세요.
Ruby on Rails 에는, 임의의 날짜를 취득해, 「오래전」으로 인쇄할 수 있는 기능이 있습니다.
예를 들어 다음과 같습니다.
8 minutes ago
8 hours ago
8 days ago
8 months ago
8 years ago
Java에서 쉽게 할 수 있는 방법이 있나요?
Pretty Time 라이브러리를 보세요.
사용법은 매우 간단합니다.
import org.ocpsoft.prettytime.PrettyTime;
PrettyTime p = new PrettyTime();
System.out.println(p.format(new Date()));
// prints "moments ago"
국제화된 메시지의 로케일을 전달할 수도 있습니다.
PrettyTime p = new PrettyTime(new Locale("fr"));
System.out.println(p.format(new Date()));
// prints "à l'instant"
코멘트에 기재되어 있듯이, Android는 이 기능을 클래스에 내장하고 있습니다.
Time Unit 열거를 고려해 보셨습니까?이런 종류의 일에는 꽤 유용할 수 있다.
try {
SimpleDateFormat format = new SimpleDateFormat("dd/MM/yyyy");
Date past = format.parse("01/10/2010");
Date now = new Date();
System.out.println(TimeUnit.MILLISECONDS.toMillis(now.getTime() - past.getTime()) + " milliseconds ago");
System.out.println(TimeUnit.MILLISECONDS.toMinutes(now.getTime() - past.getTime()) + " minutes ago");
System.out.println(TimeUnit.MILLISECONDS.toHours(now.getTime() - past.getTime()) + " hours ago");
System.out.println(TimeUnit.MILLISECONDS.toDays(now.getTime() - past.getTime()) + " days ago");
}
catch (Exception j){
j.printStackTrace();
}
RealHowTo와 Ben J의 답변을 받아 나만의 버전을 만듭니다.
public class TimeAgo {
public static final List<Long> times = Arrays.asList(
TimeUnit.DAYS.toMillis(365),
TimeUnit.DAYS.toMillis(30),
TimeUnit.DAYS.toMillis(1),
TimeUnit.HOURS.toMillis(1),
TimeUnit.MINUTES.toMillis(1),
TimeUnit.SECONDS.toMillis(1) );
public static final List<String> timesString = Arrays.asList("year","month","day","hour","minute","second");
public static String toDuration(long duration) {
StringBuffer res = new StringBuffer();
for(int i=0;i< TimeAgo.times.size(); i++) {
Long current = TimeAgo.times.get(i);
long temp = duration/current;
if(temp>0) {
res.append(temp).append(" ").append( TimeAgo.timesString.get(i) ).append(temp != 1 ? "s" : "").append(" ago");
break;
}
}
if("".equals(res.toString()))
return "0 seconds ago";
else
return res.toString();
}
public static void main(String args[]) {
System.out.println(toDuration(123));
System.out.println(toDuration(1230));
System.out.println(toDuration(12300));
System.out.println(toDuration(123000));
System.out.println(toDuration(1230000));
System.out.println(toDuration(12300000));
System.out.println(toDuration(123000000));
System.out.println(toDuration(1230000000));
System.out.println(toDuration(12300000000L));
System.out.println(toDuration(123000000000L));
}}
다음을 인쇄합니다.
0 second ago
1 second ago
12 seconds ago
2 minutes ago
20 minutes ago
3 hours ago
1 day ago
14 days ago
4 months ago
3 years ago
public class TimeUtils {
public final static long ONE_SECOND = 1000;
public final static long SECONDS = 60;
public final static long ONE_MINUTE = ONE_SECOND * 60;
public final static long MINUTES = 60;
public final static long ONE_HOUR = ONE_MINUTE * 60;
public final static long HOURS = 24;
public final static long ONE_DAY = ONE_HOUR * 24;
private TimeUtils() {
}
/**
* converts time (in milliseconds) to human-readable format
* "<w> days, <x> hours, <y> minutes and (z) seconds"
*/
public static String millisToLongDHMS(long duration) {
StringBuilder res = new StringBuilder();
long temp = 0;
if (duration >= ONE_SECOND) {
temp = duration / ONE_DAY;
if (temp > 0) {
duration -= temp * ONE_DAY;
res.append(temp).append(" day").append(temp > 1 ? "s" : "")
.append(duration >= ONE_MINUTE ? ", " : "");
}
temp = duration / ONE_HOUR;
if (temp > 0) {
duration -= temp * ONE_HOUR;
res.append(temp).append(" hour").append(temp > 1 ? "s" : "")
.append(duration >= ONE_MINUTE ? ", " : "");
}
temp = duration / ONE_MINUTE;
if (temp > 0) {
duration -= temp * ONE_MINUTE;
res.append(temp).append(" minute").append(temp > 1 ? "s" : "");
}
if (!res.toString().equals("") && duration >= ONE_SECOND) {
res.append(" and ");
}
temp = duration / ONE_SECOND;
if (temp > 0) {
res.append(temp).append(" second").append(temp > 1 ? "s" : "");
}
return res.toString();
} else {
return "0 second";
}
}
public static void main(String args[]) {
System.out.println(millisToLongDHMS(123));
System.out.println(millisToLongDHMS((5 * ONE_SECOND) + 123));
System.out.println(millisToLongDHMS(ONE_DAY + ONE_HOUR));
System.out.println(millisToLongDHMS(ONE_DAY + 2 * ONE_SECOND));
System.out.println(millisToLongDHMS(ONE_DAY + ONE_HOUR + (2 * ONE_MINUTE)));
System.out.println(millisToLongDHMS((4 * ONE_DAY) + (3 * ONE_HOUR)
+ (2 * ONE_MINUTE) + ONE_SECOND));
System.out.println(millisToLongDHMS((5 * ONE_DAY) + (4 * ONE_HOUR)
+ ONE_MINUTE + (23 * ONE_SECOND) + 123));
System.out.println(millisToLongDHMS(42 * ONE_DAY));
/*
output :
0 second
5 seconds
1 day, 1 hour
1 day and 2 seconds
1 day, 1 hour, 2 minutes
4 days, 3 hours, 2 minutes and 1 second
5 days, 4 hours, 1 minute and 23 seconds
42 days
*/
}
}
more @시간(밀리초)을 사람이 읽을 수 있는 형식으로 포맷합니다.
이것은 RealHow에 근거하고 있습니다.대답하기 위해서라도 좋으면 사랑해주세요.
이 정리 버전을 사용하면 관심 있는 시간 범위를 지정할 수 있습니다.
또, 「」와 「」의 처리도 조금 다릅니다.문자열을 딜리미터와 결합하면 복잡한 로직을 건너뛰고 작업이 끝나면 마지막 딜리미터를 삭제하는 것이 훨씬 쉬워집니다.
import java.util.concurrent.TimeUnit;
import static java.util.concurrent.TimeUnit.MILLISECONDS;
public class TimeUtils {
/**
* Converts time to a human readable format within the specified range
*
* @param duration the time in milliseconds to be converted
* @param max the highest time unit of interest
* @param min the lowest time unit of interest
*/
public static String formatMillis(long duration, TimeUnit max, TimeUnit min) {
StringBuilder res = new StringBuilder();
TimeUnit current = max;
while (duration > 0) {
long temp = current.convert(duration, MILLISECONDS);
if (temp > 0) {
duration -= current.toMillis(temp);
res.append(temp).append(" ").append(current.name().toLowerCase());
if (temp < 2) res.deleteCharAt(res.length() - 1);
res.append(", ");
}
if (current == min) break;
current = TimeUnit.values()[current.ordinal() - 1];
}
// clean up our formatting....
// we never got a hit, the time is lower than we care about
if (res.lastIndexOf(", ") < 0) return "0 " + min.name().toLowerCase();
// yank trailing ", "
res.deleteCharAt(res.length() - 2);
// convert last ", " to " and"
int i = res.lastIndexOf(", ");
if (i > 0) {
res.deleteCharAt(i);
res.insert(i, " and");
}
return res.toString();
}
}
시도하기 위한 작은 코드:
import static java.util.concurrent.TimeUnit.*;
public class Main {
public static void main(String args[]) {
long[] durations = new long[]{
123,
SECONDS.toMillis(5) + 123,
DAYS.toMillis(1) + HOURS.toMillis(1),
DAYS.toMillis(1) + SECONDS.toMillis(2),
DAYS.toMillis(1) + HOURS.toMillis(1) + MINUTES.toMillis(2),
DAYS.toMillis(4) + HOURS.toMillis(3) + MINUTES.toMillis(2) + SECONDS.toMillis(1),
DAYS.toMillis(5) + HOURS.toMillis(4) + MINUTES.toMillis(1) + SECONDS.toMillis(23) + 123,
DAYS.toMillis(42)
};
for (long duration : durations) {
System.out.println(TimeUtils.formatMillis(duration, DAYS, SECONDS));
}
System.out.println("\nAgain in only hours and minutes\n");
for (long duration : durations) {
System.out.println(TimeUtils.formatMillis(duration, HOURS, MINUTES));
}
}
}
그러면 다음이 출력됩니다.
0 seconds
5 seconds
1 day and 1 hour
1 day and 2 seconds
1 day, 1 hour and 2 minutes
4 days, 3 hours, 2 minutes and 1 second
5 days, 4 hours, 1 minute and 23 seconds
42 days
Again in only hours and minutes
0 minutes
0 minutes
25 hours
24 hours
25 hours and 2 minutes
99 hours and 2 minutes
124 hours and 1 minute
1008 hours
그리고 누군가 필요할 경우를 대비해 위와 같은 문자열을 밀리초로 다시 변환하는 클래스가 있습니다.이것은 사람들이 읽을 수 있는 텍스트로 다양한 사물의 타임아웃을 지정할 수 있도록 하는 데 매우 유용합니다.
간단한 방법이 있습니다.
예를 들어, 20분 전의 시간을 원하는 경우:
Long minutesAgo = new Long(20);
Date date = new Date();
Date dateIn_X_MinAgo = new Date (date.getTime() - minutesAgo*60*1000);
바로 그거야..
여기에 있는 수많은 답변을 바탕으로 저의 활용 사례에 대해 다음과 같이 작성했습니다.
사용 예:
String relativeDate = String.valueOf(
TimeUtils.getRelativeTime( 1000L * myTimeInMillis() ));
import java.util.Arrays;
import java.util.List;
import static java.util.concurrent.TimeUnit.DAYS;
import static java.util.concurrent.TimeUnit.HOURS;
import static java.util.concurrent.TimeUnit.MINUTES;
import static java.util.concurrent.TimeUnit.SECONDS;
/**
* Utilities for dealing with dates and times
*/
public class TimeUtils {
public static final List<Long> times = Arrays.asList(
DAYS.toMillis(365),
DAYS.toMillis(30),
DAYS.toMillis(7),
DAYS.toMillis(1),
HOURS.toMillis(1),
MINUTES.toMillis(1),
SECONDS.toMillis(1)
);
public static final List<String> timesString = Arrays.asList(
"yr", "mo", "wk", "day", "hr", "min", "sec"
);
/**
* Get relative time ago for date
*
* NOTE:
* if (duration > WEEK_IN_MILLIS) getRelativeTimeSpanString prints the date.
*
* ALT:
* return getRelativeTimeSpanString(date, now, SECOND_IN_MILLIS, FORMAT_ABBREV_RELATIVE);
*
* @param date String.valueOf(TimeUtils.getRelativeTime(1000L * Date/Time in Millis)
* @return relative time
*/
public static CharSequence getRelativeTime(final long date) {
return toDuration( Math.abs(System.currentTimeMillis() - date) );
}
private static String toDuration(long duration) {
StringBuilder sb = new StringBuilder();
for(int i=0;i< times.size(); i++) {
Long current = times.get(i);
long temp = duration / current;
if (temp > 0) {
sb.append(temp)
.append(" ")
.append(timesString.get(i))
.append(temp > 1 ? "s" : "")
.append(" ago");
break;
}
}
return sb.toString().isEmpty() ? "now" : sb.toString();
}
}
내장 솔루션에 대해서:
및 Java-8의 패키지인 Java-8은 .java.time영어밖에 필요 없는 경우 수작업으로 해결한 솔루션이라면 @RealHowTo의 답변을 참조하십시오(단, 현지 시간 단위로 인스턴트 델타를 번역할 때 시간대를 고려하지 않는 단점이 있습니다!).어쨌든, 특히 다른 로케일의 경우, 집에서 개발한 복잡한 회피책을 피하고 싶다면, 외부 라이브러리가 필요합니다.
후자의 경우는, 제 라이브러리 Time4J(Android의 경우는 Time4A)를 사용하는 것을 추천합니다.최고의 유연성과 최고의 i18n 파워를 제공합니다.클래스 net.time4j.Pretty Time에는 7가지 방법이 있습니다.printRelativeTime...(...)이 목적을 위해.「 」 「 」 、 「 」 、 「 」 。
TimeSource<?> clock = () -> PlainTimestamp.of(2015, 8, 1, 10, 24, 5).atUTC();
Moment moment = PlainTimestamp.of(2015, 8, 1, 17, 0).atUTC(); // our input
String durationInDays =
PrettyTime.of(Locale.GERMAN).withReferenceClock(clock).printRelative(
moment,
Timezone.of(EUROPE.BERLIN),
TimeUnit.DAYS); // controlling the precision
System.out.println(durationInDays); // heute (german word for today)
다른 에서는 '보다 낫다'를 사용하기도 합니다.java.time.Instant★★★★
String relativeTime =
PrettyTime.of(Locale.ENGLISH)
.printRelativeInStdTimezone(Moment.from(Instant.EPOCH));
System.out.println(relativeTime); // 45 years ago
이 라이브러리는 최신 버전(v4.17) 80개 언어 및 일부 국가별 로케일(특히 스페인어, 영어, 아랍어, 프랑스어)을 지원합니다.i18n 데이터는 주로 최신 CLDR 버전 v29에 기초하고 있습니다.이 라이브러리를 사용하는 다른 중요한 이유로는 복수의 규칙(다른 로케일의 영어와는 다른 경우가 많다), 생략형식 스타일(예를 들어 "1초 전") 및 시간대를 고려한 표현 방법이 있습니다.Time4J는 상대시간 계산에서 윤초와 같은 이색적인 세부 사항도 알고 있습니다(별로 중요하지 않지만 기대치 지평선과 관련된 메시지를 형성합니다).Java-8과의 호환성은 다음과 같은 유형의 변환 방법을 쉽게 사용할 수 있기 때문에 존재합니다.java.time.Instant ★★★★★★★★★★★★★★★★★」java.time.Period.
단점이 있나요?두 개만.
- 라이브러리는 작지 않습니다(i18n 데이터 저장소가 크기 때문이기도 합니다).
- API는 잘 알려져 있지 않기 때문에 커뮤니티 지식 및 지원을 이용할 수 없습니다.그 이외의 경우 제공된 문서는 매우 상세하고 포괄적입니다.
(콤팩트한) 대안:
더 작은 솔루션을 찾고 많은 기능이 필요하지 않으며 i18n 데이터와 관련하여 발생할 수 있는 품질 문제를 감수할 의향이 있다면 다음과 같이 하십시오.
ocpsoft/Pretty Time (실제 32개 언어 지원(34개 언어 지원)을 추천합니다)
java.util.Date@ataylor) @ @ 、 @ @ @ @ @ @ 。큰 커뮤니티 배경을 가진 업계 표준 CLDR(Unicode 컨소시엄)은 불행히도 i18n 데이터의 기반이 아니기 때문에 데이터의 추가 개선 또는 개선에는 시간이 걸릴 수 있습니다.Android의 경우 도우미 클래스 Android.text.format을 사용합니다.Date Utils는 슬림한 대체 수단입니다(단, 몇 년 또는 몇 개월 동안 지원되지 않는다는 단점이 있습니다).그리고 이 도우미 클래스의 API 스타일을 좋아하는 사람은 거의 없을 것입니다.
Joda-Time의 팬이라면 클래스 PeriodFormat(릴리스 v2.9.4의 14개 언어 지원, 반대편: Joda-Time도 확실히 콤팩트하지 않기 때문에, 여기서 간단하게 설명하겠습니다)을 참조해 주세요.상대 시간은 전혀 지원되지 않기 때문에 이 라이브러리는 실제 답이 아닙니다.최소한 리터럴 "이전"을 추가해야 합니다(그리고 생성된 목록 형식에서 모든 하위 단위를 수동으로 제거합니다). 어색합니다.Time4J나 Android-DateUtils와 달리 약어나 상대시간에서 절대시간 표현으로의 자동 전환은 특별히 지원하지 않습니다.Pretty Time과 마찬가지로 Java 커뮤니티의 프라이빗 멤버의 i18n 데이터에 대한 확인되지 않은 기여에 전적으로 의존하고 있습니다.
간단한 '오늘', '어제', 'x일 전'을 찾는다면
private String getDaysAgo(Date date){
long days = (new Date().getTime() - date.getTime()) / 86400000;
if(days == 0) return "Today";
else if(days == 1) return "Yesterday";
else return days + " days ago";
}
java.time
Java 8 이후에 내장된 java.time 프레임워크를 사용합니다.
LocalDateTime t1 = LocalDateTime.of(2015, 1, 1, 0, 0, 0);
LocalDateTime t2 = LocalDateTime.now();
Period period = Period.between(t1.toLocalDate(), t2.toLocalDate());
Duration duration = Duration.between(t1, t2);
System.out.println("First January 2015 is " + period.getYears() + " years ago");
System.out.println("First January 2015 is " + period.getMonths() + " months ago");
System.out.println("First January 2015 is " + period.getDays() + " days ago");
System.out.println("First January 2015 is " + duration.toHours() + " hours ago");
System.out.println("First January 2015 is " + duration.toMinutes() + " minutes ago");
java.time
Habsq의 답변은 옳지만 잘못된 방법을 가지고 있다.
타임라인에 연결되어 있지 않은 기간(년/월/일)의 경우 를 사용합니다.달력과 시간-분-초와 무관한 24시간 청크를 의미하는 일에는 를 사용하십시오.두 척도를 혼재시키는 것은 의미가 없습니다.
Duration
먼저 클래스를 사용하여 UTC에 표시된 현재 모멘트를 가져옵니다.
Instant now = Instant.now(); // Capture the current moment as seen in UTC.
Instant then = now.minus( 8L , ChronoUnit.HOURS ).minus( 8L , ChronoUnit.MINUTES ).minus( 8L , ChronoUnit.SECONDS );
Duration d = Duration.between( then , now );
시간, 분 및 초의 텍스트를 생성합니다.
// Generate text by calling `to…Part` methods.
String output = d.toHoursPart() + " hours ago\n" + d.toMinutesPart() + " minutes ago\n" + d.toSecondsPart() + " seconds ago";
콘솔에 덤프합니다.
System.out.println( "From: " + then + " to: " + now );
System.out.println( output );
시작: 2019-06-04T11:53.714965Z ~ 2019-06-04T20:02:03.714965Z
8시간전에
8분전에
8초 전에
Period
현재 날짜를 가져오는 것부터 시작합니다.
표준 시간대는 날짜를 결정하는 데 매우 중요합니다.날짜는 지역에 따라 전 세계적으로 다릅니다.예를 들어 프랑스 파리에서는 자정 몇 분 후가 새로운 날이고 몽트레알 퀘벡에서는 여전히 "어제"입니다.
시간대가 지정되지 않은 경우 JVM은 현재 기본 시간대를 암묵적으로 적용합니다.이 기본값은 런타임(!) 중 언제든지 변경될 수 있으므로 결과가 달라질 수 있습니다.원하는/예상 시간대를 인수로 명시적으로 지정하는 것이 좋습니다.중요한 경우 사용자에게 존을 확인합니다.
다음 형식으로 적절한 시간대 이름을 지정합니다.Continent/Region 「」, 「」등입니다.America/Montreal,Africa/Casablanca , 「」Pacific/Auckland .EST ★★★★★★★★★★★★★★★★★」IST이는 실시간 존이 아니며 표준화되지 않았으며 고유하지도 않기 때문입니다(!).
ZoneId z = ZoneId.of( "America/Montreal" ) ;
LocalDate today = LocalDate.now( z ) ;
8일, 월, 년 전 날짜를 다시 만듭니다.
LocalDate then = today.minusYears( 8 ).minusMonths( 8 ).minusDays( 7 ); // Notice the 7 days, not 8, because of granularity of months.
경과시간을 계산합니다.
Period p = Period.between( then , today );
"time ago" 조각의 줄을 만듭니다.
String output = p.getDays() + " days ago\n" + p.getMonths() + " months ago\n" + p.getYears() + " years ago";
콘솔에 덤프합니다.
System.out.println( "From: " + then + " to: " + today );
System.out.println( output );
시작일 : 2010-09-27 ~ 2019-06-04
8일전에
8개월 전
8년 전
java.time 정보
java.time 프레임워크는 Java 8 이후에 포함되어 있습니다.이러한 클래스는 , 및 등 문제가 많은 오래된 레거시 날짜 시간 클래스를 대체합니다.
자세한 내용은 Oracle 자습서를 참조하십시오.또한 Stack Overflow를 검색하여 많은 예와 설명을 확인하십시오.사양은 JSR 310입니다.
현재 유지보수 모드에 있는 조다 타임 프로젝트는 java.time 클래스로의 이행을 권장합니다.
java.time 객체를 데이터베이스와 직접 교환할 수 있습니다.JDBC 4.2 이후에 준거한JDBC 드라이버를 사용합니다.스트링도 필요 없고java.sql.*②.
java.time 클래스는 어디서 얻을 수 있습니까?
- 자바 SE 8, 자바 SE 9, 자바 SE 10, 자바 SE 11 및 이후 - 표준 Java API의 일부이며 번들 구현이 포함되어 있습니다.
- Java 9에는 몇 가지 사소한 기능과 수정 사항이 추가되어 있습니다.
- 자바 SE 6 및 자바 SE 7
- java.time 기능의 대부분은 ThreeTen 백포트의 Java 6 및7로 백포트됩니다.
- 안드로이드
- 최신 버전의 Android 번들 구현 java.time 클래스.
- 이전의 Android(<26)에서는 쓰리텐ABP 프로젝트가 ThreeTen-Backport(상기)를 채택하고 있습니다.'쓰리텐ABP 사용방법'을 참조하십시오.
쓰리텐 엑스트라 프로젝트는 java.time을 추가 클래스로 확장합니다.이 프로젝트는 향후 java.time에 추가될 수 있는 가능성을 입증하는 기반입니다.여기에는 , , , 등 유용한 클래스가 있습니다.
당신이 원하는 jquery-timeago 플러그인의 간단한 Java timeago 포트를 만들었습니다.
TimeAgo time = new TimeAgo();
String minutes = time.timeAgo(System.currentTimeMillis() - (15*60*1000)); // returns "15 minutes ago"
Android용 앱을 개발하는 경우, 이러한 모든 요건에 대한 유틸리티 클래스 DateUtils가 제공됩니다.DateUtils#getRelativeTimeSpanString() 유틸리티 메서드를 확인합니다.
의 문서로부터
CharSequence getRelative TimeSpanString(긴 시간, 긴 시간, 긴 시간, 긴 최소 해상도)
'time'을 'now'에 상대적인 시간으로 설명하는 문자열을 반환합니다.과거의 시간 범위는 "42분 전"과 같은 형식입니다.미래의 시간 범위는 "In 42 minutes"와 같은 형식입니다.
통과하게 될 거야.timestamp시간적으로 그리고System.currentTimeMillis()지금처럼.그minResolution를 사용하여 보고할 최소 시간 범위를 지정할 수 있습니다.
예를 들어, 과거 3초가 MINUTE_IN_MILLIS로 설정되어 있으면 "0분 전"으로 보고됩니다.0, MINUTE_IN_MILLIS, HOUR_ 중 하나를 통과시킵니다.IN_MILLIS, 요일_IN_MILLIS, WEK_IN_MILLIS 등
Android의 경우:
이것만 사용해 주세요.
public static String getTimeAgoFormat(long timestamp) {
return android.text.format.DateUtils.getRelativeTimeSpanString(timestamp).toString();
}
(댓글에서)
joda-time 패키지에는 Period라는 개념이 있습니다.Periods와 DateTimes로 계산을 할 수 있습니다.
문서에서:
public boolean isRentalOverdue(DateTime datetimeRented) {
Period rentalPeriod = new Period().withDays(2).withHours(12);
return datetimeRented.plus(rentalPeriod).isBeforeNow();
}
이 함수를 사용하여 시간 전을 계산할 수 있습니다.
private String timeAgo(long time_ago) {
long cur_time = (Calendar.getInstance().getTimeInMillis()) / 1000;
long time_elapsed = cur_time - time_ago;
long seconds = time_elapsed;
int minutes = Math.round(time_elapsed / 60);
int hours = Math.round(time_elapsed / 3600);
int days = Math.round(time_elapsed / 86400);
int weeks = Math.round(time_elapsed / 604800);
int months = Math.round(time_elapsed / 2600640);
int years = Math.round(time_elapsed / 31207680);
// Seconds
if (seconds <= 60) {
return "just now";
}
//Minutes
else if (minutes <= 60) {
if (minutes == 1) {
return "one minute ago";
} else {
return minutes + " minutes ago";
}
}
//Hours
else if (hours <= 24) {
if (hours == 1) {
return "an hour ago";
} else {
return hours + " hrs ago";
}
}
//Days
else if (days <= 7) {
if (days == 1) {
return "yesterday";
} else {
return days + " days ago";
}
}
//Weeks
else if (weeks <= 4.3) {
if (weeks == 1) {
return "a week ago";
} else {
return weeks + " weeks ago";
}
}
//Months
else if (months <= 12) {
if (months == 1) {
return "a month ago";
} else {
return months + " months ago";
}
}
//Years
else {
if (years == 1) {
return "one year ago";
} else {
return years + " years ago";
}
}
}
1) 여기서 time_ago는 마이크로초 단위입니다.
private const val SECOND_MILLIS = 1
private const val MINUTE_MILLIS = 60 * SECOND_MILLIS
private const val HOUR_MILLIS = 60 * MINUTE_MILLIS
private const val DAY_MILLIS = 24 * HOUR_MILLIS
object TimeAgo {
fun timeAgo(time: Int): String {
val now = TimeUnit.MILLISECONDS.toSeconds(System.currentTimeMillis())
if (time > now || time <= 0) {
return "in the future"
}
val diff = now - time
return when {
diff < MINUTE_MILLIS -> "Just now"
diff < 2 * MINUTE_MILLIS -> "a minute ago"
diff < 60 * MINUTE_MILLIS -> "${diff / MINUTE_MILLIS} minutes ago"
diff < 2 * HOUR_MILLIS -> "an hour ago"
diff < 24 * HOUR_MILLIS -> "${diff / HOUR_MILLIS} hours ago"
diff < 48 * HOUR_MILLIS -> "yesterday"
else -> "${diff / DAY_MILLIS} days ago"
}
}
}
불러
val 문자열 = timeAgo(unixTimeStamp)
코틀린에 도착해서
예쁘지 않아...하지만 가장 가까운 것은 Joda-Time을 사용하는 것입니다(이 게시물에서 설명한 바와 같이).Joda Time으로 앞으로의 경과시간을 계산하는 방법은 무엇입니까?
퍼포먼스를 생각하면 이 코드가 더 좋습니다.그러면 계산 횟수가 줄어듭니다.Reason Minutes는 60초보다 큰 경우에만 계산되며 Hours는 60분보다 큰 경우에만 계산됩니다.
class timeAgo {
static String getTimeAgo(long time_ago) {
time_ago=time_ago/1000;
long cur_time = (Calendar.getInstance().getTimeInMillis())/1000 ;
long time_elapsed = cur_time - time_ago;
long seconds = time_elapsed;
// Seconds
if (seconds <= 60) {
return "Just now";
}
//Minutes
else{
int minutes = Math.round(time_elapsed / 60);
if (minutes <= 60) {
if (minutes == 1) {
return "a minute ago";
} else {
return minutes + " minutes ago";
}
}
//Hours
else {
int hours = Math.round(time_elapsed / 3600);
if (hours <= 24) {
if (hours == 1) {
return "An hour ago";
} else {
return hours + " hrs ago";
}
}
//Days
else {
int days = Math.round(time_elapsed / 86400);
if (days <= 7) {
if (days == 1) {
return "Yesterday";
} else {
return days + " days ago";
}
}
//Weeks
else {
int weeks = Math.round(time_elapsed / 604800);
if (weeks <= 4.3) {
if (weeks == 1) {
return "A week ago";
} else {
return weeks + " weeks ago";
}
}
//Months
else {
int months = Math.round(time_elapsed / 2600640);
if (months <= 12) {
if (months == 1) {
return "A month ago";
} else {
return months + " months ago";
}
}
//Years
else {
int years = Math.round(time_elapsed / 31207680);
if (years == 1) {
return "One year ago";
} else {
return years + " years ago";
}
}
}
}
}
}
}
}
}
java.time
ISO-8601 표준에 따라 모델링된 및 를 사용할 수 있으며 JSR-310 구현의 일부로 Java-8과 함께 도입되었습니다.Java-9에서는 몇 가지 편리한 방법이 도입되었습니다.
Duration시간 기반 수량 또는 시간을 계산합니다.나노초, 초, 분, 시간 등의 기간별 단위를 사용하여 액세스할 수 있습니다.또한 DAYS 단위를 사용할 수 있으며 24시간과 정확히 동일하게 취급되므로 여름 시간 효과는 무시됩니다.Period날짜 기반 시간을 계산합니다.월 등 할 수 .
데모:
import java.time.Duration;
import java.time.LocalDateTime;
import java.time.Month;
public class Main {
public static void main(String[] args) {
// An arbitrary local date and time
LocalDateTime startDateTime = LocalDateTime.of(2020, Month.DECEMBER, 10, 15, 20, 25);
// Current local date and time
LocalDateTime endDateTime = LocalDateTime.now();
Duration duration = Duration.between(startDateTime, endDateTime);
// Default format
System.out.println(duration);
// Custom format
// ####################################Java-8####################################
String formattedElapsedTime = String.format("%d days, %d hours, %d minutes, %d seconds, %d nanoseconds ago",
duration.toDays(), duration.toHours() % 24, duration.toMinutes() % 60, duration.toSeconds() % 60,
duration.toNanos() % 1000000000);
System.out.println(formattedElapsedTime);
// ##############################################################################
// ####################################Java-9####################################
formattedElapsedTime = String.format("%d days, %d hours, %d minutes, %d seconds, %d nanoseconds ago",
duration.toDaysPart(), duration.toHoursPart(), duration.toMinutesPart(), duration.toSecondsPart(),
duration.toNanosPart());
System.out.println(formattedElapsedTime);
// ##############################################################################
}
}
출력:
PT1395H35M7.355288S
58 days, 3 hours, 35 minutes, 7 seconds, 355288000 nanoseconds ago
58 days, 3 hours, 35 minutes, 7 seconds, 355288000 nanoseconds ago
두 분 정도 시간이 있으시다면UTC , 을 사용하면 .InstantLocalDateTime를 들어 예를 들어.
import java.time.Duration;
import java.time.Instant;
import java.time.temporal.ChronoUnit;
public class Main {
public static void main(String[] args) {
// Current moment at UTC
Instant now = Instant.now();
// An instant in the past
Instant startDateTime = now.minus(58, ChronoUnit.DAYS)
.minus(2, ChronoUnit.HOURS)
.minus(54, ChronoUnit.MINUTES)
.minus(24, ChronoUnit.SECONDS)
.minus(808624000, ChronoUnit.NANOS);
Duration duration = Duration.between(startDateTime, now);
// Default format
System.out.println(duration);
// Custom format
// ####################################Java-8####################################
String formattedElapsedTime = String.format("%d days, %d hours, %d minutes, %d seconds, %d nanoseconds ago",
duration.toDays(), duration.toHours() % 24, duration.toMinutes() % 60, duration.toSeconds() % 60,
duration.toNanos() % 1000000000);
System.out.println(formattedElapsedTime);
// ##############################################################################
// ####################################Java-9####################################
formattedElapsedTime = String.format("%d days, %d hours, %d minutes, %d seconds, %d nanoseconds ago",
duration.toDaysPart(), duration.toHoursPart(), duration.toMinutesPart(), duration.toSecondsPart(),
duration.toNanosPart());
System.out.println(formattedElapsedTime);
// ##############################################################################
}
}
출력:
PT1394H54M24.808624S
58 days, 2 hours, 54 minutes, 24 seconds, 808624000 nanoseconds ago
58 days, 2 hours, 54 minutes, 24 seconds, 808624000 nanoseconds ago
Period:
import java.time.LocalDate;
import java.time.Period;
import java.time.ZoneId;
public class Main {
public static void main(String[] args) {
// Replace ZoneId.systemDefault() with the applicable timezone ID e.g.
// ZoneId.of("Europe/London"). For LocalDate in the JVM's timezone, simply use
// LocalDate.now()
LocalDate endDate = LocalDate.now(ZoneId.systemDefault());
// Let's assume the start date is 1 year, 2 months, and 3 days ago
LocalDate startDate = endDate.minusYears(1).minusMonths(2).minusDays(3);
Period period = Period.between(startDate, endDate);
// Default format
System.out.println(period);
// Custom format
String formattedElapsedPeriod = String.format("%d years, %d months, %d days ago", period.getYears(),
period.getMonths(), period.getDays());
System.out.println(formattedElapsedPeriod);
}
}
출력:
P1Y2M3D
1 years, 2 months, 3 days ago
최신 날짜 API에 대한 자세한 내용은 Trail: Date Time을 참조하십시오.
- 어떤 이유로든 Java 6 또는 Java 7을 고수해야 하는 경우 대부분의 java.time 기능을 Java 6 및7로 백포트하는 ThreeTen 백포트를 사용할 수 있습니다.
- Android 프로젝트에서 일하고 있으며 Android API 레벨이 Java-8과 호환되지 않는 경우 Dissugaring과 How to Use ThreeTen을 통해 이용 가능한 Java 8+ API를 확인하십시오.Android Project의 ABP.
오랜 연구 끝에 이것을 발견했다.
public class GetTimeLapse {
public static String getlongtoago(long createdAt) {
DateFormat userDateFormat = new SimpleDateFormat("E MMM dd HH:mm:ss Z yyyy");
DateFormat dateFormatNeeded = new SimpleDateFormat("MM/dd/yyyy HH:MM:SS");
Date date = null;
date = new Date(createdAt);
String crdate1 = dateFormatNeeded.format(date);
// Date Calculation
DateFormat dateFormat = new SimpleDateFormat("MM/dd/yyyy HH:mm:ss");
crdate1 = new SimpleDateFormat("MM/dd/yyyy HH:mm:ss").format(date);
// get current date time with Calendar()
Calendar cal = Calendar.getInstance();
String currenttime = dateFormat.format(cal.getTime());
Date CreatedAt = null;
Date current = null;
try {
CreatedAt = dateFormat.parse(crdate1);
current = dateFormat.parse(currenttime);
} catch (java.text.ParseException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
// Get msec from each, and subtract.
long diff = current.getTime() - CreatedAt.getTime();
long diffSeconds = diff / 1000;
long diffMinutes = diff / (60 * 1000) % 60;
long diffHours = diff / (60 * 60 * 1000) % 24;
long diffDays = diff / (24 * 60 * 60 * 1000);
String time = null;
if (diffDays > 0) {
if (diffDays == 1) {
time = diffDays + "day ago ";
} else {
time = diffDays + "days ago ";
}
} else {
if (diffHours > 0) {
if (diffHours == 1) {
time = diffHours + "hr ago";
} else {
time = diffHours + "hrs ago";
}
} else {
if (diffMinutes > 0) {
if (diffMinutes == 1) {
time = diffMinutes + "min ago";
} else {
time = diffMinutes + "mins ago";
}
} else {
if (diffSeconds > 0) {
time = diffSeconds + "secs ago";
}
}
}
}
return time;
}
}
Java 라이브러리 RelativeDateTimeFormatter를 사용하면 다음과 같은 작업을 수행할 수 있습니다.
RelativeDateTimeFormatter fmt = RelativeDateTimeFormatter.getInstance();
fmt.format(1, Direction.NEXT, RelativeUnit.DAYS); // "in 1 day"
fmt.format(3, Direction.NEXT, RelativeUnit.DAYS); // "in 3 days"
fmt.format(3.2, Direction.LAST, RelativeUnit.YEARS); // "3.2 years ago"
fmt.format(Direction.LAST, AbsoluteUnit.SUNDAY); // "last Sunday"
fmt.format(Direction.THIS, AbsoluteUnit.SUNDAY); // "this Sunday"
fmt.format(Direction.NEXT, AbsoluteUnit.SUNDAY); // "next Sunday"
fmt.format(Direction.PLAIN, AbsoluteUnit.SUNDAY); // "Sunday"
fmt.format(Direction.LAST, AbsoluteUnit.DAY); // "yesterday"
fmt.format(Direction.THIS, AbsoluteUnit.DAY); // "today"
fmt.format(Direction.NEXT, AbsoluteUnit.DAY); // "tomorrow"
fmt.format(Direction.PLAIN, AbsoluteUnit.NOW); // "now"
SQL 타임스탬프를 현재 경과시간으로 설정합니다.독자적인 타임 존을 설정합니다.
참고 1: 단수/복수를 처리합니다.
주의 2: Joda time을 사용하고 있습니다.
String getElapsedTime(String strMysqlTimestamp) {
DateTimeFormatter formatter = DateTimeFormat.forPattern("YYYY-MM-dd HH:mm:ss.S");
DateTime mysqlDate = formatter.parseDateTime(strMysqlTimestamp).
withZone(DateTimeZone.forID("Asia/Kuala_Lumpur"));
DateTime now = new DateTime();
Period period = new Period(mysqlDate, now);
int seconds = period.getSeconds();
int minutes = period.getMinutes();
int hours = period.getHours();
int days = period.getDays();
int weeks = period.getWeeks();
int months = period.getMonths();
int years = period.getYears();
String elapsedTime = "";
if (years != 0)
if (years == 1)
elapsedTime = years + " year ago";
else
elapsedTime = years + " years ago";
else if (months != 0)
if (months == 1)
elapsedTime = months + " month ago";
else
elapsedTime = months + " months ago";
else if (weeks != 0)
if (weeks == 1)
elapsedTime = weeks + " week ago";
else
elapsedTime = weeks + " weeks ago";
else if (days != 0)
if (days == 1)
elapsedTime = days + " day ago";
else
elapsedTime = days + " days ago";
else if (hours != 0)
if (hours == 1)
elapsedTime = hours + " hour ago";
else
elapsedTime = hours + " hours ago";
else if (minutes != 0)
if (minutes == 1)
elapsedTime = minutes + " minute ago";
else
elapsedTime = minutes + " minutes ago";
else if (seconds != 0)
if (seconds == 1)
elapsedTime = seconds + " second ago";
else
elapsedTime = seconds + " seconds ago";
return elapsedTime;
}
Android의 경우 Ravi가 말한 대로입니다만, 많은 사람이 카피 페이스트 하고 싶어하기 때문에, 여기에 있습니다.
try {
SimpleDateFormat formatter = new SimpleDateFormat("EEE, dd MMM yyyy HH:mm:ss Z");
Date dt = formatter.parse(date_from_server);
CharSequence output = DateUtils.getRelativeTimeSpanString (dt.getTime());
your_textview.setText(output.toString());
} catch (Exception ex) {
ex.printStackTrace();
your_textview.setText("");
}
시간이 더 있는 분들을 위한 설명
- 어디선가 데이터를 얻을 수 있습니다.먼저, 그것의 형식을 파악해야 합니다.
예. 2016년 1월 27일(수) 09:32:35 GMT 형식으로 서버로부터 데이터를 받습니다.[이 경우는 고객님의 경우가 아닐 수 있습니다]
이것은 로 번역된다.
SimpleDateFormatter = 새로운 SimpleDateFormat("EE, dd MMM yyy HH:mm:ss Z");
내가 어떻게 알아?메뉴얼은 이쪽에서 읽어 주세요.
그걸 해석하고 나면 데이트 상대도 얻을 수 있어요getRelativeTimeSpanString에 입력한 날짜(기본값은 분 단위이므로 추가 파라미터는 필요 없습니다)
올바른 구문 분석 문자열, 문자 5의 예외와 같은 것을 알아내지 못한 경우 예외가 발생합니다.문자 5를 보고 첫 번째 구문 분석 문자열을 수정합니다.다른 예외가 발생할 수 있습니다. 올바른 수식이 나올 때까지 이 단계를 반복합니다.
다음은 이 기능의 Java 구현입니다.
public static String relativeDate(Date date){
Date now=new Date();
if(date.before(now)){
int days_passed=(int) TimeUnit.MILLISECONDS.toDays(now.getTime() - date.getTime());
if(days_passed>1)return days_passed+" days ago";
else{
int hours_passed=(int) TimeUnit.MILLISECONDS.toHours(now.getTime() - date.getTime());
if(hours_passed>1)return days_passed+" hours ago";
else{
int minutes_passed=(int) TimeUnit.MILLISECONDS.toMinutes(now.getTime() - date.getTime());
if(minutes_passed>1)return minutes_passed+" minutes ago";
else{
int seconds_passed=(int) TimeUnit.MILLISECONDS.toSeconds(now.getTime() - date.getTime());
return seconds_passed +" seconds ago";
}
}
}
}
else
{
return new SimpleDateFormat("HH:mm:ss MM/dd/yyyy").format(date).toString();
}
}
나에겐 효과가 있어
public class TimeDifference {
int years;
int months;
int days;
int hours;
int minutes;
int seconds;
String differenceString;
public TimeDifference(@NonNull Date curdate, @NonNull Date olddate) {
float diff = curdate.getTime() - olddate.getTime();
if (diff >= 0) {
int yearDiff = Math.round((diff / (AppConstant.aLong * AppConstant.aFloat)) >= 1 ? (diff / (AppConstant.aLong * AppConstant.aFloat)) : 0);
if (yearDiff > 0) {
years = yearDiff;
setDifferenceString(years + (years == 1 ? " year" : " years") + " ago");
} else {
int monthDiff = Math.round((diff / AppConstant.aFloat) >= 1 ? (diff / AppConstant.aFloat) : 0);
if (monthDiff > 0) {
if (monthDiff > AppConstant.ELEVEN) {
monthDiff = AppConstant.ELEVEN;
}
months = monthDiff;
setDifferenceString(months + (months == 1 ? " month" : " months") + " ago");
} else {
int dayDiff = Math.round((diff / (AppConstant.bFloat)) >= 1 ? (diff / (AppConstant.bFloat)) : 0);
if (dayDiff > 0) {
days = dayDiff;
if (days == AppConstant.THIRTY) {
days = AppConstant.TWENTYNINE;
}
setDifferenceString(days + (days == 1 ? " day" : " days") + " ago");
} else {
int hourDiff = Math.round((diff / (AppConstant.cFloat)) >= 1 ? (diff / (AppConstant.cFloat)) : 0);
if (hourDiff > 0) {
hours = hourDiff;
setDifferenceString(hours + (hours == 1 ? " hour" : " hours") + " ago");
} else {
int minuteDiff = Math.round((diff / (AppConstant.dFloat)) >= 1 ? (diff / (AppConstant.dFloat)) : 0);
if (minuteDiff > 0) {
minutes = minuteDiff;
setDifferenceString(minutes + (minutes == 1 ? " minute" : " minutes") + " ago");
} else {
int secondDiff = Math.round((diff / (AppConstant.eFloat)) >= 1 ? (diff / (AppConstant.eFloat)) : 0);
if (secondDiff > 0) {
seconds = secondDiff;
} else {
seconds = 1;
}
setDifferenceString(seconds + (seconds == 1 ? " second" : " seconds") + " ago");
}
}
}
}
}
} else {
setDifferenceString("Just now");
}
}
public String getDifferenceString() {
return differenceString;
}
public void setDifferenceString(String differenceString) {
this.differenceString = differenceString;
}
public int getYears() {
return years;
}
public void setYears(int years) {
this.years = years;
}
public int getMonths() {
return months;
}
public void setMonths(int months) {
this.months = months;
}
public int getDays() {
return days;
}
public void setDays(int days) {
this.days = days;
}
public int getHours() {
return hours;
}
public void setHours(int hours) {
this.hours = hours;
}
public int getMinutes() {
return minutes;
}
public void setMinutes(int minutes) {
this.minutes = minutes;
}
public int getSeconds() {
return seconds;
}
public void setSeconds(int seconds) {
this.seconds = seconds;
} }
쉽게 수 .이치노
: ( 전) 전오늘 : (XXX일 전/어제/일)
<span id='hourpost'></span>
,or
<span id='daypost'></span>
<script>
var postTime = new Date('2017/6/9 00:01');
var now = new Date();
var difference = now.getTime() - postTime.getTime();
var minutes = Math.round(difference/60000);
var hours = Math.round(minutes/60);
var days = Math.round(hours/24);
var result;
if (days < 1) {
result = "Today";
} else if (days < 2) {
result = "Yesterday";
} else {
result = days + " Days ago";
}
document.getElementById("hourpost").innerHTML = hours + "Hours Ago" ;
document.getElementById("daypost").innerHTML = result ;
</script>
에 나는 이 일을 .Just Now, seconds ago, min ago, hrs ago, days ago, weeks ago, months ago, years ago에서는 날짜를 할 수 .2018-09-05T06:40:46.183Z this or any like this or like below.
string.xml에 아래 값을 추가합니다.
<string name="lbl_justnow">Just Now</string>
<string name="lbl_seconds_ago">seconds ago</string>
<string name="lbl_min_ago">min ago</string>
<string name="lbl_mins_ago">mins ago</string>
<string name="lbl_hr_ago">hr ago</string>
<string name="lbl_hrs_ago">hrs ago</string>
<string name="lbl_day_ago">day ago</string>
<string name="lbl_days_ago">days ago</string>
<string name="lbl_lstweek_ago">last week</string>
<string name="lbl_week_ago">weeks ago</string>
<string name="lbl_onemonth_ago">1 month ago</string>
<string name="lbl_month_ago">months ago</string>
<string name="lbl_oneyear_ago" >last year</string>
<string name="lbl_year_ago" >years ago</string>
Java 코드 아래 시도
public String getFormatDate(String postTime1) {
Calendar cal=Calendar.getInstance();
Date now=cal.getTime();
String disTime="";
try {
Date postTime;
//2018-09-05T06:40:46.183Z
postTime = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'").parse(postTime1);
long diff=(now.getTime()-postTime.getTime()+18000)/1000;
//for months
Calendar calObj = Calendar.getInstance();
calObj.setTime(postTime);
int m=calObj.get(Calendar.MONTH);
calObj.setTime(now);
SimpleDateFormat monthFormatter = new SimpleDateFormat("MM"); // output month
int mNow = Integer.parseInt(monthFormatter.format(postTime));
diff = diff-19800;
if(diff<15) { //below 15 sec
disTime = getResources().getString(R.string.lbl_justnow);
} else if(diff<60) {
//below 1 min
disTime= diff+" "+getResources().getString(R.string.lbl_seconds_ago);
} else if(diff<3600) {//below 1 hr
// convert min
long temp=diff/60;
if(temp==1) {
disTime= temp + " " +getResources().getString(R.string.lbl_min_ago);
} else {
disTime = temp + " " +getResources().getString(R.string.lbl_mins_ago);
}
} else if(diff<(24*3600)) {// below 1 day
// convert hr
long temp= diff/3600;
System.out.println("hey temp3:"+temp);
if(temp==1) {
disTime = temp + " " +getResources().getString(R.string.lbl_hr_ago);
} else {
disTime = temp + " " +getResources().getString(R.string.lbl_hrs_ago);
}
} else if(diff<(24*3600*7)) {// below week
// convert days
long temp=diff/(3600*24);
if (temp==1) {
// disTime = "\nyesterday";
disTime = temp + " " +getResources().getString(R.string.lbl_day_ago);
} else {
disTime = temp + " " +getResources().getString(R.string.lbl_days_ago);
}
} else if(diff<((24*3600*28))) {// below month
// convert week
long temp=diff/(3600*24*7);
if (temp <= 4) {
if (temp < 1) {
disTime = getResources().getString(R.string.lbl_lstweek_ago);
}else{
disTime = temp + " " + getResources().getString(R.string.lbl_week_ago);
}
} else {
int diffMonth = mNow - m;
Log.e("count : ", String.valueOf(diffMonth));
disTime = diffMonth + " " + getResources().getString(R.string.lbl_month_ago);
}
}else if(diff<((24*3600*365))) {// below year
// convert month
long temp=diff/(3600*24*30);
System.out.println("hey temp2:"+temp);
if (temp <= 12) {
if (temp == 1) {
disTime = getResources().getString(R.string.lbl_onemonth_ago);
}else{
disTime = temp + " " + getResources().getString(R.string.lbl_month_ago);
}
}
}else if(diff>((24*3600*365))) { // above year
// convert year
long temp=diff/(3600*24*30*12);
System.out.println("hey temp8:"+temp);
if (temp == 1) {
disTime = getResources().getString(R.string.lbl_oneyear_ago);
}else{
disTime = temp + " " + getResources().getString(R.string.lbl_year_ago);
}
}
} catch(Exception e) {
e.printStackTrace();
}
return disTime;
}
Instant, Date 및 Date Time Utils를 사용하고 있습니다.데이터베이스에 String 유형으로 저장된 후 Instant로 변환되는 데이터(날짜)입니다.
/*
This method is to display ago.
Example: 3 minutes ago.
I already implement the latest which is including the Instant.
Convert from String to Instant and then parse to Date.
*/
public String convertTimeToAgo(String dataDate) {
//Initialize
String conversionTime = null;
String suffix = "Yang Lalu";
Date pastTime;
//Parse from String (which is stored as Instant.now().toString()
//And then convert to become Date
Instant instant = Instant.parse(dataDate);
pastTime = DateTimeUtils.toDate(instant);
//Today date
Date nowTime = new Date();
long dateDiff = nowTime.getTime() - pastTime.getTime();
long second = TimeUnit.MILLISECONDS.toSeconds(dateDiff);
long minute = TimeUnit.MILLISECONDS.toMinutes(dateDiff);
long hour = TimeUnit.MILLISECONDS.toHours(dateDiff);
long day = TimeUnit.MILLISECONDS.toDays(dateDiff);
if (second < 60) {
conversionTime = second + " Saat " + suffix;
} else if (minute < 60) {
conversionTime = minute + " Minit " + suffix;
} else if (hour < 24) {
conversionTime = hour + " Jam " + suffix;
} else if (day >= 7) {
if (day > 30) {
conversionTime = (day / 30) + " Bulan " + suffix;
} else if (day > 360) {
conversionTime = (day / 360) + " Tahun " + suffix;
} else {
conversionTime = (day / 7) + " Minggu " + suffix;
}
} else if (day < 7) {
conversionTime = day + " Hari " + suffix;
}
return conversionTime;
}
다음 솔루션은 모두 순수 Java로 구성되어 있습니다.
옵션 1: 반올림 없음, 최대 시간 컨테이너만
는 예를이 is음 음 is the음 the is is is is the is the the the the the the the the 인 경우 가장 큰 컨테이너만 합니다. 「 」, 「 」"1 month 14 days ago"이 함수는 표시만 합니다."1 month ago"에 반올림 시간이 "50 days ago"됩니다."1 month"
public String formatTimeAgo(long millis) {
String[] ids = new String[]{"second","minute","hour","day","month","year"};
long seconds = millis / 1000;
long minutes = seconds / 60;
long hours = minutes / 60;
long days = hours / 24;
long months = days / 30;
long years = months / 12;
ArrayList<Long> times = new ArrayList<>(Arrays.asList(years, months, days, hours, minutes, seconds));
for(int i = 0; i < times.size(); i++) {
if(times.get(i) != 0) {
long value = times.get(i).intValue();
return value + " " + ids[ids.length - 1 - i] + (value == 1 ? "" : "s") + " ago";
}
}
return "0 seconds ago";
}
옵션 2: 반올림 포함
를 Math 반올림하고 Math.round(...)로 묶습니다.50 days로로 합니다.2 months , 「」long months = days / 30로로 합니다.long months = Math.round(days / 30.0)
언급URL : https://stackoverflow.com/questions/3859288/how-to-calculate-time-ago-in-java
반응형
'IT' 카테고리의 다른 글
| LoDash: 객체 속성 배열에서 값 배열 가져오기 (0) | 2022.12.07 |
|---|---|
| 숫자가 정확성을 잃지 않고 도달할 수 있는 JavaScript의 최대 정수 값은 얼마입니까? (0) | 2022.12.07 |
| libcurl이 있는 HTTP 상태 코드? (0) | 2022.12.07 |
| PHP에서 5의 가장 가까운 배수까지 반올림 (0) | 2022.12.07 |
| Intelij IDEA에서 메서드 파라미터 힌트를 표시하는 방법 (0) | 2022.12.07 |