备案控制台
开发者社区 开发与运维 文章 正文

IP地址计算工具类（Java）

2022-06-16 981
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： IP地址计算工具类（Java） 
importjava.math.BigDecimal;
importjava.util.ArrayList;
importjava.util.List;
importjava.util.regex.Pattern;
publicclassIpUtil {
/*** 在main方法里面可以测试下* 主要功能都在main方法里，需要什么自己找*/publicstaticvoidmain(String[] args) {
Stringip="172.31.0.4";//ipStringmask="24";//位数，如果只知道子网掩码不知道位数的话在参考getMaskMap()方法Stringsubmark=getMaskMap(mask);
System.out.println("子网掩码为："+submark);
//获得起始IP和终止IP的方法（包含网络地址和广播地址）StringstartIp=getBeginIpStr(ip, mask);
StringendIp=getEndIpStr(ip, mask);
System.out.println("起始IP："+startIp+"终止IP："+endIp);
//根据位数查询IP数量intipCount=getIpCount("24");
System.out.println("ip个数："+ipCount);
//获得起始IP和终止IP的方法（不包含网络地址和广播地址）StringsubStart=startIp.split("\\.")[0]+"."+startIp.split("\\.")[1]+"."+startIp.split("\\.")[2]+".";
StringsubEnd=endIp.split("\\.")[0]+"."+endIp.split("\\.")[1]+"."+endIp.split("\\.")[2]+".";
startIp=subStart+(Integer.parseInt(startIp.split("\\.")[3])+1);
endIp=subEnd+(Integer.parseInt(endIp.split("\\.")[3])-1);
System.out.println("起始IP："+startIp+"终止IP："+endIp);
//判断一个IP是否属于某个网段booleanflag=isInRange("10.2.0.0", "10.3.0.0/17");
System.out.println(flag);
//判断是否是一个IPSystem.out.println(isIP("192.168.1.0"));
//把ip转换为数字(mysql中inet_aton()的实现)System.out.println(ipToDouble("192.168.1.1"));
//打印IP段所有IP（IP过多会内存溢出）//      List<String> list = parseIpMaskRange(ip, mask);//      for (String s : list){//          System.out.println(s);//      }    }
/*** 功能：判断一个IP是不是在一个网段下的* 格式：isInRange("192.168.8.3", "192.168.9.10/22");*/publicstaticbooleanisInRange(Stringip, Stringcidr) {
String[] ips=ip.split("\\.");
intipAddr= (Integer.parseInt(ips[0]) <<24)
| (Integer.parseInt(ips[1]) <<16)
| (Integer.parseInt(ips[2]) <<8) |Integer.parseInt(ips[3]);
inttype=Integer.parseInt(cidr.replaceAll(".*/", ""));
intmask=0xFFFFFFFF<< (32-type);
StringcidrIp=cidr.replaceAll("/.*", "");
String[] cidrIps=cidrIp.split("\\.");
intcidrIpAddr= (Integer.parseInt(cidrIps[0]) <<24)
| (Integer.parseInt(cidrIps[1]) <<16)
| (Integer.parseInt(cidrIps[2]) <<8)
|Integer.parseInt(cidrIps[3]);
return (ipAddr&mask) == (cidrIpAddr&mask);
    }
/*** 功能：根据IP和位数返回该IP网段的所有IP* 格式：parseIpMaskRange("192.192.192.1.", "23")*/publicstaticList<String>parseIpMaskRange(Stringip,Stringmask){
List<String>list=newArrayList<>();
if ("32".equals(mask)) {
list.add(ip);
        }else{
StringstartIp=getBeginIpStr(ip, mask);
StringendIp=getEndIpStr(ip, mask);
if (!"31".equals(mask)) {
StringsubStart=startIp.split("\\.")[0]+"."+startIp.split("\\.")[1]+"."+startIp.split("\\.")[2]+".";
StringsubEnd=endIp.split("\\.")[0]+"."+endIp.split("\\.")[1]+"."+endIp.split("\\.")[2]+".";
startIp=subStart+(Integer.parseInt(startIp.split("\\.")[3])+1);
endIp=subEnd+(Integer.parseInt(endIp.split("\\.")[3])-1);
            }
list=parseIpRange(startIp, endIp);
        }
returnlist;
    }
/*** 功能：根据位数返回IP总数* 格式：parseIpMaskRange("192.192.192.1", "23")*/publicstaticintgetIpCount(Stringmask) {
returnBigDecimal.valueOf(Math.pow(2, 32-Integer.parseInt(mask))).setScale(0, BigDecimal.ROUND_DOWN).intValue();//IP总数，去小数点    }
/*** 功能：根据位数返回IP总数* 格式：isIP("192.192.192.1")*/publicstaticbooleanisIP(Stringstr) {
Stringregex="\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}";
Patternpattern=Pattern.compile(regex);
returnpattern.matcher(str).matches();
    }
publicstaticList<String>parseIpRange(Stringipfrom, Stringipto) {
List<String>ips=newArrayList<String>();
String[] ipfromd=ipfrom.split("\\.");
String[] iptod=ipto.split("\\.");
int[] int_ipf=newint[4];
int[] int_ipt=newint[4];
for (inti=0; i<4; i++) {
int_ipf[i] =Integer.parseInt(ipfromd[i]);
int_ipt[i] =Integer.parseInt(iptod[i]);
        }
for (intA=int_ipf[0]; A<=int_ipt[0]; A++) {
for (intB= (A==int_ipf[0] ?int_ipf[1] : 0); B<= (A==int_ipt[0] ?int_ipt[1]
                    : 255); B++) {
for (intC= (B==int_ipf[1] ?int_ipf[2] : 0); C<= (B==int_ipt[1] ?int_ipt[2]
                        : 255); C++) {
for (intD= (C==int_ipf[2] ?int_ipf[3] : 0); D<= (C==int_ipt[2] ?int_ipt[3]
                            : 255); D++) {
ips.add(A+"."+B+"."+C+"."+D);
                    }
                }
            }
        }
returnips;
    }
/*** 把long类型的Ip转为一般Ip类型：xx.xx.xx.xx** @param ip* @return*/publicstaticStringgetIpFromLong(Longip)
    {
Strings1=String.valueOf((ip&4278190080L) /16777216L);
Strings2=String.valueOf((ip&16711680L) /65536L);
Strings3=String.valueOf((ip&65280L) /256L);
Strings4=String.valueOf(ip&255L);
returns1+"."+s2+"."+s3+"."+s4;
    }
/*** 把xx.xx.xx.xx类型的转为long类型的** @param ip* @return*/publicstaticLonggetIpFromString(Stringip)
    {
LongipLong=0L;
StringipTemp=ip;
ipLong=ipLong*256+Long.parseLong(ipTemp.substring(0, ipTemp.indexOf('.')));
ipTemp=ipTemp.substring(ipTemp.indexOf('.') +1, ipTemp.length());
ipLong=ipLong*256+Long.parseLong(ipTemp.substring(0, ipTemp.indexOf('.')));
ipTemp=ipTemp.substring(ipTemp.indexOf(".") +1, ipTemp.length());
ipLong=ipLong*256+Long.parseLong(ipTemp.substring(0, ipTemp.indexOf('.')));
ipTemp=ipTemp.substring(ipTemp.indexOf('.') +1, ipTemp.length());
ipLong=ipLong*256+Long.parseLong(ipTemp);
returnipLong;
    }
/*** 根据掩码位获取掩码** @param maskBit*            掩码位数，如"28"、"30"* @return*/publicstaticStringgetMaskByMaskBit(StringmaskBit)
    {
return"".equals(maskBit) ?"error, maskBit is null !" : getMaskMap(maskBit);
    }
/*** 根据 ip/掩码位 计算IP段的起始IP 如 IP串 218.240.38.69/30** @param ip*            给定的IP，如218.240.38.69* @param maskBit*            给定的掩码位，如30* @return 起始IP的字符串表示*/publicstaticStringgetBeginIpStr(Stringip, StringmaskBit)
    {
returngetIpFromLong(getBeginIpLong(ip, maskBit));
    }
/*** 根据 ip/掩码位 计算IP段的起始IP 如 IP串 218.240.38.69/30** @param ip*            给定的IP，如218.240.38.69* @param maskBit*            给定的掩码位，如30* @return 起始IP的长整型表示*/publicstaticLonggetBeginIpLong(Stringip, StringmaskBit)
    {
returngetIpFromString(ip) &getIpFromString(getMaskByMaskBit(maskBit));
    }
/*** 根据 ip/掩码位 计算IP段的终止IP 如 IP串 218.240.38.69/30** @param ip*            给定的IP，如218.240.38.69* @param maskBit*            给定的掩码位，如30* @return 终止IP的字符串表示*/publicstaticStringgetEndIpStr(Stringip, StringmaskBit)
    {
returngetIpFromLong(getEndIpLong(ip, maskBit));
    }
/*** 根据 ip/掩码位 计算IP段的终止IP 如 IP串 218.240.38.69/30** @param ip*            给定的IP，如218.240.38.69* @param maskBit*            给定的掩码位，如30* @return 终止IP的长整型表示*/publicstaticLonggetEndIpLong(Stringip, StringmaskBit)
    {
returngetBeginIpLong(ip, maskBit)
+~getIpFromString(getMaskByMaskBit(maskBit));
    }
/*** 根据子网掩码转换为掩码位 如 255.255.255.252转换为掩码位 为 30** @param netmarks* @return*/publicstaticintgetNetMask(Stringnetmarks)
    {
StringBuildersbf;
Stringstr;
intinetmask=0;
intcount=0;
String[] ipList=netmarks.split("\\.");
for (intn=0; n<ipList.length; n++)
        {
sbf=toBin(Integer.parseInt(ipList[n]));
str=sbf.reverse().toString();
count=0;
for (inti=0; i<str.length(); i++)
            {
i=str.indexOf('1', i);
if (i==-1)
                {
break;
                }
count++;
            }
inetmask+=count;
        }
returninetmask;
    }
/*** 计算子网大小** @param maskBit*            掩码位* @return*/publicstaticintgetPoolMax(intmaskBit)
    {
if (maskBit<=0||maskBit>=32)
        {
return0;
        }
return (int) Math.pow(2, 32-maskBit) -2;
    }
privatestaticStringBuildertoBin(intx)
    {
StringBuilderresult=newStringBuilder();
result.append(x%2);
x/=2;
while (x>0)
        {
result.append(x%2);
x/=2;
        }
returnresult;
    }
publicstaticStringgetMaskMap(StringmaskBit) {
if ("1".equals(maskBit)) {
return"128.0.0.0";
        }
if ("2".equals(maskBit)) {
return"192.0.0.0";
        }
if ("3".equals(maskBit)) {
return"224.0.0.0";
        }
if ("4".equals(maskBit)) {
return"240.0.0.0";
        }
if ("5".equals(maskBit)) {
return"248.0.0.0";
        }
if ("6".equals(maskBit)) {
return"252.0.0.0";
        }
if ("7".equals(maskBit)) {
return"254.0.0.0";
        }
if ("8".equals(maskBit)) {return"255.0.0.0";}
if ("9".equals(maskBit)) {return"255.128.0.0";}
if ("10".equals(maskBit)) {return"255.192.0.0";}
if ("11".equals(maskBit)) {return"255.224.0.0";}
if ("12".equals(maskBit)) {return"255.240.0.0";}
if ("13".equals(maskBit)) {return"255.248.0.0";}
if ("14".equals(maskBit)) {return"255.252.0.0";}
if ("15".equals(maskBit)) {return"255.254.0.0";}
if ("16".equals(maskBit)) {return"255.255.0.0";}
if ("17".equals(maskBit)) {return"255.255.128.0";}
if ("18".equals(maskBit)) {return"255.255.192.0";}
if ("19".equals(maskBit)) {return"255.255.224.0";}
if ("20".equals(maskBit)) {return"255.255.240.0";}
if ("21".equals(maskBit)) {return"255.255.248.0";}
if ("22".equals(maskBit)) {return"255.255.252.0";}
if ("23".equals(maskBit)) {return"255.255.254.0";}
if ("24".equals(maskBit)) {return"255.255.255.0";}
if ("25".equals(maskBit)) {return"255.255.255.128";}
if ("26".equals(maskBit)) {return"255.255.255.192";}
if ("27".equals(maskBit)) {return"255.255.255.224";}
if ("28".equals(maskBit)) {return"255.255.255.240";}
if ("29".equals(maskBit)) {return"255.255.255.248";}
if ("30".equals(maskBit)) {return"255.255.255.252";}
if ("31".equals(maskBit)) {return"255.255.255.254";}
if ("32".equals(maskBit)) {return"255.255.255.255";}
return"-1";
    }
publicstaticdoubleipToDouble(Stringip) {
String[] arr=ip.split("\\.");
doubled1=Double.parseDouble(arr[0]);
doubled2=Double.parseDouble(arr[1]);
doubled3=Double.parseDouble(arr[2]);
doubled4=Double.parseDouble(arr[3]);
returnd1*Math.pow(256, 3) +d2*Math.pow(256, 2) +d3*256+d4;
    }
}
文章标签：
Java
关键词：
Java工具类
Java计算
Java ip
Java地址
工具类Java
kunfire
目录
相关文章
Byyyi
|
4天前
|
存储 算法 安全
Java工具类
Java工具类
Byyyi
27 5
Java工具类
渐暖
|
15天前
|
存储 Java 定位技术
【Java】根据IP地址获取省市
【Java】根据IP地址获取省市
渐暖
38 1
阿文没烦恼
|
21天前
|
存储 Java
Java动态转发代理IP的实现方法
Java动态转发代理IP的实现方法
阿文没烦恼
32 11
Hsu琛君珩
|
21天前
|
监控 安全 Java
【JavaEE多线程】深入解析Java并发工具类与应用实践
【JavaEE多线程】深入解析Java并发工具类与应用实践
Hsu琛君珩
33 1
桃李春风一杯酒
|
21天前
|
安全 Java
深入理解 Java 多线程和并发工具类
【4月更文挑战第19天】本文探讨了Java多线程和并发工具类在实现高性能应用程序中的关键作用。通过继承`Thread`或实现`Runnable`创建线程，利用`Executors`管理线程池，以及使用`Semaphore`、`CountDownLatch`和`CyclicBarrier`进行线程同步。保证线程安全、实现线程协作和性能调优（如设置线程池大小、避免不必要同步）是重要环节。理解并恰当运用这些工具能提升程序效率和可靠性。
桃李春风一杯酒
18 0
阿文没烦恼
|
22天前
|
安全 Java API
java借助代理ip，解决访问api频繁导致ip被禁的问题
java借助代理ip，解决访问api频繁导致ip被禁的问题
阿文没烦恼
27 2
一百减一是零
|
22天前
|
Java
java日期工具类（DateUtil）
java日期工具类（DateUtil）
一百减一是零
15 0
阿文没烦恼
|
22天前
|
Java Python
设置代理ip——java
设置代理ip——java
阿文没烦恼
12 0
桃李春风一杯酒
|
23天前
|
网络协议 Java API
深度剖析：Java网络编程中的TCP/IP与HTTP协议实践
【4月更文挑战第17天】Java网络编程重在TCP/IP和HTTP协议的应用。TCP提供可靠数据传输，通过Socket和ServerSocket实现；HTTP用于Web服务，常借助HttpURLConnection或Apache HttpClient。两者结合，构成网络服务基础。Java有多种高级API和框架（如Netty、Spring Boot）简化开发，助力高效、高并发的网络通信。
桃李春风一杯酒
8 0
程序三两行
|
1月前
|
存储 缓存 Java
java多线程之线程通信工具类
java多线程之线程通信工具类
程序三两行
19 0

热门文章

最新文章

  • 1
    Java中的多线程编程：概念、实现与性能优化
  • 2
    使用Redis进行Java缓存策略设计
  • 3
    Java语言开发的AI智慧导诊系统源码springboot+redis 3D互联网智导诊系统源码
  • 4
    基于 java + Springboot + vue +mysql 大学生实习管理系统（含源码）
  • 5
    Java 中文官方教程 2022 版（二十九）（2）
  • 6
    使用Java代码打印log日志
  • 7
    Java 中文官方教程 2022 版（二十八）（1）
  • 8
    Java 中文官方教程 2022 版（十四）（1）
  • 9
    Java 中文官方教程 2022 版（九）（2）
  • 10
    深入理解Java并发编程：线程安全与性能优化
  • 1
    [Java基础]——类的生命周期
    14
  • 2
    [java进阶]——泛型类、泛型方法、泛型接口、泛型的通配符
    28
  • 3
    【java进阶】Java中线程的实现方式
    22
  • 4
    【java进阶】集合的三种遍历(迭代器、增强for、Lambda)
    19
  • 5
    [java进阶]——方法引用改写Lambda表达式
    35
  • 6
    深入理解 Java 多线程、Lambda 表达式及线程安全最佳实践
    124
  • 7
    java base64转doc文件
    36
  • 8
    [JavaWeb]——过滤器filter与拦截器Interceptor的使用、执行过程、区别
    46
  • 9
    Java中的异常语法知识居然这么好玩！后悔没有早点学习
    37
  • 10
    Java必刷入门递归题×5（内附详细递归解析图）
    26

    • 相关课程

    更多
  • Java面试疑难点解析 - 面试技巧及语言基础
  • Java面试疑难点解析 - Java Web开发
  • Java编程入门
  • Java面向对象编程
  • Java高级编程

    • 相关电子书

    更多
  • Spring Cloud Alibaba - 重新定义 Java Cloud-Native
  • The Reactive Cloud Native Arch
  • JAVA开发手册1.5.0

    • 相关实验场景

    更多
  • 基于ECS搭建Java Web开发环境
  • 使用Aliyun Java Intializr进行项目开发
  • 搭建Java Web开发环境
  • 部署基于Dragonwell的Java运行环境
  • 阿里云平台上进行Java程序的编译与运行
    • 下一篇
    部署LAMP环境（Alibaba Cloud Linux 3）