微信公众号搜"智元新知"关注
微信扫一扫可直接关注哦！

Java基础之java处理ip的工具类

分类：Java作者：编程之家AI导航网

这篇文章主要介绍了Java基础应用，使用java处理ip的工具类的相关资料,需要的朋友可以参考下

java处理ip的工具类，包括把long类型的Ip转为一般Ip类型、把xx.xx.xx.xx类型的转为long类型、根据掩码位获取掩码、根据 ip/掩码位 计算IP段的起始IP、根据 ip/掩码位 计算IP段的终止IP等方法，可以直接使用！

复制代码 代码如下:

package com.hh.test;

import java.util.HashMap;

import java.util.Map;

import org.apache.commons.lang3.StringUtils;

/**

* IP工具类

*

* @author bl

* @email kutekute00@gmail.com

*

*/

public class IPUtils

{

    /**

     * 把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 StringUtils.isEmpty(maskBit) ? "error, maskBit is null !"

                : maskBitMap().get(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)

    {

        StringBuffer sbf;

        String str;

        int inetmask = 0, count = 0;

        String[] ipList = netmarks.split("\.");

        for (int n = 0; n         {

            sbf = toBin(Integer.parseInt(ipList[n]));

            str = sbf.reverse().toString();

            count = 0;

            for (int i = 0; i             {

                i = str.indexOf('1', i);

                if (i == -1)

                {

                    break;

                }

                count++;

            }

            inetmask += count;

        }

        return inetmask;

    }

    /**

     * 计算子网大小

     *

     * @param netmask

     *            掩码位

     * @return

     */

    public static int getPoolMax(int maskBit)

    {

        if (maskBit = 32)

        {

            return 0;

        }

        return (int) Math.pow(2, 32 - maskBit) - 2;

    }

    private static StringBuffer toBin(int x)

    {

        StringBuffer result = new StringBuffer();

        result.append(x % 2);

        x /= 2;

        while (x > 0)

        {

            result.append(x % 2);

            x /= 2;

        }

        return result;

    }

    /*

     * 存储着所有的掩码位及对应的掩码 key:掩码位 value:掩码（x.x.x.x）

     */

    private static Map maskBitMap()

    {

        Map maskBit = new HashMap();

        maskBit.put("1", "128.0.0.0");

        maskBit.put("2", "192.0.0.0");

        maskBit.put("3", "224.0.0.0");

        maskBit.put("4", "240.0.0.0");

        maskBit.put("5", "248.0.0.0");

        maskBit.put("6", "252.0.0.0");

        maskBit.put("7", "254.0.0.0");

        maskBit.put("8", "255.0.0.0");

        maskBit.put("9", "255.128.0.0");

        maskBit.put("10", "255.192.0.0");

        maskBit.put("11", "255.224.0.0");

        maskBit.put("12", "255.240.0.0");

        maskBit.put("13", "255.248.0.0");

        maskBit.put("14", "255.252.0.0");

        maskBit.put("15", "255.254.0.0");

        maskBit.put("16", "255.255.0.0");

        maskBit.put("17", "255.255.128.0");

        maskBit.put("18", "255.255.192.0");

        maskBit.put("19", "255.255.224.0");

        maskBit.put("20", "255.255.240.0");

        maskBit.put("21", "255.255.248.0");

        maskBit.put("22", "255.255.252.0");

        maskBit.put("23", "255.255.254.0");

        maskBit.put("24", "255.255.255.0");

        maskBit.put("25", "255.255.255.128");

        maskBit.put("26", "255.255.255.192");

        maskBit.put("27", "255.255.255.224");

        maskBit.put("28", "255.255.255.240");

        maskBit.put("29", "255.255.255.248");

        maskBit.put("30", "255.255.255.252");

        maskBit.put("31", "255.255.255.254");

        maskBit.put("32", "255.255.255.255");

        return maskBit;

    }

    /**

     * 根据掩码位获取掩码

     *

     * @param masks

     * @return

     */

    @Deprecated

    public static String getMaskByMaskBit(int masks)

    {

        String ret = "";

        if (masks == 1)

            ret = "128.0.0.0";

        else if (masks == 2)

            ret = "192.0.0.0";

        else if (masks == 3)

            ret = "224.0.0.0";

        else if (masks == 4)

            ret = "240.0.0.0";

        else if (masks == 5)

            ret = "248.0.0.0";

        else if (masks == 6)

            ret = "252.0.0.0";

        else if (masks == 7)

            ret = "254.0.0.0";

        else if (masks == 8)

            ret = "255.0.0.0";

        else if (masks == 9)

            ret = "255.128.0.0";

        else if (masks == 10)

            ret = "255.192.0.0";

        else if (masks == 11)

            ret = "255.224.0.0";

        else if (masks == 12)

            ret = "255.240.0.0";

        else if (masks == 13)

            ret = "255.248.0.0";

        else if (masks == 14)

            ret = "255.252.0.0";

        else if (masks == 15)

            ret = "255.254.0.0";

        else if (masks == 16)

            ret = "255.255.0.0";

        else if (masks == 17)

            ret = "255.255.128.0";

        else if (masks == 18)

            ret = "255.255.192.0";

        else if (masks == 19)

            ret = "255.255.224.0";

        else if (masks == 20)

            ret = "255.255.240.0";

        else if (masks == 21)

            ret = "255.255.248.0";

        else if (masks == 22)

            ret = "255.255.252.0";

        else if (masks == 23)

            ret = "255.255.254.0";

        else if (masks == 24)

            ret = "255.255.255.0";

        else if (masks == 25)

            ret = "255.255.255.128";

        else if (masks == 26)

            ret = "255.255.255.192";

        else if (masks == 27)

            ret = "255.255.255.224";

        else if (masks == 28)

            ret = "255.255.255.240";

        else if (masks == 29)

            ret = "255.255.255.248";

        else if (masks == 30)

            ret = "255.255.255.252";

        else if (masks == 31)

            ret = "255.255.255.254";

        else if (masks == 32)

            ret = "255.255.255.255";

        return ret;

    }

}

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 dio@foxmail.com 举报，一经查实，本站将立刻删除。

相关推荐

String真的不可变吗？
Java中的String是不可变对象 在面向对象及函数编程语言中，不可变对象（英语：Immutable object）是一种对象，在被创造之后，它的状态就不可以被改变。至于状态可以被改变的对象，则被称为可变对象（英语：mutable object）。-- 来自百度百科 Java8 String源码
String, StringBuffer 和 StringBuilder之间的区别
String, StringBuffer 和 StringBuilder 可变性 String不可变 StringBuffer 和 StringBuilder 可变 线程安全 String 不可变，因此是线程安全的 StringBuilder不是线程安全的 StringBuffer 是线程安全的，内
讲讲Java的序列化反序列化？
序列化：把对象转换为字节序列的过程称为对象的序列化. 反序列化：把字节序列恢复为对象的过程称为对象的反序列化. 什么时候会用到 当只在本地 JVM 里运行下 Java 实例，这个时候是不需要什么序列化和反序列化的，但当出现以下场景时，就需要序列化和反序列化了： 当需要将内存中的对象持久化到磁盘，数据
数组到底是不是对象
先说结论，是对象！可以继续往下看 数组是不是对象 什么是对象？对象是类的一个实例，有状态和行为 Java对象： 软件的对象也有行为和状态 软件对象的状态称之为属性 方法操作对象内部状态的改变，对象的相互调用也是通过方法来完成 而java中的数组具有java中其他对象的一些基本特点。比如封装了一些数据
金融、支付行业的开发者不得不知道的float、double计算误差问题
为什么浮点数 float 或 double 运算的时候会有精度丢失的风险呢？ 《阿里巴巴 Java 开发手册》中提到：“浮点数之间的等值判断，基本数据类型不能用 == 来比较，包装数据类型不能用 equals 来判断”。“为了避免精度丢失，可以使用 BigDecimal 来进行浮点数的运算”。 浮点
浅谈Integer缓存机制原理
面试题引入 这里引申出一个经典问题，看下面代码 Integer a = 100; Integer b = 100; System.out.println(a == b);//true Integer c = 200; Integer d = 200; System.out.println(c ==
能否自定义一个String类使用
先说下结论，可以自定义包名不为java.lang的String类，区别包名是可以正常使用的。 包名不为java.lang package com.seven.jvm; public final class String { /** The value is used for character st
一文讲清楚static关键字
static能修饰的地方 静态变量 静态变量: 又称为类变量，也就是说这个变量属于类的，类所有的实例都共享静态变量，可以直接通过类名来访问它；静态变量在内存中只存在一份。 实例变量: 每创建一个实例就会产生一个实例变量，它与该实例同生共死。 静态方法 静态方法在类加载的时候就存在了，它不依赖于任何实
String究竟能存储多少字符？
能存储多少字符，通过以下步骤来看 首先String的length方法返回是int。所以理论上长度一定不会超过int的最大值。 编译器对字符串字面量长度的限制源自Java编译器（如javac）在处理常量池时的实现。编译器源码如下，限制了字符串长度大于等于65535就会编译不通过：// src/jdk.
解决哈希冲突的三种方法
为什么会哈希冲突 我们知道，在使用Map，Set这些集合时，都会重写hashcode方法，但Java中的hashCode方法会将对象映射到一个32位的整数范围（即从-2^31 到 2^31-1）。无论输入数据多么庞大，哈希函数生成的哈希值总是落在这个有限范围内。因此是会存在hash冲突的。 无论哈希
苹果市值2025年有望达4万亿美元
pythonJavaScriptjavaHTMLreactjsC#AndroidCSSNode.jssqlrpython-3.xMysqLjQueryc++pandasFlutterangularIOSdjangolinuxswifttypescript路由器JSON路由器设置无线路由器h3c华三华三路由器设置华三路由器电脑软件教程arraysdocker软件图文教程Cvue.jslaravelspring-bootreact-native