输入IP段和想要拆分的IP段数自定义拆分成几个小IP段

最新推荐文章于 2023-08-10 10:32:05 发布
最新推荐文章于 2023-08-10 10:32:05 发布
阅读量1.1k 收藏 3
点赞数 1
分类专栏： JAVA 计算机网络 文章标签： tcp/ip java 网络协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41527073/article/details/121213039
版权 
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.regex.Pattern;

public class ipDivide1 {
	
	public static void main(String[] args) {
		System.err.println(subnetDivide("121.79.128.0/18",10));
		
	}
	
	/***
	 * 判断一个数是否是2的次幂
	 * @param n
	 * @return
	 */
	public static boolean isPowerOfTwo(int n) {
        String str = Integer.toBinaryString(n);
        if(n < 1) {
			return false;
		} else if(str.lastIndexOf("1") == 0) {
			return true;
		} else {
			return false;
		}
  }
	
	
//	public static String toBinary(String str){ //把字符串转成字符数组 
//		char[] strChar=str.toCharArray(); 
//		String result=""; 
//		for(int i=0;i<strChar.length;i++){ 
//			//toBinaryString(int i)返回变量的二进制表示的字符串 
//			//toHexString(int i) 八进制 
//			//toOctalString(int i) 十六进制 
//			result +=Integer.toBinaryString(strChar[i])+ " ";
//		} 
//		return result; 
//	}
	/***
	 * 大于等于2的次幂的最小值
	 * @param v 任意数
	 * @return
	 */
	public static int roundup_power_of_2(int v)
	{
		v--;
		v |= v >> 1;
		v |= v >> 2;
		v |= v >> 4;
		v |= v >> 8;
		v |= v >> 16;
		v++;
		return v;
	}
	
	/***
	 * 2的次幂
	 * @param n 次幂
	 * @return
	 */
	private static int calculate2Num(int n) {
        if (n == 0) {
			return 1;
		}
        return 2 * calculate2Num(n - 1);
    }
	/***
	 * 具体划分步骤
	 * @return
	 */
	public static List<String> divideByPow(String ips,int pow){
//		Map<String,String> map=new HashMap<>();
		List<String> ipList = new ArrayList<String>();
		try {
			if(ips ==null || "".equals(ips.trim()) || "null".equals(ips.trim())){
				return ipList;
			}
			ips = ips.trim();
			if(ips.indexOf("/")>0) {
				String temp[] = ips.split("/");
				if(temp.length == 2 && isIP(temp[0])){
					String ip=temp[0];
					String subnet=temp[1];
					String ipBitStr = makeBinaryString( getIpFromString(ip).intValue());
					int leg = ipBitStr.length();
					int bitNum  = Integer.parseInt(subnet);
					String str0 = "00000000000000000000000000000000";
					String str1 = "11111111111111111111111111111111";
					if(bitNum <= 32){
						String startIPBit = ipBitStr.substring(0, leg-(32-bitNum))+str0.substring(0, 32-bitNum);
						String endIPBit   = ipBitStr.substring(0, leg-(32-bitNum))+str1.substring(0, 32-bitNum);
						Long  startIPLong = getIpFromString(getIpStringFrom10bit(startIPBit));
						Long  endIPLong   =  getIpFromString(getIpStringFrom10bit(endIPBit));
						Integer midNum=Integer.valueOf(1+str0.substring(0, 32-(bitNum+pow)), 2);
						int subnetT=bitNum+pow;
						for (int i = 0; i < calculate2Num(pow); i++) {
//							map.put(getIpFromLong(startIPLong)+"/"+subnetT,getIpFromLong(startIPLong)+"/"+subnetT);
							ipList.add(getIpFromLong(startIPLong)+"/"+subnetT);
							startIPLong+=midNum;
						}
					}
					
//					System.err.println(ipList+"--------------");
				}
			}
			return ipList;
		} catch (Exception e) {
			return ipList;
		}
	}
	/***
	 * 小于等于2的次幂的最大值
	 * @param subNum 划分数目
	 * @return pow 2的几次幂
	 */
	public static int judge(int subNum) {
		int pow=0;
		if(isPowerOfTwo(subNum)) {//是否是2的次幂
			pow=(int) (Math.log(subNum)/Math.log(2));//2的几次幂
		}else {
			pow=roundup_power_of_2(subNum)/2;//小于等于2的次幂的最大值
			pow=(int) (Math.log(pow)/Math.log(2));
		}
		return pow;
	}
	
	
	/***
	 * 子网划分
	 * @param ips 网段192.168.0.0/22
	 * @param subNum 子网划分数量
	 * @return
	 */
	public static List<String> subnetDivide(String ips,int subNum) {
		List<String> ipList = new ArrayList<String>();
		if(subNum>1){
			int pow =judge(subNum);
			int difference=subNum-calculate2Num(pow);
			ipList =divideByPow(ips,pow);//第一次划分
			if(difference!=0) {
				while (difference>0) {
					if(difference==1) {
						difference--;
						ipList.addAll(divideByPow(ipList.get(0),1));
						ipList.remove(ipList.get(0));
					}else {
						pow =judge(difference);
						difference=difference-calculate2Num(pow);
						for (int i = 0; i < calculate2Num(pow); i++) {
							ipList.addAll(divideByPow(ipList.get(0),pow));
							ipList.remove(ipList.get(0));
						}
						
					}
				}
			}
		}else {
			ipList.add(ips);
		}
		return ipList;
	}
	
	/** 
     * 把long类型的Ip转为一般Ip类型：xx.xx.xx.xx 
     * 
     * @param ip 
     * @return 
     */  
    public static String getIpFromLong(Long ip)  
    {  
        String s1 = String.valueOf((ip & 4278190080L) / 16777216L);  
        String s2 = String.valueOf((ip & 16711680L) / 65536L);  
        String s3 = String.valueOf((ip & 65280L) / 256L);  
        String s4 = String.valueOf(ip & 255L);  
        return s1 + "." + s2 + "." + s3 + "." + s4;  
    }  
    /** 
     * 把xx.xx.xx.xx类型的转为long类型的 
     * 
     * @param ip 
     * @return 
     */  
    public static Long getIpFromString(String ip)  
    {  
        Long ipLong = 0L;  
        String ipTemp = 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);  
        return ipLong;  
    }  
    /** 
     * 根据掩码位获取掩码 
     * 
     * @param maskBit 
     *            掩码位数，如"28"、"30" 
     * @return 
     */  
    public static String getMaskByMaskBit(String maskBit)  
    {  
        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的字符串表示 
     */  
    public static String getBeginIpStr(String ip, String maskBit)  
    {  
        return getIpFromLong(getBeginIpLong(ip, maskBit));  
    }  
    /** 
     * 根据 ip/掩码位 计算IP段的起始IP 如 IP串 218.240.38.69/30 
     * 
     * @param ip 
     *            给定的IP，如218.240.38.69 
     * @param maskBit 
     *            给定的掩码位，如30 
     * @return 起始IP的长整型表示 
     */  
    public static Long getBeginIpLong(String ip, String maskBit)  
    {  
        return getIpFromString(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的字符串表示 
     */  
    public static String getEndIpStr(String ip, String maskBit)  
    {  
        return getIpFromLong(getEndIpLong(ip, maskBit));  
    }  
      
     /** 
     * 根据 ip/掩码位 计算IP段的终止IP 如 IP串 218.240.38.69/30 
     * 
     * @param ip 
     *            给定的IP，如218.240.38.69 
     * @param maskBit 
     *            给定的掩码位，如30 
     * @return 终止IP的长整型表示 
     */  
    public static Long getEndIpLong(String ip, String maskBit)  
    {  
        return getBeginIpLong(ip, maskBit)  
                + ~getIpFromString(getMaskByMaskBit(maskBit));  
    }  
    
    public static String getMaskMap(String maskBit) {
    	switch (maskBit){
			case "1" : return "128.0.0.0";
			case "2" : return "192.0.0.0";
			case "3" : return "224.0.0.0";
			case "4" : return "240.0.0.0";
			case "5" : return "248.0.0.0";
			case "6" : return "252.0.0.0";
			case "7" : return "254.0.0.0";
			case "8" : return "255.0.0.0";
			case "9" : return "255.128.0.0";
			case "10" : return "255.192.0.0";
			case "11" : return "255.224.0.0";
			case "12" : return "255.240.0.0";
			case "13" : return "255.248.0.0";
			case "14" : return "255.252.0.0";
			case "15" : return "255.254.0.0";
			case "16" : return "255.255.0.0";
			case "17" : return "255.255.128.0";
			case "18" : return "255.255.192.0";
			case "19" : return "255.255.224.0";
			case "20" : return "255.255.240.0";
			case "21" : return "255.255.248.0";
			case "22" : return "255.255.252.0";
			case "23" : return "255.255.254.0";
			case "24" : return "255.255.255.0";
			case "25" : return "255.255.255.128";
			case "26" : return "255.255.255.192";
			case "27" : return "255.255.255.224";
			case "28" : return "255.255.255.240";
			case "29" : return "255.255.255.248";
			case "30" : return "255.255.255.252";
			case "31" : return "255.255.255.254";
			case "32" : return "255.255.255.255";
			default: return "-1";
		}
    }
    
    
    /**
	 * 十进制转换成二进制
	 */
	public static String makeBinaryString(int i){
		String binary = "";  
		do{  
			int Bit = (i & 1);  
			String newDigit = ((Bit == 0) ? "0" : "1");  
			binary = newDigit + binary;  
			i >>>= 1;  
		}while (i != 0);  
		return binary; 
	}
    
	/**
	 * 
	 *  输入从10进制转换过来的2进制，再转换成ip地址
	 * @return
	 */
	public static  String getIpStringFrom10bit(String ss)
	{
		while(ss.length() <32 ){
			ss = "0"+ss ;
		}

		String[] ssArray =new String [8];

		ssArray[0]=ss.substring(0, 8);
		ssArray[1]=ss.substring(8, 16);
		ssArray[2]=ss.substring(16, 24);
		ssArray[3]=ss.substring(24, 32);

		String sttttt=
				Integer.valueOf(ssArray[0],2).toString()
				+'.'+Integer.valueOf(ssArray[1],2).toString()
				+'.'+Integer.valueOf(ssArray[2],2).toString()
				+'.'+Integer.valueOf(ssArray[3],2).toString();		 

		return sttttt;
	}
	
	/** 
     * 功能：根据位数返回IP总数 
     * 格式：isIP("192.192.192.1") 
     */  
    public static boolean isIP(String str) {    
        String regex = "\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}";    
        Pattern pattern = Pattern.compile(regex);    
        return pattern.matcher(str).matches();    
    } 
}
隔壁老王的隔壁！
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java ip地址段计算
02-15
输入IP地址及掩码（如24），计算出地址范围 1、计算出掩码指定的IP地址个数 2、分割IP地址 3、将10.0.0.0形式的ip地址转换成10进制整数 4、将10进制整数形式转换成127.0.0.1形式的IP地址
IPV4大网段拆分为多个均分子网段
05-23
公司妹子写的一个小程序(java)，对ipv4的大网段进行拆分，拆成多个小网段。。。有需要的赏个分
【解决方案】关于IP地址字符串拆分组装，以及大小比较、范围判断
赵庆明老师
09-30 1255
关于IP地址字符串拆分组装，以及大小比较、范围判断，比较不容易。 但是，我们知道IP地址，实际上是四组十六进制的数字，这样就简单多了。 比如： 10.201.18.6–&amp;amp;amp;amp;gt; 10-&amp;amp;amp;amp;gt;0A 201-&amp;amp;amp;amp;gt;C9 18-&amp;amp;amp;amp;gt;12 6-&amp;amp;amp;amp;gt;06 组合起来，就是0AC91206 10
一款IP合并和分解工具（一）
ftzchina的博客
05-20 2320
一款IP合并和分解工具
EXCEL将网段地址分解成明细地址
weixin_44375751的博客
03-22 1418
如图，将图1中四个网段地址分解成图2中的明细地址 图1 网段地址 图2 明细地址 一、将网段地址分解 图3 分解网段地址 网络地址公式为 B2=left(A2,len(A2)-3) 掩码位数公式为 C2=right(A2,2) 主机位数公式为 D2=32-C2 主机数公式为 E2=2^D2-1 整理网络地址和主机数，得到图4 图4 网络地址和主机数 二、利用Power Query进行分行 选中A2:B5，在Excel中依次点击数据-来自表格/区域-添加列-自定义...
Java 描述，分割IP地址。
m0_74099927的博客
02-14 836
Java 描述，分割IP地址。
Java利用split分割ip
来杯咖啡，随便聊聊。
02-24 612
[code="java"] public void test() { String address = "11.12.13.14:800"; System.out.println(address.split("\\.").length); String[] num = address.split("\\."); for (int i = 0; i < num.leng...
Java实现从IP和端口列表List<String>获取分离的IP和端口值
11-17 103
List&lt;String&gt; addrList = getFromSomeWhere(); InetSocketAddress[] addrs = new InetSocketAddress[addrList.length()]; for (int i = 0; i &lt; addrList.length(); ++i) { String[] parts = addrList.get(...
python实现将ip段解析为单个ip
sakura_ll的博客
06-05 3608
文章目录将ip段解析为单个ip192.168.1.*样式的ip段分解192.168.1-10.*样式的ip段进行分解192.168.1.0-255样式的ip段进行分解192.168.1.0/24样式的ip段进行分解整体代码附上 将ip段解析为单个ip 将类似于192.168.1.* 192.168.1.0-255 192.168.1-10.* 192.168.1.0/24 这样的段IP解析为单个的ip，以方便后续的扫描等操作。 192.168.1.*样式的ip段分解 def IP
DNS-layer-Fragmentation:DNS层中的代理分段程序包可解决DNS程序包大小问题
05-01
在IPv4中，有时无法将单个数据包中无法容纳的DNS数据报拆分为几个较小的数据包，然后由网络进行重组。 这些代理的想法是探索在协议本身中拆分DNS消息，因此它们不会被IP层分段。 这是概念证明的设置，它提供了...
C#开发实例大全（基础卷）.软件开发技术联盟(带详细书签) PDF 下载
02-20
《C#开发实例大全（基础卷）》筛选、汇集了C#开发从基础知识到高级应用各个层面约600个实例及源代码，每个实例都按实例说明、关键技术、设计过程、详尽注释、秘笈心法的顺序进行了分析解读。全书分6篇共25章，主要...
一键解析IP地址段为IP地址列表
最新发布
qq_20373369的博客
08-10 197
使用UU在线工具的IP地址段解析还原工具，可以快速将IP地址段解析成IP地址列表
移动浏览器中分四个Input控件仿制的IP地址输入控件，以及端口检查
czyhy的专栏
05-19 664
在部分国外主流移动浏览中在不支持键盘代码
将多个连续的IP地址转为一个IP范围
shizhihua11的博客
09-20 1543
1.问题背景 项目中有这样的一个需求：创建防火墙规则时，在用户选择的云主机、负载均衡、子网的IP地址中，如果有连续的IP地址，就把这些连续的IP地址合并为一个IP范围； 具体实现方法如下：（实现框架为vue，放在methods里实现） mergeIP(ipArr){ // IP排序 前半部分 相同的排到一起；后半部分按数字大小 ipArr.sort(function(a,b){ let pre = a.split("."); let next = b.split(".");
input输入框自动截断输入
forgiveForever的博客
11-23 648
input输入框自动截断输入
java拆分ip地址段
05-15
在Java中拆分IP地址段可以使用String的split方法来实现。首先需要将IP地址段以“.”为分隔符分成四个字符串，然后对每个字符串进行相应的处理，最后拼接得到拆分后的IP地址段。 具体步骤如下： 1. 将IP地址段用“.”分隔成四个字符串。 ``` String[] ipSegments = ipAddress.split("\\."); ``` 2. 将分隔后的四个字符串转换成int类型的数值。 ``` int ipByte1 = Integer.parseInt(ipSegments[0]); int ipByte2 = Integer.parseInt(ipSegments[1]); int ipByte3 = Integer.parseInt(ipSegments[2]); int ipByte4 = Integer.parseInt(ipSegments[3]); ``` 3. 对每个数值进行范围检查，确保它们在0到255之间。 ``` if (ipByte1 > 255 || ipByte2 > 255 || ipByte3 > 255 || ipByte4 > 255) { throw new IllegalArgumentException("Invalid IP address"); } ``` 4. 拼接处理后的IP地址段。 ``` String ipSplit = ipByte1 + "." + ipByte2 + "." + ipByte3 + "." + ipByte4; ``` 最终得到的ipSplit就是拆分后的IP地址段。 需要注意的是，在拆分IP地址段之前要先进行IP地址的合法性检查，确保输入的IP地址符合规范。此外，还可以使用正则表达式对IP地址格式进行验证，提高程序的健壮性。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值