it-swarm.com.de

Ü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?

55
iRunner

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

83
Necronet

Versuchen Sie es mit der InetAddressValidator-Dienstprogrammklasse.

Dokumente hier:

http://commons.Apache.org/validator/apidocs/org/Apache/commons/validator/routines/InetAddressValidator.html

Hier herunterladen:

http://commons.Apache.org/validator/

50
worpet

Verwenden Sie Guava s InetAddresses.forString ()

try {
  InetAddresses.forString(ipStr);
} catch (IllegalArgumentException e) {
  ...
}
19
wileyquixote

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. 

9
mdma

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.

7
Jason C

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);
}
6
Akarshit Wal

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;
    }
}
3
Pian0_M4n

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
    }
2
Sean F

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)$.

2
khachik

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));
}
1
Mulalo Madida

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));

}
1
Deepali Agg

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}"
1
darkconeja

Bitte schauen Sie rein IPAddressUtil OOTB Klasse vorhanden in Sun.net.util , das sollte dir helfen. 

0
Girish
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();
}
0
veeson

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;;

    }
0
Arpan Saini