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

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

IP ——> 整数：

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

整数 ——> IP：

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

二、java代码示例

IPv4Util.java

packagemichael.utils;

importjava.net.InetAddress;

/**
*@authormichael<br>
*blog:http://sjsky.iteye.com<br>
*mail:[e-mail]
*/
publicclassIPv4Util{

privatefinalstaticintINADDRSZ=4;

/**
*把IP地址转化为字节数组
*@paramipAddr
*@returnbyte[]
*/
publicstaticbyte[]ipToBytesByInet(StringipAddr){
try{
returnInetAddress.getByName(ipAddr).getAddress();
}catch(Exceptione){
thrownewIllegalArgumentException(ipAddr+"isinvalidIP");
}
}

/**
*把IP地址转化为int
*@paramipAddr
*@returnint
*/
publicstaticbyte[]ipToBytesByReg(StringipAddr){
byte[]ret=newbyte[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);
returnret;
}catch(Exceptione){
thrownewIllegalArgumentException(ipAddr+"isinvalidIP");
}

}

/**
*字节数组转化为IP
*@parambytes
*@returnint
*/
publicstaticStringbytesToIp(byte[]bytes){
returnnewStringBuffer().append(bytes[0]&0xFF).append('.').append(
bytes[1]&0xFF).append('.').append(bytes[2]&0xFF)
.append('.').append(bytes[3]&0xFF).toString();
}

/**
*根据位运算把byte[]->int
*@parambytes
*@returnint
*/
publicstaticintbytesToInt(byte[]bytes){
intaddr=bytes[3]&0xFF;
addr|=((bytes[2]<<8)&0xFF00);
addr|=((bytes[1]<<16)&0xFF0000);
addr|=((bytes[0]<<24)&0xFF000000);
returnaddr;
}

/**
*把IP地址转化为int
*@paramipAddr
*@returnint
*/
publicstaticintipToInt(StringipAddr){
try{
returnbytesToInt(ipToBytesByInet(ipAddr));
}catch(Exceptione){
thrownewIllegalArgumentException(ipAddr+"isinvalidIP");
}
}

/**
*ipInt->byte[]
*@paramipInt
*@returnbyte[]
*/
publicstaticbyte[]intToBytes(intipInt){
byte[]ipAddr=newbyte[INADDRSZ];
ipAddr[0]=(byte)((ipInt>>>24)&0xFF);
ipAddr[1]=(byte)((ipInt>>>16)&0xFF);
ipAddr[2]=(byte)((ipInt>>>8)&0xFF);
ipAddr[3]=(byte)(ipInt&0xFF);
returnipAddr;
}

/**
*把int->ip地址
*@paramipInt
*@returnString
*/
publicstaticStringintToIp(intipInt){
returnnewStringBuilder().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数组范围
*@paramipAndMask
*@returnint[]
*/
publicstaticint[]getIPIntScope(StringipAndMask){

String[]ipArr=ipAndMask.split("/");
if(ipArr.length!=2){
thrownewIllegalArgumentException("invalidipAndMaskwith:"
+ipAndMask);
}
intnetMask=Integer.valueOf(ipArr[1].trim());
if(netMask<0||netMask>31){
thrownewIllegalArgumentException("invalidipAndMaskwith:"
+ipAndMask);
}
intipInt=IPv4Util.ipToInt(ipArr[0]);
intnetIP=ipInt&(0xFFFFFFFF<<(32-netMask));
inthostScope=(0xFFFFFFFF>>>netMask);
returnnewint[]{netIP,netIP+hostScope};

}

/**
*把192.168.1.1/24转化为IP数组范围
*@paramipAndMask
*@returnString[]
*/
publicstaticString[]getIPAddrScope(StringipAndMask){
int[]ipIntArr=IPv4Util.getIPIntScope(ipAndMask);
returnnewString[]{IPv4Util.intToIp(ipIntArr[0]),
IPv4Util.intToIp(ipIntArr[0])};
}

/**
*根据IP子网掩码（192.168.1.1255.255.255.0）转化为IP段
*@paramipAddripAddr
*@parammaskmask
*@returnint[]
*/
publicstaticint[]getIPIntScope(StringipAddr,Stringmask){

intipInt;
intnetMaskInt=0,ipcount=0;
try{
ipInt=IPv4Util.ipToInt(ipAddr);
if(null==mask||"".equals(mask)){
returnnewint[]{ipInt,ipInt};
}
netMaskInt=IPv4Util.ipToInt(mask);
ipcount=IPv4Util.ipToInt("255.255.255.255")-netMaskInt;
intnetIP=ipInt&netMaskInt;
inthostScope=netIP+ipcount;
returnnewint[]{netIP,hostScope};
}catch(Exceptione){
thrownewIllegalArgumentException("invalidipscopeexpressip:"
+ipAddr+"mask:"+mask);
}

}

/**
*根据IP子网掩码（192.168.1.1255.255.255.0）转化为IP段
*@paramipAddripAddr
*@parammaskmask
*@returnString[]
*/
publicstaticString[]getIPStrScope(StringipAddr,Stringmask){
int[]ipIntArr=IPv4Util.getIPIntScope(ipAddr,mask);
returnnewString[]{IPv4Util.intToIp(ipIntArr[0]),
IPv4Util.intToIp(ipIntArr[0])};
}

/**
*@paramargs
*@throwsException
*/
publicstaticvoidmain(String[]args)throwsException{
StringipAddr="192.168.8.1";

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

StringBufferbyteStr=newStringBuffer();

for(byteb: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=newStringBuffer();

for(byteb: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));

intipInt=IPv4Util.ipToInt(ipAddr);

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

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

StringipAndMask="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])+"]");

StringipAddr1="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])+"]");

}
}

package michael.utils;

import java.net.InetAddress;

/**
 * @author michael <br>
 *         blog: http://sjsky.iteye.com <br>
 *         mail: [e-mail]
 */
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 ]