在 Java 中验证 IPv4 字符串

Question

Bellow 方法正在验证字符串是否是正确的 IPv4 地址，如果有效则返回 true。正则表达式和优雅方面的任何改进将不胜感激：

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

这是一种更容易阅读、效率稍低的方法。

public static boolean validIP (String ip) {
    try {
        if ( ip == null || ip.isEmpty() ) {
            return false;
        }

        String[] parts = ip.split( "\\." );
        if ( parts.length != 4 ) {
            return false;
        }

        for ( String s : parts ) {
            int i = Integer.parseInt( s );
            if ( (i < 0) || (i > 255) ) {
                return false;
            }
        }
        if ( ip.endsWith(".") ) {
            return false;
        }

        return true;
    } catch (NumberFormatException nfe) {
        return false;
    }
}

Answer 2

更新： Commons-HttpClient 及其后继者 HttpComponents-HttpClient 已采用此功能。您可以像这样使用它的这个版本：InetAddressUtils.isIPv4Address(Str)。

---

Apache Commons Validator 的开发版本有一个 InetAddressValidator 类，它有一个 isValidInet4Address(String) 方法执行检查以查看给定的 String 是否是有效的 IPv4 地址。

源代码可以从存储库中查看，因此如果您认为有任何改进，这可能会提供一些改进的想法。

快速浏览一下所提供的代码就会发现，您的方法正在每次调用该方法时编译一个Pattern。我会将 Pattern 类移出到 static 字段，以避免每次调用时昂贵的模式编译过程。

Answer 3

如果您想使用已发布版本同时支持 IPv4 和 IPv6 的库，可以使用 番石榴

boolean isValid = InetAddresses.isInetAddress("1.2.3.4");

Answer 4

如果您不介意对 www.example.com 等无效 IP 地址使用 dns 解析，则可以使用 InetAddress 要检查的方法：

public static final boolean checkIPv4(final String ip) {
    boolean isIPv4;
    try {
    final InetAddress inet = InetAddress.getByName(ip);
    isIPv4 = inet.getHostAddress().equals(ip)
            && inet instanceof Inet4Address;
    } catch (final UnknownHostException e) {
    isIPv4 = false;
    }
    return isIPv4;
}

该方法检查它是否是 Inet4Address 的实例，如果该参数是 IP 地址而不是主机名。
如果您期望使用大量主机名作为参数，请注意此实现使用 DNS 来尝试解析它。这可能是一个性能问题。

否则你可能会达到高峰
boolean sun.net.util.IPAddressUtil.isIPv4LiteralAddress(String src) 如何解析字符串以进行 IPv4 检查。

Answer 5

下面是一个使用 Java 8 流来检查地址是否由 0 到 255（含）之间的 4 个数字组成的解决方案，并用点分隔：

public class IpValidation {

    /**
     * Check that a string represents a decimal number
     * @param string The string to check
     * @return true if string consists of only numbers without leading zeroes, false otherwise
     */
    public static boolean isDecimal(String string) {
        // Check whether string has a leading zero but is not "0"
        if (string.startsWith("0")) {
            return string.length() == 1;
        }
        for(char c : string.toCharArray()) {
            if(c < '0' || c > '9') {
                return false;
            }
        }
        return true;
    }

    public static boolean isIp(String string) {
        String[] parts = string.split("\\.", -1);
        return parts.length == 4 // 4 parts
                && Arrays.stream(parts)
                .filter(IpValidation::isDecimal) // Only decimal numbers
                .map(Integer::parseInt)
                .filter(i -> i <= 255 && i >= 0) // Must be inside [0, 255]
                .count() == 4; // 4 numerical parts inside [0, 255]
    }
}

Answer 6

从 this 中查找正则表达式示例

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 7

认为这个解决方案非常优雅，尽管需要花一点时间才能理解它。

基本思想是获取一个子字符串并验证它。
请注意，我交换了 x 和 y，因为子字符串的开头始终是最后一个加 1 的结尾。

这个解决方案是比正则表达式变体快大约 20 倍，比分割快 2 倍。

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

如果您知道会有很多错误的 IP，请考虑在第一个 if 下面添加以下代码。这将使代码速度慢 1.5 倍，但如果出现错误，速度会提高 700 倍

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

Answer 8

尝试使用以下 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}$";

希望它有帮助:)

Answer 9

如果您使用问题中的代码，您需要将该行更改

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

为：

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

Answer 10

大多数答案（除了 Michael Konietzka 的答案）都是错误的：例如，10.8 是一个有效的 IP4 地址（10.0.0.8 的简写）。

请参阅IP 地址的文本表示 Java 规范。

如在参考文献中可以看到的，为了检查数字表示，可能有 1 到 4 个部分，并且在每种情况下对这些部分应用不同的限制。

Answer 11

我认为正确的方法是构建一个 IPAddress 类并通过为其提供 IP 地址的字符串表示形式来实例化它。

通过这种方式，您可以将不同的验证步骤拆分为实例方法，并进行一些关注点分离。

例如，这里通常是它自己的方法，简单地调用它isEmpty：

return (ip == null || ip.isEmpty());

此外，这应该是一个单独的方法，您可以调用它hasProbableLength。

ip = ip.trim();
return ((ip.length() < 6) & (ip.length() > 15));

这里发生了很多事情。我会尝试打破这个问题，也许尝试完全跳过正则表达式。

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

我首先将字符串按点分开，然后看到正好得到四个组。调用此方法 divideIntoGroups

然后，我将验证每个组的值是否在 0 到 255 之间。调用此方法 validateGroups

现在您已经有了这个方法，如果您想扩展这个类来查找 IP 是否是本地主机或者是否是广播地址，这很容易做到。这就是关注点分离为您提供的功能。

您还可以准确判断哪一项验证规则在 IP 地址字符串验证中被破坏。正则表达式不会的东西。

Answer 12

IPAddress Java 库 会做到这一点。 javadoc 可在链接中找到。免责声明：我是项目经理。

该库透明地支持 IPv4 和 IPv6，因此验证两者的工作方式如下，并且它还支持 CIDR 前缀长度 IPC4 地址。它支持更不寻常的格式，例如 inet_aton （例如，在另一个答案中提到了 10.8）

验证地址是否有效：

    String str = "1.2.3.4";
    IPAddressString addrString = new IPAddressString(str);
    try {
         IPAddress addr = addrString.toAddress();
         ...
    } catch(AddressStringException e) {
        //e.getMessage provides validation issue
    }

Answer 13

我发现检查给定 ip 在 ipv4 中是否正确的最简单方法是使用 commons-validator-1.4.0.jar 有类：--

org.apache.commons.validator.routines.InetAddressValidator

InetAddressValidator

例如

InetAddressValidator inetValidator = InetAddressValidator.getInstance();
inetValidator.isValidInet4Address(yourIPAddress);

使用这个简单的正则表达式：--

  "^(\\d{1,3})\\.(\\d{1,3})\\.(\\d{1,3})\\.(\\d{1,3})$";

Answer 14

这将对你有用，

boolean isIPv4Address(String inputString) {
    String[] splitString = inputString.split("[.]");
    if (splitString.length > 4) {
        return false;
    }
    for (String string : splitString) {
        if (string.isEmpty()) {
            return false;
        }
        if (!string.matches("[0-9]{1,3}")) {
            return false;
        }
        int number = Integer.parseInt(string);
        if (!(number >= 0 && number <= 255)) {
            return false;
        }
    }
    return true;
}

Answer 15

我建议使用您正在开发的平台/框架上可用的内容。

如果您认为没有什么足够好，那么您可能只想将已编译的正则表达式添加到辅助类中。例如， Android 框架的实现方式如下：

public static final Pattern IP_ADDRESS
    = Pattern.compile(
        "((25[0-5]|2[0-4][0-9]|[0-1][0-9]{2}|[1-9][0-9]|[1-9])\\.(25[0-5]|2[0-4]"
        + "[0-9]|[0-1][0-9]{2}|[1-9][0-9]|[1-9]|0)\\.(25[0-5]|2[0-4][0-9]|[0-1]"
        + "[0-9]{2}|[1-9][0-9]|[1-9]|0)\\.(25[0-5]|2[0-4][0-9]|[0-1][0-9]{2}"
        + "|[1-9][0-9]|[0-9]))");

Answer 16

boolean isValid = inetAddressValidator.isValid(hostName) || hostName.equalsIgnoreCase("localhost");

与 coobird 相同的答案。只需将 localhost 添加到语句中即可。大多数环境都将“localhost”作为有效的主机名。它不是 ipv4 格式，但应包含它以考虑有效性。

Answer 17

public static boolean ipv4Check(String ipAddress){

    try{
        if(ipAddress!=null && !ipAddress.isEmpty()){
            String [] ip = ipAddress.split("\\.");
            if(ip.length!=4)
                return false;

            for(int i=0;i<=ip.length-1;i++){
                int j=Integer.parseInt(ip[i]);
                if(j<0 || j>255){
                    return false;
                }
            }
            if ( ipAddress.endsWith(".") ) {
                return false;
            }
            if ( ipAddress.startsWith(".") ) {
                return false;
            }

        }
        return true;
    } catch (NumberFormatException ex) {
        return false;
    }       
}