[java]根据ip和掩码计算网段、广播地址及可用ip地址范围

亦凉 2022-10-19 13:59 421阅读 0赞

## ip地址与掩码、网段、广播地址、可用ip范围 ##

*  IP： 网络地址
 *  掩码： 指明一个IP地址的哪些位标识的是主机所在的子网。
 *  网段：网络中可通信的部分，一般用子网第一个地址表示。
 *  广播地址：专门用于同时向网络中所有工作站进行发送的一个地址；一般用子网最后一个地址表示。
 *  可用子网ip：一般指子网中去除网段、广播地址的地址范围  
    参考资料：  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21hc3RlcjMzNg_size_16_color_FFFFFF_t_70]

[子网划分][Link 1]  
完整代码：

import java.util.HashMap;
    
    public class IpUtil { 
    
        /** * 在main方法里面可以测试下 * 主要功能都在main方法里，需要什么自己找 */
        public static void main(String[] args) { 
            String ip="192.168.1.21";//ip
            String mask="255.255.254.0";//位数，如果只知道子网掩码不知道位数的话在参考getMaskMap()方法
            NetInfo info = new NetInfo(ip,mask);
            System.out.println("ip:"+info.getIp());
            System.out.println("mask:"+info.getMask());
            System.out.println("broadcase:"+info.getBroadcast());
            System.out.println("segment:"+info.getSegment());
            System.out.println("startip:"+info.getStartIp());
            System.out.println("endIP:"+info.getEndIp());
            System.out.println("count:"+info.getCount());
    // System.out.println(getIpFromLong(getNetStartIp(ip,mask)));
    
        }
    
    
        /** * 输出二进制 * @param n */
        public static void binaryToDecimal(long n){ 
            for(int i = 63;i >= 0; i--) { 
                System.out.print(n >>> i & 1);
            }
            System.out.println("---->");
        }
        /** * 把xx.xx.xx.xx类型的转为long类型的 * * @param ip * @return */
        public static Long getIpFromString(String ip)
        { 
            // 进制 2^8 = 256 共四段
            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;
        }
        /** * 把long类型的Ip转为一般Ip类型：xx.xx.xx.xx * * @param ip * @return */
        public static String getIpFromLong(Long ip)
        { 
            String s1 = String.valueOf((ip & 4278190080L) / 16777216L); // 255.0.0.0 ~ 1.0.0.0 截取第一个八位
            String s2 = String.valueOf((ip & 16711680L) / 65536L); // 0.255.0.0 ~ 0.1.0.0 截取第二个八位
            String s3 = String.valueOf((ip & 65280L) / 256L); // 0.0.255.0 ~ 0.0.1.0 截取第三个八位
            String s4 = String.valueOf(ip & 255L); // 0.0.0.255 ~ 0.0.0.1 截取第四个八位
            return s1 + "." + s2 + "." + s3 + "." + s4;
        }
        public static class NetInfo{ 
            private static final long VALIDATE_DATA = Long.MAX_VALUE>>31;
            private static final HashMap<Integer,String> NET_MASK = new HashMap<>();
            private static String IP_REGEX = "^(1\\d{2}|2[0-4]\\d|25[0-5]|[1-9]\\d|[1-9])\\."
                    + "(1\\d{2}|2[0-4]\\d|25[0-5]|[1-9]\\d|\\d)\\." +"(1\\d{2}|2[0-4]\\d|25[0-5]|[1-9]\\d|\\d)\\."
                    + "(1\\d{2}|2[0-4]\\d|25[0-5]|[1-9]\\d|\\d)$";
            // ip
            private String ipStr;
            private Long ip;
            // 掩码
            private String maskStr;
            private Long mask;
            // 网段
            private String segmentStr;
            private Long segment;
            // 广播地址
            private String broadcastStr;
            private Long broadcast;
            // 开始ip
            private String startIpStr;
            private Long startIp;
            // 结束ip
            private String endIpStr;
            private Long endIp;
            // 可用ip数
            private Long count;
            // 初始化掩码
            static{ 
                NET_MASK.put(32,getIpFromLong(VALIDATE_DATA));
                for(int i=1;i<32;i++) { 
                    NET_MASK.put(32-i,getIpFromLong(VALIDATE_DATA << i & VALIDATE_DATA));
                }
            }
            public NetInfo(String ipStr, String maskStr) { 
                this.ipStr = ipStr;
                this.maskStr = maskStr;
                checkParam();
                init();
            }
            public NetInfo(String ipStr, int mask) { 
                this(ipStr,NET_MASK.get(mask));
            }
            public void checkParam(){ 
                if(maskStr == null
                        || "".equals(maskStr.trim())
                        || !NET_MASK.containsValue(maskStr)){ 
                    throw new RuntimeException("掩码无效");
                }
                if(ipStr == null || "".equals(ipStr.trim())){ 
                    throw new RuntimeException("ip地址为空");
                }
                // 判断ip地址是否与正则表达式匹配
                if (!ipStr.matches(IP_REGEX)) { 
                    throw new RuntimeException("IP地址不合规范");
                }
            }
            public void init(){ 
                this.ip = getIpFromString(ipStr);
                this.mask = getIpFromString(maskStr);
                // 网段 = ip & 掩码
                this.segment = this.ip & this.mask;
                this.segmentStr = getIpFromLong(this.segment);
                // 广播地址 网段末尾用1补齐
                this.broadcast = this.segment | (~this.mask & VALIDATE_DATA);
                binaryToDecimal(broadcast);
                this.broadcastStr = getIpFromLong(this.broadcast);
                // 开始地址 网段+1
                this.startIp = this.segment +1;
                this.startIpStr = getIpFromLong(this.startIp);
                // 结束地址 广播地址-1
                this.endIp = this.broadcast -1;
                this.endIpStr = getIpFromLong(this.endIp);
                /*for( long i = startIp;i< endIp;i++){ System.out.println(getIpFromLong(i + 1)); }*/
                this.count = this.broadcast - this.startIp;
            }
    
            public String getIp() { 
                return ipStr;
            }
    
            public String getMask() { 
                return maskStr;
            }
    
            public String getSegment() { 
                return segmentStr;
            }
    
            public String getBroadcast() { 
                return broadcastStr;
            }
    
            public String getStartIp() { 
                return startIpStr;
            }
    
            public String getEndIp() { 
                return endIpStr;
            }
    
            public Long getCount() { 
                return count;
            }
        }
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21hc3RlcjMzNg_size_16_color_FFFFFF_t_70]: /images/20221004/33dd1249776c46a19605e020809c8909.png
[Link 1]: https://baike.baidu.com/item/%E5%AD%90%E7%BD%91%E5%88%92%E5%88%86/5446046?fr=aladdin