Überprüfen Sie die IPv4-Adresse in Java
Ich möchte eine IPv4-Adresse mit Java überprüfen. Es sollte mit der Punkt-Dezimal-Schreibweise geschrieben werden, es sollte also 3 Punkte (".") haben, keine Zeichen, Zahlen zwischen den Punkten und Zahlen sollten in einem gültigen Bereich liegen. Wie soll es gemacht werden?
Ziemlich einfach mit regulären Ausdrücken (beachten Sie jedoch, dass dies weniger effizient ist und viel schwieriger zu lesen ist als die Antwort von worpet, die ein Apache Commons Utility verwendet).
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();
}
Basierend auf post Mkyong
Versuchen Sie es mit der InetAddressValidator-Dienstprogrammklasse.
Dokumente hier:
Hier herunterladen:
Verwenden Sie Guava s InetAddresses.forString ()
try {
InetAddresses.forString(ipStr);
} catch (IllegalArgumentException e) {
...
}
Sie können einen Regex wie folgt verwenden:
(([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]))
Hiermit wird bestätigt, dass die Werte innerhalb des Bereichs liegen.
Android unterstützt reguläre Ausdrücke. Siehe 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();
}
}
Um zu vermeiden, das Muster immer wieder neu zu kompilieren, sollten Sie den Aufruf Pattern.compile() so platzieren, dass er nur einmal ausgeführt wird.
Es gibt auch eine undokumentierte Dienstprogrammklasse Sun.net.util.IPAddressUtil, die Sie eigentlich nicht verwenden sollten , obwohl dies für ein einmaliges, einmaliges Wegwerfprogramm nützlich sein könnte:
boolean isIP = IPAddressUtil.isIPv4LiteralAddress(ipAddressString);
Intern ist dies die Dienstprogrammklasse, mit der InetAddress IP-Adressen analysiert.
Beachten Sie, dass dies für Zeichenfolgen wie "123" den Wert true zurückgibt, die technisch gesehen gültige IPv4-Adressen sind, jedoch nicht in Punkt-Dezimal-Notation.
Sie können diese Funktion verwenden -
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);
}
Dies ist für Android und testet für IPv4 und IPv6
Hinweis: Die häufig verwendete InetAddressUtils ist veraltet. Verwenden Sie neue InetAddress-Klassen
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;
}
}
Die IPAddress Java-Bibliothek wird es tun. Der Javadoc ist unter dem Link verfügbar. Haftungsausschluss: Ich bin der Projektmanager.
Diese Bibliothek unterstützt transparent IPv4 und IPv6. Die Überprüfung funktioniert also wie folgt und auch CIDR-Subnetze.
Überprüfen Sie, ob eine Adresse gültig ist
String str = "1.2.3.4";
IPAddressString addrString = new IPAddressString(str);
try {
IPAddress addr = addrString.toAddress();
...
} catch(AddressStringException e) {
//e.getMessage provides validation issue
}
Wenn es sich um IP4 handelt, können Sie einen regulären Ausdruck wie folgt verwenden:
^(2[0-5][0-5])|(1\\d\\d)|([1-9]?\\d)\\.){3}(2[0-5][0-5])|(1\\d\\d)|([1-9]?\\d)$.
Es gibt so viele Möglichkeiten, dies zu erreichen, aber regulärer Ausdruck ist effizienter.
Schauen Sie sich den Code an:
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));
}
Schreiben Sie einen geeigneten regulären Ausdruck und validieren Sie ihn danach. Die JVM bietet volle Unterstützung für reguläre Ausdrücke.
Regulärer Ausdruck ist der effizienteste Weg, um dieses Problem zu lösen ... Schauen Sie sich den folgenden Code an. Neben der Gültigkeit prüft es auch die IP-Adressklasse, zu der es gehört, und ob es sich um eine reservierte IP-Adresse handelt oder nicht
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));
}
Wenn Sie sich nicht für den Bereich interessieren, ist der folgende Ausdruck für die Validierung von 1.1.1.1 bis 999.999.999.999 hilfreich
"[1-9]{1,3}\\.[1-9]{1,3}\\.[1-9]{1,3}\\.[1-9]{1,3}"
Bitte schauen Sie rein IPAddressUtil OOTB Klasse vorhanden in Sun.net.util , das sollte dir helfen.
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();
}
Ermitteln Sie die gültige IP-Adresse in zwei Zeilen mithilfe des regulären Ausdrucks. Überprüfen Sie in der Kommentarsitzung des Codes, wie der reguläre Ausdruck funktioniert, um den Nummernbereich zu ermitteln.
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;;
}