11 metodi parse() in Java con esempi

L'analisi nel suo senso più generale è l'estrazione delle informazioni necessarie da alcuni dati, il più delle volte dati testuali. Cos'è l'analisi in Java? Ci sono molte classi Java che hanno il metodo parse() . Di solito il metodo parse() riceve una stringa come input, "estrae" da essa le informazioni necessarie e la converte in un oggetto della classe chiamante. Ad esempio, ha ricevuto una stringa e ha restituito la data che era "nascosta" in questa stringa. In questo post, daremo un'occhiata alle 10 utili varianti di parse() .

0. analisiInt()

Partiamo da uno dei metodi parse() più popolari , che non è esattamente parse() , ma parseInt() . Il metodo Java parseInt () viene utilizzato per ottenere il tipo di dati primitivo da una stringa specifica. In altre parole, converte una stringa in un numero. parseInt() può avere uno o due argomenti. Ecco la sintassi di parseInt() :

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

Dove s è la stringa che rappresenta un valore decimale con segno e radix la base di un sistema numerico. Tieni presente che non esiste un valore di base predefinito: devi inserirne uno compreso tra 2 e 36. Ecco un esempio. Come analizzare 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));
         
       }
   }

L'uscita è:

1. Metodo parse() del periodo

Period è una classe Java per modellare una quantità di tempo in termini di anni, mesi e giorni come "3 anni, 5 mesi e 2 giorni". Ha un metodo parse() per ottenere un periodo da un testo. Ecco la sintassi di period parse()

public static Period parse(CharSequence text)

CharSequence è un'interfaccia, implementata da stringhe. Quindi puoi usare le stringhe come elemento di testo nel metodo parse() . Sicuramente la stringa dovrebbe essere nel formato corretto per restituire un oggetto della classe Periodo. Questo formato è PnYnMnD . Dove Y sta per "anno", M - per "mese", D - per "giorno". N è un numero corrispondente a ciascun valore del periodo.

• Il metodo ha un parametro: un valore di testo.
• Parse() restituisce un valore Periodo in cui il valore di una stringa diventa un parametro.
• Come eccezione, period parse() può restituire DateTimeParseException se il valore della stringa non soddisfa la struttura di un punto.

Ecco un esempio di utilizzo di Period parse() nel contesto del mondo reale:

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

L'uscita è:

2. Metodo SimpleDateFormat Parse()

SimpleDateFormat è una classe utilizzata per la formattazione e l'analisi delle date in modo sensibile alle impostazioni locali. Il metodo SimpleDateFormat parse() suddivide una stringa in token di data e restituisce un valore Data nel formato corrispondente. Il metodo avvia l'analisi della stringa in corrispondenza di un indice, definito da uno sviluppatore. Questa è la sintassi di SimpleDateFormat parse() :

public Date parse(String the_text, ParsePosition position)

Il metodo ha due parametri:

• Posizione: i dati nell'indice iniziale che è sempre il tipo di oggetto ParsePosition.
• the_text: definisce la stringa che il metodo analizzerà ed è un valore di tipo String.

È possibile utilizzare questo metodo senza dichiarazione di posizione. In questo caso i dati iniziano dall'indice zero. SimpleDateFormat parse() restituisce una data o un valore nullo (nel caso in cui la stringa non sia stata elaborata a causa di un errore). Ecco un esempio di implementazione di SimpleDateFormat parse() :

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

L'uscita è: L'ultimo è nullo perché non esiste uno schema di date a partire dalla quinta posizione. A proposito, se provi ad analizzare date5 senza posizione come Date date5 = simpleDateFormat2.parse(myString) , otterrai un'eccezione:

3. Metodo LocalDate parse()

LocalDate è una classe apparsa in Java 8 per rappresentare una data come anno-mese-giorno (è possibile accedere anche a giorno dell'anno, giorno della settimana e settimana dell'anno). LocalDate non rappresenta un'ora o un fuso orario. Il metodo LocalDate parse() ha due varianti. Entrambi aiutano a convertire una stringa in una nuova API data Java 8 — java.time.LocalDate .

parse (testo CharSequence, DateTimeFormatter, formattatore)

Questo metodo analizza una stringa utilizzando un formattatore specifico per ottenere un'istanza di LocalDate. Ecco la sintassi del metodo:

public static LocalTime parse(CharSequence text,
                              DateTimeFormatter formatter)

Esistono due parametri per il metodo: il testo che verrà analizzato e il formattatore applicato da uno sviluppatore. Come valore di ritorno, il metodo restituisce un oggetto LocalTime che verrà riconosciuto come l'ora del giorno locale. Se il valore del testo non è stato analizzato, il sistema genera l'eccezione DayTimeParseException. Facciamo un esempio di codice sull'uso di LocalDate parse() con due parametri:

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

L'uscita è: Il metodo LocalDate parse() con un parametro ha la seguente sintassi:

public static LocalTime parse(CharSequence text)

Questo metodo non richiede di specificare un formattatore. Dopo che uno sviluppatore ha inserito i valori della stringa tra parentesi, il sistema utilizzerà automaticamente DateTimeFormatter.ISO_LOCAL_DATE. Questo metodo ha un singolo parametro: un testo CharSequence. Puoi usare qui il valore della stringa. Assicurati che non sia nullo e rispetti la struttura del formattatore. Se non è possibile analizzare una stringa, uno sviluppatore riceve DateTimeExceptionAlert. Ecco un esempio di applicazione 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);
       }
   }

L'uscita è:

4. Metodo LocalDateTime parse()

LocalDateTime un oggetto data-ora che rappresenta una data-ora visualizzata molto spesso come anno-mese-giorno-ora-minuto-secondo. Inoltre, gli sviluppatori possono utilizzare altri campi di data e ora (giorno dell'anno, giorno della settimana e settimana dell'anno). Questa classe è immutabile. Il tempo è rappresentato con precisione al nanosecondo. Ad esempio, puoi memorizzare il valore "17nd November 2020 at 13:30.30.123456789" in LocalDateTime. Questa lezione non riguarda la rappresentazione di un fuso orario. È piuttosto una rappresentazione standard della data più l'ora locale. Metodo LocalDateTime parse() rappresentato in due varianti:

• static LocalDateTime parse(CharSequence text) restituisce un'istanza di LocalDateTime da una stringa di testo come 2007-12-03T10:15:30.
• static LocalDateTime parse(CharSequence text, DateTimeFormatter formatter) restituisce un'istanza di LocalDateTime da una stringa di testo utilizzando un formattatore specifico.

Ecco un esempio del metodo 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);
       }
   }

L'uscita è:

5. Metodo ZonedDateTime parse()

La classe ZonedDateTime rappresenta una data-ora con un fuso orario. Questa classe è immutabile. Memorizza i campi di data e ora con una precisione di nanosecondi e un fuso orario, con un offset di zona utilizzato per gestire date e orari locali ambigui. Quindi, se devi mantenere un valore come "14 ottobre 2020 alle 17:50.30.123456789 +02:00 nel fuso orario Europa/Parigi" puoi utilizzare ZonedDateTime. La classe viene spesso utilizzata per manipolare dati basati sull'ora locale. ZondeDateTime parse() è un parser che suddivide la stringa in token nel sistema ISO-8061. Ecco un esempio di un valore che otterrai dopo l'analisi: Viene utilizzato ogni volta che sono necessari dati ad alta precisione (dopotutto, i dati che ottieni sono precisi fino a nanosecondi). La classe viene spesso utilizzata per manipolare dati basati sull'ora locale. Diamo un'occhiata alla sintassi generale del metodo ZonedDateTime parse() che gli sviluppatori usano per convertire i valori stringa nella classe ZonedDateTime.

public static ZonedDateTime parse(CharSequence text)

L'unico parametro utilizzato dal metodo è una stringa di testo. Come valore di ritorno, otterrai uno o una serie di oggetti nel formato ZonedDateTime. Se c'è un errore durante l'analisi o è impossibile, per cominciare, il metodo restituisce DateTimeParseException. Inoltre c'è un metodo parse() con due variabili.

public static ZonedDateTime parse(CharSequence text, DateFormatter formatter)

Questo metodo ottiene un'istanza di ZonedDateTime da un valore di testo usando un formattatore specifico. Per impostazione predefinita viene utilizzato il metodo con un parametro, il formattatore DateTimeFormatter.ISO_LOCAL_TIME . Diamo un'occhiata al caso d'uso per 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);
   }
}

L'uscita è:

6. Metodo LocalTime parse()

La classe LocalTime rappresenta un'ora, spesso visualizzata come ora-minuto-secondo. Questa classe è anche immutabile, ad esempio ZonedDateTime.Time è rappresentato con una precisione di nanosecondi. Ad esempio, il valore "13:45.30.123456789" può essere memorizzato in LocalTime. Esistono due metodi LocalTime parse() , con uno e due parametri. Diamo un'occhiata a entrambi:

public static LocalTime parse(CharSequence text)

Puoi usare LocalTime parse() con un solo parametro, la stringa che vuoi analizzare. In questo caso, per impostazione predefinita viene utilizzato il formattatore DateTimeFormatter.ISO_LOCAL_TIME.

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

Ottiene un'istanza di LocalTime da un valore di testo utilizzando un formattatore specifico. Entrambi i metodi restituiscono il valore LocalTime nel formato hh/mm/ss. Fai attenzione agli avvisi DateTimeParceException. Significano che il formato del testo della stringa non corrisponde a quello degli oggetti LocalTime. Ecco un esempio di utilizzo di LocalTime parse() in produzione:

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. Metodo MessageFormat Parse()

MessageFormat estende la classe Format. Format è una classe base astratta per la formattazione di dati sensibili alle impostazioni locali (date, messaggi e numeri). MessageFormat ottiene alcuni oggetti e li formatta. Quindi inserisce le stringhe formattate nel modello nei punti appropriati. Il MessageFormat parse() viene utilizzato per ottenere un valore di stringa se viene dato l'inizio dell'indice. Ecco la sintassi generale del metodo:

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

Dove source è una stringa da analizzare e position è l'indice iniziale dell'analisi. Ecco un esempio di funzionamento del metodo 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. Metodo livello parse()

Quando un programmatore utilizza un Logger per registrare un messaggio, viene registrato con un certo livello di registro. Sono disponibili sette livelli di registro integrati:

• ACUTO
• AVVERTIMENTO
• INFORMAZIONI
• CONFIG
• BENE
• PIÙ FINE
• PIÙ BELLO

Esistono inoltre livelli aggiuntivi OFF che possono essere utilizzati per disattivare la registrazione e ALL che possono essere utilizzati per abilitare la registrazione di tutti i messaggi. Il livello di log è rappresentato dalla classe java.util.logging.Level . La classe di livello contiene una costante per ognuno di questi sette livelli. Quindi usi una di queste costanti, incluse All e OFF durante la registrazione di un messaggio in un Logger. Anche tutti questi livelli inizializzati su alcuni numeri interi. Ad esempio, FINE è inizializzato a 500. Il metodo Level parse() analizza un'informazione necessaria da un valore di testo e restituisce un oggetto Level. Ecco la sintassi del metodo level parse() :

public static Level parse(String name)

Il parametro di un metodo è il nome di una stringa che uno sviluppatore desidera analizzare. Potrebbe essere un nome del livello, il suo nome di inizializzazione o qualche altro numero intero. In cambio, un programmatore ottiene un valore del nome del livello, corrispondente a quello della stringa iniziale. Nel caso in cui l'argomento contenga simboli impossibili da analizzare, il sistema genererà IllegalArgumentException. Se una stringa non contiene valori, uno sviluppatore riceve un'eccezione NullPointerException. Ecco un pezzo di codice che mostra l'implementazione di 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());
   }
}

L'uscita è:

9. Metodo parse() istantaneo

La classe istantanea modella un singolo punto istantaneo sulla linea del tempo. Puoi usarlo per registrare i timestamp degli eventi nella tua app. Instant parse() ottiene un valore Instant da un valore di testo. La stringa verrà successivamente archiviata come valore del fuso orario UTC. Il sistema utilizza DateTimeFormatter.ISO_INSTANT come 2020-10-14T11:28:15.00Z. Ecco una sintassi del metodo Instant parse() :

public static Instant parse(CharSequence text)

Per analizzare una stringa e ottenere un istante, uno sviluppatore deve assicurarsi che la stringa contenga del testo. Nel caso in cui sia nullo, otterrai un'eccezione DateTimeException. Ecco un esempio di utilizzo dell'analisi istantanea in 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);
       }
   }

L'uscita è:

10. Metodo NumberFormat parse()

La classe java.text.NumberFormat viene utilizzata per formattare i numeri. NumberFormat parse() è un metodo predefinito di questa classe. Il metodo parse() della classe NumberFormat converte una stringa in un numero. Gli sviluppatori lo usano per scomporre una stringa fino ai numeri dei suoi componenti. L'analisi inizia dall'inizio della stringa. Se si chiama setParseIntegerOnly (true) prima di chiamare il metodo parse() , come mostrato nell'esempio seguente, viene convertita solo la parte intera del numero. Ecco la sintassi di NumberFormat parse() :

public Number parse(String str)

Come parametro, la funzione accetta stringhe. Un valore restituito dall'analisi è un valore numerico. Se l'inizio di una stringa non può essere analizzato, riceverai un avviso ParseException. Per vedere l'applicazione del metodo NumberFormat parse() , dai un'occhiata all'esempio seguente:

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

L'uscita è:

Conclusione

Esistono molti metodi di analisi che gli sviluppatori possono utilizzare per convertire le stringhe in vari tipi di dati. Sebbene ricordarli possa sembrare noioso, una tale varietà di comandi offre agli sviluppatori molta flessibilità e precisione. Assicurati di esercitarti nell'uso dell'analisi dei dati per assicurarti di ricordare la sintassi e di non dimenticare quali parametri sono essenziali per ciascun metodo.