Validate time in java

Validate Time In 12 Hours Format with Java Regular Expression example

So this is the regular expression we are going to use for 12 hours format validation:

You can take a look at the Pattern class documentation to learn how to construct your own regular expressions according to your policy.

1. Validator class

This is the class that we are going to use for 12 hours time format validation.

package com.javacodegeeks.java.core; import java.util.regex.Matcher; import java.util.regex.Pattern; public class Time12hFormatValidator < private Pattern pattern; private Matcher matcher; private static final String TIME12HOURS_PATTERN = "(1[012]|2):17(\\s)?(?i)(am|pm)"; public Time12hFormatValidator()< pattern = Pattern.compile(TIME12HOURS_PATTERN); >public boolean validate(final String time) < matcher = pattern.matcher(time); return matcher.matches(); >>

2. Unit Testing our Time12hFormatValidator class

For unit testing we are going to use JUnit . Unit testing is very important in these situations because they provide good feedback about the correctness of our regular expressions. You can test your program and reassure that your regular expression meets the rules on your policy about the form of 12 hour time format.

This is a basic test class:

package com.javacodegeeks.java.core; import static org.junit.Assert.*; import java.util.Arrays; import java.util.Collection; import org.junit.BeforeClass; import org.junit.Test; import org.junit.runner.RunWith; import org.junit.runners.Parameterized; import org.junit.runners.Parameterized.Parameters; @RunWith(Parameterized.class) public class Time12hFormatValidatorTest < private String arg; private static Time12hFormatValidator time12hFormatValidator; private Boolean expectedValidation; public Time12hFormatValidatorTest(String str, Boolean expectedValidation) < this.arg = str; this.expectedValidation = expectedValidation; >@BeforeClass public static void initialize() < time12hFormatValidator = new Time12hFormatValidator(); >@Parameters public static Collection data() < Object[][] data = new Object[][] < < "00:00 am", false >, // 12h format is out of range < "2.20", false >, // wrong format < "17:10 pm", false >, // it is 12 hour format! < "1:20", false >, // there is no pm am < "9:35 pm", true >, < "7:30 AM", true >, < "12:01 am", true >>; return Arrays.asList(data); > @Test public void test() < Boolean res = time12hFormatValidator.validate(this.arg); String validv = (res) ? "valid" : "invalid"; System.out.println("Time Format "+arg+ " is " + validv); assertEquals("Result", this.expectedValidation, res); >>

Time Format 00:00 am is invalid Time Format 2.20 is invalid Time Format 17:10 pm is invalid Time Format 1:20 is invalid Time Format 9:35 pm is valid Time Format 7:30 AM is valid Time Format 12:01 am is valid 

This was an exampl on how to validate time in 12 Hours format with Java Regular Expression.

Источник

Write a java program to validate Date and Time

Java code to validate a date and time format. There are two different programs one is to validate a Date format “dd/MM/yyyy” and the other is to validate a Time format “hh: mm am” or “hh: mm pm” in Java. Along with validation time in 24 hr format.

Obtain a date string in the format dd/mm/yyyy. Write code to validate the given date against the given format. The return type of the validateDate method is 1 if the given date format matches the specified format. If the validation fails, return the output as -1.

Input and Output Format to validate Date

Refer sample output for formatting specifications

Sample Input 1:

Sample Output 1:

Sample Input 2:

Sample Output 2:

Program in Java for Validating Date Format

Following are the steps to validate date format in Java:

• Input a string.
• Pass the string to getValues() method.
• Inside the getValues() method, use the regex pattern to match the string.
• Now, create the object of SimpleDateFormat class using the ‘dd/MM/yyyy’ pattern.
• Here, call the setLenient() method with value false.
• Now, use the parse method to validate the date and return 1 if valid else return -1.
• At last, catch this value in a variable n and check if it is 1 then just print “Valid date format” else print “Invalid date format”.

import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.Date; import java.util.Scanner; public class Main < public static void main(String[] args) < Scanner sc = new Scanner(System.in); String s1 = sc.nextLine(); int n = getvalues(s1); if(n==1)< System.out.println("Valid date format"); >else < System.out.println("Invalid date format"); >> public static int getvalues(String s1) < if(s1.matches("1[/]6[/]3")) < SimpleDateFormat sdf=new SimpleDateFormat("dd/MM/yyyy"); sdf.setLenient(false); try < Date d1=sdf.parse(s1); return 1; >catch (ParseException e) < return -1; >> else return -1; >>

Output

Validate Time format in Java

Obtain a time string as input in the following format ‘hh:mm am’ or ‘hh:mm pm’. Write code to validate it using the following rules:

• It should be a valid time in 12 hrs format.
• It should have case-insensitive AM or PM.
• If the given time is as per the given rules then return 1 else return -1. If the value returned is 1 then print as valid time else print as Invalid time.

Input and Output Format to validate time format in Java

Sample Input 1:

Sample Output 1:

Sample Input 2:

Sample Output 2:

Write a java program to validate the time format in Java

• Input a string.
• Now, break the string into tokens by using StringTokenizer class.
• If the count of tokens is equal to 3, then create the object of SimpleDateFormat class with ‘h:mm:ss a’ pattern.
• Set the leniency to false.
• Now, use the parse method to validate the string and print “Valid Time”.
• If the string token count is not equal to 3, then once again create the object of SimpleDateFormat class with “h:mm a” pattern.
• Repeat the above process and print “Valid Time”.

package com.date; import java.text.SimpleDateFormat; import java.util.Date; import java.util.Scanner; import java.util.StringTokenizer; public class ValidateTime < public static void main(String[] args) < Scanner sc = new Scanner(System.in); String str = sc.nextLine(); StringTokenizer st = new StringTokenizer(str, ":"); if (st.countTokens() == 3) < SimpleDateFormat sdf1 = new SimpleDateFormat("h:mm:ss a"); sdf1.setLenient(false); try < Date d2 = sdf1.parse(str); System.out.println("Valid time"); >catch (Exception e) < System.out.println("Invalid time"); >> else < SimpleDateFormat sdf = new SimpleDateFormat("h:mm a"); sdf.setLenient(false); try < Date d1 = sdf.parse(str); System.out.println("Valid time"); >catch (Exception e) < System.out.println("Invalid time"); >> > >

Output

Validate Time in 24 hr format using regex

• It should start with 0-23 or 00-23.
• It should be followed by ‘:’.
• After this, there should be two digits 00 to 59.
• In the end, it should not be, am, pm, AM, and PM.

Input and Output Format to validate time format in Java

Sample Input 1:

Sample Output 1:

Sample Input 2:

Sample Output 2:

Program to validate time in 24 hr using regex in Java

• Input time in string.
• Now, match the time with the pattern as shown below

• • ([01]?2|22) – It represents the start of the pattern.
  • : – It represents that the above pattern should be followed by a colon (:).
  • 16 – It should end with two digits.

  package com.date; import java.text.SimpleDateFormat; import java.util.Scanner; import java.util.StringTokenizer; public class ValidateTimeFormat < public static void main(String[] args) < Scanner scanner = new Scanner(System.in); String time = scanner.next(); if(time.matches("([01]?9|23):48"))< System.out.println("Valid Time"); >else < System.out.println("Invalid Time"); >> >

  Output

  

  

  Thus, in this way, we learn How to validate time format and date format in Java. Along with validating time in 24 hr format using regex.

  Additionally, Check These java program Articles Too:

  Источник

  Check if a Date is Valid in Java

  Learn to validate if a given string contains a date value or not. We will learn various date validation techniques available in Java 7, Java 8 and above.

  1. LocalDate and DateTimeFormatter (Java 8 and Later)

  1.1. Default Pattern -> ‘yyyy-MM-dd’

  The best chances are that your application already uses Java 8 or a later release. In this case, the best way to represent a date in Java is by using LocalDate class.

  By default, LocalDate.parse() method parsed a date using ISO_LOCAL_DATE pattern (yyyy-MM-dd). The format consists of the following:

  • four digits or more for the year, where the range 0000 to 9999 will be pre-padded by zero to ensure four digits. Years outside that range will have a prefixed positive or negative symbol.
  • two digits for the month of the year and pre-padded by zero to ensure two digits.
  • two digits for the day of the month and pre-padded by zero to ensure two digits.

  LocalDate localDate = LocalDate.parse("2023-02-08"); //08-Feb-2023 Assertions.assertNotNull(localDate); Assertions.assertEquals(8, localDate.getDayOfMonth()); Assertions.assertEquals(2, localDate.getMonthValue()); Assertions.assertEquals(2023, localDate.getYear());

  1.2. Custom Patterns with DateTimeFormatter

  If we do have our own custom date pattern then we can create one using DateTimeFormatter.ofPattern() method.

  • By default, the ResolverStyle.SMART is used, which uses the sensible default for each date field. For example, a value greater than 31 for a day field will be valid and treated as the last day of the month.
  • Often, this smart resolution is not aligned with business needs, and we want to raise parse exceptions if such invalid values are encountered. Use ResolverStyle.STRICT to resolve dates and times strictly. The strict resolution will ensure that all parsed values are within the field’s outer range of valid values.

  static final String CUSTOM_PATTERN = "MM-dd-yyyy"; static final DateTimeFormatter DATE_TIME_FORMATTER = DateTimeFormatter.ofPattern(CUSTOM_PATTERN);

  Remember that DateTimeFormatter instance is thread-safe and immutable, so we can create only one instance per pattern/application and share it across the other functions.

  We can use LocalDate’s parse(dateString, dateTimeFormatter) to parse the string to Localdate instance.

  public static LocalDate isValidLocalDate(String dateStr, DateTimeFormatter dateFormatter) < LocalDate date = null; try < date = LocalDate.parse(dateStr, dateFormatter); >catch (DateTimeParseException e) < //handle exception e.printStackTrace(); >return date; >

  The given below is a Java program to check if a given date is in a valid format of “MM-dd-yyyy“.

  LocalDate parsedLocalDate = isValidLocalDate("01-26-2023", DATE_TIME_FORMATTER); Assertions.assertNotNull(parsedLocalDate); Assertions.assertEquals(26, parsedLocalDate.getDayOfMonth()); Assertions.assertEquals(1, parsedLocalDate.getMonthValue()); Assertions.assertEquals(2023, parsedLocalDate.getYear());

  2. SimpleDateFormat (Java 7)

  In case you are still stuck at Java 7 and can’t upgrade due to some legacy application’s dependencies, you can use SimpleDateFormat for date validation.

  • Though SimpleDateFormat is not thread-safe or immutable, still, it serves the purpose pretty well. Do not use this class in a multi-threaded environment with added synchronization.
  • Do not forget to use setLenient() method to specify the leniency factor. With lenient parsing, the parser may use heuristics to interpret inputs that do not precisely match this object’s format. With strict parsing, inputs must match this object’s format.

  Then use SimpleDateFormat‘s parse(dateString) method which throws checked exception ParseException which signals that some error has occurred while parsing the date string to java.util.Date object.

  public static Date isValidDate(String dateString, String dateFormat) < Date date = null; DateFormat sdf = new SimpleDateFormat(dateFormat); sdf.setLenient(false); try < date = sdf.parse(dateString); >catch (ParseException e) < e.printStackTrace(); >return date; >

  We can use this method as follows:

  String dateFormat = "MM-dd-yyyy"; String dateString = "05-26-2020"; Date parsedDate = isValidDate(dateString, dateFormat);

  3. Best Practices for Java Date Validation

  Below are some best practices you can follow during validating dates in Java.

  • Although, it will not make any difference in 99% cases, still consider using ‘uuuu’ instead of ‘yyyy’ . Refer to this SO thread for more information.
  • Use strict parsing using relevant methods i.e. sdf.setLenient(false) or dtf.withResolverStyle(ResolverStyle.STRICT) .
  • Though strict date parsing solves most problems, still consider using extra checks – for example, a valid parsed date must lie within a predefined date range. This can prove really useful when parsing date-sensitive records in bulk. For example, we can use this kind of validation while importing financial records from a large excel sheet where the chances of manual errors are high.
  • If you can upgrade a Java 7 application to the latest Java version, please do on priority. The thread-safe and immutable nature of DateTimeFormatter is a huge win in terms of performance over SimpleDateFormat .

  Источник

  Java — how to check if String is valid date?

  

  Geo-Baby

  1. Overview

  In this post we can find code which can validate if String contains valid Date based on defined pattern.

  2. With SimpleDateFormat

  import java.text.ParseException; import java.text.SimpleDateFormat; public class Example1 < public static void main(String[] args) < System.out.println(checkIfDateIsValid("2019-10-13")); // true System.out.println(checkIfDateIsValid("2019:10:13")); // false >private static boolean checkIfDateIsValid(String date) < SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd"); // With lenient parsing, the parser may use heuristics to interpret // inputs that do not precisely match this object's format. format.setLenient(false); try < format.parse(date); >catch (ParseException e) < return false; >return true; > >

  3. With SimpleDateFormat + different patterns

  import java.text.ParseException; import java.text.SimpleDateFormat; public class Example2 < public static void main(String[] args) < System.out.println("# Example 1"); System.out.println(checkIfDateIsValid("yyyy-MM-dd", "2019-10-13")); // true System.out.println(checkIfDateIsValid("yyyy-MM-dd", "2019:10:13")); // false System.out.println("# Example 2"); System.out.println(checkIfDateIsValid("yyyy/MM/dd", "2019/10/13")); // true System.out.println("# Example 3"); System.out.println(checkIfDateIsValid("yyyy:MM:dd", "2019:10:13")); // true System.out.println("# Example 4"); System.out.println(checkIfDateIsValid("MM/dd/yyyy", "10/13/2019")); // true >private static boolean checkIfDateIsValid(String pattern, String date) < SimpleDateFormat format = new SimpleDateFormat(pattern); // With lenient parsing, the parser may use heuristics to interpret // inputs that do not precisely match this object's format. format.setLenient(false); try < format.parse(date); >catch (ParseException e) < return false; >return true; > >

  # Example 1 true false # Example 2 true # Example 3 true # Example 4 true

  4. LocalDate — Java 8

  import java.time.LocalDate; import java.time.format.DateTimeFormatter; import java.time.format.DateTimeParseException; public class Example3 < public static void main(String[] args) < System.out.println(checkIfDateIsValid("2019-10-13")); // true System.out.println(checkIfDateIsValid("2019:10:13")); // false >private static boolean checkIfDateIsValid(String date) < try < LocalDate.parse(date, DateTimeFormatter.ISO_DATE); >catch (DateTimeParseException e) < return false; >return true; > >

  5. LocalDate + DateTimeFormatter build-in patterns

  import java.time.LocalDate; import java.time.format.DateTimeFormatter; import java.time.format.DateTimeParseException; public class Example4 < public static void main(String[] args) < System.out.println("# Example 1"); System.out.println(checkIfDateIsValid( DateTimeFormatter.ISO_DATE, "2019-10-13")); // true System.out.println(checkIfDateIsValid( DateTimeFormatter.ISO_DATE, "2019:10:13")); // false System.out.println("# Example 2"); System.out.println(checkIfDateIsValid( DateTimeFormatter.BASIC_ISO_DATE, "20191013")); // true System.out.println("# Example 3"); System.out.println(checkIfDateIsValid( DateTimeFormatter.ISO_LOCAL_DATE, "2019-10-13")); // true >private static boolean checkIfDateIsValid(DateTimeFormatter formatter, String date) < try < LocalDate.parse(date, formatter); >catch (DateTimeParseException e) < return false; >return true; > >

  # Example 1 true false # Example 2 true # Example 3 true

  6. LocalDate + DateTimeFormatter different patterns

  import java.time.LocalDate; import java.time.format.DateTimeFormatter; import java.time.format.DateTimeParseException; public class Example5 < public static void main(String[] args) < System.out.println("# Example 1"); System.out.println(checkIfDateIsValid("yyyy-MM-dd", "2019-10-13")); // true System.out.println(checkIfDateIsValid("yyyy-MM-dd", "2019:10:13")); // false System.out.println("# Example 2"); System.out.println(checkIfDateIsValid("yyyy/MM/dd", "2019/10/13")); // true System.out.println("# Example 3"); System.out.println(checkIfDateIsValid("yyyy:MM:dd", "2019:10:13")); // true System.out.println("# Example 4"); System.out.println(checkIfDateIsValid("MM/dd/yyyy", "10/13/2019")); // true >private static boolean checkIfDateIsValid(String pattern, String date) < try < DateTimeFormatter formatter = DateTimeFormatter.ofPattern(pattern); LocalDate.parse(date, formatter); >catch (DateTimeParseException e) < return false; >return true; > >

  # Example 1 true false # Example 2 true # Example 3 true # Example 4 true

  References

  Источник

  Читайте также:  Вывод максимального значения java