11 métodos parse() en Java con ejemplos

El análisis sintáctico en su sentido más general es la extracción de la información necesaria de algún dato, la mayoría de las veces datos textuales. ¿Qué es analizar en Java? Hay muchas clases de Java que tienen el método parse() . Por lo general, el método parse() recibe una cadena como entrada, "extrae" la información necesaria y la convierte en un objeto de la clase que llama. Por ejemplo, recibió una cadena y devolvió la fecha que estaba "oculta" en esta cadena. En esta publicación, vamos a echar un vistazo a las 10 variaciones útiles de parse() .

0. parseInt()

Comencemos con uno de los métodos parse() más populares , que no es exactamente parse() , sino parseInt() . El método Java parseInt () se utiliza para obtener el tipo de datos primitivo de una cadena específica. En otras palabras, convierte una cadena en un número. parseInt() puede tener uno o dos argumentos. Aquí está la sintaxis de parseInt() :

static int parseInt(String s)
static int parseInt(String s, int radix)

Donde s es la cadena que representa un valor decimal con signo y radix la base de un sistema numérico. Tenga en cuenta que no hay un valor base predeterminado: debe ingresar uno dentro del rango de 2 y 36. Aquí hay un ejemplo. Cómo analizar con ParseInt():

public class ParseInt0 {

       public static void main(String args[]){
           int x = Integer.parseInt("12");
           double c = Double.parseDouble("12");
           int b = Integer.parseInt("100",2);

           System.out.println(Integer.parseInt("12"));
           System.out.println(Double.parseDouble("12"));
           System.out.println(Integer.parseInt("100",2));
           System.out.println(Integer.parseInt("101", 8));
         
       }
   }

La salida es:

1. Método de análisis de período ()

El período es una clase de Java para modelar una cantidad de tiempo en términos de años, meses y días, como "3 años, 5 meses y 2 días". Tiene un método parse() para obtener un punto de un texto. Aquí está la sintaxis del período parse()

public static Period parse(CharSequence text)

CharSequence es una interfaz, implementada por Strings. Entonces puede usar Strings como un elemento de texto en el método parse() . Seguro que la cadena debe tener el formato adecuado para devolver un objeto de la clase Período. Este formato es PnYnMnD . Donde Y significa "año", M - para "mes", D - para "día". N es un número correspondiente a cada valor de período.

• El método tiene un parámetro: un valor de texto.
• Parse() devuelve un valor de Período donde el valor de una cadena se convierte en un parámetro.
• Como excepción, period parse() puede devolver la excepción DateTimeParseException si el valor de la cadena no cumple con la estructura de un período.

Aquí hay un ejemplo del uso de Period parse() en el contexto del mundo real:

import java.time.Period;
public class ParseDemo1 {

   public static void main(String[] args)
   {
       //Here is the age String in format to  parse
       String age = "P17Y9M5D";

       // Converting strings into period value
       // using parse() method
       Period p = Period.parse(age);
       System.out.println("the age is: ");
       System.out.println(p.getYears() + " Years\n"
                          + p.getMonths() + " Months\n"
                          + p.getDays() + " Days\n");
   }
}
	} 
} 

La salida es:

2. Método SimpleDateFormat Parse()

SimpleDateFormat es una clase que se usa para formatear y analizar fechas de manera sensible a la configuración regional. El método parse() de SimpleDateFormat divide una cadena en tokens de fecha y devuelve un valor de datos en el formato correspondiente. El método comienza a analizar la cadena en un índice, definido por un desarrollador. Esta es la sintaxis de SimpleDateFormat parse() :

public Date parse(String the_text, ParsePosition position)

El método tiene dos parámetros:

• Posición: los datos en el índice inicial que siempre es el tipo de objeto ParsePosition.
• the_text: define la cadena que analizará el método y es un valor de tipo Cadena.

Puede utilizar este método sin declaración de posición. En este caso, los datos comienzan desde el índice cero. SimpleDateFormat parse() devuelve una fecha o un valor nulo (en caso de que la cadena no se haya procesado debido a un error). Aquí hay un ejemplo de implementación de parse() de SimpleDateFormat :

// Parsing strings into the Date format with two different patterns import java.text.ParseException;
import java.text.ParsePosition;
import java.text.SimpleDateFormat;
import java.util.Date;

public class ParseDemo2 {
   public static void main(String[] args) throws ParseException {
       SimpleDateFormat simpleDateFormat1 = new SimpleDateFormat("MM/dd/yyyy");
       SimpleDateFormat simpleDateFormat2 = new SimpleDateFormat("dd/MM/yyyy");
       //simpleDateFormat1.setLenient(false);
       Date date1 = simpleDateFormat1.parse("010/14/2020");
       System.out.println(date1);
       Date date2 = simpleDateFormat2.parse("14/10/2020");
       System.out.println(date2);
       ParsePosition p1 = new ParsePosition(18);
       ParsePosition p2 = new ParsePosition(19);
       ParsePosition p3 = new ParsePosition(5);

       String myString = "here is the date: 14/010/2020";
       Date date3 = simpleDateFormat2.parse(myString,p1);
       Date date4 = simpleDateFormat2.parse(myString,p2);
       Date date5 = simpleDateFormat2.parse(myString,p3);

       System.out.println(date3);
       System.out.println(date4);
       System.out.println(date5);
   }
}

La salida es: El último es nulo porque no hay un patrón de fecha que comience en la quinta posición. Por cierto, si intenta analizar date5 sin posición como Date date5 = simpleDateFormat2.parse(myString) , obtendrá una excepción:

3. Método de análisis LocalDate()

LocalDate es una clase que apareció en Java 8 para representar una fecha como año-mes-día (también se puede acceder a día del año, día de la semana y semana del año). LocalDate no representa una hora o zona horaria. El método LocalDate parse() tiene dos variantes. Ambos ayudan a convertir una cadena en una nueva API de fecha de Java 8: java.time.LocalDate .

analizar (texto CharSequence, DateTimeFormatter, formateador)

Este método analiza una cadena utilizando un formateador específico para obtener una instancia de LocalDate. Aquí está la sintaxis del método:

public static LocalTime parse(CharSequence text,
                              DateTimeFormatter formatter)

Hay dos parámetros para el método: el texto que se analizará y el formateador que aplicará un desarrollador. Como valor de retorno, el método devuelve un objeto LocalTime que se reconocerá como la hora del día local. Si el valor del texto no pudo pasar por el análisis, el sistema genera la excepción DayTimeParseException. Veamos un ejemplo de código del uso de LocalDate parse() con dos parámetros:

import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
public class ParserDemo3 {

   public static void main(String[]args) {

       DateTimeFormatter formatter = DateTimeFormatter.ofPattern("dd/MM/yyyy");
       String date = "14/10/2020";
       LocalDate localDate = LocalDate.parse(date, formatter);
       System.out.println("parsed local date: " + localDate);
       System.out.println("formatted local date: " + formatter.format(localDate));
   }
}

La salida es: El método LocalDate parse() con un parámetro tiene la siguiente sintaxis:

public static LocalTime parse(CharSequence text)

Este método no requiere especificar un formateador. Después de que un desarrollador ingrese los valores de cadena entre corchetes, el sistema usará automáticamente DateTimeFormatter.ISO_LOCAL_DATE. Este método tiene un solo parámetro: un texto CharSequence. Puede usar aquí el valor de cadena. Asegúrese de que no sea nulo y respete la estructura del formateador. Si no hay forma de analizar una cadena, un desarrollador obtiene DateTimeExceptionAlert. Aquí hay un ejemplo de la aplicación LocalDate parse() :

import java.time.*;
public class ParseDemo3 {
       public static void main(String[] args)
       {
           // let’s make a new LocalDate object
           LocalDate localDate = LocalDate.parse("2020-10-14");
           System.out.println("LocalDate : " + localDate);
       }
   }

La salida es:

4. Método de análisis LocalDateTime()

LocalDateTime un objeto de fecha y hora que representa una fecha y hora vista con bastante frecuencia como año-mes-día-hora-minuto-segundo. Además, los desarrolladores pueden usar otros campos de fecha y hora (día del año, día de la semana y semana del año). Esta clase es inmutable. El tiempo se representa con una precisión de nanosegundos. Por ejemplo, puede almacenar el valor "17 de noviembre de 2020 a las 13:30.30.123456789" en LocalDateTime. Esta clase no se trata de representar una zona horaria. Es más bien una representación de fecha estándar más la hora local. Método LocalDateTime parse() representado en dos variantes:

• El análisis LocalDateTime estático (texto CharSequence) devuelve una instancia de LocalDateTime de una cadena de texto como 2007-12-03T10:15:30.
• El análisis LocalDateTime estático (texto CharSequence, formateador DateTimeFormatter) devuelve una instancia de LocalDateTime de una cadena de texto usando un formateador específico.

Aquí hay un ejemplo del método parse() de LocalDateTime :

import java.time.*;
public class ParseDemo11 {
       public static void main(String[] args) {
           LocalDateTime localDateTime = LocalDateTime.parse("2020-11-17T19:34:50.63");
           System.out.println("LocalDateTime is: " + localDateTime);
       }
   }

La salida es:

5. Método ZonedDateTime parse()

La clase ZonedDateTime representa una fecha y hora con una zona horaria. Esta clase es inmutable. Almacena campos de fecha y hora con una precisión de nanosegundos y una zona horaria, con un desplazamiento de zona utilizado para manejar fechas y horas locales ambiguas. Entonces, si necesita mantener un valor como "14 de octubre de 2020 a las 17:50.30.123456789 +02:00 en la zona horaria de Europa/París", puede usar ZonedDateTime. La clase se usa a menudo para manipular datos basados ​​en la hora local. ZondeDateTime parse() es un analizador que divide la cadena en tokens en el sistema ISO-8061. Este es un ejemplo de un valor que obtendrá después del análisis: Se usa siempre que se necesitan datos de alta precisión (después de todo, los datos que obtiene son precisos hasta en nanosegundos). La clase se usa a menudo para manipular datos basados ​​en la hora local. Echemos un vistazo a la sintaxis general del método ZonedDateTime parse() que usan los desarrolladores para convertir valores de cadena en la clase ZonedDateTime.

public static ZonedDateTime parse(CharSequence text)

El único parámetro que utiliza el método es un texto de cadena. Como valor de retorno, obtendrá uno o una serie de objetos en el formato ZonedDateTime. Si hay un error durante el análisis o es imposible, para empezar, el método devuelve DateTimeParseException. También hay un método parse() con dos variables.

public static ZonedDateTime parse(CharSequence text, DateFormatter formatter)

Este método obtiene una instancia de ZonedDateTime a partir de un valor de texto utilizando un formateador específico. El método con un parámetro, el formateador DateTimeFormatter.ISO_LOCAL_TIME se utiliza de forma predeterminada. Echemos un vistazo al caso de uso de ZonedDateTime parse():

// An example program that uses
// ZonedDateTime.parse() method
  
import java.time.ZonedDateTime;
import java.time.format.DateTimeFormatter;

public class ParseDemo4 {
   public static void main(String[] args) {
       ZonedDateTime zonedDateTime = ZonedDateTime.parse("2020-10-15T10:15:30+01:00");
       System.out.println(zonedDateTime);

       DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ISO_ZONED_DATE_TIME;
       String date = "2020-10-15T13:30:25+01:00";
       ZonedDateTime zoneDateTime1 = ZonedDateTime.parse(date, dateTimeFormatter);
       System.out.println(zoneDateTime1);
   }
}

La salida es:

6. Método de análisis de hora local ()

Class LocalTime representa una hora, a menudo vista como hora-minuto-segundo. Esta clase también es inmutable, como ZonedDateTime.Time se representa con una precisión de nanosegundos. Por ejemplo, el valor "13:45.30.123456789" se puede almacenar en LocalTime. Hay dos métodos LocalTime parse() , con uno y dos parámetros. Echemos un vistazo a ambos:

public static LocalTime parse(CharSequence text)

Puede usar LocalTime parse() con solo un parámetro, la cadena que desea analizar. En este caso, el formateador DateTimeFormatter.ISO_LOCAL_TIME se utiliza de forma predeterminada.

Method with two parameters has the next syntax: 
public static LocalTime parse(CharSequence text,
                              DateTimeFormatter formatter)

Obtiene una instancia de LocalTime a partir de un valor de texto usando un formateador específico. Ambos métodos devuelven el valor LocalTime en el formato hh/mm/ss. Tenga cuidado con las alertas de DateTimeParceException. Significan que el formato del texto de la cadena no se corresponde con el de los objetos LocalTime. Aquí hay un ejemplo del uso de LocalTime parse() en producción:

import java.time.*;
import java.time.format.*;
public class ParseDemo5 {

       public static void main(String[] args)
       {

           LocalTime localTime
                   = LocalTime.parse("10:25:30");

           // return the output value
           System.out.println("LocalTime : "
                              + localTime);

           // create a formater
           DateTimeFormatter formatter
                   = DateTimeFormatter.ISO_LOCAL_TIME;

           LocalTime localTime1
                   = LocalTime.parse("12:30:50");
           // parse a string to get a LocalTime object in return

           LocalTime.parse("12:30:50",
               formatter);
           // print the output
           System.out.println("LocalTime : "
                              + localTime1);
       }
   }

7. Método MessageFormat Parse()

MessageFormat amplía la clase Format. El formato es una clase base abstracta para dar formato a datos sensibles a la configuración regional (fechas, mensajes y números). MessageFormat obtiene algunos objetos y les da formato. Luego inserta las cadenas formateadas en el patrón en los lugares apropiados. El parse() de MessageFormat se usa para obtener un valor de cadena si se le da el comienzo del índice. Aquí está la sintaxis general del método:

public Object[] parse(String source, ParsePosition position)

Donde source es una cadena para analizar y position es el índice de inicio del análisis. Aquí hay un ejemplo del funcionamiento del método parse() de MessageFormat :

import java.text.MessageFormat;
import java.text.ParsePosition;

public class ParseDemo7 {
   public static void main(String[] args) {
    try {
           MessageFormat messageFormat = new MessageFormat("{1, number, #}, {0, number, #.#}, {2, number, #.##}");

           ParsePosition pos = new ParsePosition(3);
           Object[] hash = messageFormat.parse("12.101, 21.382, 35.121", pos);

           System.out.println("value after parsing: ");
           for (int i = 0; i < hash.length; i++)
               System.out.println(hash[i]);
       }
       catch (NullPointerException e) {
          System.out.println("\nNull");
          System.out.println("Exception thrown : " + e);
       } }
}

8. Método de análisis de nivel ()

Cuando un programador usa un registrador para registrar un mensaje, se registra con un cierto nivel de registro. Hay siete niveles de registro incorporados:

• SEVERO
• ADVERTENCIA
• INFORMACIÓN
• CONFIGURAR
• BIEN
• MÁS FINO
• MEJOR

También hay niveles adicionales APAGADO que se pueden usar para desactivar el registro y TODOS que se pueden usar para habilitar el registro de todos los mensajes. El nivel de registro está representado por la clase java.util.logging.Level . La clase de nivel contiene una constante para cada uno de estos siete niveles. Por lo tanto, utiliza una de estas constantes, incluidas Todas y APAGADO, mientras registra un mensaje en un registrador. Además, todos estos niveles se inicializaron en algunos números enteros. Por ejemplo, FINE se inicializa en 500. El método Level parse() analiza la información necesaria de un valor de texto y devuelve un objeto Level. Esta es la sintaxis del método level parse() :

public static Level parse(String name)

El parámetro de un método es el nombre de una cadena que un desarrollador desea analizar. Podría ser un nombre del nivel, su nombre de inicialización o algún otro número entero. A cambio, un programador obtiene un valor de nombre de Nivel, correspondiente al de la cadena inicial. En caso de que el argumento contenga símbolos que sean imposibles de analizar, el sistema lanzará IllegalArgumentException. Si una cadena no contiene valores, un desarrollador obtiene una NullPointerException. Aquí hay un fragmento de código que muestra la implementación de Level parse() .

import java.util.logging.Level;
public class ParseDemo6 {

   public static void main(String[] args)
   {
       Level level = Level.parse("500");
       System.out.println("Level = " + level.toString());

       Level level1 = Level.parse("FINE");
       System.out.println("Level = " + level1.toString());

       Level level2 = level.parse ("OFF");
       System.out.println(level2.toString());
   }
}

La salida es:

9. Método de análisis instantáneo ()

La clase instantánea modela un único punto instantáneo en la línea de tiempo. Puede usarlo para registrar marcas de tiempo de eventos en su aplicación. Instant parse() obtiene un valor instantáneo de un valor de texto. La cadena se almacenará más tarde como un valor de zona horaria UTC. El sistema usa DateTimeFormatter.ISO_INSTANT como 2020-10-14T11:28:15.00Z. Aquí hay una sintaxis del método Instant parse() :

public static Instant parse(CharSequence text)

Para analizar una cadena y obtener un instante, un desarrollador debe asegurarse de que la cadena contenga algo de texto. En caso de que sea nulo, obtendrá una DateTimeException. Aquí hay un ejemplo del uso de análisis instantáneo en Java:

import java.time.Instant;

public class ParseDemo8 {
       public static void main(String[] args) {

           Instant instant = Instant.parse("2020-10-14T10:37:30.00Z");
           System.out.println(instant);
       }
   }

La salida es:

10. Método parse() de NumberFormat

La clase java.text.NumberFormat se usa para formatear números. NumberFormat parse() es un método predeterminado de esta clase. El método parse() de la clase NumberFormat convierte una cadena en un número. Los desarrolladores lo usan para dividir una cadena en sus números de componente. El análisis comienza desde el principio de la cadena. Si llama a setParseIntegerOnly (true) antes de llamar al método parse() , como se muestra en el siguiente ejemplo, solo se convierte la parte entera del número. Aquí está la sintaxis de NumberFormat parse() :

public Number parse(String str)

Como parámetro, la función acepta cadenas. Un valor de retorno del análisis es un valor numérico. Si no se puede analizar el comienzo de una cadena, recibirá una advertencia ParseException. Para ver la aplicación del método parse() de NumberFormat , observe el siguiente ejemplo:

import java.text.NumberFormat;
import java.text.ParseException;

public class ParseDemo9 {

       public static void main(String[] args) throws ParseException {
           NumberFormat numberFormat = NumberFormat.getInstance();
           System.out.println(numberFormat.parse("3,141592"));
           numberFormat.setParseIntegerOnly(true);
           System.out.println(numberFormat.parse("3,141592"));
       }
   }

La salida es:

Conclusión

Hay muchos métodos de análisis que los desarrolladores pueden usar para convertir cadenas en varios tipos de datos. Aunque recordarlos puede parecer tedioso, tal variedad de comandos brinda a los desarrolladores mucha flexibilidad y precisión. Asegúrese de practicar el uso del análisis de datos para asegurarse de que recuerda la sintaxis y no olvidará qué parámetros son esenciales para cada método.