Valider l'adresse IPv4 en Java
Je veux valider une adresse IPv4 en utilisant Java. Il doit être écrit avec la notation point-décimale , il doit donc comporter 3 points ("."), aucun caractère, aucun nombre entre les points et les nombres ne doivent être dans une plage valide. Comment devrait-il être fait?
Assez simple avec une expression régulière (mais notez que c'est beaucoup moins efficace et beaucoup plus difficile à lire que la réponse de worpet qui utilise un utilitaire Apache Commons)
private static final Pattern PATTERN = Pattern.compile(
"^(([01]?\\d\\d?|2[0-4]\\d|25[0-5])\\.){3}([01]?\\d\\d?|2[0-4]\\d|25[0-5])$");
public static boolean validate(final String ip) {
return PATTERN.matcher(ip).matches();
}
Basé sur post Mkyong
Essayez la classe d’utilitaire InetAddressValidator.
Docs ici:
Télécharger ici:
Utilisez Goyave 's InetAddresses.forString ()
try {
InetAddresses.forString(ipStr);
} catch (IllegalArgumentException e) {
...
}
Vous pouvez utiliser une regex, comme ceci:
(([0-1]?[0-9]{1,2}\.)|(2[0-4][0-9]\.)|(25[0-5]\.)){3}(([0-1]?[0-9]{1,2})|(2[0-4][0-9])|(25[0-5]))
Celui-ci valide les valeurs sont dans la plage.
Android prend en charge les expressions régulières. Voir Java.util.regex.Pattern .
class ValidateIPV4
{
static private final String IPV4_REGEX = "(([0-1]?[0-9]{1,2}\\.)|(2[0-4][0-9]\\.)|(25[0-5]\\.)){3}(([0-1]?[0-9]{1,2})|(2[0-4][0-9])|(25[0-5]))";
static private Pattern IPV4_PATTERN = Pattern.compile(IPV4_REGEX);
public static boolean isValidIPV4(final String s)
{
return IPV4_PATTERN.matcher(s).matches();
}
}
Pour éviter de recompiler le modèle encore et encore, il est préférable de placer l'appel Pattern.compile() afin qu'il ne soit exécuté qu'une seule fois.
Il existe également une classe d'utilitaires non documentée Sun.net.util.IPAddressUtil, que vous ne devriez pas utiliser réellement }, bien qu'elle puisse être utile dans un utilitaire rapide, jetable:
boolean isIP = IPAddressUtil.isIPv4LiteralAddress(ipAddressString);
En interne, il s’agit de la classe d’utilitaire que InetAddress utilise pour analyser les adresses IP.
Notez que cela retournera true pour des chaînes telles que "123", qui, techniquement, sont adresses IPv4 valides }, mais pas en notation décimale à point.
Vous pouvez utiliser cette fonction -
public static boolean validate(final String ip) {
String PATTERN = "^((0|1\\d?\\d?|2[0-4]?\\d?|25[0-5]?|[3-9]\\d?)\\.){3}(0|1\\d?\\d?|2[0-4]?\\d?|25[0-5]?|[3-9]\\d?)$";
return ip.matches(PATTERN);
}
Ceci est pour Android, test pour IPv4 et IPv6
Remarque: la variable InetAddressUtils couramment utilisée est obsolète. Utiliser les nouvelles classes InetAddress
public static Boolean isIPv4Address(String address) {
if (address.isEmpty()) {
return false;
}
try {
Object res = InetAddress.getByName(address);
return res instanceof Inet4Address || res instanceof Inet6Address
} catch (final UnknownHostException ex) {
return false;
}
}
La bibliothèque Java IPAddress le fera. Le javadoc est disponible sur le lien. Disclaimer: Je suis le chef de projet.
Cette bibliothèque prend en charge IPv4 et IPv6 de manière transparente. Par conséquent, la validation fonctionne de la même manière que ci-dessous et prend également en charge les sous-réseaux CIDR.
Vérifier si une adresse est valide
String str = "1.2.3.4";
IPAddressString addrString = new IPAddressString(str);
try {
IPAddress addr = addrString.toAddress();
...
} catch(AddressStringException e) {
//e.getMessage provides validation issue
}
S'il s'agit d'IP4, vous pouvez utiliser une expression régulière comme suit:
^(2[0-5][0-5])|(1\\d\\d)|([1-9]?\\d)\\.){3}(2[0-5][0-5])|(1\\d\\d)|([1-9]?\\d)$.
Il y a tellement de façons d'y parvenir, mais l'expression régulière est plus efficace.
Regardez le code ci-dessous:
public static void main(String[] args) {
String ipStr1 = "255.245.188.123"; // valid IP address
String ipStr2 = "255.245.188.273"; // invalid IP address - 273 is greater than 255
validateIP(ipStr1);
validateIP(ipStr2);
}
public static void validateIP(String ipStr) {
String regex = "\\b((25[0–5]|2[0–4]\\d|[01]?\\d\\d?)(\\.)){3}(25[0–5]|2[0–4]\\d|[01]?\\d\\d?)\\b";
System.out.println(ipStr + " is valid? " + Pattern.matches(regex, ipStr));
}
Ecrivez une expression rationnelle appropriée et validez-la. La machine virtuelle Java prend totalement en charge les expressions régulières.
L’expression régulière est le moyen le plus efficace de résoudre ce problème ..__ Regardez le code ci-dessous. En plus de sa validité, il vérifie également la classe d’adresses IP à laquelle il appartient et s’il est réservé ou non Adresse IP
Pattern ipPattern;
int[] arr=new int[4];
int i=0;
//Method to check validity
private String validateIpAddress(String ipAddress) {
Matcher ipMatcher=ipPattern.matcher(ipAddress);
//Condition to check input IP format
if(ipMatcher.matches()) {
//Split input IP Address on basis of .
String[] octate=ipAddress.split("[.]");
for(String x:octate) {
//Convert String number into integer
arr[i]=Integer.parseInt(x);
i++;
}
//Check whether input is Class A IP Address or not
if(arr[0]<=127) {
if(arr[0]==0||arr[0]==127)
return(" is Reserved IP Address of Class A");
else if(arr[1]==0&&arr[2]==0&&arr[3]==0)
return(" is Class A Network address");
else if(arr[1]==255&&arr[2]==255&&arr[3]==255)
return( " is Class A Broadcast address");
else
return(" is valid IP Address of Class A");
}
//Check whether input is Class B IP Address or not
else if(arr[0]>=128&&arr[0]<=191) {
if(arr[2]==0&&arr[3]==0)
return(" is Class B Network address");
else if(arr[2]==255&&arr[3]==255)
return(" is Class B Broadcast address");
else
return(" is valid IP Address of Class B");
}
//Check whether input is Class C IP Address or not
else if(arr[0]>=192&&arr[0]<=223) {
if(arr[3]==0)
return(" is Class C Network address");
else if(arr[3]==255)
return(" is Class C Broadcast address");
else
return( " is valid IP Address of Class C");
}
//Check whether input is Class D IP Address or not
else if(arr[0]>=224&&arr[0]<=239) {
return(" is Class D IP Address Reserved for multicasting");
}
//Execute if input is Class E IP Address
else {
return(" is Class E IP Address Reserved for Research and Development by DOD");
}
}
//Input not matched with IP Address pattern
else
return(" is Invalid IP Address");
}
public static void main(String[] args) {
Scanner scan= new Scanner(System.in);
System.out.println("Enter IP Address: ");
//Input IP Address from user
String ipAddress=scan.nextLine();
scan.close();
IPAddress obj=new IPAddress();
//Regex for IP Address
obj.ipPattern=Pattern.compile("((([0-1]?\\d\\d?|2[0-4]\\d|25[0-5])\\.){3}([0-1]?\\d\\d?|2[0-4]\\d|25[0-5]))");
//Display output
System.out.println(ipAddress+ obj.validateIpAddress(ipAddress));
}
Si vous ne vous souciez pas de la plage, l'expression suivante sera utile pour valider du 1.1.1.1 au 999.999.999.999
"[1-9]{1,3}\\.[1-9]{1,3}\\.[1-9]{1,3}\\.[1-9]{1,3}"
S'il vous plaît jeter un oeil dans IPAddressUtil OOTB classe présente dans Sun.net.util , cela devrait vous aider.
public static boolean isIpv4(String ipAddress) {
if (ipAddress == null) {
return false;
}
String ip = "^(1\\d{2}|2[0-4]\\d|25[0-5]|[1-9]\\d|[1-9])\\."
+ "(1\\d{2}|2[0-4]\\d|25[0-5]|[1-9]\\d|\\d)\\."
+ "(1\\d{2}|2[0-4]\\d|25[0-5]|[1-9]\\d|\\d)\\."
+ "(1\\d{2}|2[0-4]\\d|25[0-5]|[1-9]\\d|\\d)$";
Pattern pattern = Pattern.compile(ip);
Matcher matcher = pattern.matcher(ipAddress);
return matcher.matches();
}
Obtenez l'adresse IP valide sur deux lignes en utilisant une expression régulière Veuillez vérifier la session de commentaires du code sur le fonctionnement de l'expression régulière pour obtenir la plage de numéros.
public class regexTest {
public static void main(String[] args) {
String IP = "255.001.001.255";
System.out.println(IP.matches(new MyRegex().pattern));
}
}
/*
* /d - stands for any number between 0 to 9
* /d{1,2} - preceding number that 0 to 9 here , can be of 1 digit to 2 digit . so minimum 0 and maximum 99
* | this stands for or operator
*
* () this is applied on a group to get the single value of outcome
* (0|1)\d{2} = first digit is either 0 or 1 and other two digits can be any number between ( 0 to 9)
* 2[0-4]\d - first digit is 2 , second digit can be between 0 to 4 and last digit can be 0 to 9
* 25[0-5] - first two digit will be 25 and last digit will be between 0 to 5
*
* */
class MyRegex {
String zeroTo255 = "(\\d{1,2}|(0|1)\\d{2}|2[0-4]\\d|25[0-5])";
public String pattern = zeroTo255 + "\\." + zeroTo255 + "\\." + zeroTo255 + "\\." + zeroTo255;;
}