多格式IP解析为单个IP实现方式

由于项目需要，需要设置多格式IP，然后将其分成单个ip缓存起来，下面是实现方式：

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.*;

/**
  * @author: SJT
  * @date: 2019/3/22
  * @desc: 将a：127.0.0.1 b：127.0.0.1,2,3 c：127.0.0.* d：127.0.0.1-10 e：127.0.0.1-127.0.0.3 格式解析为单个ip存到singleAddress集合~.~以供使用
  *
 **/
public class IPSToSingleUtil {
    private static Logger logger = LoggerFactory.getLogger(LoggerFactory.class);
    private static List<String> singleAddress = new ArrayList<>();

    /**
     * @author: SJT
     * @desc: 刷新IP地址列表并返回
     * @date: 2019/3/22
     * @param: [ips]
     * @return: java.util.List<java.lang.String>
     **/
    public static void refreshIps(List<String> ips) {
        parseIps(ips);
    }

    /**
     * @author: SJT
     * @desc: 获取IP地址列表
     * @date: 2019/3/22
     * @param: []
     * @return: java.util.List<java.lang.String>
     **/
    public static List<String> getSingleAddress() {
        return singleAddress;
    }

    /**
     * @author: SJT
     * @desc: 调用此方法将ip解析存入singleAddress
     * @date: 2019/3/22
     * @param: [ips]
     * @return: void
     **/
    private static void parseIps(List<String> ips) {
        singleAddress.clear();
        ips.forEach(ip -> {
            if (ip.contains(",")) {
                parseMulti(ip);
            } else if (ip.contains("*")) {
                parseAsterisk(ip);
            } else if (ip.contains("-")) {
                parseDash(ip);
            } else {
                try {
                    singleAddress.add(ip);
                } catch (Exception e) {
                    logger.error("Parse ip exception", e);
                }
            }
        });
    }

    private static void parseMulti(String ip) {
        try {
            String[] splits = ip.split(",");
            int index = splits[0].lastIndexOf(".");
            String partIp = splits[0].substring(0, index);
            Long longIp = NetUtil.ipv4ToLong(splits[0]);
            singleAddress.add(splits[0]);
            for (int i = 1; i < splits.length; i++) {
                if (isInteger(splits[i])) {
                    singleAddress.add(partIp + "." + splits[i]);
                } else {
                    singleAddress.add(splits[i]);
                }
            }
        } catch (Exception e) {
            logger.error("Parse multi ip exception", e);
            e.printStackTrace();
        }

    }

    /**
     * @author: SJT
     * @desc: 解析：192.168.0.*
     * @date: 2019/3/22
     * @param: [ip]
     * @return: void
     **/
    private static void parseAsterisk(String ip) {
        try {
            String[] splits = ip.split("\\.");
            if (splits.length != 4) {
                return;
            }
            if (splits[0].equals("*") || splits[1].equals("*") || splits[2].equals("*")) {
                return;
            }
            String part = splits[0] + "." + splits[1] + "." + splits[2] + ".";
            for(int i=0;i<256;i++){
                singleAddress.add(part + i);
            }
        } catch (Exception e) {
            logger.error("Parse asterisk ip exception", e);
        }

    }

    /**
     * @author: SJT
     * @desc: 解析：192.168.0.0-100
     * @date: 2019/3/22
     * @param: [ip]
     * @return: void
     **/
    private static void parseDash(String ip) {
        try {
            String[] splits = ip.split("-");
            if (splits.length != 2) {
                return;
            }
            if (isInteger(splits[1])) {
                int index = splits[0].lastIndexOf(".");
                String partIp = splits[0].substring(0, index);
                Integer init = Integer.valueOf(splits[0].split("\\.")[3]);
                Integer end = Integer.valueOf(splits[1]);
                if(init > end){
                    int a = end;
                    end = init;
                    init = a;
                }
                for (int i=init;i<end+1;i++){
                    singleAddress.add(partIp + "." + i);
                }
            } else {
                delWith(splits[0],splits[1]);
            }

        } catch (Exception e) {
            logger.error("Parse dash ip exception", e);
        }
    }
    /**
     * @author: SJT
     * @desc: 解析：192.168.1.1-192.168.1.100
     * @date: 2019/3/22
     * @param: [ipStart, ipEnd]
     * @return: void
     **/
    private static void delWith(String ipStart,String ipEnd){
        if (isNullOrEmpty(ipStart) || isNullOrEmpty(ipEnd)) {
            return;
        }
        if (isNotIPv4(ipStart) || isNotIPv4(ipEnd)) {
            return;
        }
        long startIPValue, endIPValue;
        try {
            startIPValue = ipToLong(ipStart);
            endIPValue = ipToLong(ipEnd);
        } catch (Exception e) {
            logger.error("ip地址转整形出错, ipStart={}, ipEnd={}", ipStart, ipEnd, e);
            return;
        }
        if (startIPValue >= endIPValue) {
            return;
        }
        for (long i=startIPValue; i<=endIPValue; i++) {
            singleAddress.add(longToIP(i));
        }
    }

    private static boolean isNullOrEmpty(String str) {
        return str == null || "".equals(str);
    }

    private static String longToIP(long longIp) {
        StringBuffer sb = new StringBuffer("");
        // 直接右移24位
        sb.append(String.valueOf((longIp >>> 24)));
        sb.append(".");
        // 将高8位置0，然后右移16位
        sb.append(String.valueOf((longIp & 0x00FFFFFF) >>> 16));
        sb.append(".");
        // 将高16位置0，然后右移8位
        sb.append(String.valueOf((longIp & 0x0000FFFF) >>> 8));
        sb.append(".");
        // 将高24位置0
        sb.append(String.valueOf((longIp & 0x000000FF)));
        return sb.toString();
    }

    private static long ipToLong(String strIp) {
        long[] ip = new long[4];
        // 先找到IP地址字符串中.的位置
        int position1 = strIp.indexOf(".");
        int position2 = strIp.indexOf(".", position1 + 1);
        int position3 = strIp.indexOf(".", position2 + 1);
        // 将每个.之间的字符串转换成整型
        ip[0] = Long.parseLong(strIp.substring(0, position1));
        ip[1] = Long.parseLong(strIp.substring(position1 + 1, position2));
        ip[2] = Long.parseLong(strIp.substring(position2 + 1, position3));
        ip[3] = Long.parseLong(strIp.substring(position3 + 1));
        return (ip[0] << 24) + (ip[1] << 16) + (ip[2] << 8) + ip[3];
    }

    public static boolean isNotIPv4(String ip) {
        try {
            String[] ipsubs = ip.split("\\.");
            if (ipsubs.length != 4) {
                return true;
            }
            for (String ipsub : ipsubs) {
                if("*".equals(ipsubs[3]) && ipsub.equals(ipsubs[3])){
                    return false;
                }
                if (Integer.parseInt(ipsub) > 255
                        || Integer.parseInt(ipsub) < 0)
                    return true;
            }
        } catch (Exception e) {
            return true;
        }
        return false;
    }


    private static boolean isInteger(String s) {
        try {
            Integer.parseInt(s);
        } catch (NumberFormatException e) {
            return false;
        }
        return true;
    }

    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("127.0.0.1");
        list.add("182.1.12.1,2,3,4");
        list.add("199.1.1.*");
        list.add("200.1.1.1-10");
        list.add("201.1.2.1-201.1.2.10");
        refreshIps(list);
        List<String> aa = getSingleAddress();
        System.out.println(aa);
    }

}

ok，这样既可~.~