11 métodos parse() em Java com exemplos

Parsing em seu sentido mais geral é a extração das informações necessárias de algum dado, na maioria das vezes dados textuais. O que é análise em Java? Existem muitas classes Java que possuem o método parse() . Normalmente o método parse() recebe alguma string como entrada, "extrai" dela as informações necessárias e a converte em um objeto da classe chamadora. Por exemplo, ele recebeu uma string e retornou a data que estava "escondida" nesta string. Neste post, vamos dar uma olhada nas 10 variações úteis de parse() .

0. parseInt()

Vamos começar com um dos métodos parse() mais populares , que não é exatamente parse() , mas parseInt() . O método Java parseInt () é usado para obter o tipo de dados primitivo de uma string específica. Em outras palavras, ele converte uma string em um número. parseInt () pode ter um ou dois argumentos. Aqui está a sintaxe de parseInt() :

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

Onde s é a string que representa um valor decimal com sinal e a raiz a base de um sistema numérico. Lembre-se de que não há um valor base padrão — você precisa inserir um entre 2 e 36. Aqui está um exemplo. Como analisar com 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));
         
       }
   }

A saída é:

1. Método parse() de período

Period é uma classe Java para modelar uma quantidade de tempo em termos de anos, meses e dias, como “3 anos, 5 meses e 2 dias”. Possui um método parse() para obter um ponto de um texto. Aqui está a sintaxe de period parse()

public static Period parse(CharSequence text)

CharSequence é uma Interface, implementada por Strings. Então você pode usar Strings como um elemento de texto no método parse() . Certifique-se de que a string deve estar no formato adequado para retornar um objeto da classe Período. Este formato é PnYnMnD . Onde Y significa “ano”, M — para “mês”, D — para “dia”. N é um número correspondente a cada valor de período.

• O método tem um parâmetro — um valor de texto.
• Parse() retorna um valor de período em que o valor de uma string se torna um parâmetro.
• Como exceção, period parse() pode retornar DateTimeParseException se o valor da string não atender à estrutura de um período.

Aqui está um exemplo de uso de Period parse() no contexto do 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");
   }
}
	} 
} 

A saída é:

2. Método SimpleDateFormat Parse()

SimpleDateFormat é uma classe usada para formatar e analisar datas de maneira sensível à localidade. O método SimpleDateFormat parse() divide uma string em tokens de data e retorna um valor Data no formato correspondente. O método começa a analisar a string em um índice, definido por um desenvolvedor. Esta é a sintaxe do parse() SimpleDateFormat :

public Date parse(String the_text, ParsePosition position)

O método tem dois parâmetros:

• Position: os dados no índice inicial que é sempre o tipo de objeto ParsePosition.
• the_text: define a string que o método irá analisar e é um valor do tipo String.

Você pode usar este método sem declaração de posição. Nesse caso, os dados começam do índice zero. SimpleDateFormat parse() retorna uma data ou um valor nulo (caso a string não tenha sido processada devido a um erro). Aqui está um exemplo de implementação de parse() 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);
   }
}

A saída é: O último é nulo porque não há padrão de data a partir da 5ª posição. A propósito, se você tentar analisar o date5 sem posição, como Date date5 = simpleDateFormat2.parse(myString) , receberá uma exceção:

3. Método localDate parse()

LocalDate é uma classe que surgiu no Java 8 para representar uma data como ano-mês-dia (dia do ano, dia da semana e semana do ano, também podem ser acessados). LocalDate não representa uma hora ou fuso horário. O método LocalDate parse() tem duas variantes. Ambos ajudam a converter uma string em uma nova API de data do Java 8 — java.time.LocalDate .

parse(CharSequence text, DateTimeFormatter, formatador)

Este método analisa uma string usando um formatador específico para obter uma instância de LocalDate. Aqui está a sintaxe do método:

public static LocalTime parse(CharSequence text,
                              DateTimeFormatter formatter)

Existem dois parâmetros para o método — o texto que será analisado e o formatador que um desenvolvedor aplicará. Como valor de retorno, o método retorna um objeto LocalTime que será reconhecido como o horário local. Se o valor de texto não puder passar pela análise, o sistema lançará DayTimeParseException. Vamos ter um exemplo de código usando LocalDate parse() com dois 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));
   }
}

A saída é: O método LocalDate parse() com um parâmetro tem a seguinte sintaxe:

public static LocalTime parse(CharSequence text)

Este método não requer a especificação de um formatador. Depois que um desenvolvedor insere os valores de string entre colchetes, o sistema usará automaticamente o DateTimeFormatter.ISO_LOCAL_DATE. Este método tem um único parâmetro — um texto CharSequence. Você pode usar aqui o valor da string. Certifique-se de que não seja nulo e respeite a estrutura do formatador. Se não houver como analisar uma string, um desenvolvedor obtém o DateTimeExceptionAlert. Aqui está um exemplo de aplicação 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);
       }
   }

A saída é:

4. Método localDateTime parse()

LocalDateTime um objeto de data e hora que representa uma data e hora exibida com bastante frequência como ano-mês-dia-hora-minuto-segundo. Os desenvolvedores também podem usar outros campos de data e hora (dia do ano, dia da semana e semana do ano). Esta classe é imutável. O tempo é representado com precisão de nanossegundos. Por exemplo, você pode armazenar o valor "17 de novembro de 2020 às 13:30.30.123456789" em LocalDateTime. Esta classe não representa um fuso horário. Em vez disso, é uma representação de data padrão mais a hora local. LocalDateTime parse() método representado em duas variantes:

• static LocalDateTime parse(CharSequence text) retorna uma instância de LocalDateTime de uma string de texto como 2007-12-03T10:15:30.
• static LocalDateTime parse(CharSequence text, DateTimeFormatter formatador) retorna uma instância de LocalDateTime de uma string de texto usando um formatador específico.

Aqui está um exemplo do método LocalDateTime parse() :

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);
       }
   }

A saída é:

5. Método parse() ZonedDateTime

A classe ZonedDateTime representa uma data/hora com um fuso horário. Esta classe é imutável. Ele armazena campos de data e hora com uma precisão de nanossegundos e um fuso horário, com um deslocamento de zona usado para lidar com datas e horas locais ambíguas. Portanto, se você precisar manter um valor como "14 de outubro de 2020 às 17:50.30.123456789 +02:00 no fuso horário Europa/Paris", poderá usar ZonedDateTime. A classe geralmente é usada para manipular dados locais baseados em tempo. ZondeDateTime parse() é um analisador que divide a string em tokens no sistema ISO-8061. Aqui está um exemplo de um valor que você obterá após a análise: Ele é usado sempre que dados de alta precisão são necessários (afinal, os dados obtidos são precisos até nanossegundos). A classe geralmente é usada para manipular dados locais baseados em tempo. Vamos dar uma olhada na sintaxe geral do método ZonedDateTime parse() que os desenvolvedores usam para converter valores de string na classe ZonedDateTime.

public static ZonedDateTime parse(CharSequence text)

O único parâmetro que o método usa é um texto de string. Como valor de retorno, você obterá um ou uma série de objetos no formato ZonedDateTime. Se houver um erro durante a análise ou se for impossível, para começar, o método retorna DateTimeParseException. Também existe um método parse() com duas variáveis.

public static ZonedDateTime parse(CharSequence text, DateFormatter formatter)

Este método obtém uma instância de ZonedDateTime de um valor de texto usando um formatador específico. O método com um parâmetro, o formatador DateTimeFormatter.ISO_LOCAL_TIME é usado por padrão. Vamos dar uma olhada no 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);
   }
}

A saída é:

6. Método localTime parse()

A classe LocalTime representa um horário, normalmente visto como hora-minuto-segundo. Essa classe também é imutável, como ZonedDateTime.Time é representada com precisão de nanossegundos. Por exemplo, o valor "13:45.30.123456789" pode ser armazenado em LocalTime. Existem dois métodos LocalTime parse() , com um e dois parâmetros. Vamos dar uma olhada em ambos:

public static LocalTime parse(CharSequence text)

Você pode usar LocalTime parse() com apenas um parâmetro, a string que deseja analisar. Nesse caso, o formatador DateTimeFormatter.ISO_LOCAL_TIME é usado por padrão.

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

Obtém uma instância de LocalTime a partir de um valor de texto usando um formatador específico. Ambos os métodos retornam o valor LocalTime no formato hh/mm/ss. Fique atento aos alertas DateTimeParceException. Eles significam que o formato do texto da string não corresponde ao dos objetos LocalTime. Aqui está um exemplo de uso de LocalTime parse() na produção:

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 estende a classe Format. Format é uma classe base abstrata para formatar dados sensíveis à localidade (datas, mensagens e números). MessageFormat obtém alguns objetos e os formata. Em seguida, ele insere as strings formatadas no padrão nos locais apropriados. O MessageFormat parse() é usado para obter um valor de string se for dado o início do índice. Aqui está a sintaxe geral do método:

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

Onde source é uma string a ser analisada e position é o índice inicial da análise. Aqui está um exemplo de funcionamento do método MessageFormat parse() :

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 parse() de nível

Quando um programador usa um Logger para registrar uma mensagem, ela é registrada com um determinado nível de log. Existem sete níveis de log integrados:

• FORTE
• AVISO
• INFORMAÇÕES
• CONFIG
• MULTAR
• MAIS FINO
• MELHOR

Também existem níveis adicionais OFF que podem ser usados ​​para desligar o log e ALL que podem ser usados ​​para habilitar o log de todas as mensagens. O nível de log é representado pela classe java.util.logging.Level . A classe de nível contém uma constante para cada um desses sete níveis. Portanto, você usa uma dessas constantes, incluindo All e OFF ao registrar uma mensagem em um Logger. Além disso, todos esses níveis foram inicializados com alguns inteiros. Por exemplo, FINE é inicializado com 500. O método Level parse() analisa uma informação necessária de um valor de texto e retorna um objeto Level. Aqui está a sintaxe do método level parse() :

public static Level parse(String name)

O parâmetro de um método é o nome de uma string que um desenvolvedor deseja analisar. Pode ser o nome do nível, seu nome de inicialização ou algum outro inteiro. Em troca, um programador obtém um valor de nome de nível, correspondente ao da string inicial. Caso o argumento contenha símbolos impossíveis de analisar, o sistema lançará o IllegalArgumentException. Se uma string não contiver valores, um desenvolvedor receberá um NullPointerException. Aqui está um trecho de código que mostra a implementação 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());
   }
}

A saída é:

9. Método parse() instantâneo

A classe instantânea modela um único ponto instantâneo na linha do tempo. Você pode usá-lo para registrar carimbos de data/hora de eventos em seu aplicativo. Instant parse() obtém um valor Instant de um valor de texto. A string será posteriormente armazenada como um valor de fuso horário UTC. O sistema usa DateTimeFormatter.ISO_INSTANT como 2020-10-14T11:28:15.00Z. Aqui está uma sintaxe do método Instant parse() :

public static Instant parse(CharSequence text)

Para analisar uma string e obter um instante, um desenvolvedor precisa garantir que a string contenha algum texto. Caso seja nulo, você obterá um DateTimeException. Aqui está um exemplo de uso da análise instantânea em 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);
       }
   }

A saída é:

10. Método parse() NumberFormat

A classe java.text.NumberFormat é usada para formatar números. NumberFormat parse() é um método padrão desta classe. O método parse () da classe NumberFormat converte uma string em um número. Os desenvolvedores o usam para quebrar uma string em seus números de componentes. A análise começa no início da string. Se você chamar setParseIntegerOnly (true) antes de chamar o método parse () , conforme mostrado no exemplo a seguir, somente a parte inteira do número será convertida. Aqui está a sintaxe de NumberFormat parse() :

public Number parse(String str)

Como parâmetro, a função aceita strings. Um valor de retorno da análise é um valor numérico. Se o início de uma string não puder ser analisado, você receberá um aviso de ParseException. Para ver a aplicação do método NumberFormat parse() , veja o exemplo abaixo:

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"));
       }
   }

A saída é:

Conclusão

Existem muitos métodos de análise que os desenvolvedores podem usar para converter strings em vários tipos de dados. Embora lembrá-los possa parecer tedioso, essa variedade de comandos oferece aos desenvolvedores muita flexibilidade e precisão. Certifique-se de praticar o uso da análise de dados para garantir que você se lembre da sintaxe e não esqueça quais parâmetros são essenciais para cada método.