IP地址工具，判断IP是否在指定范围内(支持ipv6)

常用方法，判断一个ip是否在指定的ip范围内，范围可能包括起始ip范围或者掩码形式，无其它依赖，
java 复制代码
package com.yk.ip;

import java.math.BigInteger;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.List;

public class IpUtil {

    /**
     * 判断目标ip是否在ip范围内(起始ip范围),支持ipv6
     * @param ipAddress 目标ip
     * @param startIp 开始ip
     * @param endIp 结束ip
     * @return boolean
     * @throws UnknownHostException 异常
     */
    public static boolean isInRange(String ipAddress,String startIp,String endIp) throws UnknownHostException {
        InetAddress address = InetAddress.getByName(ipAddress);
        InetAddress startAddress = InetAddress.getByName(startIp);
        InetAddress endAddress = InetAddress.getByName(endIp);
        BigInteger start = new BigInteger(1, startAddress.getAddress());
        BigInteger end = new BigInteger(1, endAddress.getAddress());
        BigInteger target = new BigInteger(1, address.getAddress());
        int st = start.compareTo(target);
        int te = target.compareTo(end);
        return (st <= 0) && (te <= 0);
    }

    /**
     * 判断目标ip是否在ip范围内(掩码),支持ipv6
     * @param ipAddress 目标ip
     * @param ipWithMask 带掩码ip
     * @return boolean
     * @throws UnknownHostException 异常
     */
    public static boolean isInRange(String ipAddress,String ipWithMask) throws UnknownHostException {
        if (ipWithMask.contains("/")) {
            String addressPart = ipWithMask.substring(0, ipWithMask.indexOf("/"));
            String networkPart = ipWithMask.substring(ipWithMask.indexOf("/") + 1);
            ByteBuffer maskBuffer;
            int targetSize;
            InetAddress inetAddress = InetAddress.getByName(addressPart);
            if (inetAddress.getAddress().length == 4) {
                maskBuffer = ByteBuffer
                                .allocate(4)
                                .putInt(-1);
                targetSize = 4;
            } else {
                maskBuffer = ByteBuffer.allocate(16)
                        .putLong(-1L)
                        .putLong(-1L);
                targetSize = 16;
            }
            BigInteger mask = (new BigInteger(1, maskBuffer.array())).not().shiftRight(Integer.parseInt(networkPart));

            ByteBuffer buffer = ByteBuffer.wrap(inetAddress.getAddress());
            BigInteger ipVal = new BigInteger(1, buffer.array());

            BigInteger startIp = ipVal.and(mask);
            BigInteger endIp = startIp.add(mask.not());

            byte[] startIpArr = toBytes(startIp.toByteArray(), targetSize);
            byte[] endIpArr = toBytes(endIp.toByteArray(), targetSize);

            InetAddress startAddress = InetAddress.getByAddress(startIpArr);
            InetAddress endAddress = InetAddress.getByAddress(endIpArr);
            return isInRange(ipAddress, startAddress.getHostAddress(), endAddress.getHostAddress());
        } else {
            throw new IllegalArgumentException("not an valid CIDR format!");
        }
    }

    private static byte[] toBytes(byte[] array, int targetSize) {
        int counter = 0;
        List<Byte> newArr = new ArrayList<Byte>();
        while (counter < targetSize && (array.length - 1 - counter >= 0)) {
            newArr.add(0, array[array.length - 1 - counter]);
            counter++;
        }

        int size = newArr.size();
        for (int i = 0; i < (targetSize - size); i++) {

            newArr.add(0, (byte) 0);
        }

        byte[] ret = new byte[newArr.size()];
        for (int i = 0; i < newArr.size(); i++) {
            ret[i] = newArr.get(i);
        }
        return ret;
    }
}