java - reales - libro de android studio en español pdf

Compruebe si un tiempo determinado se encuentra entre dos veces, independientemente de la fecha

Question

Tengo timespans:

String time1 = 01:00:00

String time2 = 05:00:00

Quiero verificar si 20:11:13 and 14:49:00 encuentran entre las 20:11:13 and 14:49:00 .

En realidad, 01:00:00 es mayor que 20:11:13 y menos de 14:49:00 considerando 20:11:13 siempre es menos de 14:49:00 . Esto es un requisito previo.

Entonces lo que quiero es, 20:11:13 < 01:00:00 < 14:49:00 .

Entonces necesito algo como eso:

 public void getTimeSpans()
{
boolean firstTime = false, secondTime = false;
if(time1 > "20:11:13" && time1 < "14:49:00")
{
firstTime = true;
}
if(time2 > "20:11:13" && time2 < "14:49:00")
{
secondTime = true;
}
}

Sé que este código no da un resultado correcto ya que estoy comparando los objetos de cadena.

¿Cómo hacer eso, ya que son los intervalos de tiempo, pero no las cadenas para comparar?

Answer 1

Código modificado @Surendra Jnawali ''. Falla

si la hora actual es 23:40:00 es decir, mayor que la hora de inicio y menor que igual a 23:59:59.

Todo el crédito va al verdadero dueño

Así es como debería ser: Esto funciona perfecto

public static boolean isTimeBetweenTwoTime(String argStartTime,
String argEndTime, String argCurrentTime) throws ParseException {
String reg = "^([0-1][0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9])$";
//
if (argStartTime.matches(reg) && argEndTime.matches(reg)
&& argCurrentTime.matches(reg)) {
boolean valid = false;
// Start Time
java.util.Date startTime = new SimpleDateFormat("HH:mm:ss")
.parse(argStartTime);
Calendar startCalendar = Calendar.getInstance();
startCalendar.setTime(startTime);
// Current Time
java.util.Date currentTime = new SimpleDateFormat("HH:mm:ss")
.parse(argCurrentTime);
Calendar currentCalendar = Calendar.getInstance();
currentCalendar.setTime(currentTime);
// End Time
java.util.Date endTime = new SimpleDateFormat("HH:mm:ss")
.parse(argEndTime);
Calendar endCalendar = Calendar.getInstance();
endCalendar.setTime(endTime);
//
if (currentTime.compareTo(endTime) < 0) {
currentCalendar.add(Calendar.DATE, 1);
currentTime = currentCalendar.getTime();
}
if (startTime.compareTo(endTime) < 0) {
startCalendar.add(Calendar.DATE, 1);
startTime = startCalendar.getTime();
}
//
if (currentTime.before(startTime)) {
System.out.println(" Time is Lesser ");
valid = false;
} else {
if (currentTime.after(endTime)) {
endCalendar.add(Calendar.DATE, 1);
endTime = endCalendar.getTime();
}
System.out.println("Comparing , Start Time /n " + startTime);
System.out.println("Comparing , End Time /n " + endTime);
System.out
.println("Comparing , Current Time /n " + currentTime);
if (currentTime.before(endTime)) {
System.out.println("RESULT, Time lies b/w");
valid = true;
} else {
valid = false;
System.out.println("RESULT, Time does not lies b/w");
}
}
return valid;
} else {
throw new IllegalArgumentException(
"Not a valid time, expecting HH:MM:SS format");
}
}

RESULTADO

Comparing , Start Time /n Thu Jan 01 23:00:00 IST 1970
Comparing , End Time /n Fri Jan 02 02:00:00 IST 1970
Comparing , Current Time /n Fri Jan 02 01:50:00 IST 1970
RESULT, Time lies b/w

Answer 2

Después de leer algunas respuestas, creo que la escritura es demasiado complicada. Prueba mi código

public static boolean compare(String system_time, String currentTime, String endtimes) {
try {
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("HH:mm:ss");
Date startime = simpleDateFormat.parse("19:25:00");
Date endtime = simpleDateFormat.parse("20:30:00");
//current time
Date current_time = simpleDateFormat.parse("20:00:00");
if (current_time.after(startime) && current_time.before(endtime)) {
System.out.println("Yes");
return true;
} else {
System.out.println("No");
return false;
}
} catch (ParseException e) {
e.printStackTrace();
}
return false;
}

Answer 3

Al igual que con la ayuda de @kocko, el código de trabajo completo es el siguiente:

try{
Date time11 = new SimpleDateFormat("HH:mm:ss").parse("20:11:13");
Calendar calendar1 = Calendar.getInstance();
calendar1.setTime(time11);
Date time22 = new SimpleDateFormat("HH:mm:ss").parse("14:49:00");
Calendar calendar2 = Calendar.getInstance();
calendar2.setTime(time22);
Date currentTime = new SimpleDateFormat("HH:mm:ss").parse("00:00:00");
Calendar startingCalendar = Calendar.getInstance();
startingCalendar.setTime(currentTime);
startingCalendar.add(Calendar.DATE, 1);
//let''s say we have to check about 01:00:00
String someRandomTime = time1;
Date d = new SimpleDateFormat("HH:mm:ss").parse(someRandomTime);
Calendar calendar3 = Calendar.getInstance();
calendar3.setTime(d);
if(startingCalendar.getTime().after(calendar1.getTime()))
{
calendar2.add(Calendar.DATE, 1);
calendar3.add(Calendar.DATE, 1);
}
Date x = calendar3.getTime();
if (x.after(calendar1.getTime()) && x.before(calendar2.getTime()))
{
System.out.println("Time is in between..");
}
else
{
System.out.println("Time is not in between..");
}
} catch (ParseException e)
{
e.printStackTrace();
}

Answer 4

Puede usar la clase Calendar para verificar.

Por ejemplo:

try {
String string1 = "20:11:13";
Date time1 = new SimpleDateFormat("HH:mm:ss").parse(string1);
Calendar calendar1 = Calendar.getInstance();
calendar1.setTime(time1);
String string2 = "14:49:00";
Date time2 = new SimpleDateFormat("HH:mm:ss").parse(string2);
Calendar calendar2 = Calendar.getInstance();
calendar2.setTime(time2);
calendar2.add(Calendar.DATE, 1);
String someRandomTime = "01:00:00";
Date d = new SimpleDateFormat("HH:mm:ss").parse(someRandomTime);
Calendar calendar3 = Calendar.getInstance();
calendar3.setTime(d);
calendar3.add(Calendar.DATE, 1);
Date x = calendar3.getTime();
if (x.after(calendar1.getTime()) && x.before(calendar2.getTime())) {
//checkes whether the current time is between 14:49:00 and 20:11:13.
System.out.println(true);
}
} catch (ParseException e) {
e.printStackTrace();
}

Answer 5

perdón por el código de sudo ... estoy en un teléfono. ;)

entre = (tiempo <cadena2 && tiempo> cadena1); if (string1> string2) entre =! between;

si son marcas de tiempo o cadenas esto funciona. simplemente cambie los nombres de las variables para que coincidan

Answer 6

 Calendar now = Calendar.getInstance();
int hour = now.get(Calendar.HOUR_OF_DAY); // Get hour in 24 hour format
int minute = now.get(Calendar.MINUTE);
Date date = parseDate(hour + ":" + minute);
Date dateCompareOne = parseDate("08:00");
Date dateCompareTwo = parseDate("20:00");
if (dateCompareOne.before( date ) && dateCompareTwo.after(date)) {
//your logic
}
private Date parseDate(String date) {
final String inputFormat = "HH:mm";
SimpleDateFormat inputParser = new SimpleDateFormat(inputFormat, Locale.US);
try {
return inputParser.parse(date);
} catch (java.text.ParseException e) {
return new Date(0);
}
}

Además, para ser más preciso, si compara un tiempo entre un intervalo de más de 00:00 a 24:00 de ese día, también debe analizar el día.

Answer 7

separa dos puntos de las cadenas $ time, $ to y $ from, convierte a int y luego usa la siguiente condición para verificar si el tiempo está entre from y to. El ejemplo está en php, pero no debería importar.

if(($to < $from && ($time >= $from || $time <= $to)) ||
($time >= $from && $time <= $to)) {
return true;
}

Answer 8

La respuesta dada por @kocko funciona solo el mismo día.
Si la hora de inicio es "23:00:00" y finaliza "02:00:00" [día siguiente] y la hora actual es "01:30:00" , el resultado será falso ...
Modifiqué la respuesta de @ kocko para que funcione perfecto

public static boolean isTimeBetweenTwoTime(String initialTime, String finalTime, String currentTime) throws ParseException {
String reg = "^([0-1][0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9])$";
if (initialTime.matches(reg) && finalTime.matches(reg) && currentTime.matches(reg)) {
boolean valid = false;
//Start Time
java.util.Date inTime = new SimpleDateFormat("HH:mm:ss").parse(initialTime);
Calendar calendar1 = Calendar.getInstance();
calendar1.setTime(inTime);
//Current Time
java.util.Date checkTime = new SimpleDateFormat("HH:mm:ss").parse(currentTime);
Calendar calendar3 = Calendar.getInstance();
calendar3.setTime(checkTime);
//End Time
java.util.Date finTime = new SimpleDateFormat("HH:mm:ss").parse(finalTime);
Calendar calendar2 = Calendar.getInstance();
calendar2.setTime(finTime);
if (finalTime.compareTo(initialTime) < 0) {
calendar2.add(Calendar.DATE, 1);
calendar3.add(Calendar.DATE, 1);
}
java.util.Date actualTime = calendar3.getTime();
if ((actualTime.after(calendar1.getTime()) || actualTime.compareTo(calendar1.getTime()) == 0)
&& actualTime.before(calendar2.getTime())) {
valid = true;
}
return valid;
} else {
throw new IllegalArgumentException("Not a valid time, expecting HH:MM:SS format");
}
}

Salida

"07:00:00" - "17:30:00" - "15:30:00" [current] - true
"17:00:00" - "21:30:00" - "16:30:00" [current] - false
"23:00:00" - "04:00:00" - "02:00:00" [current] - true
"00:30:00" - "06:00:00" - "06:00:00" [current] - false 

(He incluido el valor límite inferior a [valor límite superior-1])

Answer 9

La función de trabajo real será la siguiente

public static boolean isTimeBetweenTwoTime(Date startTime, Date stopTime, Date currentTime) {
//Start Time
Calendar StartTime = Calendar.getInstance();
StartTime.setTime(startTime);
//Current Time
Calendar CurrentTime = Calendar.getInstance();
CurrentTime.setTime(currentTime);
//Stop Time
Calendar StopTime = Calendar.getInstance();
StopTime.setTime(stopTime);
if (stopTime.compareTo(startTime) < 0) {
if (CurrentTime.compareTo(StopTime) < 0) {
CurrentTime.add(Calendar.DATE, 1);
}
StopTime.add(Calendar.DATE, 1);
}
return CurrentTime.compareTo(StartTime) >= 0 && CurrentTime.compareTo(StopTime) < 0;
}

Answer 10

En su caso, la hora de inicio (20:11:13) es mayor que la hora de finalización (14:49:00). Es una suposición razonable que podría resolver el problema agregando un día en la hora de finalización o restando un día de la hora de inicio. Si lo hace, quedará atrapado porque no sabe en qué día es el momento de la prueba.

Puede evitar esta trampa comprobando si el tiempo de prueba es entre la hora de finalización y la hora de inicio. Si es verdadero, el resultado es "no intermedio"; else resultado es "bien intermedio".

Aquí está la función en JAVA que he estado usando. Funciona tan lejos para mí. Buena suerte.

boolean IsTimeInBetween(Calendar startC, Calendar endC, Calendar testC){
// assume year, month and day of month are all equal.
startC.set(1,1,1);
endC.set(1,1,1);
testC.set(1,1,1);
if (endC.compareTo(startC) > 0) {
if ((testC.compareTo(startC)>=0) && (testC.compareTo(endC)<=0)) {
return true;
}else {
return false;
}
}else if (endC.compareTo(startC) < 0) {
if ((testC.compareTo(endC) >= 0) && (testC.compareTo(startC) <= 0)) {
return false;
} else {
return true;
}
} else{ // when endC.compareTo(startC)==0, I return a ture value. Change it if you have different application.
return true;
}
}

Para crear una instancia de Calender, puede usar:

Calendar startC = Calendar.getInstance();
startC.set(Calendar.HOUR_OF_DAY, 20);
startC.set(Calendar.MINUTE,11);
startC.set(Calendar.SECOND,13);

Answer 11

Me parece que su problema es una situación OR ... Quiere verificar si time1> 20:11:13 OR time1 <14:49:00.

Nunca habrá un tiempo mayor a 20:11:13 que exceda su rango hasta el otro extremo (14:49:00) y viceversa. Piense en ello como si estuviera comprobando que el tiempo NO es entre un par de marcas de tiempo debidamente ordenadas.

Answer 12

Java 8 - LocalDateTime

¿Qué hay de esto?

final LocalDateTime now = LocalDateTime.now();
final LocalDateTime minRange = LocalDateTime.of(now.getYear(), now.getMonth(), now.getDayOfMonth(), 22, 30); //Today, 10:30pm
LocalDateTime maxRange = LocalDateTime.of(now.getYear(), now.getMonth(), now.getDayOfMonth(), 6, 30); //Tomorrow, 6:30am
maxRange = maxRange.plusDays(1); //Ensures that you don''t run into an exception if minRange is the last day in the month.
if (now.isAfter(minRange) && now.isBefore(maxRange)) {
//Action
}

Answer 13

El uso de LocalTime simplemente ignoraría el valor de la Fecha:

public class TimeIntervalChecker {
static final LocalTime time1 = LocalTime.parse( "20:11:13" ) ;
static final LocalTime time2 = LocalTime.parse( "14:49:00" ) ;
public static void main(String[] args) throws java.lang.Exception {
LocalTime nowUtcTime = LocalTime.now(Clock.systemUTC());
if (nowUtcTime.isAfter(time1) && nowUtcTime.isBefore(time2)){
System.out.println(nowUtcTime+" is after: "+ time1+" and before: "+ time2);
}
}

Answer 14

El siguiente método verifica si ''validateTime'' está entre ''startTime'' y ''endTime'' o no mientras se considera la posibilidad de que ''endTime'' pueda ser al día siguiente. Para usarlo correctamente analizar las fechas en formato "HH: mm".

 public static final boolean isBetweenValidTime(Date startTime, Date endTime, Date validateTime)
{
boolean validTimeFlag = false;
if(endTime.compareTo(startTime) <= 0)
{
if(validateTime.compareTo(endTime) < 0 || validateTime.compareTo(startTime) >= 0)
{
validTimeFlag = true;
}
}
else if(validateTime.compareTo(endTime) < 0 && validateTime.compareTo(startTime) >= 0)
{
validTimeFlag = true;
}
return validTimeFlag;
}

Answer 15

tl; dr

20:11:13 <01:00:00 <14:49:00

LocalTime target = LocalTime.parse( "01:00:00" ) ;
Boolean targetInZone = (
target.isAfter( LocalTime.parse( "20:11:13" ) )
&&
target.isBefore( LocalTime.parse( "14:49:00" ) )
) ; 

java.time.LocalTime

Las clases java.time incluyen LocalTime para representar una hora del día solo sin una fecha y sin una zona horaria.

Entonces lo que quiero es, 20:11:13 <01:00:00 <14:49:00.

Primero definimos los límites. Sus cadenas de entrada cumplen con los formatos estándar ISO 8601 . Las clases java.time usan formatos ISO 8601 de forma predeterminada, por lo que no es necesario especificar un patrón de formateo.

LocalTime start = LocalTime.parse( "20:11:13" );
LocalTime stop = LocalTime.parse( "14:49:00" );

Y define nuestro caso de prueba, el objetivo 01:00:00 .

LocalTime target = LocalTime.parse( "01:00:00" );

Ahora estamos configurados para comparar estos objetos LocalTime . Queremos ver si el objetivo está después del tiempo posterior pero antes de la hora anterior. Eso significa que a media noche en este caso, entre aproximadamente las 8 p.m. y las 3 a.m. de la mañana siguiente.

Boolean isTargetAfterStartAndBeforeStop = ( target.isAfter( start ) && target.isBefore( stop ) ) ;

Esa prueba puede decirse más simplemente como " no entre las 3 AM y las 8 PM". Podríamos generalizar a cualquier par de objetos LocalTime donde LocalTime entre si el inicio viene antes de la parada con un reloj de 24 horas, y no entre si el inicio viene después de la detención (como en el caso de esta Pregunta).

Además, los períodos de tiempo se manejan generalmente con el enfoque de Medio Abierto, donde el comienzo es inclusivo, mientras que el final es exclusivo . Entonces, una comparación "entre", estrictamente hablando, sería "es el objetivo igual o más tarde que el inicio Y el objetivo es antes de detenerse", o más simplemente, "es el objetivo no antes del inicio Y antes de la detención".

Boolean isBetweenStartAndStopStrictlySpeaking =
( ( ! target.isBefore( start ) && target.isBefore( stop ) ) ;

Si el inicio es posterior a la parada, dentro de un reloj de 24 horas, supongamos que queremos la lógica sugerida en la Pregunta (es después de las 8 PM pero antes de las 3 AM).

if( start.isAfter( stop ) ) {
return ! isBetweenStartAndStopStrictlySpeaking ;
} else {
return isBetweenStartAndStopStrictlySpeaking ;
}

Acerca de java.time

El marco java.time está integrado en Java 8 y posterior. Estas clases suplantan a las problemáticas antiguas clases heredadas de fecha y hora, como java.util.Date , Calendar y SimpleDateFormat .

El proyecto Joda-Time , ahora en modo de mantenimiento , aconseja la migración a las clases java.time .

Para obtener más información, consulte el Tutorial de Oracle . Y busque para obtener muchos ejemplos y explicaciones. La especificación es JSR 310 .

¿Dónde obtener las clases de java.time?

• Java SE 8 y SE 9 y posteriores
  • Incorporado.
  • Parte de la API Java estándar con una implementación integrada.
  • Java 9 agrega algunas características y correcciones menores.
• Java SE 6 y SE 7
  • Gran parte de la funcionalidad de java.time se transfiere a Java 6 y 7 en ThreeTen-Backport .
• Androide
  • El proyecto ThreeTenABP adapta ThreeTen-Backport (mencionado anteriormente) específicamente para Android.
  • Consulte Cómo utilizar ThreeTenABP ....

El proyecto ThreeTen-Extra amplía java.time con clases adicionales. Este proyecto es un terreno de prueba para posibles adiciones futuras a java.time. Puede encontrar algunas clases útiles aquí, como Interval , YearWeek , YearQuarter y más .

Answer 16

En el snipet de código a continuación, se verifica que si la hora actual (puede ser cualquiera) existe entre la hora de inicio y de finalización o no:

 Calendar startTimeCal = Calendar.getInstance();
startTimeCal.setTime(startTime);
int startTimeHour = startTimeCal.get(Calendar.HOUR_OF_DAY);
if (startTimeHour == 0){
startTimeHour = 24;
}
int startTimeMinutes = startTimeCal.get(Calendar.MINUTE);
Calendar curTimeCal = Calendar.getInstance();
curTimeCal.setTime(currentTime);
int curTimeHour = curTimeCal.get(Calendar.HOUR_OF_DAY);
int curTimeMinutes = curTimeCal.get(Calendar.MINUTE);
Calendar endTimeCal = Calendar.getInstance();
endTimeCal.setTime(endTime);
int endTimeHour = endTimeCal.get(Calendar.HOUR_OF_DAY);
if (endTimeHour == 0) {
endTimeHour = 24;
}
int endTimeMinutes = endTimeCal.get(Calendar.MINUTE);
if (((curTimeHour > startTimeHour) || (curTimeHour == startTimeHour && curTimeMinutes >= startTimeMinutes)) &&
((curTimeHour < endTimeHour) || (curTimeHour == endTimeHour && curTimeMinutes <= endTimeHour))) {
//time exists between start and end time
} else {
//time doesn''t exist between start and end time
}