Validation d'une chaîne IPv4 en Java

Question

La méthode ci-dessous valide si la chaîne de caractères est une adresse IPv4 correcte et renvoie vrai si elle est valide. Toute amélioration en matière de regex et d'élégance serait très appréciée :

public static boolean validIP(String ip) {
    if (ip == null || ip.isEmpty()) return false;
    ip = ip.trim();
    if ((ip.length() < 6) & (ip.length() > 15)) return false;

    try {
        Pattern pattern = Pattern.compile("^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$");
        Matcher matcher = pattern.matcher(ip);
        return matcher.matches();
    } catch (PatternSyntaxException ex) {
        return false;
    }
}

Answer 1

Trouver un exemple de regex à partir de ce

package com.mkyong.regex;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class IPAddressValidator{

    private Pattern pattern;
    private Matcher matcher;

    private static final String IPADDRESS_PATTERN = 
        "^([01]?\\d\\d?|2[0-4]\\d|25[0-5])\\." +
        "([01]?\\d\\d?|2[0-4]\\d|25[0-5])\\." +
        "([01]?\\d\\d?|2[0-4]\\d|25[0-5])\\." +
        "([01]?\\d\\d?|2[0-4]\\d|25[0-5])$";

    public IPAddressValidator(){
      pattern = Pattern.compile(IPADDRESS_PATTERN);
    }

   /**
    * Validate ip address with regular expression
    * @param ip ip address for validation
    * @return true valid ip address, false invalid ip address
    */
    public boolean validate(final String ip){         
      matcher = pattern.matcher(ip);
      return matcher.matches();             
    }
}

Answer 2

Je pense que cette solution est assez élégante, même s'il faut une minute pour la comprendre.

L'idée de base est de prendre une sous-chaîne de caractères et de la valider.
Veuillez noter que je permute x et y, puisque le début d'une sous-chaîne sera toujours la fin de la dernière plus 1.

Cette solution est environ 20 fois plus rapide qu'une variante de l'expression rationnelle et 2 fois plus rapide que le fractionnement.

public static boolean validIP(String ip) {
    if(ip == null || ip.length() < 7 || ip.length() > 15) return false;

    try {
        int x = 0;
        int y = ip.indexOf('.');

        if (y == -1 || ip.charAt(x) == '-' || Integer.parseInt(ip.substring(x, y)) > 255) return false;

        x = ip.indexOf('.', ++y);
        if (x == -1 || ip.charAt(y) == '-' || Integer.parseInt(ip.substring(y, x)) > 255) return false;

        y = ip.indexOf('.', ++x);
        return  !(y == -1 ||
                ip.charAt(x) == '-' ||
                Integer.parseInt(ip.substring(x, y)) > 255 ||
                ip.charAt(++y) == '-' ||
                Integer.parseInt(ip.substring(y, ip.length())) > 255 ||
                ip.charAt(ip.length()-1) == '.');

    } catch (NumberFormatException e) {
        return false;
    }
}

Si vous savez que vous aurez beaucoup de mauvaises IPs, pensez à ajouter le code suivant sous le premier if. Cela rendra le code 1,5 fois plus lent, mais en cas d'erreur, il sera multiplié par 700.

    for (int i = 0; i < ip.length(); i++) {
        if (!Character.isDigit(ip.charAt(i)) && ip.charAt(i) != '.') return false;
    }

Answer 3

Si vous utilisez le code figurant dans la question, vous devrez modifier la ligne :

if ((ip.length() < 6) & (ip.length() > 15)) return false;

à

if ((ip.length() <= 6) || (ip.length() > 15)) return false;

Answer 4

Essayez d'utiliser le regrex suivant pour IPv4

String ip4Regex="^(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[0-9]{1,2})(\\.(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[0-9]{1,2})){3}$";

J'espère que cela vous aidera :)

Answer 5

La plupart des réponses (sauf celle de Michael Konietzka) sont fausses : 10.8, par exemple, est une adresse IP4 valide (un raccourci pour 10.0.0.8).

Voir Représentation textuelle des adresses IP dans les spécifications Java.

Comme on peut le voir dans la référence, pour vérifier une représentation numérique, il peut y avoir de 1 à 4 parties, et dans chaque cas, différentes limitations sur les parties s'appliquent.