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

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

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

子网划分
完整代码：

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;
        }
    }
}