Java 目前如何接近时间[Android Studio]
我有5次 例如： 凌晨4:21 12:1下午 下午3:32 下午6:30 晚上8:4 现在的时间是 上午10:4 我想做一个比较 下一次最接近当前时间的时间是什么 结果将是：Java 目前如何接近时间[Android Studio],java,android,Java,Android,我有5次 例如： 凌晨4:21 12:1下午 下午3:32 下午6:30 晚上8:4 现在的时间是 上午10:4 我想做一个比较 下一次最接近当前时间的时间是什么 结果将是： 下次：12:1 PM您可以将时间转换为日期对象，然后转换为长时间（自1970年1月1日起的毫秒），并以毫秒为单位计算差值 long diffInMs = currentDate.getTime() - anotherDate.getTime(); 然后检查哪个差值最小，但也等于或大于零。负差表示旧日期，您需要下一个最近的
下次：12:1 PM您可以将时间转换为日期对象，然后转换为长时间（自1970年1月1日起的毫秒），并以毫秒为单位计算差值
long diffInMs = currentDate.getTime() - anotherDate.getTime();
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
sdf.setTimeZone(TimeZone.getTimeZone("UTC"));
String inputString = "00:01:30.500";
Date date = sdf.parse("1970-01-01 " + inputString);
您可以将时间转换为日期对象，然后转换为长时间（自1970年1月1日以来的毫秒），并以毫秒为单位计算差值
long diffInMs = currentDate.getTime() - anotherDate.getTime();
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
sdf.setTimeZone(TimeZone.getTimeZone("UTC"));
String inputString = "00:01:30.500";
Date date = sdf.parse("1970-01-01 " + inputString);
public static String findNext(String current, String... times) throws ParseException {
SimpleDateFormat fmt = new SimpleDateFormat("hh:mm a");
fmt.setTimeZone(TimeZone.getTimeZone("UTC"));
long currentMillis = fmt.parse(current).getTime();
long bestMillis = 0, minMillis = 0;
String bestTime = null, minTime = null;
for (String time : times) {
long millis = fmt.parse(time).getTime();
if (millis >= currentMillis && (bestTime == null || millis < bestMillis)) {
bestMillis = millis;
bestTime = time;
}
if (minTime == null || millis < minMillis) {
minMillis = millis;
minTime = time;
}
}
return (bestTime != null ? bestTime : minTime);
}
12:1下午
上午4:21
如果保证已对给定时间进行排序，则可通过二进制搜索完成：
public static String findNext(String current, String... times) {
SimpleDateFormat fmt = new SimpleDateFormat("hh:mm a");
fmt.setTimeZone(TimeZone.getTimeZone("UTC"));
int idx = Arrays.binarySearch(times, current, new Comparator<String>() {
@Override
public int compare(String s1, String s2) {
try {
return fmt.parse(s1).compareTo(fmt.parse(s2));
} catch (ParseException e) {
throw new RuntimeException(e);
}
}
});
if (idx < 0)
idx = -idx - 1;
return times[idx < times.length ? idx : 0];
}
公共静态字符串findNext（字符串当前、字符串…次）{
SimpleDataFormat fmt=新SimpleDataFormat（“hh:mm a”）；
fmt.setTimeZone（TimeZone.getTimeZone（“UTC”））；
int idx=Arrays.binarySearch（时间、当前、新比较器（）{
@凌驾
公共整数比较（字符串s1、字符串s2）{
试一试{
返回fmt.parse（s1）.compareTo（fmt.parse（s2））；
}捕获（解析异常）{
抛出新的运行时异常（e）；
}
}
});
if（idx<0）
idx=-idx-1；
返回次数[idxpublic static String findNext(String current, String... times) throws ParseException {
SimpleDateFormat fmt = new SimpleDateFormat("hh:mm a");
fmt.setTimeZone(TimeZone.getTimeZone("UTC"));
long currentMillis = fmt.parse(current).getTime();
long bestMillis = 0, minMillis = 0;
String bestTime = null, minTime = null;
for (String time : times) {
long millis = fmt.parse(time).getTime();
if (millis >= currentMillis && (bestTime == null || millis < bestMillis)) {
bestMillis = millis;
bestTime = time;
}
if (minTime == null || millis < minMillis) {
minMillis = millis;
minTime = time;
}
}
return (bestTime != null ? bestTime : minTime);
}
12:1下午
上午4:21
如果保证已对给定时间进行排序，则可通过二进制搜索完成：
public static String findNext(String current, String... times) {
SimpleDateFormat fmt = new SimpleDateFormat("hh:mm a");
fmt.setTimeZone(TimeZone.getTimeZone("UTC"));
int idx = Arrays.binarySearch(times, current, new Comparator<String>() {
@Override
public int compare(String s1, String s2) {
try {
return fmt.parse(s1).compareTo(fmt.parse(s2));
} catch (ParseException e) {
throw new RuntimeException(e);
}
}
});
if (idx < 0)
idx = -idx - 1;
return times[idx < times.length ? idx : 0];
}
公共静态字符串findNext（字符串当前、字符串…次）{
SimpleDataFormat fmt=新SimpleDataFormat（“hh:mm a”）；
fmt.setTimeZone（TimeZone.getTimeZone（“UTC”））；
int idx=Arrays.binarySearch（时间、当前、新比较器（）{
@凌驾
公共整数比较（字符串s1、字符串s2）{
试一试{
返回fmt.parse（s1）.compareTo（fmt.parse（s2））；
}捕获（解析异常）{
抛出新的运行时异常（e）；
}
}
});
if（idx<0）
idx=-idx-1；
返回次数[idx/**
*
* @author Niravdas
*/
public class TimeDiff {
String[] times = { "04:21 AM", "12:01 PM", "03:32 PM", "06:30 PM", "08:04 PM"};
String findingafter="10:04 AM";
public TimeDiff()
{
int time=nextTimeArrayIndex(findingafter,times);
if(time>=0)
System.out.println("NEXT TIME: "+times[time]);
}
public static void main(String argv[])
{
new TimeDiff();
}
int nextTimeArrayIndex(String Finding,String[] fromArray)
{
int shortest=-1,shortestsec=-1;
long minsecdif=(24*60*60+1),minsec=(24*60*60+1);
int hr=Integer.parseInt(Finding.substring(0, 2));
int min=Integer.parseInt(Finding.substring(3, 5));
long seconds = convertToSec(hr, min, 0, Finding.substring(Finding.length()-2));
System.out.println("seconds :" + seconds);
for(int i=0;i<fromArray.length;i++)
{
int temphr=Integer.parseInt(fromArray[i].substring(0, 2));
int tempmin = Integer.parseInt(fromArray[i].substring(3,5));
long tempsec = convertToSec(temphr, tempmin, 0, fromArray[i].substring(Finding.length()-2));
System.out.println("Compared to :" + tempsec);
if((tempsec - seconds) > 0 && minsecdif > (tempsec - seconds))
{
minsecdif = (tempsec - seconds);
shortest = i;
}
if(minsec > tempsec)
{
minsec = tempsec;
shortestsec=i;
}
}
if(shortest >=0)
{
return shortest;
}
else
{
return shortestsec;
}
}
long convertToSec(int hr,int min,int sec,String AMorPM)
{
if(hr==12)
{
hr=0;
}
long secs = (hr*60*60) + (min*60) + (sec*60);
if(AMorPM.equalsIgnoreCase("PM"))
{
secs += (12*60*60);
}
return secs;
}
}
/**
*
*@作者Niravdas
*/
公共类时间差{
字符串[]次={“04:21 AM”，“12:01 PM”，“03:32 PM”，“06:30 PM”，“08:04 PM”}；
字符串查找时间=“10:04 AM”；
公共时间差（）
{
int time=nextTimeArrayIndex（findingafter，times）；
如果（时间>=0）
System.out.println（“下一次：+次[时间]）；
}
公共静态void main（字符串argv[]）
{
新的TimeDiff（）；
}
int nextTimeArrayIndex（字符串查找，字符串[]fromArray）
{
int shortest=-1，shortestsec=-1；
long minsecdif=（24*60*60+1），minsec=（24*60*60+1）；
int hr=Integer.parseInt（Finding.substring（0，2））；
intmin=Integer.parseInt（Finding.substring（3,5））；
long seconds=convertToSec（hr，min，0，Finding.substring（Finding.length（）-2））；
System.out.println（“秒：+秒）；
对于（inti=0；i0&&minsecdif>（tempsec-seconds））
{
minsecdif=（tempsec-秒）；
最短=i；
}
如果（分钟>秒）
{
minsec=tempsec；
最短秒=i；
}
}
如果（最短>=0）
{
返回时间最短；
}
其他的
{
返回最短秒；
}
}
长转换秒（整数小时、整数分钟、整数秒、字符串时间）
{
如果（hr==12）
{
hr=0；
}
长秒=（小时*60*60）+（分钟*60）+（秒*60）；
if（非对称等信号情况（“PM”））
{
秒+=（12*60*60）；
}
返回秒数；
}
}
我希望它能解决您的问题。我专门设计了一个函数来解决您的问题，可以根据您的需要使用函数 这肯定对你有用
/**
*
* @author Niravdas
*/
public class TimeDiff {
String[] times = { "04:21 AM", "12:01 PM", "03:32 PM", "06:30 PM", "08:04 PM"};
String findingafter="10:04 AM";
public TimeDiff()
{
int time=nextTimeArrayIndex(findingafter,times);
if(time>=0)
System.out.println("NEXT TIME: "+times[time]);
}
public static void main(String argv[])
{
new TimeDiff();
}
int nextTimeArrayIndex(String Finding,String[] fromArray)
{
int shortest=-1,shortestsec=-1;
long minsecdif=(24*60*60+1),minsec=(24*60*60+1);
int hr=Integer.parseInt(Finding.substring(0, 2));
int min=Integer.parseInt(Finding.substring(3, 5));
long seconds = convertToSec(hr, min, 0, Finding.substring(Finding.length()-2));
System.out.println("seconds :" + seconds);
for(int i=0;i<fromArray.length;i++)
{
int temphr=Integer.parseInt(fromArray[i].substring(0, 2));
int tempmin = Integer.parseInt(fromArray[i].substring(3,5));
long tempsec = convertToSec(temphr, tempmin, 0, fromArray[i].substring(Finding.length()-2));
System.out.println("Compared to :" + tempsec);
if((tempsec - seconds) > 0 && minsecdif > (tempsec - seconds))
{
minsecdif = (tempsec - seconds);
shortest = i;
}
if(minsec > tempsec)
{
minsec = tempsec;
shortestsec=i;
}
}
if(shortest >=0)
{
return shortest;
}
else
{
return shortestsec;
}
}
long convertToSec(int hr,int min,int sec,String AMorPM)
{
if(hr==12)
{
hr=0;
}
long secs = (hr*60*60) + (min*60) + (sec*60);
if(AMorPM.equalsIgnoreCase("PM"))
{
secs += (12*60*60);
}
return secs;
}
}
/**
*
*@作者Niravdas
*/
公共类时间差{
字符串[]次={“04:21 AM”，“12:01 PM”，“03:32 PM”，“06:30 PM”，“08:04 PM”}；
字符串查找时间=“10:04 AM”；
公共时间差（）
{
int time=nextTimeArrayIndex（findingafter，times）；
如果（时间>=0）
System.out.println（“下一次：+次[时间]）；
}
公共静态void main（字符串argv[]）
{
新Ti