En programmation Java, déterminer le type d'informations saisies par le client peut être une tâche courante, en particulier lors de la création d'applications nécessitant une approbation ou un traitement d'informations. Les expressions régulières ou expressions régulières sont un outil efficace pour identifier les conceptions de chaînes et calculer les catégories d'informations. Cet article examine une méthode unique d'utilisation d'expressions standard en Java pour rechercher le type d'informations saisies par le client.
La structure du langage des expressions régulières en Java est basée sur le package java.util.regex. Il fournit des classes telles que Design et Matcher pour gérer la conception d'expressions régulières et effectuer des opérations de coordination.
Pour utiliser des expressions régulières en Java, nous devons d'abord créer un modèle d'expression régulière à l'aide de la classe Design. Ce modèle représente le modèle souhaité auquel nous devons faire correspondre. Nous utiliserons divers caractères et opérateurs prédéfinis dans les expressions régulières pour définir des modèles.
Une fois le design déterminé, nous créons un problème Matcher en appelant la stratégie matcher() sur le design. Les matchers nous permettent d'appliquer des conceptions à des chaînes d'entrée spécifiques et d'effectuer des opérations coordonnées.
Créez des modèles d'expressions régulières pour chaque type de données (par exemple, entiers, flottants, chaînes, etc.).
Utilisez la classe Pattern pour compiler des modèles d'expressions régulières.
Crée un objet Matcher en utilisant le modèle compilé et la chaîne d'entrée utilisateur.
Utilisez la méthode matches() de la classe Matcher pour vérifier si la chaîne d'entrée correspond au modèle d'un type de données spécifique.
Répétez ce processus jusqu'à ce qu'un modèle de type de données correspondant soit trouvé.
import java.util.regex.*;
public class DataTypeFinder {
public static void main(String[] args) {
String userInput = "42.5"; // Example user input
// Define regex patterns for data types
String integerPattern = "\d+";
String floatPattern = "\d+\.\d+";
String stringPattern = "[a-zA-Z]+";
// Compile the patterns
Pattern integerRegex = Pattern.compile(integerPattern);
Pattern floatRegex = Pattern.compile(floatPattern);
Pattern stringRegex = Pattern.compile(stringPattern);
// Create Matcher objects for each pattern
Matcher integerMatcher = integerRegex.matcher(userInput);
Matcher floatMatcher = floatRegex.matcher(userInput);
Matcher stringMatcher = stringRegex.matcher(userInput);
// Check for matches
if (integerMatcher.matches()) {
System.out.println("Input is an integer.");
} else if (floatMatcher.matches()) {
System.out.println("Input is a float.");
} else if (stringMatcher.matches()) {
System.out.println("Input is a string.");
} else {
System.out.println("Unable to determine the data type.");
}
}
}
Input is a float.
Dans cette approche, nous créons des modèles d'expressions régulières distincts pour chaque type de données que nous souhaitons reconnaître : entiers, flottants et chaînes. Ces modèles sont compilés à l'aide de la classe Pattern.
Nous comparons ensuite les objets Matcher pour chaque modèle, en transmettant la chaîne de saisie du client à chaque matcher. Nous utilisons la méthode matches() pour vérifier si la chaîne d’entrée correspond au modèle d’un type de données spécifique.
Si une coordonnée est trouvée, nous imprimons le tri des informations de comparaison. Sinon, si les coordonnées ne sont pas trouvées, nous imprimons un message d'erreur indiquant que le type de données ne peut pas être déterminé.
Utilisez l'opérateur OR (|) pour combiner des modèles de tous les types de données en un seul modèle d'expression régulière.
Utilisez le mode de compilation de classe Pattern.
Crée un objet Matcher en utilisant le modèle compilé et la chaîne d'entrée utilisateur.
Utilisez la méthode matches() de la classe Matcher pour vérifier si la chaîne d'entrée correspond à un modèle de type de données.
import java.util.regex.*;
public class DataTypeFinder {
public static void main(String[] args) {
String userInput = "42.5"; // Example user input
// Define regex pattern for all data types
String dataTypePattern = "\d+|\d+\.\d+|[a-zA-Z]+";
// Compile the pattern
Pattern regex = Pattern.compile(dataTypePattern);
// Create a Matcher object
Matcher matcher = regex.matcher(userInput);
// Check for matches
if (matcher.matches()) {
System.out.println("Input is of a recognized data type.");
} else {
System.out.println("Unable to determine the data type.");
}
}
}
Input is of a recognized data type.
Dans cette méthode, nous utilisons l'opérateur OR (|) pour créer un seul modèle d'expression régulière qui combine des modèles de tous les types de données. De cette façon, nous pouvons faire correspondre n'importe quel modèle avec la chaîne saisie par l'utilisateur.
Nous utilisons la classe Design pour compiler la conception et créer un objet Matcher en utilisant la conception compilée et la chaîne d'entrée du client. Nous utilisons ensuite la méthode matches() de l'objet Matcher pour vérifier si la chaîne d'entrée correspond à un modèle de type de données.
Si les coordonnées sont trouvées, nous imprimons un message indiquant que l'entrée est d'un type d'information reconnu. De plus, si les coordonnées ne sont pas trouvées, nous imprimons un message d'erreur indiquant que le type de données ne peut pas être déterminé.
Créez un modèle d'expression régulière pour vérifier les modèles spécifiques associés à chaque type de données.
Utilisez le mode de compilation de classe Pattern.
Utilisez la méthode find() de la classe Matcher pour déterminer si un modèle de type de données existe dans la chaîne d'entrée utilisateur.
import java.util.regex.*;
public class DataTypeFinder {
public static void main(String[] args) {
String userInput = "42.5"; // Example user input
// Define regex pattern for each data type
String integerPattern = "\d+";
String floatPattern = "\d+\.\d+";
String stringPattern = "[a-zA-Z]+";
// Compile the patterns
Pattern integerRegex = Pattern.compile(integerPattern);
Pattern floatRegex = Pattern.compile(floatPattern);
Pattern stringRegex = Pattern.compile(stringPattern);
// Create Matcher objects for each pattern
Matcher integerMatcher = integerRegex.matcher(userInput);
Matcher floatMatcher = floatRegex.matcher(userInput);
Matcher stringMatcher = stringRegex.matcher(userInput);
// Check for matches
if (integerMatcher.find()) {
System.out.println("Input contains an integer.");
}
if (floatMatcher.find()) {
System.out.println("Input contains a float.");
}
if (stringMatcher.find()) {
System.out.println("Input contains a string.");
}
if (!integerMatcher.find() && !floatMatcher.find() && !stringMatcher.find()) {
System.out.println("Unable to determine the data type.");
}
}
}
Input contains an integer. Input contains a float.
Dans cette approche, nous créons des modèles d'expressions régulières distincts pour chaque type de données et les compilons à l'aide de la classe Pattern.
Nous comparons ensuite les objets Matcher pour chaque modèle, en transmettant la chaîne de saisie du client à chaque matcher. Au lieu d'utiliser la méthode matches(), nous utilisons la méthode find() de la classe Matcher pour rechercher la présence de tout modèle de type de données dans la chaîne d'entrée.
Si les coordonnées sont trouvées, nous imprimons un message indiquant que l'entrée contient une catégorie d'informations de comparaison. Si aucune coordonnée n'est trouvée pour une conception de classement des données, nous imprimons un message d'erreur indiquant que le classement des données ne peut pas être déterminé.
Créez un modèle d'expression régulière pour vérifier les modèles spécifiques associés à chaque type de données.
Utilisez le mode de compilation de classe Pattern.
Utilisez la méthode find() de la classe Matcher pour déterminer si chaque modèle de type de données est présent dans la chaîne de saisie utilisateur.
Stockez le type de données trouvé dans une variable pour un traitement ultérieur.
import java.util.regex.*;
public class DataTypeFinder {
public static void main(String[] args) {
String userInput = "42.5"; // Example user input
// Define regex pattern for each data type
String integerPattern = "\d+";
String floatPattern = "\d+\.\d+";
String stringPattern = "[a-zA-Z]+";
// Compile the patterns
Pattern integerRegex = Pattern.compile(integerPattern);
Pattern floatRegex = Pattern.compile(floatPattern);
Pattern stringRegex = Pattern.compile(stringPattern);
// Create Matcher objects for each pattern
Matcher integerMatcher = integerRegex.matcher(userInput);
Matcher floatMatcher = floatRegex.matcher(userInput);
Matcher stringMatcher = stringRegex.matcher(userInput);
// Check for matches and store the found data type
String dataType = "";
if (integerMatcher.find()) {
dataType = "integer";
}
if (floatMatcher.find()) {
dataType = "float";
}
if (stringMatcher.find()) {
dataType = "string";
}
// Process the found data type
if (!dataType.isEmpty()) {
System.out.println("Input is of data type: " + dataType);
} else {
System.out.println("Unable to determine the data type.");
}
}
}
Input is of data type: float
在这种方法中，我们为每种数据类型创建单独的正则表达式模式，并使用 Pattern 类对其进行编译。
我们然后对每个模式进行Matcher对象的比较，将客户输入的字符串传递给每个matcher。再次使用Matcher类的find()方法来查找输入字符串中每个数据类型模式的存在。
在找到匹配项的情况下，我们将相应的数据类型存储在一个名为dataType的变量中。在处理完所有的模式后，我们检查dataType变量是否为空。如果不为空，我们打印一条消息显示找到的数据类型。如果dataType变量为空，我们打印一条错误消息，显示无法确定数据类型。
决定客户端输入的信息类型是许多 Java 应用程序的一个重要方面。正则表达式提供了一种强大的方法来识别字符串中的模式并有效地确定数据类型。在本文中，我们探索了使用 Java 中的正则表达式查找用户输入的数据类型的不同方法。
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!
Quels sont les types de données ?
Vérifier l'occupation du port sous Linux
Comment utiliser la fonction de ligne
Comment ouvrir un fichier rar
Comment résoudre le problème que localhost ne peut pas être ouvert
Quels sont les quatre principaux modèles d'E/S en Java ?
La différence entre obtenir et publier
Que signifie une startup héritée ?
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
