Java判断IP在属于ip段 java判断字符串是否是ip地址

判断字符串是否为IP地址通常都是基于正则表达式实现的，无论是引入外部的依赖包亦或是自己写正则实现，基本都是基于正则表达式实现的判断。然而比较例外的是，jdk自身提供了Inet4Address.getByName方法也可以帮助我们实现ip地址的判断。本文将详细列举常见的判断字符串是否为IPV4，IPV6地址的方式，并分析其存在的局限性。

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

1. 使用Apache Commons Validator做判断

需要引入依赖包

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

有了依赖包，后续调用InetAddressValidator的核心API就好了。

1.1判断是否为IPV4地址

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

1.2判断是否为IPV6地址

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

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

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

2. 使用Guava做判断

引入依赖包

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

调用InetAddresses.isInetAddress即可实现快速的判断，但这个方式能同时判断字符串是否为IPV4或者IPV6地址，如果你只想判断其中一种格式，那就不行了。

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

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

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

1     private static final String OWASP_IPV4_REGEX =
 2             "^(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]?)\\." +
 4                     "(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\." +
 5                     "(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$";
 6 
 7     private static final Pattern OWASP_IPv4_PATTERN = Pattern.compile(OWASP_IPV4_REGEX);
 8 
 9     public static boolean isValidIPV4ByOWASP(String ip) {
10         if (ip == null || ip.trim().isEmpty()) {
11             return false;
12         }
13         return OWASP_IPv4_PATTERN.matcher(ip).matches();
14     }

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

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

1     private static final String IPV4_REGEX =
 2             "^(\\d{1,3})\\.(\\d{1,3})\\.(\\d{1,3})\\.(\\d{1,3})$";
 3 
 4     private static final Pattern IPv4_PATTERN = Pattern.compile(IPV4_REGEX);
 5 
 6     public static boolean isValidIPV4ByCustomRegex(String ip) {
 7         if (ip == null || ip.trim().isEmpty()) {
 8             return false;
 9         }
10         if (!IPv4_PATTERN.matcher(ip).matches()) {
11             return false;
12         }
13         String[] parts = ip.split("\\.");
14         try {
15             for (String segment : parts) {
16                 if (Integer.parseInt(segment) > 255 ||
17                         (segment.length() > 1 && segment.startsWith("0"))) {
18                     return false;
19                 }
20             }
21         } catch (NumberFormatException e) {
22             return false;
23         }
24         return true;
25     }

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

JDK从1.4版本开始就提供了Inet4Address类实现对IP的各项校验操作，结合该类的getByName和getHostAddress方法可实现IP地址判断，但是频繁的调用这两个方法会产生一定的性能问题。以下是通过JDK判断字符串是否为IPV4地址的方式

1     public static boolean isValidIPV4ByJDK(String ip) {
2         try {
3             return Inet4Address.getByName(ip)
4                     .getHostAddress().equals(ip);
5         } catch (UnknownHostException ex) {
6             return false;
7         }
8     }

二、并不适合ping命令

1. IPV4的标准格式

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

2. 有效性验证

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

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

用例	isValidIPV4ByValidator	isValidIPV6ByValidator	isValidByGuava	isValidIPV4ByOWASP	isValidIPV4ByCustomRegex	isValidIPV4ByJDK
172.8.9.28	true	false	true	true	true	true
192.168.0.072	false	false	false	true	false	false
172.08.9.28	false	false	false	true	false	false
172.9.28	false	false	false	false	false	false
192.168.072	false	false	false	false	false	false
192.168.1	false	false	false	false	false	false
2001:0db8:85a3:0000:0000:8a2e:0370:7334	false	true	true	false	false	false

通过这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判断IP地址到底会导致多大的性能损耗呢？实验证明，当判断使用大规模非法IP地址做输入，该方法的性能损耗将不敢想象！

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

1     private static List<String> generateFakeIp(int capacity) {
 2         List<String> ipList = new ArrayList<String>(capacity);
 3         for (int i = 0; i < capacity; i++) {
 4             int parts = boundRandom(1, 3);
 5             if (chanceOf50()) { //each ip has 50% chance to be 4 parts
 6                 parts = 4;
 7             }
 8             StringBuilder sbBuilder = new StringBuilder();
 9             for (int j = 0; j < parts; j++) {
10                 if (sbBuilder.length() > 0) {
11                     sbBuilder.append(".");
12                 }
13                 StringBuilder stringBuilder = new StringBuilder();
14                 if (chanceOf10()) { //each part has 10% chance to generate a fake number
15                     stringBuilder.append('a');
16                 } else { //each part has 90% chance to generate the correct number
17                     stringBuilder.append(boundRandom(0, 255));
18                 }
19                 sbBuilder.append(stringBuilder);
20             }
21             ipList.add(sbBuilder.toString());
22         }
23         return ipList;
24     }
25     
26     private static long correctCount(List<String> ipList) {
27         return ipList.stream().filter(ip -> isValidIPV4ByCustomRegex(ip)).collect(Collectors.toList()).size();
28     }
29     
30     // 50% chance
31     private static boolean chanceOf50() {
32         return boundRandom(0, 9) < 5;
33     }
34 
35     // 10% chance
36     private static boolean chanceOf10() {
37         return boundRandom(0, 9) < 1;
38     }
39 
40     private static Random random = new Random();
41     // random int between [start, end], both start and end are included
42     private static int boundRandom(int start, int end) {
43         return start + random.nextInt(end);
44     }

我们通过上面的generateFakeIp方法来产生一批随机的IP地址，这些IP中有正确格式的，也有非法格式的。

主体测试方法如下，该方法将比较isValidIPV4ByCustomRegex和isValidIPV4ByJDK这两种判断IP地址的总耗时，以分析性能问题。

1     public static void performanceTest() {
 2         List<String> ipList = generateFakeIp(100);
 3         double chance = correctCount(ipList);
 4         System.out.println("start testing, correct ip count is : " + chance);
 5         long t1 = System.currentTimeMillis();
 6         ipList.stream().forEach( ip-> isValidIPV4ByCustomRegex(ip));
 7         long t2 = System.currentTimeMillis();
 8         ipList.stream().forEach( ip-> isValidIPV4ByJDK(ip));
 9         long t3 = System.currentTimeMillis();
10         System.out.println("isValidIPV4ByCustomRegex cost time : " + (t2-t1));
11         System.out.println("isValidIPV4ByJDK cost time : " + (t3-t2));
12     }

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

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

可以看到，当100个IP中只有37个是合法IP时，基于正则表达式的判断方法只用了2ms，而基于JDK内置的Inet4Address实现的判断方法却用了13s，这已经不在在同一个数量级了。如果我们将测试基数再扩大，那更加不敢想象，所以实际工作中，千万不要使用Inet4Address来做IP合法性判断。

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并不是一个合法的八进制数，所以依然按十进制对待并忽略最高位的0，即实际解析成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

三、小结

这几种判断字符串是否为IPV4或者IPV6地址的方式，其内在实现原理都大同小异，除了最后一个方案外都是用正则表达式来实现的。

但是基于正则表达式实现的方法并不能很友好地处理非十进制数字位的情况，而ping命令能够接收的字符串远比这个复杂的多，如果你想通过Java来实现判断ping命令后面的地址是否是合法的IP，那应该是难于上青天，除非你去弄懂ping命令的底层源码。

当然在现实业务场景中，我们判断字符串是否为合法IP地址一般都是基于其标准格式来操作的，也不用担心文中的方法不靠谱，除了第3和最后一个方案外，大胆用吧！