[java]根据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;
        }
    }
}