IP工具类——子网划分，判断IP是否属于对应范围（10.10.122.51/24 ip号:10.10.122.27）

最新推荐文章于 2024-05-01 12:27:27 发布
最新推荐文章于 2024-05-01 12:27:27 发布
阅读量622 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/z_xiaozhuo/article/details/117920623
版权

IP工具类——子网划分，判断IP是否属于对应范围（10.10.122.51/24 ip号:10.10.122.27）

  1. 功能：判断一个IP是不是在一个网段下，格式：isInRange(“192.168.8.3”, “192.168.9.10/22”);
  2. 功能：根据IP和位数返回该IP网段的所有IP，格式：parseIpMaskRange(“192.192.192.1.”, “23”)
  3. 功能：根据位数返回IP总数，格式：parseIpMaskRange(“192.192.192.1”, “23”)
  4. 把long类型的Ip转为一般Ip类型：xx.xx.xx.xx
  5. 把xx.xx.xx.xx类型的转为long类型的
  6. 根据掩码位获取掩码
  7. 根据 ip/掩码位 计算IP段的起始IP 如 IP串 218.240.38.69/30
  8. 根据 ip/掩码位 计算IP段的终止IP 如 IP串 218.240.38.69/30
  9. 根据子网掩码转换为掩码位 如 255.255.255.252转换为掩码位 为 30
package com.sdmc.basecms.util;

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

/**
 * @author: Barry
 * @projectName: tms-modularization
 * @title: IPUtil
 * @description: TODO
 * @date: 2021/6/1 14:08
 */
public class IPUtil {

    /**
     * 在main方法里面可以测试下
     * 主要功能都在main方法里，需要什么自己找
     */
    public static void main(String[] args) {
        String ip="192.168.1.22";//ip
        String mask="22";//位数，如果只知道子网掩码不知道位数的话在参考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是不是在一个网段下的
     * 格式：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);
    }

    /**
     * 功能：根据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;
    }

}
是阿卓呀
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
IP地址划分工具
08-30
IP地址划分工具，子网掩码，通配符，十进制二进制转换
Linux与unix shell编程指南1.rar
03-09
8.2.12 查询IP地址 61 8.3 类名 62 8.4 系统grep命令 62 8.4.1 目录 63 8.4.2 passwd文件 63 8.4.3 使用ps命令 63 8.4.4 对一个字符串使用grep 64 8.5 egrep 64 8.6 小结 65 第9章 AWK介绍 66 9.1 调用awk 66 9.2 ...
根据ip和子网掩码技术可用网段的在线工具
hanxiaoyong_的博客
06-09 3200
1、在线网络计算器 | TCP/IP子网掩码计算换算 —在线工具 (sojson.com)
一款IP合并和分解工具（二）
ftzchina的博客
07-02 802
本文是对上一篇文章的补充，看过《一款IP合并和分解工具（一）》的知道，cidr-merger工具在windows上使用需要用命令行，不是很方便，在这通过python的tkinter进行二次开发，写一个可视化的界面
子网掩码划分
峰迹的博客
05-01 329
子网掩码是计算机网络中用于划分子网的重要工具，它与IP地址结合使用，用于区分网络地址和主机地址。子网掩码是一个32位的数值，通过其中1和0的组合，明确指出IP地址中哪些部分代表网络地址，哪些部分代表主机地址。
渗透测试工具分享收集-ip段整理
dzqxwzoe的博客
03-02 186
没学过的同学也不要慌，可以去B站搜索相关视频，你搜关键词网络安全工程师会出现很多相关的视频教程，我粗略的看了一下，排名第一的视频就讲的很详细。从时代发展的角度看，网络安全的知识是学不完的，而且以后要学的会更多，同学们要摆正心态，既然选择入门网络安全，就不能仅仅只是入门程度而已，能力越强机会才越多。不过我们这个水平也就算个渗透测试工程师，也就只能做个基础的安全服务，而这个领域还有很多业务，像攻防演练、等保测评、风险评估等，我们的能力根本不够看。最后网站开发知识多少也要了解点，不过别紧张，只是学习基础知识。
c++ list判断是否包含_如何判断两个IP段（IP地址/子网掩码位数）是否是包含关系？...
weixin_39575047的博客
11-24 251
首先，我们如果将每一个IP地址看做一粒沙子的话，不妨将所有的IP地址依次排列在一个横轴上，那么，IP段就可以看做这个横轴上的一个区间段。根据子网掩码的定义，理论上，合法IP段中所包含的IP地址数量只可能是1、2、4、8、16、32、64、128……（2的n次方，n≥0）。子网掩码对应CIDR值所以，对于任意两个合法IP段，在这个横轴上不会存在“部分相交”的可能，而只可能是“相等”、“真包含”或者“...
KiCad_doc_zh_CN_PDF_pcbnew_v0.4.2.pdf
08-08
3.1 工具栏和命令 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14 3.2 鼠标命令 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ....
UML基础、案例与应用（第三版）].施穆勒.扫描版_2分.pdf
11-03
3.7 类——应该做什么和如何识别它们 37 3.8 小结 39 3.9 常见问题解答 39 3.10 小测验和习题 39 3.10.1 小测验 39 3.10.2 习题 40 第4章 关系 41 4.1 关联 41 4.1.1 关联上的约束 42 4.1.2 关联类 43 4.1.3 链 43 ...
C#程序开发范例宝典（第2版）.part08
11-12
实例227 判断文件是否正在被使用 316 实例228 在程序中调用.HLP文件 317 实例229　C#中实现文件拖放 317 实例230 文件比较 318 实例231 获取文件夹中的图标资源 319 实例232 获取文件夹下的所有文件夹及文件的...
IP子网划分利器IPSubnetter
04-18
IP子网划分利器IPSubnetter IPSubnetter，是一个免费的中文版IP子网掩码计算工具，纯绿色软件，不需要安装，可所有调整掩码位，支持计算不标准的子网，只要输入点分十进制的 IP 地址，可以立刻判断出地址类，并显示其子网位、主机位、符合条件的子网数量、每个子网所包含的高效主机数量、所属子网地址、子网掩码、子网的广播地址和当前子网所包含的主机范围。 IPSubnetter支持所有调整掩码的位数，因此支持计算不同标准的子网类型，大小仅几百K，单文件，不需要安装，打开即可使用，是一个十分不错的辅助工具。 子网掩码(subnet mask)又叫网络掩码、地址掩码、子网络遮罩，它是一种用来指明一个IP地址的哪些位标识的是主机所在的子网，和哪些位标识的是主机的位掩码。子网掩码不能独自存在，它必须结合IP地址一起使用。子网掩码唯有一个功能，就是将某个IP地址划分成网络地址和主机地址两部分。
IP子网划分工具,可以方便网络规划
07-19
主要在规划网络时划分子网时用,这样比较方便主要在规划网络时划分子网时用,这样比较方便
IP地址-子网划分工具v1.1 VLSM
07-22
IP地址-子网划分工具v1.1 VLSM 输入IP地址，和其他参数（可按照子网数静态划分），可自动生成子网的IP地址，掩码等 非常好用的学习网络配置的小工具
一款非常好的子网划分工具
12-23
一款易用的 IP 子网计算器。让你点几下鼠标就可以计算你的子网配置的每个方面。
局域网子网掩码计算划分工具
12-18
用于计算子网掩码，用于子网划分，用于网段化分
为什么6lowpan 要有四个地址_大型监控网络系统如何规划ip地址
weixin_39870238的博客
10-22 169
本文转自网络对于监控项目来说，很多故障的原因都是跟ip地址设置不当有关，如ip冲突，或者有几路监控图像没有显示等，都是跟ip有一定关联，合理的分配ip地址十分重要。一、为什么要合理分配IP对于小型监控项目来说，ip地址的设置比较简单，大部分的人都不会出错，对于超过254个点位的监控项目来说，就有些容易出错了，为什么呢？第一、如果超过254个点位不划分网段的话，让系统自动分配ip地址的话，...
IP划分好工具 子网划分工具
12-02
子网划分工具 子网掩码 IP划分
IP地址划分--主机号--子网号
热门推荐
朝游碧海的博客
04-10 1万+
假设一个主机的IP地址是202.112.14.137，掩码是255.255.255.224 主机IP地址的二进制表示11001010.01110000.00001110.10001001 子网掩码的二进制表示 11111111.11111111.11111111.11100000 ip地址与子网掩码二进制相与得到网络地址 二进制为11001010.01110000.00001110.100000...
dockerfile FROM 10.10.38.90:31104/public/jdk/alpinejdk8:1.8_362
最新发布
05-17
这是一个Dockerfile的指令，表示当前镜像将会基于10.10.38.90:31104/public/jdk/alpinejdk8:1.8_362这个镜像构建，即在当前镜像的基础上添加自己的配置和文件。该镜像是一个alpine操作系统上的jdk8环境，版本号为1.8...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值