根据IP/掩码位获取IP的起始范围、IP总数、IP属不属于某个网段或者打印网段内所有的IP（略有修改）

已于 2022-03-14 16:19:43 修改
阅读量1.1k 收藏 2
点赞数 1
文章标签： java 蓝桥杯 开发语言
于 2022-03-14 16:13:15 首次发布
原文链接：https://blog.csdn.net/hjgzj/article/details/77989432
版权 
package com.sino.apprelation.utils;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;
import java.util.regex.Pattern;


/**
 * @Description: 用于判断IP是否在网段内，给定网段判断IP的范围
 * @Author: liujian
 * @Version: 1.0
 * @Create Date Time: 2022-03-14 14:08
 * @Update Date Time:
 * @see
 */
public class IpUtil {

    /**
     * 功能：判断一个IP是不是在一个网段下的
     * 格式：isInRange("192.168.8.3", "192.168.9.10/22");
     */
    public static boolean isInRange(String ip, String cidr) {
        String[] ips = ip.split("\\.");
        int ipAddr = (Integer.parseInt(ips[0]) << 24)
                | (Integer.parseInt(ips[1]) << 16)
                | (Integer.parseInt(ips[2]) << 8) | Integer.parseInt(ips[3]);
        int type = Integer.parseInt(cidr.replaceAll(".*/", ""));
        int mask = 0xFFFFFFFF << (32 - type);
        String cidrIp = cidr.replaceAll("/.*", "");
        String[] cidrIps = cidrIp.split("\\.");
        int cidrIpAddr = (Integer.parseInt(cidrIps[0]) << 24)
                | (Integer.parseInt(cidrIps[1]) << 16)
                | (Integer.parseInt(cidrIps[2]) << 8)
                | Integer.parseInt(cidrIps[3]);

        return (ipAddr & mask) == (cidrIpAddr & mask);
    }

    /**
     * 根据地址段（192.168.30.0/24）的ip地址（192.168.30.0）和位数（24）获取具体ip的范围
     * @param ip
     * @param mask
     * @return
     */
    public static String getIpRange(String ip, String mask) {
        //获得起始IP和终止IP的方法（包含网络地址和广播地址）
        String startIp = getBeginIpStr(ip, mask);
        String endIp = getEndIpStr(ip, mask);
        //获得起始IP和终止IP的方法（不包含网络地址和广播地址）
        String subStart = startIp.split("\\.")[0] + "." + startIp.split("\\.")[1] + "." + startIp.split("\\.")[2] + ".";
        String subEnd = 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);
        return startIp + "-" + endIp;
    }

    /**
     * 功能：根据IP和位数返回该IP网段的所有IP
     * 格式：parseIpMaskRange("192.192.192.1.", "23")
     */
    public static List<String> parseIpMaskRange(String ip, String mask) {
        List<String> list = new ArrayList<>();
        if ("32".equals(mask)) {
            list.add(ip);
        } else {
            String startIp = getBeginIpStr(ip, mask);
            String endIp = getEndIpStr(ip, mask);
            if (!"31".equals(mask)) {
                String subStart = startIp.split("\\.")[0] + "." + startIp.split("\\.")[1] + "." + startIp.split("\\.")[2] + ".";
                String subEnd = 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);
        }
        return list;
    }

    /**
     * 功能：根据位数返回IP总数
     * 格式：parseIpMaskRange("192.192.192.1", "23")
     */
    public static int getIpCount(String mask) {
        return BigDecimal.valueOf(Math.pow(2, 32 - Integer.parseInt(mask))).setScale(0, BigDecimal.ROUND_DOWN).intValue();//IP总数，去小数点
    }

    /**
     * 功能：根据位数返回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();
    }

    public static List<String> parseIpRange(String ipfrom, String ipto) {
        List<String> ips = new ArrayList<String>();
        String[] ipfromd = ipfrom.split("\\.");
        String[] iptod = ipto.split("\\.");
        int[] int_ipf = new int[4];
        int[] int_ipt = new int[4];
        for (int i = 0; i < 4; i++) {
            int_ipf[i] = Integer.parseInt(ipfromd[i]);
            int_ipt[i] = Integer.parseInt(iptod[i]);
        }
        for (int A = int_ipf[0]; A <= int_ipt[0]; A++) {
            for (int B = (A == int_ipf[0] ? int_ipf[1] : 0); B <= (A == int_ipt[0] ? int_ipt[1]
                    : 255); B++) {
                for (int C = (B == int_ipf[1] ? int_ipf[2] : 0); C <= (B == int_ipt[1] ? int_ipt[2]
                        : 255); C++) {
                    for (int D = (C == int_ipf[2] ? int_ipf[3] : 0); D <= (C == int_ipt[2] ? int_ipt[3]
                            : 255); D++) {
                        ips.add(A + "." + B + "." + C + "." + D);
                    }
                }
            }
        }
        return ips;
    }

    /**
     * 把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));
    }


    /**
     * 根据子网掩码转换为掩码位 如 255.255.255.252转换为掩码位 为 30
     *
     * @param netmarks
     * @return
     */
    public static int getNetMask(String netmarks) {
        StringBuilder sbf;
        String str;
        int inetmask = 0;
        int count = 0;
        String[] ipList = netmarks.split("\\.");
        for (int n = 0; n < ipList.length; n++) {
            sbf = toBin(Integer.parseInt(ipList[n]));
            str = sbf.reverse().toString();
            count = 0;
            for (int i = 0; i < str.length(); i++) {
                i = str.indexOf('1', i);
                if (i == -1) {
                    break;
                }
                count++;
            }
            inetmask += count;
        }
        return inetmask;
    }

    /**
     * 计算子网大小
     *
     * @param maskBit 掩码位
     * @return
     */
    public static int getPoolMax(int maskBit) {
        if (maskBit <= 0 || maskBit >= 32) {
            return 0;
        }
        return (int) Math.pow(2, 32 - maskBit) - 2;
    }

    private static StringBuilder toBin(int x) {
        StringBuilder result = new StringBuilder();
        result.append(x % 2);
        x /= 2;
        while (x > 0) {
            result.append(x % 2);
            x /= 2;
        }
        return result;
    }

    public static String getMaskMap(String maskBit) {
        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";
    }

    public static double ipToDouble(String ip) {
        String[] arr = ip.split("\\.");
        double d1 = Double.parseDouble(arr[0]);
        double d2 = Double.parseDouble(arr[1]);
        double d3 = Double.parseDouble(arr[2]);
        double d4 = Double.parseDouble(arr[3]);
        return d1 * Math.pow(256, 3) + d2 * Math.pow(256, 2) + d3 * 256 + d4;
    }

    /**
     * 在main方法里面可以测试下
     * 主要功能都在main方法里，需要什么自己找
     */
    public static void main(String[] args) {
        //样例：10.16.30.0/24
        String ip = "10.16.30.0";//ip
        String mask = "24";//位数，如果只知道子网掩码不知道位数的话在参考getMaskMap()方法

        //获得起始IP和终止IP的方法（包含网络地址和广播地址）
        String startIp = getBeginIpStr(ip, mask);
        String endIp = getEndIpStr(ip, mask);
        //System.out.println("起始IP：" + startIp + "终止IP：" + endIp);

        //获得起始IP和终止IP的方法（不包含网络地址和广播地址）
        String subStart = startIp.split("\\.")[0] + "." + startIp.split("\\.")[1] + "." + startIp.split("\\.")[2] + ".";
        String subEnd = 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是否属于某个网段
        boolean flag = isInRange("10.2.0.0", "10.3.0.0/17");
        System.out.println(flag);

        //根据位数查询IP数量
        int ipCount = getIpCount("8");
        System.out.println(ipCount);

        //判断是否是一个IP
        System.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);
//      }
    }
}

Liu-1998
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
php求一个网段开始与结束IP地址的方法
01-21
本文实例讲述了php求一个网段开始与结束IP地址的方法。分享给大家供大家参考。具体如下： 比如：网段(192168.1.5/24)，其子网掩码根据24划分为： 11111111.11111111.11111111.00000000(255.255.255.0) 说明：IP地址为32bits，24在划分网段中就表示前面有24个1，后面有8个0. 开始IP地址的算法是：192.168.1.5的二进制与子网掩码的二进制进行“与”运算出来的。 结束IP地址的算法是：子网掩码的二进制先取反，然后和192.168.1.5的二进制进行“或”运算 实际的就应用中，那样得出的是网络地址和广播地址，网络地址+1才
IP地址合并工具，将IP地址转换为起始IP，终止IP;或者IP/mask两种形式。保留IP地址后附加信息
01-12
作者:qihai python版本:3.7.4 输入文件内容：IP地址|info 输出文件1内容：起始IP|终止IP|info 输出文件2内容：ip/mask|info 分割符'|'
IP地址计算起始地址和终止地址
09-24
EXCEL表格IP，计算起始地址和终止地址！子网掩码的测算，起始地址和终止地址中间IP地址的填充公式！
ip地址的处理-根据255个划分网段的个数及每个网段的起始终止ip
12-26
根据 ip/掩码位 计算IP段的起始、终止IP,根据掩码位获取掩码，获取Ip段之间的容量，根据255个划分网段的个数及每个网段的起始终止ip等
根据ip及掩码计算ip段及掩码和ip互转
09-30
根据网段ip和掩码自动计算ip段，ip相关操作基础类。包括：根据 ip/掩码位 计算IP段的起始IP；根据 ip/掩码位 计算IP段的终止IP；计算子网大小等。
java的ip常用工具类
08-17
此工具类包含根据ip和掩码(cidr)计算网段 判断ip是否在网段内 判断是否是ip ip转long long类型的ip转string
Java根据IP地址/掩码位（CIDR）和起始IP-终止IP计算网段（IPV4和IPV6）
qq_41936784的博客
11-17 3891
Java根据IP地址/掩码位（CIDR）和起始IP-终止IP计算网段（IPV4和IPV6）
ip地址掩码和位数对应关系表、子网掩码、网络地址、主机地址-yellowcong
热门推荐
08-05 5万+
ip的地址掩码，刚开始感觉特别蒙蔽，网掩码都是每段8位二进制,共32位，子网掩码用来划分局域网的ip地址的，需要和网络地址结合起来一起用，计算方法是2^（32-掩码位数）-2，比如常用的24位数掩码，2^（32-24）-2 = 254,减去的2代表的是网络地址和广播地址。广播地址用于在局域网中，给所有这个网段的主机发送数据，网络地址，用于网络交换
[java]根据ip和掩码计算网段、广播地址及可用ip地址范围
東₂₀₂₃²⁰²³
07-11 4万+
ip地址与掩码、网段、广播地址、可用ip范围 IP： 网络地址 掩码： 指明一个IP地址的哪些位标识的是主机所在的子网。 网段：网络中可通信的部分，一般用子网第一个地址表示。 广播地址：专门用于同时向网络中所有工作站进行发送的一个地址；一般用子网最后一个地址表示。 可用子网ip：一般指子网中去除网段、广播地址的地址范围 参考资料： 子网划分 完整代码： import java.util.HashMap; public class IpUtil { /** * 在main方法里
通过掩码计算IP范围
qq_38328144的博客
03-17 1万+
疑问一： 对掩码小于24，地址数反而多不理解。 子网掩码是一串连续的1和一串连续的0组成，共4段，每段8位，即32位数 以255.255.255.0为例子，11111111.11111111.11111111.00000000 子网掩码决定的是一个子网的计算机数目，公式是2的m次方，其中m可以看作是后面的多少颗0. 掩码为24的时候，子网内计算机数为2的8次方-1。 掩码为23的时候，子网内计算机...
IP地址拆分小工具v1.1-用于批量计算、拆分IP地址、地址段，支持批量excel拆分转换
03-31
可以实现： ...3、可以根据excel文件进行拆分，excel文件中IP地址，支持上述两种方式，Excel中只要包含起始IP列、终止IP列，或者包含IP地址段，就可以自动批量生成单个IP，并且还可以保留原来excel的字段；
java ip 掩码_如何从CIDR表示法或使用Java的地址网络掩码对中获取IP范围
weixin_28783937的博客
02-21 229
#include // ncurses.h includes stdio.h#include #include // determine network range of masked ip. eg: 192.168.113.0/25// unsigned int network = 0x0a427200; /* 10.66.114.0 */// unsigned int subnet_lengt...
python 整数与IP地址转换
douyaoxin_126的博客
04-03 366
【代码】python 整数与IP地址转换。
如何根据一个IP地址和掩码，算出它的子网IP及范围
yi193229833的博客
05-24 6756
1.算出192.168.210.181/19的子网地址及范围 解： 1. 先把192.168.210.181/19转化成二进制 192.168.210.181 = 11000000 10101000 11010010 10110101 255.255.224.0 = 11111111 11111111 11100000 00000000 2. 将ip的二进制与掩码的二进制进行“与”运算：即1与1=1,0与1=0,1与0=0 11010010 10110101 1
JAVA根据ip地址和子网掩码获取子网地址
weixin_41844891的博客
11-18 1507
JAVA根据ip地址和子网掩码获取子网地址
通过IP地址 子网掩码计算网络地址 广播地址 地址范围 主机数量 （包含基础概念）
weixin_45346457的博客
04-22 7153
1. Internet上每一台计算机都有唯一的地址来标识它的身份，即IP地址，使用域名其实也是要转化为IP地址的 2. IP地址分类： A类：000~127，默认子网掩码：255.0.0.0 B类：128~191，默认子网掩码：255.255.0.0 C类：192~223，默认子网掩码：255.255.255.0 D类：224~239 E类：240~255 3...
根据IP和子网掩码计算网络段内全部地址
Songcz的博客
11-25 1189
一个神奇的需求，给个TXT上吗都是IP和子网掩码 127.0.0.1,255.255.255.0; 127.1.1.1,255.255.255.0; 127.1.1.118,255.255.255.0; 就类似这样吧，根据这个求出来全部的地址，然后再生产一个TXT… （能有3k多个，为啥要TXT至今入库不好吗 还挺有意思… 直接代码吧 找了个工具类特别好用 package com.dxm; ...
python ip地址处理_python中处理IP地址
weixin_31255215的博客
03-01 2011
python中处理IP地址IPy - 提供了一些有用的类和函数来处理ipv6和ipv4地址和网络APIIPy库包含类IP，使用它你可以方便处理对大部分格式的ipv6和ipv4网络和地址的格式化和处理。它的接口借鉴了Perl的NET::IP模块，但是实现上采用了不同的方法。它没有实现non-CIDR网络掩码，所以打算使用0xffffff0f格式网络掩码的无法使用。>>> from ...
python中netaddr库用法详解
IT之一小佬的博客
08-07 4237
python中netaddr库用法详解
起始IP地址为2.0.1.2，结束IP地址为2.0.1.254，掩码为24，求网段和IP范围
最新发布
06-09
已知起始IP地址为2.0.1.2，结束IP地址为2.0.1.254，掩码为24，求网段和IP范围。 根据掩码为24，可以确定子网掩码为255.255.255.0。将其转换为二进制为24个1和8个0，即11111111.11111111.11111111.00000000。 将...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值