💡 Ce tutoriel est traduit par l'IA à partir de la version anglaise. Pour voir la version originale, vous pouvez cliquer ici
Dans le monde de la programmation Java, les expressions régulières (regex) offrent des outils puissants pour le filtrage de caractères et la manipulation de texte. Ce tutoriel explore des techniques complètes pour filtrer et traiter les caractères en utilisant les capacités des expressions régulières de Java, aidant les développeurs à améliorer leurs compétences en manipulation de chaînes de caractères et à créer des solutions de traitement de texte plus robustes.
Les expressions régulières (regex) en Java sont des outils puissants pour la correspondance de motifs et la manipulation de texte. Elles offrent un moyen concis et flexible de rechercher, valider et modifier des chaînes de caractères en fonction de motifs spécifiques.
Les motifs d'expressions régulières sont des séquences de caractères qui définissent un motif de recherche. Ils peuvent inclure :
| Méthode | Description | Exemple |
|---|---|---|
| matches() | Vérifie si toute la chaîne correspond au motif | "123".matches("\\d+") |
| find() | Recherche un motif dans la chaîne | Pattern.compile("\\w+").matcher(text).find() |
| replaceAll() | Remplace toutes les correspondances par le texte spécifié | text.replaceAll("\\s", "_") |
. Correspond à n'importe quel caractère unique* Correspond à zéro ou plusieurs occurrences+ Correspond à une ou plusieurs occurrences? Correspond à zéro ou une occurrence^ Correspond au début de la chaîne$ Correspond à la fin de la chaîneLes expressions régulières sont essentielles pour :
Chez LabEx, nous recommandons de maîtriser les expressions régulières comme compétence fondamentale pour les développeurs Java.
String text = "Hello, Java Regex!";
boolean isMatch = text.matches(".*Regex.*");
System.out.println(isMatch); // trueCet exemple montre une technique de base de correspondance de motifs d'expressions régulières en Java.
Le filtrage de caractères est une technique cruciale dans le traitement de texte qui permet aux développeurs de supprimer, remplacer ou extraire sélectivement des caractères spécifiques des chaînes de caractères à l'aide d'expressions régulières.
| Méthode | Objectif | Exemple |
|---|---|---|
| replaceAll() | Supprimer des caractères spécifiques | text.replaceAll("[^a-zA-Z]", "") |
| replaceFirst() | Remplacer la première occurrence | text.replaceFirst("\\d", "X") |
| matches() | Valider l'ensemble de caractères | text.matches("[A-Za-z]+") |
public class CharacterFilter {
public static String filterAlphanumeric(String input) {
return input.replaceAll("[^a-zA-Z0-9]", "");
}
public static void main(String[] args) {
String text = "Hello, World! 123";
String filtered = filterAlphanumeric(text);
System.out.println(filtered); // Output: HelloWorld123
}
}public class CharacterExtractor {
public static String extractDigits(String input) {
return input.replaceAll("[^0-9]", "");
}
public static void main(String[] args) {
String text = "LabEx2023 Course";
String digits = extractDigits(text);
System.out.println(digits); // Output: 2023
}
}\d Correspond aux chiffres\w Correspond aux caractères de mot\s Correspond aux espaces blancs\p{Punct} Correspond aux caractères de ponctuationChez LabEx, nous soulignons l'importance de maîtriser les techniques de filtrage de caractères pour une manipulation efficace des chaînes de caractères en Java.
public class EmailValidator {
private static final String EMAIL_REGEX =
"^[A-Za-z0-9+_.-]+@[A-Za-z0-9.-]+$";
public static boolean isValidEmail(String email) {
return email.matches(EMAIL_REGEX);
}
public static void main(String[] args) {
System.out.println(isValidEmail("[email protected]")); // true
System.out.println(isValidEmail("invalid-email")); // false
}
}public class PasswordValidator {
private static final String PASSWORD_REGEX =
"^(?=.*[0-9])(?=.*[a-z])(?=.*[A-Z])(?=.*[@#$%^&+=])(?=\\S+$).{8,20}$";
public static boolean isStrongPassword(String password) {
return password.matches(PASSWORD_REGEX);
}
public static void main(String[] args) {
System.out.println(isStrongPassword("LabEx2023!")); // true
System.out.println(isStrongPassword("weak")); // false
}
}| Motif | Description | Exemple |
|---|---|---|
\d{3}-\d{2}-\d{4} |
Numéro de sécurité sociale | 123-45-6789 |
^\+?1?\d{10,14}$ |
Numéro de téléphone | +1234567890 |
\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b |
Validation d'e-mail | [email protected] |
public class DataExtractor {
public static void extractInfo(String text) {
// Extract dates
Pattern datePattern = Pattern.compile("\\d{4}-\\d{2}-\\d{2}");
Matcher dateMatcher = datePattern.matcher(text);
while (dateMatcher.find()) {
System.out.println("Found date: " + dateMatcher.group());
}
}
public static void main(String[] args) {
String sampleText = "LabEx course started on 2023-07-15";
extractInfo(sampleText);
}
}public class TextTokenizer {
public static void tokenizeText(String text) {
// Split by multiple delimiters
String[] tokens = text.split("[,;\\s]+");
for (String token : tokens) {
System.out.println("Token: + + token);
}
}
public static void main(String[] args) {
String input = "Java, Regex; Parsing, Techniques";
tokenizeText(input);
}
}En maîtrisant les techniques de filtrage de caractères des expressions régulières Java, les développeurs peuvent valider, extraire et transformer efficacement et précisément les données textuelles. Ces méthodes offrent des approches flexibles et concises pour gérer les tâches complexes de traitement de chaînes de caractères, permettant d'écrire un code plus élégant et performant dans diverses applications Java.
