11 méthodes parse() en Java avec des exemples

L'analyse, ou parsing, dans son sens le plus général, consiste à extraire les informations nécessaires d'un ensemble de données, le plus souvent textuelles. Qu'est-ce que parse en Java ? Il existe de nombreuses classes Java qui disposent de la méthode parse(). En général, la méthode parse() reçoit une chaîne de caractères en entrée, en extrait les informations nécessaires, et la convertit en un objet de la classe appelante. Par exemple, elle reçoit une chaîne de caractères et renvoie la date qui s'y « cache ». Dans cet article, nous allons examiner les 10 variantes utiles de parse().

0. parseInt()

Commençons par l'une des méthodes parse() les plus populaires, qui n'est pas exactement parse(), mais parseInt(). La méthode parseInt () de Java est utilisée pour obtenir le type de données primitif d'une chaîne spécifique. En d'autres termes, elle convertit une chaîne de caractères en un nombre. parseInt () peut avoir un ou deux arguments. Voici la syntaxe de parseInt() :

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

Où s est la chaîne représentant une valeur décimale signée et radix la base d'un système numérique. Garde à l'esprit qu'il n'y a pas de valeur de base par défaut : tu dois en saisir une dans la fourchette de 2 à 36. Voici un exemple. Comment utiliser 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));
         
       }
   }

Voici le résultat :

1. Méthode Period parse()

Period est une classe Java permettant de modéliser une quantité de temps en termes d'années, de mois et de jours, par exemple « 3 ans, 5 mois et 2 jours ». Elle possède une méthode parse() pour obtenir une période à partir d'un texte. Voici la syntaxe de Period parse() :

public static Period parse(CharSequence text)

CharSequence est une interface, implémentée par des chaînes. Tu peux donc utiliser des chaînes de caractères comme élément de texte dans la méthode parse(). Bien sûr, la chaîne de caractères doit être dans le bon format pour retourner un objet de la classe Period. Le format est PnYnMnD. Où Y signifie année, M mois et D jour. N est un nombre correspondant à chaque valeur de période.

• La méthode a un paramètre : une valeur texte.
• parse() renvoie une valeur Period où la valeur d'une chaîne de caractères devient un paramètre.
• Par exception, Period parse() peut renvoyer DateTimeParseException si la valeur de la chaîne ne correspond pas à la structure d'une période.

Voici un exemple d'utilisation de Period parse() dans le contexte du monde réel :

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

Voici le résultat :

2. Méthode SimpleDateFormat parse()

SimpleDateFormat est une classe utilisée pour le formatage et l'analyse des dates d'une manière sensible aux paramètres régionaux. La méthode SimpleDateFormat parse() décompose une chaîne en éléments de date et renvoie une valeur Data dans le format correspondant. La méthode commence à analyser la chaîne de caractères à un index, défini par le développeur. La syntaxe de la méthode SimpleDateFormat parse() :

public Date parse(String the_text, ParsePosition position)

Cette méthode prend deux paramètres :

• Position : les données à l'index de départ, qui sont toujours du type d'objet ParsePosition.
• the_text : définit la chaîne de caractères qui sera analysée par la méthode et est une valeur de type String.

Tu peux utiliser cette méthode sans déclaration de position. Dans ce cas, les données commencent à partir de l'indice zéro. SimpleDateFormat parse() renvoie une date ou une valeur nulle (dans le cas où la chaîne n'a pas été traitée en raison d'une erreur). Voici un exemple d'implémentation de 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);
   }
}

Voici le résultat : Le dernier résultat est nul, car il n'y a pas de modèle de date à partir de la 5e position. À ce propos, si tu essaies d'analyser la date5 sans position, par exemple Date date5 = simpleDateFormat2.parse(myString), tu recevras une exception :

3. Méthode LocalDate parse()

LocalDate est une classe apparue dans Java 8 pour représenter une date, par exemple au format année-mois-jour (les valeurs de jour de l'année, jour de la semaine et semaine de l'année sont également accessibles). LocalDate ne représente pas une heure ou un fuseau horaire. La méthode LocalDate parse() a deux variantes. Les deux permettent de convertir une chaîne en une nouvelle date d'API Java 8 - java.time.LocalDate.

parse(CharSequence text, DateTimeFormatter, formatter)

Cette méthode analyse une chaîne de caractères en utilisant un formateur spécifique pour obtenir une instance de LocalDate. La syntaxe de la méthode est la suivante :

public static LocalTime parse(CharSequence text,
                              DateTimeFormatter formatter)

Cette méthode prend deux paramètres : le texte qui sera analysé et le formateur qu'un développeur appliquera. Comme valeur de retour, la méthode renvoie un objet LocalTime qui sera reconnu comme l'heure locale du jour. Si la valeur du texte n'a pas pu être analysée, le système lève l'exception DayTimeParseException. Prenons un exemple de code pour utiliser LocalDate parse() avec deux paramètres :

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

Voici le résultat : La méthode LocalDate parse() avec un paramètre a la syntaxe suivante :

public static LocalTime parse(CharSequence text)

Cette méthode ne nécessite pas de spécifier un formateur. Une fois qu'un développeur a saisi les valeurs de chaîne dans les parenthèses, le système utilise automatiquement le format DateTimeFormatter.ISO_LOCAL_DATE. Cette méthode a un seul paramètre : un texte CharSequence. Tu peux utiliser ici la valeur de la chaîne de caractères. Assure-toi qu'elle n'est pas nulle et qu'elle respecte la structure du formateur. S'il n'est pas possible d'analyser une chaîne de caractères, le développeur reçoit l'alerte DateTimeExceptionAlert. Voici un exemple d' application de 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);
       }
   }

Voici le résultat :

4. Méthode LocalDateTime parse()

LocalDateTime est un objet date-heure qui représente une date-heure, assez souvent au format année-mois-jour-heure-minute-seconde. Les développeurs peuvent également utiliser d'autres champs de date et d'heure (jour de l'année, jour de la semaine et semaine de l'année). Cette classe est immuable. Le temps est représenté avec une précision de l'ordre de la nanoseconde. Par exemple, tu peux stocker la valeur « 17 novembre 2020 à 13:30.30.123456789 » dans un LocalDateTime. Cette classe n'a pas pour but de représenter un fuseau horaire. Il s'agit plutôt d'une représentation standard de la date à laquelle s'ajoute l'heure locale. La méthode LocalDateTime parse() est représentée en deux variantes :

• static LocalDateTime parse(CharSequence text) renvoie une instance de LocalDateTime à partir d'une chaîne de texte, comme 2007-12-03T10:15:30.
• static LocalDateTime parse(CharSequence text, DateTimeFormatter formatter) renvoie une instance de LocalDateTime à partir d'une chaîne de texte en utilisant un formateur spécifique.

Voici un exemple de la méthode 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);
       }
   }

Voici le résultat :

5. Méthode ZonedDateTime parse()

La classe ZonedDateTime représente une date-heure avec un fuseau horaire. Cette classe est immuable. Elle stocke les champs de date et d'heure avec une précision de l'ordre de la nanoseconde, ainsi qu'un fuseau horaire, avec un décalage de fuseau utilisé pour gérer les dates et heures locales ambiguës. Ainsi, si tu dois conserver une valeur telle que « 14 octobre 2020 à 17:50.30.123456789 +02:00 dans le fuseau horaire Europe/Paris », tu peux utiliser ZonedDateTime. Cette classe est souvent utilisée pour manipuler des données locales basées sur le temps. ZondeDateTime parse() est un analyseur syntaxique qui décompose la chaîne en jetons selon le système ISO-8061. Voici un exemple de valeur que tu obtiens après l'analyse : Cette méthode est utilisée chaque fois que des données de haute précision sont nécessaires (après tout, les données que tu obtiens sont précises à la nanoseconde près). Cette classe est souvent utilisée pour manipuler des données locales basées sur le temps. Examinons la syntaxe générale de la méthode ZonedDateTime parse() que les développeurs utilisent pour convertir les valeurs de chaîne en classe ZonedDateTime.

public static ZonedDateTime parse(CharSequence text)

Le seul paramètre utilisé par la méthode est une chaîne de caractères. Comme valeur de retour, tu recevras un objet ou une série d'objets au format ZonedDateTime. S'il y a une erreur pendant l'analyse ou si c'est impossible, la méthode renvoie DateTimeParseException. Il existe également une méthode parse() avec deux variables.

public static ZonedDateTime parse(CharSequence text, DateFormatter formatter)

Cette méthode permet d'obtenir une instance de ZonedDateTime à partir d'une valeur textuelle en utilisant un formateur spécifique. La méthode à un paramètre, et le formateur DateTimeFormatter.ISO_LOCAL_TIME est utilisé par défaut. Examinons le cas d'utilisation 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);
   }
}

Voici le résultat :

6. Méthode LocalTime parse()

La classe LocalTime représente une heure, souvent au format heure minute seconde. Cette classe est également immuable, comme ZonedDateTime. Le temps est représenté avec une précision de l'ordre de la nanoseconde. Par exemple, la valeur « 13:45.30.123456789 » peut être stockée dans un LocalTime. Il existe deux méthodes LocalTime parse(), avec un et deux paramètres respectivement. Jetons un coup d'œil aux deux :

public static LocalTime parse(CharSequence text)

Tu peux utiliser LocalTime parse() avec un seul paramètre, la chaîne que tu veux analyser. Dans ce cas, le formateur DateTimeFormatter.ISO_LOCAL_TIME est utilisé par défaut. La méthode avec deux paramètres a la syntaxe suivante :

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

Elle permet d'obtenir une instance de ZonedDateTime à partir d'une valeur textuelle en utilisant un formateur spécifique. Les deux méthodes renvoient la valeur LocalTime au format hh/mm/ss. Attention aux alertes DateTimeParceException. Elles signifient que le format de chaîne ne correspond pas à celui des objets LocalTime. Voici un exemple d'utilisation de LocalTime parse() en production :

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éthode MessageFormat Parse()

MessageFormat étend la classe Format. Format est une classe de base abstraite pour formater des données sensibles aux paramètres régionaux (dates, messages et nombres). MessageFormat obtient des objets et les formate. Ensuite, la classe insère les chaînes formatées dans le modèle aux endroits appropriés. La méthode MessageFormat parse() est utilisée pour obtenir une valeur de chaîne pour un indice de début donné. La syntaxe générale de la méthode est la suivante :

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

Où source est une chaîne à analyser et position l'indice de départ de l'analyse. Voici un exemple de la méthode 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éthode Level parse()

Lorsqu'un programmeur utilise un Logger pour enregistrer un message, il est enregistré avec un certain niveau de journal. Il existe sept niveaux de journal intégrés :

• SEVERE
• WARNING
• INFO
• CONFIG
• FINE
• FINER
• FINEST

Il y a également des niveaux supplémentaires, OFF qui peut être utilisé pour désactiver la journalisation, et ALL pour activer la journalisation de tous les messages. Le niveau de journal est représenté par la classe java.util.logging.Level. La classe Level contient une constante pour chacun de ces sept niveaux. Tu utilises donc l'une de ces constantes, y compris ALL et OFF, lorsque tu enregistres un message dans un Logger. De plus, tous ces niveaux sont initialisés sur des entiers. Par exemple, FINE est initialisé à 500. La méthode Level parse() analyse une information requise à partir d'une valeur de texte et renvoie un objet Level. Voici la syntaxe de la méthode Level parse() :

public static Level parse(String name)

Le paramètre de la méthode est le nom d'une chaîne qu'un développeur souhaite analyser. Il peut s'agir du nom du niveau, de son nom d'initialisation ou d'un autre entier. En retour, le programmeur obtient une valeur de nom de niveau, correspondant à celle de la chaîne initiale. Si l'argument contient des symboles impossibles à analyser, le système lèvera l'exception IllegalArgumentException. Si une chaîne ne contient aucune valeur, le développeur obtient une NullPointerException. Voici un morceau de code qui montre l'implémentation 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());
   }
}

Voici le résultat :

9. Méthode Instant parse()

La classe Instant modélise un seul point instantané sur la ligne temporelle. Tu peux l'utiliser pour enregistrer les horodatages des événements dans ton application. Instant parse() obtient une valeur Instant à partir d'une valeur texte. La chaîne sera ensuite stockée en tant que valeur de fuseau horaire UTC. Le système utilise DateTimeFormatter.ISO_INSTANT, par exemple 2020-10-14T11:28:15.00Z. Voici la syntaxe de la méthode Instant parse() :

public static Instant parse(CharSequence text)

Pour analyser une chaîne et obtenir un Instant, un développeur doit s'assurer que la chaîne contient du texte. Si elle est nulle, tu recevras une DateTimeException. Voici un exemple d'utilisation de Instant parse 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);
       }
   }

Voici le résultat :

10. Méthode NumberFormat parse()

La classe java.text.NumberFormat est utilisée pour formater les numéros. NumberFormat parse() est une méthode par défaut de cette classe. La méthode parse() de la classe NumberFormat convertit une chaîne en nombre. Les développeurs l'utilisent pour décomposer une chaîne en ses composantes numériques. L'analyse commence au début de la chaîne. Si tu appelles setParseIntegerOnly(true) avant d'appeler la méthode parse(), comme indiqué dans l'exemple suivant, alors seule la partie entière du nombre est convertie. Voici la syntaxe de NumberFormat parse() :

public Number parse(String str)

En tant que paramètre, la fonction accepte des chaînes. La valeur de retour de l'analyse est une valeur numérique. Si un début de chaîne ne peut pas être analysé, tu recevras un avertissement ParseException. Pour voir l'application de la méthode NumberFormat parse(), regarde l'exemple ci-dessous :

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

Voici le résultat :

Conclusion

Il existe de nombreuses méthodes d'analyse que les développeurs peuvent utiliser pour convertir des chaînes de caractères en divers types de données. Bien que leur mémorisation puisse sembler fastidieuse, une telle variété de commandes offre aux développeurs beaucoup de souplesse et de précision. Veille à t'entraîner à l'utilisation de l'analyse des données pour t'assurer que tu te souviens de la syntaxe et que tu n'oublieras pas les paramètres essentiels pour chaque méthode.