JAVA中IP和整数相互转化介绍

最新推荐文章于 2024-04-27 09:13:51 发布
最新推荐文章于 2024-04-27 09:13:51 发布
阅读量72 收藏
点赞数
文章标签： java

在项目中经常会用到IP（v4）范围判定比较的功能，一般将IP转化为整数再进行比较。
一、基本知识点

IP ——> 整数：

  • 把IP地址转化为字节数组
  • 通过左移位（<<）、与（&）、或（|）这些操作转为int

整数 ——> IP：

  • 将整数值进行右移位操作（>>>），右移24位，再进行与操作符（&）0xFF，得到的数字即为第一段IP。
  • 将整数值进行右移位操作（>>>），右移16位，再进行与操作符（&）0xFF，得到的数字即为第二段IP。
  • 将整数值进行右移位操作（>>>），右移8位，再进行与操作符（&）0xFF，得到的数字即为第三段IP。
  • 将整数值进行与操作符（&）0xFF，得到的数字即为第四段IP。

二、java代码示例

IPv4Util.java

Java代码 复制代码 收藏代码
  1. packagemichael.utils;
  3. importjava.net.InetAddress;
  5. /**
  6. *@authormichael<br>
  7. *blog:http://sjsky.iteye.com<br>
  8. *mail:sjsky007@gmail.com
  9. */
  10. publicclassIPv4Util{
  12. privatefinalstaticintINADDRSZ=4;
  14. /**
  15. *把IP地址转化为字节数组
  16. *@paramipAddr
  17. *@returnbyte[]
  18. */
  19. publicstaticbyte[]ipToBytesByInet(StringipAddr){
  20. try{
  21. returnInetAddress.getByName(ipAddr).getAddress();
  22. }catch(Exceptione){
  23. thrownewIllegalArgumentException(ipAddr+"isinvalidIP");
  24. }
  25. }
  27. /**
  28. *把IP地址转化为int
  29. *@paramipAddr
  30. *@returnint
  31. */
  32. publicstaticbyte[]ipToBytesByReg(StringipAddr){
  33. byte[]ret=newbyte[4];
  34. try{
  35. String[]ipArr=ipAddr.split("//.");
  36. ret[0]=(byte)(Integer.parseInt(ipArr[0])&0xFF);
  37. ret[1]=(byte)(Integer.parseInt(ipArr[1])&0xFF);
  38. ret[2]=(byte)(Integer.parseInt(ipArr[2])&0xFF);
  39. ret[3]=(byte)(Integer.parseInt(ipArr[3])&0xFF);
  40. returnret;
  41. }catch(Exceptione){
  42. thrownewIllegalArgumentException(ipAddr+"isinvalidIP");
  43. }
  45. }
  47. /**
  48. *字节数组转化为IP
  49. *@parambytes
  50. *@returnint
  51. */
  52. publicstaticStringbytesToIp(byte[]bytes){
  53. returnnewStringBuffer().append(bytes[0]&0xFF).append('.').append(
  54. bytes[1]&0xFF).append('.').append(bytes[2]&0xFF)
  55. .append('.').append(bytes[3]&0xFF).toString();
  56. }
  58. /**
  59. *根据位运算把byte[]->int
  60. *@parambytes
  61. *@returnint
  62. */
  63. publicstaticintbytesToInt(byte[]bytes){
  64. intaddr=bytes[3]&0xFF;
  65. addr|=((bytes[2]<<8)&0xFF00);
  66. addr|=((bytes[1]<<16)&0xFF0000);
  67. addr|=((bytes[0]<<24)&0xFF000000);
  68. returnaddr;
  69. }
  71. /**
  72. *把IP地址转化为int
  73. *@paramipAddr
  74. *@returnint
  75. */
  76. publicstaticintipToInt(StringipAddr){
  77. try{
  78. returnbytesToInt(ipToBytesByInet(ipAddr));
  79. }catch(Exceptione){
  80. thrownewIllegalArgumentException(ipAddr+"isinvalidIP");
  81. }
  82. }
  84. /**
  85. *ipInt->byte[]
  86. *@paramipInt
  87. *@returnbyte[]
  88. */
  89. publicstaticbyte[]intToBytes(intipInt){
  90. byte[]ipAddr=newbyte[INADDRSZ];
  91. ipAddr[0]=(byte)((ipInt>>>24)&0xFF);
  92. ipAddr[1]=(byte)((ipInt>>>16)&0xFF);
  93. ipAddr[2]=(byte)((ipInt>>>8)&0xFF);
  94. ipAddr[3]=(byte)(ipInt&0xFF);
  95. returnipAddr;
  96. }
  98. /**
  99. *把int->ip地址
  100. *@paramipInt
  101. *@returnString
  102. */
  103. publicstaticStringintToIp(intipInt){
  104. returnnewStringBuilder().append(((ipInt>>24)&0xff)).append('.')
  105. .append((ipInt>>16)&0xff).append('.').append(
  106. (ipInt>>8)&0xff).append('.').append((ipInt&0xff))
  107. .toString();
  108. }
  110. /**
  111. *把192.168.1.1/24转化为int数组范围
  112. *@paramipAndMask
  113. *@returnint[]
  114. */
  115. publicstaticint[]getIPIntScope(StringipAndMask){
  117. String[]ipArr=ipAndMask.split("/");
  118. if(ipArr.length!=2){
  119. thrownewIllegalArgumentException("invalidipAndMaskwith:"
  120. +ipAndMask);
  121. }
  122. intnetMask=Integer.valueOf(ipArr[1].trim());
  123. if(netMask<0||netMask>31){
  124. thrownewIllegalArgumentException("invalidipAndMaskwith:"
  125. +ipAndMask);
  126. }
  127. intipInt=IPv4Util.ipToInt(ipArr[0]);
  128. intnetIP=ipInt&(0xFFFFFFFF<<(32-netMask));
  129. inthostScope=(0xFFFFFFFF>>>netMask);
  130. returnnewint[]{netIP,netIP+hostScope};
  132. }
  134. /**
  135. *把192.168.1.1/24转化为IP数组范围
  136. *@paramipAndMask
  137. *@returnString[]
  138. */
  139. publicstaticString[]getIPAddrScope(StringipAndMask){
  140. int[]ipIntArr=IPv4Util.getIPIntScope(ipAndMask);
  141. returnnewString[]{IPv4Util.intToIp(ipIntArr[0]),
  142. IPv4Util.intToIp(ipIntArr[0])};
  143. }
  145. /**
  146. *根据IP子网掩码（192.168.1.1255.255.255.0）转化为IP段
  147. *@paramipAddripAddr
  148. *@parammaskmask
  149. *@returnint[]
  150. */
  151. publicstaticint[]getIPIntScope(StringipAddr,Stringmask){
  153. intipInt;
  154. intnetMaskInt=0,ipcount=0;
  155. try{
  156. ipInt=IPv4Util.ipToInt(ipAddr);
  157. if(null==mask||"".equals(mask)){
  158. returnnewint[]{ipInt,ipInt};
  159. }
  160. netMaskInt=IPv4Util.ipToInt(mask);
  161. ipcount=IPv4Util.ipToInt("255.255.255.255")-netMaskInt;
  162. intnetIP=ipInt&netMaskInt;
  163. inthostScope=netIP+ipcount;
  164. returnnewint[]{netIP,hostScope};
  165. }catch(Exceptione){
  166. thrownewIllegalArgumentException("invalidipscopeexpressip:"
  167. +ipAddr+"mask:"+mask);
  168. }
  170. }
  172. /**
  173. *根据IP子网掩码（192.168.1.1255.255.255.0）转化为IP段
  174. *@paramipAddripAddr
  175. *@parammaskmask
  176. *@returnString[]
  177. */
  178. publicstaticString[]getIPStrScope(StringipAddr,Stringmask){
  179. int[]ipIntArr=IPv4Util.getIPIntScope(ipAddr,mask);
  180. returnnewString[]{IPv4Util.intToIp(ipIntArr[0]),
  181. IPv4Util.intToIp(ipIntArr[0])};
  182. }
  184. /**
  185. *@paramargs
  186. *@throwsException
  187. */
  188. publicstaticvoidmain(String[]args)throwsException{
  189. StringipAddr="192.168.8.1";
  191. byte[]bytearr=IPv4Util.ipToBytesByInet(ipAddr);
  193. StringBufferbyteStr=newStringBuffer();
  195. for(byteb:bytearr){
  196. if(byteStr.length()==0){
  197. byteStr.append(b);
  198. }else{
  199. byteStr.append(","+b);
  200. }
  201. }
  202. System.out.println("IP:"+ipAddr+"ByInet-->byte[]:["+byteStr
  203. +"]");
  205. bytearr=IPv4Util.ipToBytesByReg(ipAddr);
  206. byteStr=newStringBuffer();
  208. for(byteb:bytearr){
  209. if(byteStr.length()==0){
  210. byteStr.append(b);
  211. }else{
  212. byteStr.append(","+b);
  213. }
  214. }
  215. System.out.println("IP:"+ipAddr+"ByReg-->byte[]:["+byteStr
  216. +"]");
  218. System.out.println("byte[]:"+byteStr+"-->IP:"
  219. +IPv4Util.bytesToIp(bytearr));
  221. intipInt=IPv4Util.ipToInt(ipAddr);
  223. System.out.println("IP:"+ipAddr+"-->int:"+ipInt);
  225. System.out.println("int:"+ipInt+"-->IP:"
  226. +IPv4Util.intToIp(ipInt));
  228. StringipAndMask="192.168.1.1/24";
  230. int[]ipscope=IPv4Util.getIPIntScope(ipAndMask);
  231. System.out.println(ipAndMask+"-->int地址段：["+ipscope[0]+","
  232. +ipscope[1]+"]");
  234. System.out.println(ipAndMask+"-->IP地址段：["
  235. +IPv4Util.intToIp(ipscope[0])+","
  236. +IPv4Util.intToIp(ipscope[1])+"]");
  238. StringipAddr1="192.168.1.1",ipMask1="255.255.255.0";
  240. int[]ipscope1=IPv4Util.getIPIntScope(ipAddr1,ipMask1);
  241. System.out.println(ipAddr1+","+ipMask1+"-->int地址段：["
  242. +ipscope1[0]+","+ipscope1[1]+"]");
  244. System.out.println(ipAddr1+","+ipMask1+"-->IP地址段：["
  245. +IPv4Util.intToIp(ipscope1[0])+","
  246. +IPv4Util.intToIp(ipscope1[1])+"]");
  248. }
  249. }
package michael.utils;

import java.net.InetAddress;

/**
 * @author michael <br>
 *         blog: http://sjsky.iteye.com <br>
 *         mail: sjsky007@gmail.com
 */
public class IPv4Util {

    private final static int INADDRSZ = 4;

    /**
     * 把IP地址转化为字节数组
     * @param ipAddr
     * @return byte[]
     */
    public static byte[] ipToBytesByInet(String ipAddr) {
        try {
            return InetAddress.getByName(ipAddr).getAddress();
        } catch (Exception e) {
            throw new IllegalArgumentException(ipAddr + " is invalid IP");
        }
    }

    /**
     * 把IP地址转化为int
     * @param ipAddr
     * @return int
     */
    public static byte[] ipToBytesByReg(String ipAddr) {
        byte[] ret = new byte[4];
        try {
            String[] ipArr = ipAddr.split("//.");
            ret[0] = (byte) (Integer.parseInt(ipArr[0]) & 0xFF);
            ret[1] = (byte) (Integer.parseInt(ipArr[1]) & 0xFF);
            ret[2] = (byte) (Integer.parseInt(ipArr[2]) & 0xFF);
            ret[3] = (byte) (Integer.parseInt(ipArr[3]) & 0xFF);
            return ret;
        } catch (Exception e) {
            throw new IllegalArgumentException(ipAddr + " is invalid IP");
        }

    }

    /**
     * 字节数组转化为IP
     * @param bytes
     * @return int
     */
    public static String bytesToIp(byte[] bytes) {
        return new StringBuffer().append(bytes[0] & 0xFF).append('.').append(
                bytes[1] & 0xFF).append('.').append(bytes[2] & 0xFF)
                .append('.').append(bytes[3] & 0xFF).toString();
    }

    /**
     * 根据位运算把 byte[] -> int
     * @param bytes
     * @return int
     */
    public static int bytesToInt(byte[] bytes) {
        int addr = bytes[3] & 0xFF;
        addr |= ((bytes[2] << 8) & 0xFF00);
        addr |= ((bytes[1] << 16) & 0xFF0000);
        addr |= ((bytes[0] << 24) & 0xFF000000);
        return addr;
    }

    /**
     * 把IP地址转化为int
     * @param ipAddr
     * @return int
     */
    public static int ipToInt(String ipAddr) {
        try {
            return bytesToInt(ipToBytesByInet(ipAddr));
        } catch (Exception e) {
            throw new IllegalArgumentException(ipAddr + " is invalid IP");
        }
    }

    /**
     * ipInt -> byte[]
     * @param ipInt
     * @return byte[]
     */
    public static byte[] intToBytes(int ipInt) {
        byte[] ipAddr = new byte[INADDRSZ];
        ipAddr[0] = (byte) ((ipInt >>> 24) & 0xFF);
        ipAddr[1] = (byte) ((ipInt >>> 16) & 0xFF);
        ipAddr[2] = (byte) ((ipInt >>> 8) & 0xFF);
        ipAddr[3] = (byte) (ipInt & 0xFF);
        return ipAddr;
    }

    /**
     * 把int->ip地址
     * @param ipInt
     * @return String
     */
    public static String intToIp(int ipInt) {
        return new StringBuilder().append(((ipInt >> 24) & 0xff)).append('.')
                .append((ipInt >> 16) & 0xff).append('.').append(
                        (ipInt >> 8) & 0xff).append('.').append((ipInt & 0xff))
                .toString();
    }

    /**
     * 把192.168.1.1/24 转化为int数组范围
     * @param ipAndMask
     * @return int[]
     */
    public static int[] getIPIntScope(String ipAndMask) {

        String[] ipArr = ipAndMask.split("/");
        if (ipArr.length != 2) {
            throw new IllegalArgumentException("invalid ipAndMask with: "
                    + ipAndMask);
        }
        int netMask = Integer.valueOf(ipArr[1].trim());
        if (netMask < 0 || netMask > 31) {
            throw new IllegalArgumentException("invalid ipAndMask with: "
                    + ipAndMask);
        }
        int ipInt = IPv4Util.ipToInt(ipArr[0]);
        int netIP = ipInt & (0xFFFFFFFF << (32 - netMask));
        int hostScope = (0xFFFFFFFF >>> netMask);
        return new int[] { netIP, netIP + hostScope };

    }

    /**
     * 把192.168.1.1/24 转化为IP数组范围
     * @param ipAndMask
     * @return String[]
     */
    public static String[] getIPAddrScope(String ipAndMask) {
        int[] ipIntArr = IPv4Util.getIPIntScope(ipAndMask);
        return new String[] { IPv4Util.intToIp(ipIntArr[0]),
                IPv4Util.intToIp(ipIntArr[0]) };
    }

    /**
     * 根据IP 子网掩码（192.168.1.1 255.255.255.0）转化为IP段
     * @param ipAddr ipAddr
     * @param mask mask
     * @return int[]
     */
    public static int[] getIPIntScope(String ipAddr, String mask) {

        int ipInt;
        int netMaskInt = 0, ipcount = 0;
        try {
            ipInt = IPv4Util.ipToInt(ipAddr);
            if (null == mask || "".equals(mask)) {
                return new int[] { ipInt, ipInt };
            }
            netMaskInt = IPv4Util.ipToInt(mask);
            ipcount = IPv4Util.ipToInt("255.255.255.255") - netMaskInt;
            int netIP = ipInt & netMaskInt;
            int hostScope = netIP + ipcount;
            return new int[] { netIP, hostScope };
        } catch (Exception e) {
            throw new IllegalArgumentException("invalid ip scope express  ip:"
                    + ipAddr + "  mask:" + mask);
        }

    }

    /**
     * 根据IP 子网掩码（192.168.1.1 255.255.255.0）转化为IP段
     * @param ipAddr ipAddr
     * @param mask mask
     * @return String[]
     */
    public static String[] getIPStrScope(String ipAddr, String mask) {
        int[] ipIntArr = IPv4Util.getIPIntScope(ipAddr, mask);
        return new String[] { IPv4Util.intToIp(ipIntArr[0]),
                IPv4Util.intToIp(ipIntArr[0]) };
    }

    /**
     * @param args
     * @throws Exception
     */
    public static void main(String[] args) throws Exception {
        String ipAddr = "192.168.8.1";

        byte[] bytearr = IPv4Util.ipToBytesByInet(ipAddr);

        StringBuffer byteStr = new StringBuffer();

        for (byte b : bytearr) {
            if (byteStr.length() == 0) {
                byteStr.append(b);
            } else {
                byteStr.append("," + b);
            }
        }
        System.out.println("IP: " + ipAddr + " ByInet --> byte[]: [ " + byteStr
                + " ]");

        bytearr = IPv4Util.ipToBytesByReg(ipAddr);
        byteStr = new StringBuffer();

        for (byte b : bytearr) {
            if (byteStr.length() == 0) {
                byteStr.append(b);
            } else {
                byteStr.append("," + b);
            }
        }
        System.out.println("IP: " + ipAddr + " ByReg  --> byte[]: [ " + byteStr
                + " ]");

        System.out.println("byte[]: " + byteStr + " --> IP: "
                + IPv4Util.bytesToIp(bytearr));

        int ipInt = IPv4Util.ipToInt(ipAddr);

        System.out.println("IP: " + ipAddr + "  --> int: " + ipInt);

        System.out.println("int: " + ipInt + " --> IP: "
                + IPv4Util.intToIp(ipInt));

        String ipAndMask = "192.168.1.1/24";

        int[] ipscope = IPv4Util.getIPIntScope(ipAndMask);
        System.out.println(ipAndMask + " --> int地址段：[ " + ipscope[0] + ","
                + ipscope[1] + " ]");

        System.out.println(ipAndMask + " --> IP 地址段：[ "
                + IPv4Util.intToIp(ipscope[0]) + ","
                + IPv4Util.intToIp(ipscope[1]) + " ]");

        String ipAddr1 = "192.168.1.1", ipMask1 = "255.255.255.0";

        int[] ipscope1 = IPv4Util.getIPIntScope(ipAddr1, ipMask1);
        System.out.println(ipAddr1 + " , " + ipMask1 + "  --> int地址段 ：[ "
                + ipscope1[0] + "," + ipscope1[1] + " ]");

        System.out.println(ipAddr1 + " , " + ipMask1 + "  --> IP地址段 ：[ "
                + IPv4Util.intToIp(ipscope1[0]) + ","
                + IPv4Util.intToIp(ipscope1[1]) + " ]");

    }
}


测试运行结果：

引用

IP: 192.168.8.1 ByInet --> byte[]: [ -64,-88,8,1 ]
IP: 192.168.8.1 ByReg --> byte[]: [ -64,-88,8,1 ]
byte[]: -64,-88,8,1 --> IP: 192.168.8.1
IP: 192.168.8.1 --> int: -1062729727
int: -1062729727 --> IP: 192.168.8.1
192.168.1.1/24 --> int地址段：[ -1062731520,-1062731265 ]
192.168.1.1/24 --> IP 地址段：[ 192.168.1.0,192.168.1.255 ]
192.168.1.1 , 255.255.255.0 --> int地址段 ：[ -1062731520,-1062731265 ]
192.168.1.1 , 255.255.255.0 --> IP地址段 ：[ 192.168.1.0,192.168.1.255 ]
hepeng_8
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
JAVA中IP和整数相互转化
04-08
JAVA中IP和整数相互转化
java ip 转byte_JAVA中IP和整数相互转化
weixin_29185167的博客
02-16 1188
一、基本知识点IP ——> 整数：?6?1把IP地址转化为字节数组?6?1通过左移位(<整数 ——> IP：?6?1将整数值进行右移位操作(>>>)，右移24位，再进行与操作符(&)0xFF，得到的数字即为第一段IP。?6?1将整数值进行右移位操作(>>>)，右移16位，再进行与操作符(&)0xFF，得到的数字即为第二段...
java ip 转byte_JAVA中IP和整数相互转化的方法
weixin_42280315的博客
02-12 465
本文实例讲述了JAVA中IP和整数相互转化的方法。分享给大家供大家参考。具体分析如下：一、基本知识点IP ——> 整数：把IP地址转化为字节数组通过左移位(<整数 ——> IP：将整数值进行右移位操作(>>>)，右移24位，再进行与操作符(&)0xFF，得到的数字即为第一段IP。将整数值进行右移位操作(>>>)，右移16位，再进行与操作...
JAVA中IP和整数相互转化的方法
09-03
主要介绍了JAVA中IP和整数相互转化的方法,涉及java数值转换的相关技巧,需要的朋友可以参考下
java ip地址段计算
02-15
输入IP地址及掩码（如24），计算出地址范围 1、计算出掩码指定的IP地址个数 2、分割IP地址 3、将10.0.0.0形式的ip地址转换成10进制整数 4、将10进制整数形式转换成127.0.0.1形式的IP地址
java源码包---java 源码 大量 实例
04-18
Java 组播组中发送和接受数据实例 3个目标文件。 Java读写文本文件的示例代码 1个目标文件。 java俄罗斯方块 一个目标文件。 Java非对称加密源码实例 1个目标文件 摘要:Java源码,算法相关,非对称加密 　Java非...
javascript将数字转换整数金额大写的方法
12-09
本文实例讲述了javascript将数字转换整数金额大写的方法。分享给大家供大家参考。具体实现方法如下： 代码如下:function digit_uppercase(n) { var digit = [ ‘零’, ‘壹’, ‘贰’, ‘叁’, ‘肆’, ‘伍’, ...
mybatisPlus使用MetaObjectHandler对字段进行更新
m0_56356631的博客
04-23 737
都是符合我们的预期的。
java方法重写（重点讲），方法重载
最新发布
weixin_46281068的博客
04-27 821
一、方法重载定义：一个类中，出现多个方法的名称相同，但是它们的形参列表是不同的，那么这些方法就称为方法重载了。注意：一个类中，只要一些方法的名称相同、形参列表不同，那么它们就是方法重载了，其它的都不管（如:修饰符，返回值类型是否一样都无所谓）。形参列表不同指的是:形参的个数、类型、顺序不同，不关心形参的名称。应用场景：开发中我们经常需要为处理一类业务，提供多种解决方案，此时用方法重载来设计是很专业的。
string模拟实现
m0_73969414的博客
04-23 1734
c++中string的模拟实现，面试必会知识点
实现自定义注解、实现自定义幂等性注解
qq_44721738的博客
04-23 1009
添加 Spring AOP 依赖。创建自定义注解。创建一个新的 Java 注解类，通过@interface关键字来定义，并可以添加元注解以及属性。@Target(ElementType.METHOD) //表示作用于方法上@Retention(RetentionPolicy.RUNTIME) // 表示这个注解在运行时是可见的，这样 AOP 代理才能在运行时读取到这个注解编写 AOP 拦截（自定义注解）的逻辑代码。@Aspect@Component// 方法执行前的处理。
PageHelper实现分页查询
m0_63849044的博客
04-24 1051
这行代码是在使用 MyBatis Generator (MBG) 或类似的 MyBatis 工具生成的代码来构建查询条件。（可能是MyBatis的Mapper接口）来执行基于前面定义的查询条件的查询，并获取结果列表。实例之后会被用来设置各种查询条件，如字段的等于、不等于、大于、小于、模糊查询等。实体类生成的辅助类，它通常包含了一些静态内部类和方法，用于构建查询条件。在MyBatis中，这样的对象通常用于构建查询条件。对象，可能用于作为查询条件）。的一个内部类，用于定义查询的具体条件。
C语言案例——输出 Fibonacci 数列（斐波那契数列）的前 40 项
悟道子HD
04-25 448
输出 Fibonacci 数列（斐波那契数列）的前 40 项 #include void main() { int a[40]= {1,1}; int i; printf( "%12d%12d",a[0],a[1]); for(i=2; i
MSE实现全链路灰度实践
云计算、数据库、大数据、深度学习、NLP、Python
04-24 321
待更新。
迭代器模式
LuckFairyLuckBaby的博客
04-23 690
迭代器模式(Iterator),提供一种方法顺序访问一个聚合对象中各个元素，而又不暴露该对象的内部表示。
Java的Arrays的基础知识
2301_80142564的博客
04-23 1204
在Java中，Arrays是一个用于操作数组的工具类，它提供了很多静态方法来处理数组，如排序、搜索、比较等。这个类在java.util包中，因此在使用之前需要导入这个包。
ipv4地址转换成整数 java
09-16
在Java中，将IPv4地址转换为整数可以使用以下方法： 1. 将IPv4地址字符串按照 '.' 进行分割，得到四个数字部分。例如，对于ip地址 "192.168.0.1"，将其分割为 "192", "168", "0", "1"。 2. 将每个数字部分转换为...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值