Java判断ip是否为IPV4或IPV6地址的方式有哪些

今天小编给大家分享一下Java判断ip是否为IPV4或IPV6地址的方式有哪些的相关知识点，内容详细，逻辑清晰，相信大部分人都还太了解这方面的知识，所以分享这篇文章给大家参考一下，希望大家阅读完这篇文章后有所收获，下面我们一起来了解一下吧。

判断字符串是否为IP地址通常都是基于正则表达式实现的，无论是引入外部的依赖包亦或是自己写正则实现，基本都是基于正则表达式实现的判断。然而比较例外的是，jdk自身提供了

Inet4Address.getByName

一、判断是否为IPV4，IPV6地址的常见方式

1. 使用Apache Commons Validator做判断

需要引入依赖包

    <dependency>
      <groupId>commons-validator</groupId>
      <artifactId>commons-validator</artifactId>
      <version>1.6</version>
    </dependency>

有了依赖包，后续调用

InetAddressValidator

1.1判断是否为IPV4地址

    private static final InetAddressValidator VALIDATOR = InetAddressValidator.getInstance();
    public static boolean isValidIPV4ByValidator(String inetAddress) {
        return VALIDATOR.isValidInet4Address(inetAddress);
    }

1.2判断是否为IPV6地址

    public static boolean isValidIPV6ByValidator(String inetAddress) {
        return VALIDATOR.isValidInet6Address(inetAddress);
    }

1.3判断是否为IPV6或者IPV4地址

    public static boolean isValidIPV6ByValidator(String inetAddress) {
        return VALIDATOR.isValid(inetAddress);
    }

2. 使用Guava做判断

引入依赖包

    <dependency>
      <groupId>com.google.guava</groupId>
      <artifactId>guava</artifactId>
      <version>30.0-jre</version>
    </dependency>

调用

InetAddresses.isInetAddress

    public static boolean isValidByGuava(String ip) {
        return InetAddresses.isInetAddress(ip);
    }

3. 使用OWASP正则表达式做判断

OWASP提供了一系列用于校验常见web应用名词的正则表达式，通过OWASP_Validation_Regex_Repository你可以检索到他们。这个判断方式只能判断是否为IPV4地址。

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

    private static final Pattern OWASP_IPv4_PATTERN = Pattern.compile(OWASP_IPV4_REGEX);

    public static boolean isValidIPV4ByOWASP(String ip) {
        if (ip == null || ip.trim().isEmpty()) {
            return false;
        }
        return OWASP_IPv4_PATTERN.matcher(ip).matches();
    }

4. 使用自定义正则表达式做判断

如下通过自定义的正则表达式判断字符串是否为IPV4地址，它的正则表达式以及实现细节，其实和第一种方案中判断IPV4是一致的，如果你只想判断字符串是否为IPV4地址，又懒得引入外部包，那么3，4这两种方式适合你。

    private static final String IPV4_REGEX =
            "^(d{1,3}).(d{1,3}).(d{1,3}).(d{1,3})$";

    private static final Pattern IPv4_PATTERN = Pattern.compile(IPV4_REGEX);

    public static boolean isValidIPV4ByCustomRegex(String ip) {
        if (ip == null || ip.trim().isEmpty()) {
            return false;
        }
        if (!IPv4_PATTERN.matcher(ip).matches()) {
            return false;
        }
        String[] parts = ip.split(".");
        try {
            for (String segment : parts) {
                if (Integer.parseInt(segment) > 255 ||
                        (segment.length() > 1 && segment.startsWith("0"))) {
                    return false;
                }
            }
        } catch (NumberFormatException e) {
            return false;
        }
        return true;
    }

5. 使用JDK内置的Inet4Address做判断

JDK从1.4版本开始就提供了

Inet4Address

getByName

getHostAddress

    public static boolean isValidIPV4ByJDK(String ip) {
        try {
            return Inet4Address.getByName(ip)
                    .getHostAddress().equals(ip);
        } catch (UnknownHostException ex) {
            return false;
        }
    }

二、并不适合ping命令

1. IPV4的标准格式

本文列举的几种判断方式都是针对标准的IP地址而言，标准指的是IP地址由4位通过逗号分割的8bit长度的数字字符串组成，由于每位数字只有8bit长度，所以每个数字的值应该在0~255范围内。相关文档可以参考RFC5321。

2. 有效性验证

我们选举几组字符串，有缺少位数的，有数字以0开头的，也有一组是符合标准格式的。然后通过之前列举的方法判断是否为有效的IP地址。

测试过程就不再赘述，直接将测试用例和测试结果汇总成如下的表格：

通过这7个测试用例中，不难看出：

第1个IP刚好是4位，每位都在0~255之间，且没有任何一位以0开头。所有判断IPV4的方法都返回了true，符合预期。

第2，3个IP也都是4位地址，但是某一位出现以0开始的数字，此时采用OWASP正则表达式的方式返回了true，其他方法都返回了false。

第4，5，6个IP都是3位地址，所有方法返回了false。

最后一个是合法的ipv6地址，我们通过Apache Commons Validator或者Guava包提供的判断方法能够正常返回true。

3. 性能对比

本文在列举的第5个判断方法时特意提到了性能问题，那么使用

Inet4Address

下面将通过一项测试来验证这个结论。

    private static List<String> generateFakeIp(int capacity) {
        List<String> ipList = new ArrayList<String>(capacity);
        for (int i = 0; i < capacity; i++) {
            int parts = boundRandom(1, 3);
            if (chanceOf50()) { //each ip has 50% chance to be 4 parts
                parts = 4;
            }
            StringBuilder sbBuilder = new StringBuilder();
            for (int j = 0; j < parts; j++) {
                if (sbBuilder.length() > 0) {
                    sbBuilder.append(".");
                }
                StringBuilder stringBuilder = new StringBuilder();
                if (chanceOf10()) { //each part has 10% chance to generate a fake number
                    stringBuilder.append('a');
                } else { //each part has 90% chance to generate the correct number
                    stringBuilder.append(boundRandom(0, 255));
                }
                sbBuilder.append(stringBuilder);
            }
            ipList.add(sbBuilder.toString());
        }
        return ipList;
    }
    
    private static long correctCount(List<String> ipList) {
        return ipList.stream().filter(ip -> isValidIPV4ByCustomRegex(ip)).collect(Collectors.toList()).size();
    }
    
    // 50% chance
    private static boolean chanceOf50() {
        return boundRandom(0, 9) < 5;
    }

    // 10% chance
    private static boolean chanceOf10() {
        return boundRandom(0, 9) < 1;
    }

    private static Random random = new Random();
    // random int between [start, end], both start and end are included
    private static int boundRandom(int start, int end) {
        return start + random.nextInt(end);
    }

我们通过上面的

generateFakeIp

主体测试方法如下，该方法将比较

isValidIPV4ByCustomRegex

isValidIPV4ByJDK

    public static void performanceTest() {
        List<String> ipList = generateFakeIp(100);
        double chance = correctCount(ipList);
        System.out.println("start testing, correct ip count is : " + chance);
        long t1 = System.currentTimeMillis();
        ipList.stream().forEach( ip-> isValidIPV4ByCustomRegex(ip));
        long t2 = System.currentTimeMillis();
        ipList.stream().forEach( ip-> isValidIPV4ByJDK(ip));
        long t3 = System.currentTimeMillis();
        System.out.println("isValidIPV4ByCustomRegex cost time : " + (t2-t1));
        System.out.println("isValidIPV4ByJDK cost time : " + (t3-t2));
    }

直接运行后，打印以下结果。

start testing, correct ip count is : 37.0
isValidIPV4ByCustomRegex cost time : 2
isValidIPV4ByJDK cost time : 13745

可以看到，当100个IP中只有37个是合法IP时，基于正则表达式的判断方法只用了2ms，而基于JDK内置的

Inet4Address

Inet4Address

4. 判断IPV4的方法并不适合ping命令

对于标准IPV4格式的地址来说，以上判断方式是没问题的，但是部分非标准IPV4格式的地址，却能够被ping命令正常解析。

对于ping命令来说，我们这里列举的第2~6个IP地址都是合法的，能够被正常解析。

不妨验证一下：

可以看出，当我们输入的IP地址中，某一位数字位以0开头，那么也能被正常解析，从图片可以看出

192.168.0.072

192.168.0.58

172.08.9.28

172.08.9.28

当ping命令接收的IP地址中，出现以0开头的数字位，那么ping命令将尝试以八进制解析该位，八进制的072，即对应十进制的58，所以

192.168.0.072

192.168.0.58

如果以0开头的数字位，不符合八进制的格式，则依然以十进制对待该数字位，并忽略最高位的0，由于

172.08.9.28

08

172.8.9.28

此外，当输入的IP地址并不是以逗号分割的四位，ping命令依然能够正常解析。分别ping

196.168.072

192.168

196

196.168.0.072

196.0.0.168

0.0.0.192

可以看出，当IP不足四位时，ping命令会在合适的位置补0，其规律如下所示：

1 part  (ping A)       : 0.0.0.A
2 parts (ping A.B)     : A.0.0.B
3 parts (ping A.B.C)   : A.B.0.C
4 parts (ping A.B.C.D) : A.B.C.D