Tutoriel Java

Guide Complet sur replaceFirst en Java

Dans ce guide, nous explorerons en profondeur l’utilisation de cette méthode, ses applications courantes, et fournirons des exemples pratiques pour illustrer son utilisation.

Introduction

La méthode replaceFirst de la classe String en Java est un outil puissant pour manipuler des chaînes de caractères. Elle permet de remplacer la première occurrence d’un motif correspondant à une expression régulière par une chaîne de remplacement spécifiée.

Comprendre la méthode replaceFirst

La méthode replaceFirst est une méthode de la classe String en Java. Elle permet de remplacer la première occurrence d’une séquence de caractères correspondant à une expression régulière par une autre séquence de caractères spécifiée. C’est particulièrement utile lorsqu’on ne veut remplacer qu’une seule occurrence d’un motif dans une chaîne.

La compréhension de la méthode replaceFirst repose sur une bonne connaissance des expressions régulières, qui permettent de définir des motifs de recherche de manière très flexible et puissante.

Syntaxe et Paramètres

La signature de la méthode replaceFirst est la suivante :

public String replaceFirst(String regex, String replacement)
Paramètres
  • regex : L’expression régulière (regex) définissant le motif à rechercher.
  • replacement : La chaîne de caractères à substituer au premier motif correspondant.
Retour

La méthode retourne une nouvelle chaîne de caractères résultant du remplacement de la première occurrence du motif.

Exemple de syntaxe
String modifiedString = originalString.replaceFirst("regex", "replacement");

Dans cet exemple, originalString est la chaîne d’origine, regex est l’expression régulière définissant le motif à remplacer, et replacement est la chaîne qui remplacera la première occurrence du motif.

Exemples de Base
Remplacement Simple

Supposons que nous ayons une chaîne de caractères et que nous souhaitions remplacer la première occurrence du mot “apple” par “orange”.

public class ReplaceFirstExample {
    public static void main(String[] args) {
        String original = "apple banana apple grape";
        String modified = original.replaceFirst("apple", "orange");
        System.out.println(modified);
    }
}

Sortie :

orange banana apple grape
Utilisation d’Expressions Régulières

Nous pouvons utiliser des expressions régulières pour définir des motifs plus complexes. Par exemple, remplacer la première occurrence de tout mot commençant par une voyelle.

public class ReplaceFirstExample {
    public static void main(String[] args) {
        String original = "apple banana orange grape";
        String modified = original.replaceFirst("\\b[aeiouAEIOU]\\w*", "fruit");
        System.out.println(modified);
    }
}

Sortie :

fruit banana orange grape
Expressions Régulières Avancées
Utilisation des Groupes

Les groupes d’expressions régulières permettent de capturer des parties spécifiques du motif. Par exemple, nous pouvons remplacer la première occurrence d’un mot en conservant certaines parties de ce mot.

public class ReplaceFirstExample {
    public static void main(String[] args) {
        String original = "cat bat rat";
        String modified = original.replaceFirst("(\\b\\w)at", "$1og");
        System.out.println(modified);
    }
}

Sortie :

cog bat rat
Utilisation des Métacaractères

Les métacaractères permettent des correspondances plus flexibles. Par exemple, remplacer la première séquence de chiffres par un mot.

public class ReplaceFirstExample {
    public static void main(String[] args) {
        String original = "123abc 456def";
        String modified = original.replaceFirst("\\d+", "number");
        System.out.println(modified);
    }
}

Sortie :

numberabc 456def
Utilisation des Bornes

Les bornes d’expressions régulières permettent de spécifier les débuts et les fins de mots ou de chaînes. Par exemple, remplacer un mot en début de ligne uniquement.

public class ReplaceFirstExample {
    public static void main(String[] args) {
        String original = "apple banana apple grape";
        String modified = original.replaceFirst("^apple", "orange");
        System.out.println(modified);
    }
}

Sortie :

orange banana apple grape
Cas d’Échappement

Il est parfois nécessaire d’échapper certains caractères spéciaux dans les expressions régulières, comme les points, les parenthèses, les crochets, etc.

public class ReplaceFirstExample {
    public static void main(String[] args) {
        String original = "abc.def.ghi";
        String modified = original.replaceFirst("\\.", "-");
        System.out.println(modified);
    }
}

Sortie :

abc-def.ghi
Applications Pratiques
Normalisation des Données

Supposons que vous ayez des numéros de téléphone dans différents formats et que vous souhaitiez standardiser le premier format trouvé.

public class ReplaceFirstExample {
    public static void main(String[] args) {
        String phoneNumbers = "Phone: 123-456-7890, Cell: (123) 456-7890";
        String standardized = phoneNumbers.replaceFirst("\\(?(\\d{3})\\)?[- ]?(\\d{3})[- ]?(\\d{4})", "$1-$2-$3");
        System.out.println(standardized);
    }
}

Sortie :

Phone: 123-456-7890, Cell: 123 456-7890

Masquage de Données Sensibles

Pour masquer partiellement des informations sensibles telles qu’un numéro de carte de crédit.

public class ReplaceFirstExample {
    public static void main(String[] args) {
        String creditCard = "My credit card number is 1234-5678-9012-3456.";
        String masked = creditCard.replaceFirst("\\b\\d{4}-\\d{4}-\\d{4}-\\d{4}\\b", "****-****-****-3456");
        System.out.println(masked);
    }
}

Sortie :

My credit card number is ****-****-****-3456.
Traitement de Texte

La méthode replaceFirst peut être utilisée pour divers traitements de texte, comme la correction automatique ou la mise en forme des textes.

public class ReplaceFirstExample {
    public static void main(String[] args) {
        String text = "The the quick brown fox.";
        String correctedText = text.replaceFirst("\\b[Tt]he\\b", "A");
        System.out.println(correctedText);
    }
}

Sortie :

A the quick brown fox.
Transformation de Fichiers

Lors de la manipulation de fichiers texte, replaceFirst peut être utilisée pour modifier des lignes spécifiques, comme remplacer la première occurrence d’un mot dans chaque ligne.

import java.nio.file.*;
import java.io.IOException;
import java.util.List;
import java.util.stream.Collectors;

public class ReplaceFirstInFile {
    public static void main(String[] args) throws IOException {
        Path filePath = Paths.get("example.txt");
        List<String> lines = Files.readAllLines(filePath);

        List<String> modifiedLines = lines.stream()
            .map(line -> line.replaceFirst("target", "replacement"))
            .collect(Collectors.toList());

        Files.write(filePath, modifiedLines);
    }
}
Comparaison avec d’autres Méthodes

replace

La méthode replace remplace toutes les occurrences d’un motif par une autre chaîne.

public class ReplaceExample {
    public static void main(String[] args) {
        String original = "apple banana apple grape";
        String modified = original.replace("apple", "orange");
        System.out.println(modified);
    }
}

Sortie :

orange banana orange grape

replaceAll

La méthode replaceAll remplace toutes les occurrences correspondant à une expression régulière.

public class ReplaceAllExample {
    public static void main(String[] args) {
        String original = "apple banana apple grape";
        String modified = original.replaceAll("a\\w+", "fruit");
        System.out.println(modified);
    }
}

Sortie :

fruit banana fruit grape

replaceFirst vs replace

La principale

différence entre replaceFirst et replace est que replaceFirst ne remplace que la première occurrence alors que replace remplace toutes les occurrences du motif.

replaceFirst vs replaceAll

replaceFirst remplace uniquement la première occurrence correspondant à l’expression régulière, tandis que replaceAll remplace toutes les occurrences.

Performance

En termes de performance, replaceFirst peut être plus rapide que replaceAll ou replace lorsqu’il s’agit de remplacer uniquement la première occurrence, car elle ne continue pas à rechercher après la première correspondance trouvée.

Erreurs Courantes et Dépannage
Problèmes avec les Expressions Régulières

L’une des erreurs les plus courantes est l’utilisation incorrecte des expressions régulières. Assurez-vous que votre expression régulière est correctement formée et qu’elle correspond exactement à ce que vous souhaitez remplacer.

NullPointerException

Assurez-vous que les chaînes de caractères passées à replaceFirst ne sont pas nulles, sinon une NullPointerException sera levée.

public class ReplaceFirstExample {
    public static void main(String[] args) {
        String original = null;
        try {
            String modified = original.replaceFirst("a", "b");
        } catch (NullPointerException e) {
            System.out.println("NullPointerException caught!");
        }
    }
}

Sortie :

NullPointerException caught!
Caractères d’Échappement

Lors de l’utilisation d’expressions régulières, certains caractères doivent être échappés. Par exemple, les caractères . ou * ont une signification spéciale en regex.

public class ReplaceFirstExample {
    public static void main(String[] args) {
        String original = "file.txt file2.txt";
        String modified = original.replaceFirst("\\.txt", ".csv");
        System.out.println(modified);
    }
}

Sortie :

file.csv file2.txt
Bonnes Pratiques
Utiliser des Expressions Régulières Lisibles

Les expressions régulières peuvent devenir complexes et difficiles à lire. Utilisez des commentaires et des noms de groupes pour rendre vos expressions régulières plus lisibles.

public class ReplaceFirstExample {
    public static void main(String[] args) {
        String original = "cat bat rat";
        String regex = "(\\b\\w)at"; // (start of word character followed by 'at')
        String modified = original.replaceFirst(regex, "$1og");
        System.out.println(modified);
    }
}
Tester Vos Expressions Régulières

Avant d’utiliser une expression régulière dans votre code, testez-la avec divers cas pour vous assurer qu’elle fonctionne comme prévu.

Utiliser des Librairies d’Expressions Régulières

Pour des expressions régulières complexes, envisagez d’utiliser des bibliothèques qui fournissent des outils pour générer et tester des expressions régulières.

Utilisation dans des Scénarios Concrets

Remplacement de Balises HTML

Lors de la manipulation de contenu HTML, replaceFirst peut être utilisée pour remplacer des balises spécifiques.

public class ReplaceFirstExample {
    public static void main(String[] args) {
        String html = "<div>Content</div><div>More Content</div>";
        String modifiedHtml = html.replaceFirst("<div>", "<section>");
        System.out.println(modifiedHtml);
    }
}

Sortie :

<section>Content</div><div>More Content</div>
Transformation de Chemins de Fichiers

Pour les systèmes de fichiers, vous pouvez utiliser replaceFirst pour transformer des chemins de fichiers.

public class ReplaceFirstExample {
    public static void main(String[] args) {
        String path = "/home/user/docs/file.txt";
        String newPath = path.replaceFirst("/home/user", "/mnt/data");
        System.out.println(newPath);
    }
}

Sortie :

/mnt/data/docs/file.txt
Conversion de Formules Mathématiques

Pour convertir des formules mathématiques dans des formats spécifiques, replaceFirst peut être utilisée pour remplacer des symboles ou des notations.

public class ReplaceFirstExample {
    public static void main(String[] args) {
        String formula = "E=mc^2 + c^2";
        String modifiedFormula = formula.replaceFirst("\\^2", "²");
        System.out.println(modifiedFormula);
    }
}

Sortie :

E=mc² + c^2
Ressources et Références
Documentation Java

La documentation officielle de Java fournit des informations détaillées sur la méthode replaceFirst et les expressions régulières.

Outils en Ligne

Plusieurs outils en ligne peuvent aider à tester et à comprendre les expressions régulières.

Livres Recommandés
  • “Java: The Complete Reference” par Herbert Schildt
  • “Mastering Regular Expressions” par Jeffrey E. F. Friedl
Conclusion

La méthode replaceFirst de la classe String en Java est un outil puissant et flexible pour manipuler des chaînes de caractères. Elle permet de remplacer la première occurrence d’un motif correspondant à une expression régulière par une chaîne de remplacement spécifiée. En comprenant comment utiliser cette méthode et en suivant les bonnes pratiques, vous pouvez simplifier de nombreuses tâches de traitement de texte dans vos applications Java. Que ce soit pour normaliser des données, masquer des informations sensibles ou simplement manipuler des chaînes de caractères, replaceFirst est une méthode précieuse à avoir dans votre arsenal de programmation.

Cas Particuliers d’Utilisation de replaceFirst en Java

Les cas particuliers d’utilisation de la méthode replaceFirst permettent de comprendre sa flexibilité et son utilité dans diverses situations de programmation. Voici plusieurs exemples illustrant des scénarios spécifiques où replaceFirst peut être utilisé de manière efficace.

1. Suppression de Préfixes dans les Noms de Fichiers

Lorsque vous travaillez avec des fichiers, vous pouvez avoir besoin de supprimer un préfixe spécifique des noms de fichiers.

public class RemovePrefixExample {
    public static void main(String[] args) {
        String fileName = "temp_file.txt";
        String modifiedFileName = fileName.replaceFirst("^temp_", "");
        System.out.println(modifiedFileName);
    }
}

Sortie :

file.txt
2. Conversion de Dates

Pour convertir une date dans un format spécifique, comme du format “YYYY-MM-DD” au format “DD/MM/YYYY”.

public class DateFormatExample {
    public static void main(String[] args) {
        String date = "2024-07-08";
        String modifiedDate = date.replaceFirst("(\\d{4})-(\\d{2})-(\\d{2})", "$3/$2/$1");
        System.out.println(modifiedDate);
    }
}

Sortie :

08/07/2024
3. Remplacement de l’Extension de Fichier

Changer l’extension d’un fichier peut être nécessaire lorsque vous traitez différents types de fichiers.

public class ChangeFileExtensionExample {
    public static void main(String[] args) {
        String filePath = "document.txt";
        String modifiedFilePath = filePath.replaceFirst("\\.txt$", ".md");
        System.out.println(modifiedFilePath);
    }
}

Sortie :

document.md
4. Nettoyage des Données JSON

Lors de la manipulation de données JSON, vous pouvez avoir besoin de formater ou de nettoyer les données.

public class CleanJsonExample {
    public static void main(String[] args) {
        String jsonString = "{\"name\":\"John\",\"age\":30,\"city\":\"New York\"}";
        String cleanedJsonString = jsonString.replaceFirst("\\{", "{\n\t");
        System.out.println(cleanedJsonString);
    }
}

Sortie :

{
    "name":"John","age":30,"city":"New York"
5. Modification de l’URL

Changer la première occurrence d’un sous-domaine ou d’un chemin dans une URL.

public class ModifyUrlExample {
    public static void main(String[] args) {
        String url = "http://example.com/path/to/resource";
        String modifiedUrl = url.replaceFirst("example", "demo");
        System.out.println(modifiedUrl);
    }
}

Sortie :

http://demo.com/path/to/resource
6. Normalisation des Textes

Remplacer les premières occurrences de mots spécifiques pour normaliser les textes.

public class NormalizeTextExample {
    public static void main(String[] args) {
        String text = "Mr. John Doe met Mr. Smith.";
        String normalizedText = text.replaceFirst("\\bMr\\.", "Mister");
        System.out.println(normalizedText);
    }
}

Sortie :

Mister John Doe met Mr. Smith.
7. Internationalisation de Numéros

Lors de la localisation d’applications, vous pouvez vouloir formater les numéros de téléphone selon un format international.

public class InternationalizePhoneNumberExample {
    public static void main(String[] args) {
        String phoneNumber = "555-1234";
        String internationalizedPhoneNumber = phoneNumber.replaceFirst("^555", "+1-555");
        System.out.println(internationalizedPhoneNumber);
    }
}

Sortie :

+1-555-1234

8. Correction Automatique de Texte

Pour les applications de traitement de texte, vous pouvez implémenter une correction automatique de certaines fautes courantes.

public class AutoCorrectExample {
    public static void main(String[] args) {
        String sentence = "I cant believe it!";
        String correctedSentence = sentence.replaceFirst("\\bcant\\b", "can't");
        System.out.println(correctedSentence);
    }
}

Sortie :

I can't believe it!
9. Gestion des Données de Logs

Lors de la gestion des journaux, vous pouvez avoir besoin de masquer des informations sensibles comme les adresses IP.

public class MaskIpExample {
    public static void main(String[] args) {
        String logEntry = "User logged in from 192.168.1.1";
        String maskedLogEntry = logEntry.replaceFirst("\\b\\d{1,3}(\\.\\d{1,3}){3}\\b", "xxx.xxx.xxx.xxx");
        System.out.println(maskedLogEntry);
    }
}

Sortie :

User logged in from xxx.xxx.xxx.xxx
10. Adaptation de Chemins de Répertoires

Pour les scripts d’automatisation, adapter les chemins de répertoires selon l’environnement peut être nécessaire.

public class AdaptPathExample {
    public static void main(String[] args) {
        String filePath = "/home/user/docs/report.txt";
        String adaptedPath = filePath.replaceFirst("^/home/user", "/mnt/data");
        System.out.println(adaptedPath);
    }
}

Sortie :

/mnt/data/docs/report.txt
Synthèse

La méthode replaceFirst de la classe String en Java est extrêmement versatile et utile dans une variété de scénarios de programmation. Les exemples ci-dessus montrent comment cette méthode peut être appliquée dans des cas spécifiques pour obtenir des résultats précis et pertinents. En maîtrisant replaceFirst, vous pouvez améliorer la qualité et l’efficacité de votre code Java.

Exercices Corrigés sur replaceFirst en Java
Exercice 1 : Remplacer le Préfixe des Noms de Fichiers

Énoncé :

Vous avez une liste de noms de fichiers qui commencent tous par “temp_”. Écrivez un programme Java qui remplace le préfixe “temp_” par “file_” uniquement pour la première occurrence dans chaque nom de fichier de la liste.

Solution :

import java.util.Arrays;
import java.util.List;

public class ReplacePrefixExample {
    public static void main(String[] args) {
        List<String> fileNames = Arrays.asList("temp_document.txt", "temp_image.png", "temp_data.csv");
        for (String fileName : fileNames) {
            String modifiedFileName = fileName.replaceFirst("^temp_", "file_");
            System.out.println(modifiedFileName);
        }
    }
}

Sortie :

file_document.txt
file_image.png
file_data.csv

Explication :

La méthode replaceFirst est utilisée ici pour remplacer uniquement la première occurrence du préfixe “temp_” par “file_” dans chaque nom de fichier.


Exercice 2 : Conversion de Dates

Énoncé :

Écrivez un programme Java qui prend une date au format “YYYY-MM-DD” et la convertit au format “DD/MM/YYYY” en utilisant la méthode replaceFirst.

Solution :

public class DateConversionExample {
    public static void main(String[] args) {
        String date = "2024-07-08";
        String modifiedDate = date.replaceFirst("(\\d{4})-(\\d{2})-(\\d{2})", "$3/$2/$1");
        System.out.println(modifiedDate);
    }
}

Sortie :

08/07/2024

Explication :

L’expression régulière (\\d{4})-(\\d{2})-(\\d{2}) capture les parties de la date et les réorganise dans l’ordre désiré en utilisant les groupes capturés $1, $2, et $3.


Exercice 3 : Masquer des Informations Sensibles

Énoncé :

Écrivez un programme Java qui remplace le numéro de carte de crédit dans une chaîne de texte par “-****-XXXX”, où “XXXX” correspond aux quatre derniers chiffres de la carte.

Solution :

public class MaskCreditCardExample {
    public static void main(String[] args) {
        String text = "My credit card number is 1234-5678-9012-3456.";
        String maskedText = text.replaceFirst("\\b\\d{4}-\\d{4}-\\d{4}-(\\d{4})\\b", "****-****-****-$1");
        System.out.println(maskedText);
    }
}

Sortie :

My credit card number is ****-****-****-3456.

Explication :

L’expression régulière capture les quatre derniers chiffres du numéro de carte de crédit et les utilise dans la chaîne de remplacement, masquant les douze premiers chiffres.


Exercice 4 : Remplacer les Balises HTML

Énoncé :

Écrivez un programme Java qui remplace la première occurrence de la balise <div> par <section> dans une chaîne de texte contenant du HTML.

Solution :

public class ReplaceHtmlTagExample {
    public static void main(String[] args) {
        String html = "<div>Content</div><div>More Content</div>";
        String modifiedHtml = html.replaceFirst("<div>", "<section>");
        System.out.println(modifiedHtml);
    }
}

Sortie :

<section>Content</div><div>More Content</div>

Explication :

La méthode replaceFirst remplace uniquement la première occurrence de la balise <div> par <section>, laissant la seconde occurrence inchangée.


Exercice 5 : Standardiser les Numéros de Téléphone

Énoncé :

Écrivez un programme Java qui prend une chaîne de texte contenant des numéros de téléphone dans divers formats et standardise uniquement le premier numéro trouvé au format “XXX-XXX-XXXX”.

Solution :

public class StandardizePhoneNumberExample {
    public static void main(String[] args) {
        String phoneNumbers = "Contact us at (123) 456-7890 or 987-654-3210.";
        String standardized = phoneNumbers.replaceFirst("\\(?(\\d{3})\\)?[- ]?(\\d{3})[- ]?(\\d{4})", "$1-$2-$3");
        System.out.println(standardized);
    }
}

Sortie :

Contact us at 123-456-7890 or 987-654-3210.

Explication :

L’expression régulière capture différentes parties du numéro de téléphone et les réorganise dans le format standard “XXX-XXX-XXXX”, mais uniquement pour le premier numéro trouvé.


Exercice 6 : Remplacement d’Unités de Mesure

Énoncé :

Écrivez un programme Java qui remplace la première occurrence de “10 km” par “6.21 miles” dans une chaîne de texte.

Solution :

public class ReplaceUnitsExample {
    public static void main(String[] args) {
        String text = "The race is 10 km long. Another race is 5 km.";
        String modifiedText = text.replaceFirst("\\b10 km\\b", "6.21 miles");
        System.out.println(modifiedText);
    }
}

Sortie :

The race is 6.21 miles long. Another race is 5 km.

Explication :

L’expression régulière \\b10 km\\b correspond exactement à “10 km” en tant que mot entier, et le remplace par “6.21 miles”.


Exercice 7 : Normalisation des Textes

Énoncé :

Écrivez un programme Java qui remplace la première occurrence de “Mr.” par “Mister” dans une chaîne de texte.

Solution :

public class NormalizeTextExample {
    public static void main(String[] args) {
        String text = "Mr. John Doe met Mr. Smith.";
        String normalizedText = text.replaceFirst("\\bMr\\.", "Mister");
        System.out.println(normalizedText);
    }
}

Sortie :

Mister John Doe met Mr. Smith.

Explication :

La méthode replaceFirst remplace la première occurrence de “Mr.” par “Mister”, laissant les occurrences suivantes inchangées.


Exercice 8 : Réécriture d’URL

Énoncé :

Écrivez un programme Java qui remplace le paramètre id dans une URL par un chemin. Par exemple, convertir https://example.com/product?id=123 en https://example.com/product/123.

Solution :

public class RewriteUrlExample {
    public static void main(String[] args) {
        String url = "https://example.com/product?id=123";
        String rewrittenUrl = url.replaceFirst("\\?id=", "/");
        System.out.println(rewrittenUrl);
    }
}

Sortie :

https://example.com/product/123

Explication :

La méthode replaceFirst remplace le premier ?id= par /, réécrivant l’URL selon le format désiré.


Exercice 9 : Correction Automatique de Texte

Énoncé :

Écrivez un programme Java qui corrige automatiquement la première occurrence de “cant” en “can’t” dans une chaîne de texte.

Solution :

public class AutoCorrectExample {
    public static void main(String[] args) {
        String sentence = "I cant believe it!";
        String correctedSentence = sentence.replaceFirst("\\bcant\\b", "can't");
        System.out.println(correctedSentence);
    }
}

Sortie :

I can't believe it!

Explication :

L’expression régulière \\bcant\\b correspond exactement au mot “cant”, en le remplaçant par “can’t”.


Exercice 10 : Préparation de Chaînes JSON

Énoncé :

Écrivez un programme Java qui remplace la valeur du champ “password” dans une chaîne JSON par “[REDACTED]”.

Solution :

public class ReplaceJsonFieldExample {
    public static void main(String[] args) {
        String jsonString = "{\"username\":\"user1\",\"password\":\"pass123\"}";
        String modifiedJson = jsonString.replaceFirst("\"password\":\"[^\"]+\"", "\"password\":\"[REDACTED]\"");
        System.out.println(modifiedJson);
    }
}

Sortie :

“{
“username”:”user1″,”password”:”[REDACTED]”
}
“`

Explication :

L’expression régulière "password":"[^\"]+" correspond à la valeur du champ “password” dans la chaîne JSON et la remplace par “[REDACTED]”.


Ces exercices couvrent une variété d’applications de la méthode replaceFirst, allant de la manipulation de chaînes de caractères à la normalisation de données, en passant par la sécurisation des informations sensibles. En les prati

quant, vous renforcerez votre compréhension de l’utilisation des expressions régulières en Java et de la manière dont replaceFirst peut être appliquée efficacement dans divers scénarios.

Autres articles

Guide détaillé sur l'utilisation de Math.round en...
Dans le développement logiciel, la manipulation des nombres est une...
Read more
Comprendre et Utiliser toString() en Java :...
La méthode toString() en Java est une fonctionnalité fondamentale...
Read more
toString() en Java : Guide complet
Dans le monde de la programmation Java, la méthode toString()...
Read more

Laisser un commentaire

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *