常用工具类合集-持续完善

 

常用工具类-持续完善

1.Map工具类  模糊匹配key

import org.apache.commons.collections.MapUtils;

import java.util.Map;
import java.util.Optional;
import java.util.stream.Collectors;

/**
 * map工具类
 */
public class BusMapUtils {
    /**
     * 从map中查询想要的map项，根据模糊key
     */
    public static Map<String, Object> parseMapForFilter(Map<String, Object> map, String filters) {
        if (map == null) {
            return null;
        } else {
            map = map.entrySet().stream()
                    .filter((e) -> checkKey(e.getKey(),filters))
                    .collect(Collectors.toMap(
                            (e) -> (String) e.getKey(),
                            (e) -> e.getValue()
                    ));
        }
        return map;
    }

    /**
     * 从map中查询想要的map项，根据模糊key
     */
    public static String mapFilterFindFirstValue(Map<String, String> map, String filters) {
        if (map == null) {
            return null;
        } else {
            Optional<Map.Entry<String, String>> first = map.entrySet().stream()
                    .filter((e) -> checkKey(e.getKey(), filters) && null != e.getValue())
                    .collect(Collectors.toMap(
                            (e) -> e.getKey(),
                            (e) -> String.valueOf(e.getValue())
                    )).entrySet().stream().findFirst();
            if (first.isPresent()) {
                return String.valueOf(first.get().getValue());
            }else{
                return "";
            }
        }
    }

    /**
     * 通过indexof匹配想要查询的字符
     */
    private static boolean checkKey(String key,String filters) {
        if (key.indexOf(filters)>-1){
            return true;
        }else {
            return false;
        }
    }
}

2.压缩GZip工具类

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.util.zip.GZIPInputStream;
import java.util.zip.GZIPOutputStream;

import org.apache.commons.codec.binary.StringUtils;


    public class GzipUtil {

        public static final String GZIP_ENCODE_UTF_8 = "UTF-8";

        public static final String GZIP_ENCODE_ISO_8859_1 = "ISO-8859-1";

        /**
         * 字符串压缩为GZIP字节数组
         *
         * @param str
         * @return
         */
        public static byte[] compress(String str) {
            return compress(str, GZIP_ENCODE_UTF_8);
        }

        /**
         * 字符串压缩为GZIP字节数组
         *
         * @param str
         * @param encoding
         * @return
         */
        public static byte[] compress(String str, String encoding) {
            if (str == null || str.length() == 0) {
                return null;
            }
            ByteArrayOutputStream out = new ByteArrayOutputStream();
            GZIPOutputStream gzip;
            try {
                gzip = new GZIPOutputStream(out);
                gzip.write(str.getBytes(encoding));
                gzip.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return out.toByteArray();
        }

        /**
         * GZIP解压缩
         *
         * @param bytes
         * @return
         */
        public static byte[] uncompress(byte[] bytes) {
            if (bytes == null || bytes.length == 0) {
                return null;
            }
            ByteArrayOutputStream out = new ByteArrayOutputStream();
            ByteArrayInputStream in = new ByteArrayInputStream(bytes);
            try {
                GZIPInputStream ungzip = new GZIPInputStream(in);
                byte[] buffer = new byte[256];
                int n;
                while ((n = ungzip.read(buffer)) >= 0) {
                    out.write(buffer, 0, n);
                }
            } catch (IOException e) {
                e.printStackTrace();
            }

            return out.toByteArray();
        }

        /**
         *
         * @param bytes
         * @return
         */
        public static String uncompressToString(byte[] bytes) {
            return uncompressToString(bytes, GZIP_ENCODE_UTF_8);
        }

        /**
         *
         * @param bytes
         * @param encoding
         * @return
         */
        public static String uncompressToString(byte[] bytes, String encoding) {
            if (bytes == null || bytes.length == 0) {
                return null;
            }
            ByteArrayOutputStream out = new ByteArrayOutputStream();
            ByteArrayInputStream in = new ByteArrayInputStream(bytes);
            try {
                GZIPInputStream ungzip = new GZIPInputStream(in);
                byte[] buffer = new byte[256];
                int n;
                while ((n = ungzip.read(buffer)) >= 0) {
                    out.write(buffer, 0, n);
                }
                return out.toString(encoding);
            } catch (IOException e) {
                e.printStackTrace();
            }
            return null;
        }

        public static String compress2(String str) {
            if (str == null || str.length() == 0) {
                return str;
            }
            ByteArrayOutputStream out = new ByteArrayOutputStream();
            GZIPOutputStream gzip = null;
            try {
                gzip = new GZIPOutputStream(out);
                gzip.write(str.getBytes());
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if (gzip != null) {
                    try {
                        gzip.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }//加入Java开发交流君样：756584822一起吹水聊天
                }
            }
            return new sun.misc.BASE64Encoder().encode(out.toByteArray());
        }

        /**
         * 使用gzip解压缩
         * @param compressedStr 压缩字符串
         * @return
         */
        public static byte[] uncompress2(String compressedStr) {
            if (compressedStr == null) {
                return null;
            }

            ByteArrayOutputStream out = new ByteArrayOutputStream();
            ByteArrayInputStream in = null;
            GZIPInputStream ginzip = null;
            byte[] compressed = null;
            String decompressed = null;

            byte[] zbytes = null;
            try {
                compressed = new sun.misc.BASE64Decoder().decodeBuffer(compressedStr);
                in = new ByteArrayInputStream(compressed);
                ginzip = new GZIPInputStream(in);
                byte[] buffer = new byte[1024];
                int offset = -1;
                while ((offset = ginzip.read(buffer)) != -1) {
                    out.write(buffer, 0, offset);
                }
                zbytes = out.toByteArray();
                //decompressed = out.toString();
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if (ginzip != null) {
                    try {
                        ginzip.close();
                    } catch (IOException e) {
                    }//加入Java开发交流君样：756584822一起吹水聊天
                }
                if (in != null) {
                    try {
                        in.close();
                    } catch (IOException e) {
                    }
                }
                if (out != null) {
                    try {
                        out.close();
                    } catch (IOException e) {
                    }
                }
            }
            return zbytes;
        }


        public static void main2(String[] args) {
            String str ="{\n" +
                    "\t\"url\": \"/auth/crec/code\",\n" +
                    "\t\"srcIp\": \"10.81.107.84\",\n" +
                    "\t\"srcPort\": \"58457\",\n" +
                    "\t\"dstIp\": \"10.2.244.219\",\n" +
                    "\t\"dstPort\": \"80\"}";
            System.out.println("原长度：" + str.length());
            System.out.println("压缩后字符串长度：" + GzipUtil.compress(str).toString().length());
            //System.out.println("解压缩后字符串：" + StringUtils.newStringUtf8(GzipUtil.uncompress(GzipUtil.compress(str))));
            System.out.println("压缩后字符串："+GzipUtil.compress(str).toString());
            System.out.println("解压缩后字符串：" + GzipUtil.uncompressToString(GzipUtil.compress(str)));
        }

        public static void main(String[] args) {
            String ss = "asdfzxcv";
            System.out.println(ss.indexOf("asd"));
            System.out.println(ss.indexOf("zxc"));
            System.out.println(ss.indexOf("gggggggg"));
        }
    }

3.EncodeUtil

import org.apache.commons.codec.DecoderException;
import org.apache.commons.codec.binary.Base64;
import org.apache.commons.codec.binary.Hex;
import org.apache.commons.lang3.StringEscapeUtils;

import java.net.URLDecoder;
import java.net.URLEncoder;

public class EncodeUtil {
    private static final String DEFAULT_URL_ENCODING = "UTF-8";
    private static final char[] BASE62 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz".toCharArray();

    /**
     * Hex编码.
     */
    public static String encodeHex(byte[] input) {
        return new String(Hex.encodeHex(input));
    }

    /**
     * Hex解码.
     */
    public static byte[] decodeHex(String input) {
        try {
            return Hex.decodeHex(input.toCharArray());
        } catch (DecoderException e) {
            return null;
        }
    }

    /**
     * Base64编码.
     */
    public static String encodeBase64(byte[] input) {
        return new String(Base64.encodeBase64(input));
    }

    /**
     * Base64编码.
     */
    public static String encodeBase64(String input) {
        try {
            return new String(Base64.encodeBase64(input.getBytes(DEFAULT_URL_ENCODING)));
        } catch (Exception e) {
            return "";
        }
    }

//    /**
//     * Base64编码, URL安全(将Base64中的URL非法字符'+'和'/'转为'-'和'_', 见RFC3548).
//     */
//    public static String encodeUrlSafeBase64(byte[] input) {
//        return Base64.encodeBase64URLSafe(input);
//    }

    /**
     * Base64解码.
     */
    public static byte[] decodeBase64(String input) {
        return Base64.decodeBase64(input.getBytes());
    }

    /**
     * Base64解码.
     */
    public static String decodeBase64String(String input) {
        try {
            return new String(Base64.decodeBase64(input.getBytes()), DEFAULT_URL_ENCODING);
        } catch (Exception e) {
            return "";
        }
    }

    /**
     * Base62编码。
     */
    public static String encodeBase62(byte[] input) {
        char[] chars = new char[input.length];
        for (int i = 0; i < input.length; i++) {
            chars[i] = BASE62[((input[i] & 0xFF) % BASE62.length)];
        }
        return new String(chars);
    }

    /**
     * Html 转码.
     */
    public static String escapeHtml(String html) {
        return StringEscapeUtils.escapeHtml4(html);
    }

    /**
     * Html 解码.
     */
    public static String unescapeHtml(String htmlEscaped) {
        return StringEscapeUtils.unescapeHtml4(htmlEscaped);
    }

    /**
     * Xml 转码.
     */
    public static String escapeXml(String xml) {
        return StringEscapeUtils.escapeXml(xml);
    }

    /**
     * Xml 解码.
     */
    public static String unescapeXml(String xmlEscaped) {
        return StringEscapeUtils.unescapeXml(xmlEscaped);
    }

    /**
     * URL 编码, Encode默认为UTF-8.
     */
    public static String urlEncode(String part) {
        try {
            return URLEncoder.encode(part, DEFAULT_URL_ENCODING);
        } catch (Exception e) {
            return  "";
        }
    }

    /**
     * URL 解码, Encode默认为UTF-8.
     */
    public static String urlDecode(String part) {
        try {
            return URLDecoder.decode(part, DEFAULT_URL_ENCODING);
        } catch (Exception e) {
            return  "";
        }
    }

    public static void main(String[] args) {
        String ss = " headerShow=false; service-mall-accesstoken=!TLZayV-T-i4R-oMhJPqn9SAN3fV8PS-WkIVu2qs_L4j_1dl8oskJtMT5yfUK0sHzXHTj_9Ng97enwdedYDOWcpfynReWC4jfSNuTcj5jDWlfc159xrdDtduxKoXJrFeZyCpZyT5F254oXjLGiV-2VIfg%3D%3D; service-mall-refreshtoken=303e86979bbb42c0a0780817425bfcdf; service-mall-userInfo=%7B%22psnId%22%3A%2232%22%2C%22name%22%3A%22%E5%AE%8B%E6%99%A8%E9%98%B3%22%2C%22tel%22%3Anull%2C%22mobile%22%3A%2218634690452%22%2C%22certType%22%3A%2201%22%2C%22certNo%22%3A%22142723199703013010%22%2C%22gend%22%3Anull%2C%22email%22%3Anull%2C%22naty%22%3Anull%2C%22resdAddr%22%3Anull%2C%22brdy%22%3Anull%2C%22crtfState%22%3A%222%22%2C%22crter%22%3Anull%2C%22crterName%22%3Anull%2C%22crteTime%22%3A1618991825000%2C%22crteIns%22%3Anull%2C%22opter%22%3Anull%2C%22opterName%22%3Anull%2C%22optTime%22%3Anull%2C%22optins%22%3Anull%2C%22poolarea%22%3Anull%2C%22dscr%22%3Anull%2C%22authCode%22%3A%22%22%2C%22cretAuth%22%3Afalse%2C%22type%22%3A%22person%22%2C%22loginTel%22%3A%2218634690452%22%2C%22prof%22%3A%7B%22certno%22%3Anull%2C%22psnCertType%22%3Anull%2C%22profNo%22%3A%2214000000000000006006%22%2C%22psnNo%22%3A%2214000000000000000000022030%22%2C%22profName%22%3A%22%E5%AE%8B%E6%99%A8%E9%98%B3%22%2C%22offTel%22%3A%220359-1111111%22%2C%22gend%22%3A%221%22%2C%22currDuty%22%3A%22%E6%B5%8B%E8%AF%95%22%2C%22profType%22%3A%221%22%2C%22dept%22%3Anull%2C%22profDoma%22%3A%2211%22%2C%22profarea%22%3A%2211%22%2C%22proTechProfttl%22%3A%22410%22%2C%22uscc%22%3Anull%2C%22empName%22%3Anull%2C%22profttlJobBegntime%22%3Anull%2C%22itro%22%3Anull%2C%22empAddr%22%3Anull%2C%22begntime%22%3A%222021-04-29%22%2C%22endtime%22%3Anull%2C%22valiFlag%22%3A%221%22%2C%22admdvs%22%3A%22140000%22%2C%22empprofFileAddr%22%3Anull%2C%22mob%22%3A%2218634690452%22%2C%22email%22%3A%22scyzry%40126.com%22%2C%22poscode%22%3A%22000000%22%2C%22dclaWay%22%3Anull%2C%22rid%22%3A%22140000202104291043193200009078%22%2C%22crteTime%22%3A%222021-04-29%22%2C%22updtTime%22%3A%222021-04-29%22%2C%22crter%22%3Anull%2C%22crterName%22%3A%22%E5%AE%8B%E6%99%A8%E9%98%B3%22%2C%22crteOptins%22%3Anull%2C%22opter%22%3Anull%2C%22opterName%22%3A%22%E5%AE%8B%E6%99%A8%E9%98%B3%22%2C%22optTime%22%3A%222021-04-29%22%2C%22optins%22%3Anull%2C%22ver%22%3A%221.0%22%2C%22radioId%22%3A0%7D%7D; headerStatus=0; SESSION_FLAG=1";
        System.out.println(urlDecode(ss));
    }
}

4.身份证工具类

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;

/**
 * 〈一句话功能简述〉<br>
 * 〈〉
 *
 * @author Admin
 * @create 2019/10/14
 * @since 1.0.0
 */
public class IdentityDocumentUtil {

    /** 中国公民身份证号码最小长度。 */
    private static final int CHINA_ID_MIN_LENGTH = 15;

    /** 中国公民身份证号码最大长度。 */
    private static final int CHINA_ID_MAX_LENGTH = 18;

    /** 省、直辖市代码表 */
    private static final String cityCode[] = {
            "11", "12", "13", "14", "15", "21", "22", "23", "31", "32", "33", "34", "35", "36", "37", "41",
            "42", "43", "44", "45", "46", "50", "51", "52", "53", "54", "61", "62", "63", "64", "65", "71",
            "81", "82", "91"
    };

    /** 每位加权因子 */
    private static final int power[] = {
            7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 2
    };

    /** 第18位校检码 */
    private static final String verifyCode[] = {
            "1", "0", "X", "9", "8", "7", "6", "5", "4", "3", "2"
    };
    /** 最低年限 */
    private static final int MIN = 1930;
    private static Map<String, String> cityCodes = new HashMap<String, String>();
    /** 台湾身份首字母对应数字 */
    private static Map<String, Integer> twFirstCode = new HashMap<String, Integer>();
    /** 香港身份首字母对应数字 */
    private static Map<String, Integer> hkFirstCode = new HashMap<String, Integer>();
    static {
        cityCodes.put("11", "北京");
        cityCodes.put("12", "天津");
        cityCodes.put("13", "河北");
        cityCodes.put("14", "山西");
        cityCodes.put("15", "内蒙古");
        cityCodes.put("21", "辽宁");
        cityCodes.put("22", "吉林");
        cityCodes.put("23", "黑龙江");
        cityCodes.put("31", "上海");
        cityCodes.put("32", "江苏");
        cityCodes.put("33", "浙江");
        cityCodes.put("34", "安徽");
        cityCodes.put("35", "福建");
        cityCodes.put("36", "江西");
        cityCodes.put("37", "山东");
        cityCodes.put("41", "河南");
        cityCodes.put("42", "湖北");
        cityCodes.put("43", "湖南");
        cityCodes.put("44", "广东");
        cityCodes.put("45", "广西");
        cityCodes.put("46", "海南");
        cityCodes.put("50", "重庆");
        cityCodes.put("51", "四川");
        cityCodes.put("52", "贵州");
        cityCodes.put("53", "云南");
        cityCodes.put("54", "西藏");
        cityCodes.put("61", "陕西");
        cityCodes.put("62", "甘肃");
        cityCodes.put("63", "青海");
        cityCodes.put("64", "宁夏");
        cityCodes.put("65", "新疆");
        cityCodes.put("71", "台湾");
        cityCodes.put("81", "香港");
        cityCodes.put("82", "澳门");
        cityCodes.put("91", "国外");
        twFirstCode.put("A", 10);
        twFirstCode.put("B", 11);
        twFirstCode.put("C", 12);
        twFirstCode.put("D", 13);
        twFirstCode.put("E", 14);
        twFirstCode.put("F", 15);
        twFirstCode.put("G", 16);
        twFirstCode.put("H", 17);
        twFirstCode.put("J", 18);
        twFirstCode.put("K", 19);
        twFirstCode.put("L", 20);
        twFirstCode.put("M", 21);
        twFirstCode.put("N", 22);
        twFirstCode.put("P", 23);
        twFirstCode.put("Q", 24);
        twFirstCode.put("R", 25);
        twFirstCode.put("S", 26);
        twFirstCode.put("T", 27);
        twFirstCode.put("U", 28);
        twFirstCode.put("V", 29);
        twFirstCode.put("X", 30);
        twFirstCode.put("Y", 31);
        twFirstCode.put("W", 32);
        twFirstCode.put("Z", 33);
        twFirstCode.put("I", 34);
        twFirstCode.put("O", 35);
        hkFirstCode.put("A", 1);
        hkFirstCode.put("B", 2);
        hkFirstCode.put("C", 3);
        hkFirstCode.put("R", 18);
        hkFirstCode.put("U", 21);
        hkFirstCode.put("Z", 26);
        hkFirstCode.put("X", 24);
        hkFirstCode.put("W", 23);
        hkFirstCode.put("O", 15);
        hkFirstCode.put("N", 14);
    }

    /**
     * 验证身份证是否合法
     */
    public static boolean validateCard(String idCard) {
        String card = idCard.trim();
        if (validateIdCard18(card)) {
            return true;
        }
        if (validateIdCard15(card)) {
            return true;
        }
        String[] cardval = validateIdCard10(card);
        if (cardval != null) {
            if (cardval[2].equals("true")) {
                return true;
            }
        }
        return false;
    }


    /**
     * 根据身份编号获取年龄
     * @param idCard 身份编号
     * @return 年龄
     */
    public static int getAgeByIdCard(String idCard) {
        int iAge = 0;
        if (idCard.length() == CHINA_ID_MIN_LENGTH) {
            idCard = conver15CardTo18(idCard);
        }
        String year = idCard.substring(6, 10);
        Calendar cal = Calendar.getInstance();
        int iCurrYear = cal.get(Calendar.YEAR);
        iAge = iCurrYear - Integer.valueOf(year);
        return iAge;
    }

    /**
     * 根据身份编号获取生日
     * @param idCard 身份编号
     * @return 生日(yyyyMMdd)
     */
    public static String getBirthByIdCard(String idCard) {
        Integer len = idCard.length();
        if (len < CHINA_ID_MIN_LENGTH) {
            return null;
        } else if (len == CHINA_ID_MIN_LENGTH) {
            idCard = conver15CardTo18(idCard);
        }
        return idCard.substring(6, 14);
    }

    /**
     * 根据身份编号获取生日年
     * @param idCard 身份编号
     * @return 生日(yyyy)
     */
    public static Short getYearByIdCard(String idCard) {
        Integer len = idCard.length();
        if (len < CHINA_ID_MIN_LENGTH) {
            return null;
        } else if (len == CHINA_ID_MIN_LENGTH) {
            idCard = conver15CardTo18(idCard);
        }
        return Short.valueOf(idCard.substring(6, 10));
    }

    /**
     * 根据身份编号获取生日月
     * @param idCard 身份编号
     * @return 生日(MM)
     */
    public static Short getMonthByIdCard(String idCard) {
        Integer len = idCard.length();
        if (len < CHINA_ID_MIN_LENGTH) {
            return null;
        } else if (len == CHINA_ID_MIN_LENGTH) {
            idCard = conver15CardTo18(idCard);
        }
        return Short.valueOf(idCard.substring(10, 12));
    }

    /**
     * 根据身份编号获取生日天
     * @param idCard 身份编号
     * @return 生日(dd)
     */
    public static Short getDateByIdCard(String idCard) {
        Integer len = idCard.length();
        if (len < CHINA_ID_MIN_LENGTH) {
            return null;
        } else if (len == CHINA_ID_MIN_LENGTH) {
            idCard = conver15CardTo18(idCard);
        }
        return Short.valueOf(idCard.substring(12, 14));
    }

    /**
     * 根据身份编号获取性别
     * @param idCard 身份编号
     * @return 性别(M-男，F-女，N-未知)
     */
    public static String getGenderByIdCard(String idCard) {
        String sGender = "N";
        if (idCard.length() == CHINA_ID_MIN_LENGTH) {
            idCard = conver15CardTo18(idCard);
        }
        String sCardNum = idCard.substring(16, 17);
        if (Integer.parseInt(sCardNum) % 2 != 0) {
            sGender = "M";
        } else {
            sGender = "F";
        }
        return sGender;
    }

    /**
     * 根据身份编号获取户籍省份
     * @param idCard 身份编码
     * @return 省级编码。
     */
    public static String getProvinceByIdCard(String idCard) {
        int len = idCard.length();
        String sProvince = null;
        String sProvinNum = "";
        if (len == CHINA_ID_MIN_LENGTH || len == CHINA_ID_MAX_LENGTH) {
            sProvinNum = idCard.substring(0, 2);
        }
        sProvince = cityCodes.get(sProvinNum);
        return sProvince;
    }

    //----------------------------------------------------------------------------------------------
    /**
     * 将15位身份证号码转换为18位
     * @param idCard 15位身份编码
     * @return 18位身份编码
     */
    private static String conver15CardTo18(String idCard) {
        String idCard18 = "";
        if (idCard.length() != CHINA_ID_MIN_LENGTH) {
            return null;
        }
        if (isNum(idCard)) {
            // 获取出生年月日
            String birthday = idCard.substring(6, 12);
            Date birthDate = null;
            try {
                birthDate = new SimpleDateFormat("yyMMdd").parse(birthday);
            } catch (ParseException e) {
                e.printStackTrace();
            }
            Calendar cal = Calendar.getInstance();
            if (birthDate != null)
                cal.setTime(birthDate);
            // 获取出生年(完全表现形式,如：2010)
            String sYear = String.valueOf(cal.get(Calendar.YEAR));
            idCard18 = idCard.substring(0, 6) + sYear + idCard.substring(8);
            // 转换字符数组
            char[] cArr = idCard18.toCharArray();
            if (cArr != null) {
                int[] iCard = converCharToInt(cArr);
                int iSum17 = getPowerSum(iCard);
                // 获取校验位
                String sVal = getCheckCode18(iSum17);
                if (sVal.length() > 0) {
                    idCard18 += sVal;
                } else {
                    return null;
                }
            }
        } else {
            return null;
        }
        return idCard18;
    }

    /**
     * 验证18位身份编码是否合法
     * @param idCard 身份编码
     * @return 是否合法
     */
    private static boolean validateIdCard18(String idCard) {
        boolean bTrue = false;
        if (idCard.length() == CHINA_ID_MAX_LENGTH) {
            // 前17位
            String code17 = idCard.substring(0, 17);
            // 第18位
            String code18 = idCard.substring(17, CHINA_ID_MAX_LENGTH);
            if (isNum(code17)) {
                char[] cArr = code17.toCharArray();
                if (cArr != null) {
                    int[] iCard = converCharToInt(cArr);
                    int iSum17 = getPowerSum(iCard);
                    // 获取校验位
                    String val = getCheckCode18(iSum17);
                    if (val.length() > 0) {
                        if (val.equalsIgnoreCase(code18)) {
                            bTrue = true;
                        }
                    }
                }
            }
        }
        return bTrue;
    }

    /**
     * 验证15位身份编码是否合法
     * @param idCard 身份编码
     * @return 是否合法
     */
    private static boolean validateIdCard15(String idCard) {
        if (idCard.length() != CHINA_ID_MIN_LENGTH) {
            return false;
        }
        if (isNum(idCard)) {
            String proCode = idCard.substring(0, 2);
            if (cityCodes.get(proCode) == null) {
                return false;
            }
            String birthCode = idCard.substring(6, 12);
            Date birthDate = null;
            try {
                birthDate = new SimpleDateFormat("yy").parse(birthCode.substring(0, 2));
            } catch (ParseException e) {
                e.printStackTrace();
            }
            Calendar cal = Calendar.getInstance();
            if (birthDate != null)
                cal.setTime(birthDate);
            if (!valiDate(cal.get(Calendar.YEAR), Integer.valueOf(birthCode.substring(2, 4)),
                    Integer.valueOf(birthCode.substring(4, 6)))) {
                return false;
            }
        } else {
            return false;
        }
        return true;
    }

    /**
     * 验证10位身份编码是否合法
     * @param idCard 身份编码
     * @return 身份证信息数组
     *         [0] - 台湾、澳门、香港 [1] - 性别(男M,女F,未知N) [2] - 是否合法(合法true,不合法false)
     *         若不是身份证件号码则返回null
     */
    private static String[] validateIdCard10(String idCard) {
        String[] info = new String[3];
        String card = idCard.replaceAll("[\\(|\\)]", "");
        if (card.length() != 8 && card.length() != 9 && idCard.length() != 10) {
            return null;
        }
        if (idCard.matches("^[a-zA-Z][0-9]{9}$")) { // 台湾
            info[0] = "台湾";
            String char2 = idCard.substring(1, 2);
            if (char2.equals("1")) {
                info[1] = "M";
            } else if (char2.equals("2")) {
                info[1] = "F";
            } else {
                info[1] = "N";
                info[2] = "false";
                return info;
            }
            info[2] = validateTWCard(idCard) ? "true" : "false";
        } else if (idCard.matches("^[1|5|7][0-9]{6}\\(?[0-9A-Z]\\)?$")) { // 澳门
            info[0] = "澳门";
            info[1] = "N";
            // TODO
        } else if (idCard.matches("^[A-Z]{1,2}[0-9]{6}\\(?[0-9A]\\)?$")) { // 香港
            info[0] = "香港";
            info[1] = "N";
            info[2] = validateHKCard(idCard) ? "true" : "false";
        } else {
            return null;
        }
        return info;
    }

    /**
     * 验证台湾身份证号码
     * @param idCard 身份证号码
     * @return 验证码是否符合
     */
    private static boolean validateTWCard(String idCard) {
        String start = idCard.substring(0, 1);
        String mid = idCard.substring(1, 9);
        String end = idCard.substring(9, 10);
        Integer iStart = twFirstCode.get(start);
        Integer sum = iStart / 10 + (iStart % 10) * 9;
        char[] chars = mid.toCharArray();
        Integer iflag = 8;
        for (char c : chars) {
            sum = sum + Integer.valueOf(c + "") * iflag;
            iflag--;
        }
        return (sum % 10 == 0 ? 0 : (10 - sum % 10)) == Integer.valueOf(end) ? true : false;
    }

    /**
     * 验证香港身份证号码(存在Bug，部份特殊身份证无法检查)
     * 身份证前2位为英文字符，如果只出现一个英文字符则表示第一位是空格，对应数字58 前2位英文字符A-Z分别对应数字10-35
     * 最后一位校验码为0-9的数字加上字符"A"，"A"代表10
     * 将身份证号码全部转换为数字，分别对应乘9-1相加的总和，整除11则证件号码有效
     * @param idCard 身份证号码
     * @return 验证码是否符合
     */
    private static boolean validateHKCard(String idCard) {
        String card = idCard.replaceAll("[\\(|\\)]", "");
        Integer sum = 0;
        if (card.length() == 9) {
            sum = (Integer.valueOf(card.substring(0, 1).toUpperCase().toCharArray()[0]) - 55) * 9
                    + (Integer.valueOf(card.substring(1, 2).toUpperCase().toCharArray()[0]) - 55) * 8;
            card = card.substring(1, 9);
        } else {
            sum = 522 + (Integer.valueOf(card.substring(0, 1).toUpperCase().toCharArray()[0]) - 55) * 8;
        }
        String mid = card.substring(1, 7);
        String end = card.substring(7, 8);
        char[] chars = mid.toCharArray();
        Integer iflag = 7;
        for (char c : chars) {
            sum = sum + Integer.valueOf(c + "") * iflag;
            iflag--;
        }
        if (end.toUpperCase().equals("A")) {
            sum = sum + 10;
        } else {
            sum = sum + Integer.valueOf(end);
        }
        return (sum % 11 == 0) ? true : false;
    }

    /**
     * 将字符数组转换成数字数组
     * @param ca 字符数组
     * @return 数字数组
     */
    private static int[] converCharToInt(char[] ca) {
        int len = ca.length;
        int[] iArr = new int[len];
        try {
            for (int i = 0; i < len; i++) {
                iArr[i] = Integer.parseInt(String.valueOf(ca[i]));
            }
        } catch (NumberFormatException e) {
            e.printStackTrace();
        }
        return iArr;
    }

    /**
     * 将身份证的每位和对应位的加权因子相乘之后，再得到和值
     * @param iArr
     * @return 身份证编码。
     */
    private static int getPowerSum(int[] iArr) {
        int iSum = 0;
        if (power.length == iArr.length) {
            for (int i = 0; i < iArr.length; i++) {
                for (int j = 0; j < power.length; j++) {
                    if (i == j) {
                        iSum = iSum + iArr[i] * power[j];
                    }
                }
            }
        }
        return iSum;
    }

    /**
     * 将power和值与11取模获得余数进行校验码判断
     * @param iSum
     * @return 校验位
     */
    private static String getCheckCode18(int iSum) {
        String sCode = "";
        switch (iSum % 11) {
            case 10:
                sCode = "2";
                break;
            case 9:
                sCode = "3";
                break;
            case 8:
                sCode = "4";
                break;
            case 7:
                sCode = "5";
                break;
            case 6:
                sCode = "6";
                break;
            case 5:
                sCode = "7";
                break;
            case 4:
                sCode = "8";
                break;
            case 3:
                sCode = "9";
                break;
            case 2:
                sCode = "x";
                break;
            case 1:
                sCode = "0";
                break;
            case 0:
                sCode = "1";
                break;
        }
        return sCode;
    }
    /**
     * 数字验证
     * @param val
     * @return 提取的数字。
     */
    private static boolean isNum(String val) {
        return val == null || "".equals(val) ? false : val.matches("^[0-9]*$");
    }

    /**
     * 验证小于当前日期 是否有效
     * @param iYear 待验证日期(年)
     * @param iMonth 待验证日期(月 1-12)
     * @param iDate 待验证日期(日)
     * @return 是否有效
     */
    private static boolean valiDate(int iYear, int iMonth, int iDate) {
        Calendar cal = Calendar.getInstance();
        int year = cal.get(Calendar.YEAR);
        int datePerMonth;
        if (iYear < MIN || iYear >= year) {
            return false;
        }
        if (iMonth < 1 || iMonth > 12) {
            return false;
        }
        switch (iMonth) {
            case 4:
            case 6:
            case 9:
            case 11:
                datePerMonth = 30;
                break;
            case 2:
                boolean dm = ((iYear % 4 == 0 && iYear % 100 != 0) || (iYear % 400 == 0))
                        && (iYear > MIN && iYear < year);
                datePerMonth = dm ? 29 : 28;
                break;
            default:
                datePerMonth = 31;
        }
        return (iDate >= 1) && (iDate <= datePerMonth);
    }

    /**
     * 测试，及使用(验证身份证是否合法)
     * @param args
     */
    public static void main(String[] args){
        System.out.println(validateCard("490927199713124022"));
        System.out.println(validateCard("N6340588"));
    }


}

5.IP工具类

import org.apache.commons.lang.StringUtils;

import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * 与ip相关的工具类
 *     1, IpLong2Str 把长整型的IP转化为字符串形式
 *  2, IpInt2Str 把整型的IP转化为字符串形式
 *  3, IpStr2Long 把IP字符串转化为长整型
 *  4, IpStr2Int 把IP字符串转化为整型
 *  5, getIpRange(String[] includeIp, String[] excludeIp)
 *  6, getIpRange(String includeIp, String excludeIp) 把包含IP串和排除IP串合并成一个不重复的IP段
 *  7, ipRanges2IpString(List<IpRange>) 将ipRanges 转化为 10.10.10.10-10.10.10.11,...
 *  8, chuChong(List<IpRange> listIpRange)
 *  9, ipString2Number 将字符串IP转换成整数IP
 *  10, ipNumber2String(Long) 将一个整数转换成其相对应的使用‘点分法’表示的IP，如127.0.0.1
 *  11, isIPV4(String s) IP格式验证

 * @version $Revision: 3542 $, $Date: 2015-7-9 下午2:12:14$
 * @LastChanged $Author: miweidong $, $Date:: 2017-07-04 14:47:34#$
 */
public class IpTools {
    
  public static String local_ip;
  
  static {
    try {
      local_ip = InetAddress.getLocalHost().getHostAddress();
    } catch (UnknownHostException e) {
      e.printStackTrace();
    }
  }
  
    /**
     * 把长整型的IP转化为字符串形式，IP以字符串方式传入。
     * 如果ipLongStr为空或者不全是数字，直接返回ipLongStr
     */
  @Deprecated
    public static String IpLong2Str(String ipLongStr) {
        if(StringUtils.isBlank(ipLongStr) || !StringUtils.isNumeric(ipLongStr)){
            return ipLongStr;
        }
        
        Long ipLong = Long.valueOf(ipLongStr);
        return IpLong2Str(ipLong);
    }

    /**
     * 把长整型的IP转化为字符串形式
     * 
     * @param ipLong
     *            IP长整型值
     * @return IP字符串
     * @throws IllegalArgumentException -
     *             ipLong超过32位
     */
    @Deprecated
    public static String IpLong2Str(Long ipLong) {
        // 长整型数值超过32位
        if (0 != (ipLong >> 32)) {
            throw new IllegalArgumentException("IP's Format error. Arg:ipLong="
                    + ipLong);
        }

        return IpInt2Str(ipLong.intValue());
    }

    /**
     * 把整型的IP转化为字符串形式
     * 
     * @param ipInt
     *            IP整型值
     * @return IP字符串
     */
    @Deprecated
    public static String IpInt2Str(int ipInt) {
        if (ipInt == 0) {
            return "";
        }
        int f1 = 0xff & (ipInt >> 24);
        int f2 = 0xff & (ipInt >> 16);
        int f3 = 0xff & (ipInt >> 8);
        int f4 = 0xff & (ipInt >> 0);
        return Integer.toString(f1) + '.' + f2 + '.' + f3 + '.' + f4;
    }

    /**
     * 把IP字符串转化为长整型
     * 
     * @param ipStr
     *            IP字符串
     * @return IP长整型值
     * @throws IllegalArgumentException -
     *             IP字符串不是有效IP，该IP存储在异常类的message中
     */
    @Deprecated
    public static long IpStr2Long(String ipStr) {
        long ip = IpStr2Int(ipStr);
        ip &= (1L << 32) - 1; // 把int转化为long时的负号影响去掉
        return ip;
    }

    /**
     * 把IP字符串转化为整型
     * 
     * @param ipStr
     *            IP字符串
     * @return IP整型值
     * @throws IllegalArgumentException -
     *             IP字符串不是有效IP，该IP存储在异常类的message中
     */
    @Deprecated
    public static int IpStr2Int(String ipStr) {
        String[] ipStrField = ipStr.split("\\.");
        int[] ipLongField = new int[ipStrField.length];

        if (4 != ipStrField.length) {
            throw new IllegalArgumentException("IP's Format error. Arg:ipStr="
                    + ipStr);
        }

        for (int i = 0; i < ipStrField.length; i++) {
            ipLongField[i] = Integer.valueOf(ipStrField[i]);
            if (255 < ipLongField[i]) {
                throw new IllegalArgumentException(
                        "IP's Format error. Arg:ipStr=" + ipStr);
            }
        }

        return (ipLongField[0] << 24) + (ipLongField[1] << 16)
                + (ipLongField[2] << 8) + ipLongField[3];
    }

    private static String getIpRangeString(List<IpRange> range) {
        StringBuffer rangeString = new StringBuffer();
        for (IpRange r : range) {
            rangeString.append(ipNumber2String(r.getStartIp()) + "-"
                    + ipNumber2String(r.getEndIp()) + ",");
        }
        rangeString.deleteCharAt(rangeString.length() - 1);
        return rangeString.toString();
    }

    public static List<IpRange> getIpRange(String[] includeIp,
            String[] excludeIp) {
        if (includeIp.length != excludeIp.length) {
            return new ArrayList<IpRange>();
        }

        StringBuffer rangeString = new StringBuffer();
        for (int i = 0; i < includeIp.length; i++) {
            rangeString
                    .append(getIpRangeString(getIpRange(includeIp[i],
                            excludeIp[i]))
                            + ",");
        }
        rangeString.deleteCharAt(rangeString.length() - 1);
        
        return getIpRange(rangeString.toString(), null);
    }

    /**
     * 把包含IP串和排除IP串合并成一个不重复的IP段
     * 
     * @param includeIp
     *            包含IP串。允许以逗号分隔的多个CIDR形式的子网，减号分隔的IP范围（大的IP可以放在减号的前面）和单个IP
     * @param excludeIp
     *            排除IP串。其他同includeIp
     * @return 按开始IP由小到大排序的IpRange列表。IpRange对象中startIp<=endIp，如果startIp==endIp，表示单个IP
     *         说明
     *         1.把参数中的子网解析为“0-255”，例如把“192.168.3.0/24”解析为“192.168.3.0-192.168.3.255”形式
     *         2.当子网的IP部分为0时，解析为“0.0.0.0-255.255.255.255”，例如“0.0.0.0/24”和“0.0.0.0/32”都符合此情况
     *         3.当单个IP为0.0.0.0时表示“0.0.0.0-255.255.255.255”
     *         4.在下列情况下，返回null：
     *             a.当includeIp为null或空串时 b.excludeIp包含includeIp时
     * @throws IllegalArgumentException -
     *             IP字符串不是有效IP，该IP存储在异常类的message中
     */
    public static List<IpRange> getIpRange(String includeIp, String excludeIp) {
        if (StringUtils.isBlank(includeIp)) {
            return new ArrayList<IpRange>();//
        }
        List<IpRange> includeList = string2SortedIpRange(includeIp);
        List<IpRange> excludeList = string2SortedIpRange(excludeIp);

        if (null == includeList) {
            return new ArrayList<IpRange>();
        }

        // 处理排除串
        if (null != excludeList && excludeList.size() > 0) {
            for (int i = 0; i < excludeList.size(); i++) {
                IpRange exclude = excludeList.get(i);
                for (int j = 0; j < includeList.size(); j++) {
                    IpRange include = includeList.get(j);

                    // 忽略exclude和include没有交集的情况
                    if ((exclude.getEndIp() < include.getStartIp())) {
                        break;
                    } else if ((exclude.getStartIp() > include.getEndIp())) {
                        continue;
                    }

                    if ((exclude.getStartIp() > include.getStartIp())
                            && (exclude.getEndIp() < include.getEndIp())) {
                        // include包含exclude
                        includeList.add(j + 1, new IpRange(
                                exclude.getEndIp() + 1, include.getEndIp()));
                        includeList.get(j).setEndIp(exclude.getStartIp() - 1);
                        j++;
                    } else if ((exclude.getStartIp() <= include.getStartIp())
                            && (exclude.getEndIp() >= include.getEndIp())) {
                        // exclude包含include
                        includeList.remove(j);
                        j--;
                    } else if ((exclude.getStartIp() <= include.getStartIp())) {
                        // exclude与include前半段重合
                        include.setStartIp(exclude.getEndIp() + 1);
                    } else {
                        // exclude与include后半段重合
                        include.setEndIp(exclude.getStartIp() - 1);
                    }
                }
            }
        }

        return (null == includeList) ? new ArrayList<IpRange>() : includeList;
    }

    /**
     * 功能描述：将ipRanges 转化为 10.10.10.10-10.10.10.11,...
     * @param ipRanges
     * @return
     * String
     */
    public static String ipRanges2IpString(List<IpRange> ipRanges){
        String ipString = "";
        if(ipRanges == null || ipRanges.size() < 1) {
      return ipString;
    }
        
        for(IpRange ipRange : ipRanges){
            ipString = ipString + ipNumber2String(ipRange.getStartIp()) + "-" + ipNumber2String(ipRange.getEndIp()) + ",";
        }
        if(ipString.endsWith(",")){
            ipString = ipString.substring(0,ipString.length() - 1);
        }
        
        return ipString;
    }

    /**
     * 功能描述：将ipRanges 转化为2008810193-2008810198,2008810200-2008810207,...
     * @param ipRanges
     * @return
     * String
     */
    public static String ipRanges2LongIpString(List<IpRange> ipRanges){
        String ipString = "";
        if(ipRanges == null || ipRanges.size() < 1) {
      return ipString;
    }
        
        for(IpRange ipRange : ipRanges){
            ipString = ipString + ipRange.getStartIp() + "-" + ipRange.getEndIp() + ",";
        }
        
        if(ipString.endsWith(",")){
            ipString = ipString.substring(0,ipString.length() - 1);
        }
        
        return ipString;
    }

    /**
     * 2000
     */
    public static long maxIpCount = 2000l;
    
    /**
     * 功能描述：将ipRanges 转化为ip 字符串的集合
     * @param ipRanges
     * @return
     * String
     */
    public static List<String> ipRanges2Ips(List<IpRange> ipRanges){
        List<String> ips =  new ArrayList<String>();
        if(ipRanges == null || ipRanges.size() == 0) {
      return ips;
    }
        if(ipSizeOfIpRanges(ipRanges) > maxIpCount)
     {
      return ips;//最多解析2000个ip出来
    }

        for(IpRange ipRange : ipRanges){
            rangeLong2Ip(ipRange.getStartIp(), ipRange.getEndIp(), ips);
        }

        return ips;
    }
    
    public static long ipSizeOfIpRanges(List<IpRange> ipRanges){
        long size = 0l;
        
        if(ipRanges != null){
            for(IpRange ipRange : ipRanges){
                size += ipRange.getRangeSize();
            }
        }
        
        return size;
    }

    public static List<String> rangeLong2Ip(long begIp, long endIp, List<String> ips) {
        ips = ips == null ? new ArrayList<String>() : ips;
        
        int[] f = { 0, 0, 0, 0 };

        for (; begIp <= endIp; begIp++) {
            for (int i = 0; i < f.length; i++) {
                f[i] = (int) (begIp >> (i << 3)) & 0xFF;
            }
            if((f[0] > 0) && (f[0] < 255)){
                ips.add(String.format("%d.%d.%d.%d", f[3], f[2], f[1], f[0]));
            }
        }
        return ips;
    }



    public static List<IpRange> chuChong(List<IpRange> listIpRange){
        if(listIpRange == null || listIpRange.size() < 1) {
      return listIpRange;
    }
        
        if (listIpRange.size() > 0) {
            // 按开始IP由小到大排序
            Collections.sort(listIpRange, new Comparator<IpRange>() {
                @Override
        public int compare(IpRange left, IpRange right) {
                    long result = left.getStartIp() - right.getStartIp();
                    return (result < 0) ? -1 : (result == 0) ? 0 : 1;
                }
            });

            // 合并重合的相邻IP段
            for (int i = 1; i < listIpRange.size(); i++) {
                IpRange range1 = listIpRange.get(i - 1);
                IpRange range2 = listIpRange.get(i);

                if (range2.getStartIp() < range1.getEndIp() + 2) {
                    // 包含两个IP段紧密相邻的情况，例如“192.168.3.0-192.168.3.255”和“192.168.4.0-192.168.4.255”。
                    // 如果不是“...<...+2”,则不能处理此情况; “...<...+2”相当于“...<=...+1”
                    range1.setEndIp(Math.max(range1.getEndIp(), range2
                            .getEndIp()));
                    listIpRange.remove(i);
                    i--;
                }
            }
            
        }
        
        return listIpRange;
    }
    
    /**
     * 把逗号分隔的多个子网、范围和IP字符串，转化为IpRange列表，并且将最后的数据进行合并返回。
     * 
     * @param ipRange
     *            逗号分隔的多个子网、范围和IP字符串
     * @return IpRange列表
     */
    public static List<IpRange> string2SortedIpRange(String ipRange) {
        if (null == ipRange || ipRange.trim().equals("")) {
            return new ArrayList<IpRange>();
        }
        ipRange = ipRange.trim();
        
        List<IpRange> listIpRange = new ArrayList<IpRange>();
        String[] ipRangeArray = StringUtils.split(ipRange, ",");
        for (int i = 0; i < ipRangeArray.length; i++) {
            IpRange range = singIpRange2IpRange(ipRangeArray[i]);
            if (null != range) {
                listIpRange.add(range);
            }
        }

        if (listIpRange.size() > 0) {
            // 按开始IP由小到大排序
            Collections.sort(listIpRange, new Comparator<IpRange>() {
                @Override
        public int compare(IpRange left, IpRange right) {
                    long result = left.getStartIp() - right.getStartIp();
                    return (result < 0) ? -1 : (result == 0) ? 0 : 1;
                }
            });

            // 合并重合的相邻IP段
            for (int i = 1; i < listIpRange.size(); i++) {
                IpRange range1 = listIpRange.get(i - 1);
                IpRange range2 = listIpRange.get(i);

                if (range2.getStartIp() < range1.getEndIp() + 2) {
                    // 包含两个IP段紧密相邻的情况，例如“192.168.3.0-192.168.3.255”和“192.168.4.0-192.168.4.255”。
                    // 如果不是“...<...+2”,则不能处理此情况; “...<...+2”相当于“...<=...+1”
                    range1.setEndIp(Math.max(range1.getEndIp(), range2
                            .getEndIp()));
                    listIpRange.remove(i);
                    i--;
                }
            }
        }

        return (0 == listIpRange.size()) ? null : listIpRange;
    }

    /**
     * 把逗号分隔的多个子网、范围和IP字符串，转化为IpRange列表
     * 
     * @param ips
     * @return
     */
    public static List<IpRange> ips2IpRanges(String ips) {
      if (null == ips || ips.trim().equals("")) {
      return new ArrayList<IpRange>();
    }
      
      ips = ips.trim();
    
    List<IpRange> ipRanges = new ArrayList<IpRange>();
    
    String[] ipsArray = StringUtils.split(ips, ",");
    
    for (int i = 0; i < ipsArray.length; i++) {
      ipRanges.add(singIpRange2IpRange(ipsArray[i]));
    }
    
    return ipRanges;
    }
    
    /**
     * 把单个子网，范围和单个IP转换为IpRange对象
     * 
     * @param ipRange
     *            单个子网、范围或IP字符串。0.0.0.0和0.0.0.0/XX表示0.0.0.0-255.255.255.255
     * @return IpRange对象。保证IpRange中的startIp <= endIp。
     */
    public static IpRange singIpRange2IpRange(String ipRange) {
        long startIp = 0;
        long endIp = 0;

        if (0 <= ipRange.indexOf('/')) {// 形如192.168.29.0/24
            String[] range = ipRange.split("/");
            startIp = IpStr2Long(range[0]);

            if (2 != range.length) {
                throw new IllegalArgumentException(
                        "IP's Format error. Arg:ipRange=" + ipRange);
            }

            int maskLen = Integer.valueOf(range[1]);
            int mask = 0x80000000 >> (maskLen - 1);
            if ((maskLen < 0) || (maskLen > 32)) {
                throw new IllegalArgumentException(
                        "Mask len error. Arg:ipRange=" + ipRange);
            }

            startIp &= mask;
            endIp = startIp | (~mask);
            if (0 == startIp) {// ip为0时，开始IP为0,结束IP为255.255.255.255
                startIp = 0;
                endIp = (1L << 32) - 1;
            }
        } else if (0 <= ipRange.indexOf('-')) {// 形如192.168.29.0-192.168.29.255
            String[] range = ipRange.split("-");
            if (2 != range.length) {
                throw new IllegalArgumentException(
                        "IP's Format error. Arg:ipRange=" + ipRange);
            }
            startIp = IpStr2Long(range[0]);
            endIp = IpStr2Long(range[1]);
        } else {// 单个IP
            startIp = endIp = IpStr2Long(ipRange);
            if (0 == endIp) {
                endIp = (1L << 32) - 1;
            }
        }

        return new IpRange(Math.min(startIp, endIp), Math.max(startIp, endIp));
    }
    
    /**
     * 将字符串IP转换成整数IP
     * 
     * @param ip
     *            待转换的IP字符串
     * @return 返回一个整数,如果格式不正常,则返回一个null指针
     */
    public static Long ipString2Number(String ip) {
      if(StringUtils.isBlank(ip)) {
        return null;
      }
      
        Long ipLong = 0L;
        boolean hasError = false;

        if (isIPV4(ip)) {
            String tmp = ip;
            // get the 3 first numbers
            int offset = 8;
            for (int i = 0; i < 3; i++) {

                // get the position of the first dot
                int index = tmp.indexOf(".");

                // if there is not a dot then the ip string representation is
                // not compliant to the decimal-dotted notation.
                if (index != -1) {

                    // get the number before the dot and convert it into
                    // an integer.
                    String numberStr = tmp.substring(0, index);
                    int number = Integer.parseInt(numberStr);
                    if ((number < 0) || (number > 255)) {
                        hasError = true;
                        break;
                    }

                    ipLong = ipLong << offset;
                    ipLong += number;
                    tmp = tmp.substring(index + 1);
                } else {
                    hasError = true;
                    break;
                }
            }

            // the remaining part of the string should be the last number.
            if (tmp.length() > 0) {
                int number = Integer.parseInt(tmp);
                if ((number < 0) || (number > 255)) {
                    hasError = true;
                }

                ipLong = ipLong << offset;
                ipLong += number;
            }
        }
        if (hasError) {
            return null;
        } else {
            return ipLong;
        }

    }

    /**
     * 将一个整数转换成其相对应的使用‘点分法’表示的IP，如127.0.0.1
     * 
     * @param ip
     *            待转换的整数
     * @return 返回一个String,内容为‘点分法’表示的IP，如127.0.0.1
     */
    public static String ipNumber2String(Long ip) {
        
        if (ip.equals(0L)) {
            return "";
        }
        StringBuffer result = new StringBuffer();
        Long temp;

        temp = ip & 0xFF000000;
        temp = temp >> 24;
        result.append(temp);
        result.append(".");

        temp = ip & 0x00FF0000;
        temp = temp >> 16;
        result.append(temp);
        result.append(".");

        temp = ip & 0x0000FF00;
        temp = temp >> 8;
        result.append(temp);
        result.append(".");

        temp = ip & 0x000000FF;
        result.append(temp);

        return result.toString();
    }

    /**
     * IP格式验证
     */
    public static boolean isIPV4(String s) {
        try {
            String number = s.substring(0, s.indexOf('.'));
            if (Integer.parseInt(number) > 255) {
        return false;
      }
            s = s.substring(s.indexOf('.') + 1);
            number = s.substring(0, s.indexOf('.'));
            if (Integer.parseInt(number) > 255) {
        return false;
      }
            s = s.substring(s.indexOf('.') + 1);
            number = s.substring(0, s.indexOf('.'));
            if (Integer.parseInt(number) > 255) {
        return false;
      }
            number = s.substring(s.indexOf('.') + 1);
            return Integer.parseInt(number) <= 255;
        } catch (Exception e) {
            return false;
        }

    }

    /**
     * 判断ip是否在ipRange集合中
     * @param ip
     * @param ipRangeList
     * @return    (参数说明)
     * @return boolean    返回类型
     * @throws
     */
    public static boolean isIpInIpRange(long ip, List<IpRange> ipRangeList) {
        boolean result = false;
        if(ipRangeList != null) {
            for(IpRange ir : ipRangeList) {
                if(ip >= ir.getStartIp() && ip <= ir.getEndIp()) {
                    result = true;
                    break;
                }
            }
        }
        
        return result;
    }

    /**
     * 判断ip是否在ipRange集合中
     * @param
     * @param ipRangeList
     * @return    (参数说明)
     * @return boolean    返回类型
     * @throws
     */
    public static boolean isIpStrInIpRange(String ipStr, List<IpRange> ipRangeList) {
        long ip = 0;
        try {
            ip = IpStr2Long(ipStr);
        } catch (Exception e) {
            return false;
        }
        
        return isIpInIpRange(ip, ipRangeList);
    }
    
    /**
     * (将包含IP串和排除IP串转成List<String ip>)
     * @param ip 包含IP串 例：192.168.1.119,192.168.2.119,192.168.2.200-192.168.2.220,192.168.3.1/31
     * @param excludeIp 排除IP串 例：192.168.2.201,192.168.1.1/31
     * @return    (返回String类型的List，其中每个String为一个ip)
     * @return List<String>    返回类型
     * @throws
     */
    public static List<String> ip2StringList(String ip,String excludeIp){
        List<IpRange> list1 = getIpRange(ip, excludeIp);
        List<String> list2 = ipRanges2Ips(list1);
        return list2;
    }
    
    /**
     * 检查单个IP是否为内网IP<br>
     * 内网IP范围：
     * <li>10.0.0.0--10.255.255.255</li>
     * <li>172.16.0.0--172.31.255.255</li>
     * <li>192.168.0.0--192.168.255.255</li>
     * @param
     * @return
     */
    public static boolean isLANIP(String ipStr) {
      long ip = 0;
    try {
      ip = IpStr2Long(ipStr);
    } catch (Exception e) {
      return false;
    }
    return isLANIP(ip);
    }
    
  /**
   * 检查单个IP是否为内网IP<br>
   * 内网IP范围：
   * <li>10.0.0.0--10.255.255.255</li>
   * <li>172.16.0.0--172.31.255.255</li>
   * <li>192.168.0.0--192.168.255.255</li>
   * @param ip
   * @return
   */
  public static boolean isLANIP(long ip) {
    /*
    List<IpRange> ipRangeList = new ArrayList<IpRange>();
    
    IpRange r_10 = new IpRange(IpTools.IpStr2Long("10.0.0.0"), IpTools.IpStr2Long("10.255.255.255"));
    IpRange r_172 = new IpRange(IpTools.IpStr2Long("172.16.0.0"), IpTools.IpStr2Long("172.31.255.255"));
    IpRange r_192 = new IpRange(IpTools.IpStr2Long("192.168.0.0"), IpTools.IpStr2Long("192.168.255.255"));
        
    ipRangeList.add(r_10);
    ipRangeList.add(r_172);
    ipRangeList.add(r_192);
    */
    List<IpRange> ipRangeList = ips2IpRanges(getLANIP());
    
    return isIpInIpRange(ip, ipRangeList);
  }

  /**
   * 指定的 ip 是否为 指定的 ip范围 ipRange 中的 ip C 网段内
   * @param ip 单个 ip
   * @param ipRange 包含IP串 例：192.168.1.119,192.168.2.119,192.168.2.200-192.168.2.220,192.168.3.1/31
   * @return
   */
  public static boolean isCLANIP(long ip, String ipRange) {
    List<IpRange> ipRangeList = ips2IpRanges(ipRange);
    
    String ipStr = IpTools.IpLong2Str(ip);
    String[] ipStrArray = ipStr.split("[.]");
    
    for(IpRange r : ipRangeList) {
      String[] startIpArray = IpTools.IpLong2Str(r.getStartIp()).split("[.]");
      String[] endIpArray = IpTools.IpLong2Str(r.getEndIp()).split("[.]");
      
      if(Integer.valueOf(ipStrArray[0]).intValue() == Integer.valueOf(startIpArray[0]).intValue()
          && Integer.valueOf(ipStrArray[0]).intValue() == Integer.valueOf(endIpArray[0]).intValue()
          && Integer.valueOf(ipStrArray[1]).intValue() == Integer.valueOf(startIpArray[1]).intValue()
          && Integer.valueOf(ipStrArray[1]).intValue() == Integer.valueOf(endIpArray[1]).intValue()
          && Integer.valueOf(ipStrArray[2]).intValue() == Integer.valueOf(startIpArray[2]).intValue()
          && Integer.valueOf(ipStrArray[2]).intValue() == Integer.valueOf(endIpArray[2]).intValue()
          && Integer.valueOf(ipStrArray[3]).intValue() >= Integer.valueOf(startIpArray[3]).intValue()
          && Integer.valueOf(ipStrArray[3]).intValue() <= Integer.valueOf(endIpArray[3]).intValue()) {
        return true;
      }
    }
    
    return false;
  }
  
  /**
   * 获得默认内网 IP 地址。
   * @return 10.0.0.0-10.255.255.255,172.16.0.0-172.31.255.255,192.168.0.0-192.168.255.255
   */
  public static String getLANIP() {
    return "10.0.0.0-10.255.255.255,172.16.0.0-172.31.255.255,192.168.0.0-192.168.255.255";
  }
  
  /**
   * 返回提供的 IP 是否为保留地址<br>
   * 目前保留地址范围为：
   * <li>0.0.0.0</li>
   * <li>255.255.255.255</li>
   * <li>224.0.0.0-239.255.255.255</li>
   * <li>xxx.xxx.xxx.0</li>
   * <li>xxx.xxx.xxx.255</li>
   * <li>0.xxx.xxx.xxx</li>
   * <li>255.xxx.xxx.xxx</li><br>
   * @return
   */
  public static boolean isReservedIP(String ip) {
    if("0".equals(ip) || "0.0.0.0".equals(ip) || "255.255.255.255".equals(ip)) {
      return true;
    }
    if(isStartReservedIP(ip) || isEndReservedIP(ip)) {
      return true;
    }
    return isReservedIP(IpStr2Long(ip));
  }
  
  /**
   * 返回提供的 IP 是否为保留地址<br>
   * 目前保留地址范围为：
   * <li>0.0.0.0</li>
   * <li>255.255.255.255</li>
   * <li>224.0.0.0-239.255.255.255</li>
   * <li>xxx.xxx.xxx.0</li>
   * <li>xxx.xxx.xxx.255</li>
   * <li>0.xxx.xxx.xxx</li>
   * <li>255.xxx.xxx.xxx</li><br>
   * @return
   */
  public static boolean isReservedIP(long ip) {
    if(ip == 0) {
      return true;
    }
    
    String ipStr = IpLong2Str(ip);
    if(isStartReservedIP(ipStr) || isEndReservedIP(ipStr)) {
      return true;
    }
    
    List<IpRange> ipRangeList = ips2IpRanges(getReservedIp());
    return isIpInIpRange(ip, ipRangeList);
  }
  
  private static boolean isStartReservedIP(String ip) {
    return ip.startsWith("0.") || ip.startsWith("255.");//0.xxx.xxx.xxx, 255.xxx.xxx.xxx
  }
  
  private static boolean isEndReservedIP(String ip) {
    return ip.endsWith(".0") || ip.endsWith(".255");//xxx.xxx.xxx.0, xxx.xxx.xxx.255
  }

  /**
   * 返回部分保留地址
   * @return
   */
  private static String getReservedIp() {
    return "255.255.255.255,224.0.0.0-239.255.255.255";//0.0.0.0?
  }
  
  /**
   * 根据提供的数据库表中 IP 列名称（columns）构造针对整型 IP 过滤掉保留地址的 WHERE 表达式。<br>
   * 目前保留地址范围为：
   * <li>0.0.0.0</li>
   * <li>255.255.255.255</li>
   * <li>224.0.0.0-239.255.255.255</li>
   * <li>xxx.xxx.xxx.0</li>
   * <li>xxx.xxx.xxx.255</li>
   * <li>0.xxx.xxx.xxx</li>
   * <li>255.xxx.xxx.xxx</li><br>
   * 若数据库表列名称为“ip”，则构造后的 WHERE 表达式为：<br>
   * <pre><b> (ip <> 0 AND ip <> 4294967295 AND (ip < 3758096384 OR ip > 4026531839)) </b></pre>
   * <b style="color:red;">注：该方法目前返回的表达中不包括如下范围 IP 的过滤：<br>xxx.xxx.xxx.0、xxx.xxx.xxx.255、0.xxx.xxx.xxx、255.xxx.xxx.xxx</b>
   * 
   * @param column 要查询的数据库表中 IP 列的名称
   * @return 构造后的针对整型 IP 过滤掉保留地址的 WHERE 表达式
   */
  public static String getExcludeReservedIpWhereExpression4LongIp(String column) {
    return " (" +
           column + " <> 0 AND " + column + " <> 4294967295 AND (" +//0.0.0.0, 255.255.255.255
           column + " < 3758096384 OR " + column + " > 4026531839)) ";//224.0.0.0-239.255.255.255
           //xxx.xxx.xxx.0, xxx.xxx.xxx.255???
           //0.xxx.xxx.xxx, 255.xxx.xxx.xxx??
  }
  /**
   * 根据提供的数据库表中 IP 列名称（columns）构造针对字符串 IP（符合 IPV4 格式的 IP 地址） 过滤掉保留地址的 WHERE 表达式。<br>
   * 目前保留地址范围为：
   * <li>0.0.0.0</li>
   * <li>255.255.255.255</li>
   * <li>224.0.0.0-239.255.255.255</li>
   * <li>xxx.xxx.xxx.0</li>
   * <li>xxx.xxx.xxx.255</li>
   * <li>0.xxx.xxx.xxx</li>
   * <li>255.xxx.xxx.xxx</li><br>
   * 若数据库表列名称为“ip”，则构造后的 WHERE 表达式为：<br>
   * <pre><b> (ip NOT LIKE '224.%' AND ip NOT LIKE '239.%' AND ip NOT LIKE '%.0' AND ip NOT LIKE '%.255') </b></pre>
   * <b style="color:red;">注：该方法目前返回的表达中不包括如下范围 IP 的过滤：<br>0.xxx.xxx.xxx、255.xxx.xxx.xxx</b>
   * 
   * @param column 要查询的数据库表中 IP 列的名称
   * @return 构造后的针对整型 IP 过滤掉保留地址的 WHERE 表达式
   */
  public static String getExcludeReservedIpWhereExpression4StringIp(String column) {
    return " " +
           //column + " <> 0.0.0.0 AND " + column + " <> 255.255.255.255 AND " +//0.0.0.0, 255.255.255.255 已经在 .0 和 .255 中包含了
           column + " NOT LIKE '224.%' AND " + column + " NOT LIKE '239.%' AND " +//224.0.0.0-239.255.255.255
           //column + " NOT LIKE '0.%' AND " + column + " NOT LIKE '255.%' AND " +//0.xxx.xxx.xxx, 255.xxx.xxx.xxx
               column + " NOT LIKE '%.0' AND " + column + " NOT LIKE '%.255' ";//xxx.xxx.xxx.0, xxx.xxx.xxx.255
  }
  
  /**
   * 构造 SQL 查询中针对 IP 范围过滤的 WHERE 查询条件。<br>
   * 返回数据格式如下：<br>
   *  <pre><b>((src_ip >= 167772160 AND src_ip <= 184549375) OR (src_ip >= 2886729728 AND src_ip <= 2887778303) OR (src_ip >= 3232235520 AND src_ip <= 3232301055))</b></pre>
   * 
   * @param ips 以逗号 “,” 分隔的多个 IP、IP 范围、子网。
   *  若该参数为 null 或 为空值，则返回默认内网 IP（IpTools.getLANIP()） 构造的 WHERE 条件表达式。
   * @param column
   * @return 包含指定IP范围的条件表达式。排除了保留地址，参见：{@link #getExcludeReservedIpWhereExpression4LongIp(String)}
   */
  public static String getWhereIncludeExpression4Ips(String ips, String column) {
    if(StringUtils.isBlank(column)) {
      return "";
    }
    
    String wlanIp = ips;
    
    if(StringUtils.isBlank(ips)) {
      wlanIp = getLANIP();
    }
    
    return getWhereIncludeExpression4IpRange(ips2IpRanges(wlanIp), column);
  }
  
  /**
   * 构造 SQL 查询中针对 IP 范围过滤的 WHERE 查询条件。<br>
   * 返回数据格式如下：<br>
   *  <pre><b>((src_ip >= 167772160 AND src_ip <= 184549375) OR (src_ip >= 2886729728 AND src_ip <= 2887778303) OR (src_ip >= 3232235520 AND src_ip <= 3232301055))</b></pre>
   * 
   * @param wlanIpRange 若该参数为 null 或 size 为 0，则返回默认内网 IP（IpTools.getLANIP()） 构造的 WHERE 条件表达式。
   * @param column
   * @return 包含指定IP范围的条件表达式。排除了保留地址，参见：{@link #getExcludeReservedIpWhereExpression4LongIp(String)}
   */
  public static String getWhereIncludeExpression4IpRange(List<IpRange> wlanIpRange, String column) {
    if(StringUtils.isBlank(column)) {
      return "";
    }
    
    List<IpRange> ipRange = wlanIpRange;
    
    if(wlanIpRange == null || wlanIpRange.size() == 0) {
      ipRange = ips2IpRanges(getLANIP());
    }
    
    long startIp = 0;
    long endIp = 0;
    
    String where = "";
    
    for(IpRange r : ipRange) {
      startIp = r.getStartIp();
      endIp = r.getEndIp();
      
      if(StringUtils.isNotBlank(where)) {
        where += " OR ";
      }
      
      if(startIp == endIp) {
        where += "(" + column + " = " + startIp + ")";
      } else {
        where += "(" + column + " >= " + startIp + " AND " + column + " <= " + endIp + ")";
      }
    }
    
    where = " (" + where + ") ";
    where += " AND " + getExcludeReservedIpWhereExpression4LongIp(column);//添加上针对保留地址的过滤
        
    return where;
  }
  
  /**
   * 构造 SQL 查询中针对 IP 范围过滤的 WHERE 查询条件。<br>
   * 返回数据格式如下：<br>
   *  <pre><b>((src_ip >= 167772160 AND src_ip <= 184549375) OR (src_ip >= 2886729728 AND src_ip <= 2887778303) OR (src_ip >= 3232235520 AND src_ip <= 3232301055))</b></pre>
   * 
   * @param ips 以逗号 “,” 分隔的多个 IP、IP 范围、子网。
   *  若该参数为 null 或 为空值，则返回默认内网 IP（IpTools.getLANIP()） 构造的 WHERE 条件表达式。
   * @param column
   * @return 排除指定IP范围的条件表达式
   */
  public static String getWhereExcludeExpression4Ips(String ips, String column) {
    if(StringUtils.isBlank(column)) {
      return "";
    }
    
    String wlanIp = ips;
    
    if(StringUtils.isBlank(ips)) {
      wlanIp = getLANIP();
    }
    
    return getWhereExcludeExpression4IpRange(ips2IpRanges(wlanIp), column);
  }
  
  /**
   * 构造 SQL 查询中针对 IP 范围过滤的 WHERE 查询条件。<br>
   * 返回数据格式如下：<br>
   *  <pre><b>((src_ip >= 167772160 AND src_ip <= 184549375) OR (src_ip >= 2886729728 AND src_ip <= 2887778303) OR (src_ip >= 3232235520 AND src_ip <= 3232301055))</b></pre>
   * 
   * @param wlanIpRange 若该参数为 null 或 size 为 0，则返回默认内网 IP（IpTools.getLANIP()） 构造的 WHERE 条件表达式。
   * @param column
   * @return 排除指定IP范围的条件表达式
   */
  public static String getWhereExcludeExpression4IpRange(List<IpRange> wlanIpRange, String column) {
    if(StringUtils.isBlank(column)) {
      return "";
    }
    
    List<IpRange> ipRange = wlanIpRange;
    
    if(wlanIpRange == null || wlanIpRange.size() == 0) {
      ipRange = ips2IpRanges(getLANIP());
    }
    
    long startIp = 0;
    long endIp = 0;
    
    String where = "";
    
    for(IpRange r : ipRange) {
      startIp = r.getStartIp();
      endIp = r.getEndIp();
      
      if(StringUtils.isNotBlank(where)) {
        where += " AND ";
      }
      
      if(startIp == endIp) {
        where += "(" + column + " <> " + startIp + ")";
      } else {
        where += "(" + column + " <= " + startIp + " OR " + column + " >= " + endIp + ")";
      }
    }
    
    where = " (" + where + ") ";
    where += " AND " + getExcludeReservedIpWhereExpression4LongIp(column);//添加上针对保留地址的过滤
    
    return where;
  }
  /**
   * 判断是否是本地局域网IP
   * @param ip
   * @return
   */
  public static boolean isLocalNetArea(String ip){
    if(!isIPV4(ip)){
      throw new IllegalArgumentException("不是IP地址！");
    }else{
      Long ipNum=ipString2Number(ip);
      Long aStart=ipString2Number("10.0.0.0");
      Long aEnd=ipString2Number("10.255.255.255");
      Long bStart=ipString2Number("172.16.0.0");
      Long bEnd=ipString2Number("172.31.255.255");
      Long cStart=ipString2Number("192.168.0.0");
      Long cEnd=ipString2Number("192.168.255.255");
        return (ipNum >= aStart && ipNum <= aEnd) || (ipNum >= bStart && ipNum <= bEnd) || (ipNum >= cStart && ipNum <= cEnd);
    }
  }
  
  /**
     * @param args
     */
    public static void main(String[] args) {
        List<String> list = rangeLong2Ip(3232235777L, 3232236079L, null);
        System.out.println(list);
        System.out.println(Long.valueOf("3232238404").intValue() + IpLong2Str("3232238404"));
        System.out.println(Long.valueOf("3232238418").intValue() + IpLong2Str("3232238418"));
        
        System.out.println("0.0.0.0=" + IpStr2Long("0.0.0.0"));
        System.out.println("255.255.255.255=" + IpStr2Long("255.255.255.255"));
        
        System.out.println("192.168.1.117=" + IpStr2Long("192.168.1.117"));
        System.out.println("172.16.10.15=" + IpStr2Long("172.16.10.15"));
        
        System.out.println("59.59.59.59=" + IpStr2Long("59.59.59.59"));
        System.out.println("3232235856=" + IpLong2Str("3232235856"));
        
        System.out.println("1.2.3.4=" + IpStr2Long("1.2.3.4"));
        
        System.out.println(isLANIP("192.168.254.90"));
        System.out.println(isLANIP("172.16.3.1"));
        
        System.out.println(IpLong2Str(IpStr2Long("192.168.10.1") + 255));

        System.out.println(ips2IpRanges("255.255.255.255"));
        System.out.println((738177535 + 255));
        
        System.out.println(getExcludeReservedIpWhereExpression4LongIp("ip"));
        System.out.println(getExcludeReservedIpWhereExpression4StringIp("ip"));
        
        System.out.println(ips2IpRanges(getLANIP()));
        
        Long l1 = 123l;
        Long l2 = 123l;
        System.out.println(l1 + "," + l2);
                
        System.out.println(getWhereIncludeExpression4Ips("192.168.0.0-192.168.0.200,192.168.1.200,172.16.1.2-172.16.1.20", "src_ip"));
        System.out.println(getWhereIncludeExpression4Ips(null, "src_ip"));
        System.out.println(getWhereIncludeExpression4IpRange(null, "src_ip"));
        
        System.out.println(getWhereExcludeExpression4Ips("192.168.0.0-192.168.0.200,192.168.1.200,172.16.1.2-172.16.1.20", "src_ip"));
    System.out.println(getWhereExcludeExpression4Ips(null, "src_ip"));
    System.out.println(getWhereExcludeExpression4IpRange(null, "src_ip"));
    }

    /**
     * 数字类型的子网掩码转换成IP格式。例如：255.255.0.0 转成16
     * @param netmask
     * @return
     */
    public static String formateNetmask(int netmask) {
      if(netmask<0||netmask>25) {
        throw new RuntimeException("错误的子网掩码："+netmask);
      }
      long x=(long) (Math.pow(2, 32)-Math.pow(2, 32-netmask));
      return ipNumber2String(x);
    }
    /**
     * IP格式的子网掩码转换成数字格式。 例如：8转换成255.0.0.0
     * @param netmask
     * @return
     */
    public static int parseNetmask(String netmask) {
      long x=ipString2Number(netmask);
      String bStr=Long.toBinaryString(x);
      int firstZeroIdx=bStr.indexOf("0");
      int lastIdx=bStr.lastIndexOf("1");
      if(firstZeroIdx-1!=lastIdx||bStr.length()!=32) {
        throw new RuntimeException("错误的子网掩码："+netmask);
      }
      return lastIdx+1;
    }
    /**
     * 判断ipv6是否合法
     *
     * @param ip
     * @return
     */
    public static boolean isValidIPv6(String ip) {
        if (ip == null || ip.trim().length() == 0) {
            return false;
        }
        String t = "^\\s*((([0-9A-Fa-f]{1,4}:){7}([0-9A-Fa-f]{1,4}|:))|(([0-9A-Fa-f]{1,4}:){6}(:[0-9A-Fa-f]{1,4}|((25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(\\.(25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3})|:))|(([0-9A-Fa-f]{1,4}:){5}(((:[0-9A-Fa-f]{1,4}){1,2})|:((25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(\\.(25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3})|:))|(([0-9A-Fa-f]{1,4}:){4}(((:[0-9A-Fa-f]{1,4}){1,3})|((:[0-9A-Fa-f]{1,4})?:((25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(\\.(25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){3}(((:[0-9A-Fa-f]{1,4}){1,4})|((:[0-9A-Fa-f]{1,4}){0,2}:((25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(\\.(25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){2}(((:[0-9A-Fa-f]{1,4}){1,5})|((:[0-9A-Fa-f]{1,4}){0,3}:((25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(\\.(25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){1}(((:[0-9A-Fa-f]{1,4}){1,6})|((:[0-9A-Fa-f]{1,4}){0,4}:((25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(\\.(25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3}))|:))|(:(((:[0-9A-Fa-f]{1,4}){1,7})|((:[0-9A-Fa-f]{1,4}){0,5}:((25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(\\.(25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3}))|:)))(%.+)?\\s*$";
        Pattern p = Pattern.compile(t);
        Matcher macher = p.matcher(ip);
        return macher.matches();
    }


    /**
     * 返回a和b的关系
     * @param a
     * @param b
     * @return 1:a包含b 2:b包含a 3:相交 4:互斥 5:相等
     */
    public static int calRelation(List<IpRange> a,List<IpRange> b){
        List<List<Long>> aRangeList=new ArrayList<List<Long>>();
        List<List<Long>> bRangeList=new ArrayList<List<Long>>();
        List<Long> points=new ArrayList<Long>();
        for(IpRange r:a){
            if (points.indexOf(r.getStartIp())==-1){
                points.add(r.getStartIp());
            }
            if (points.indexOf(r.getEndIp())==-1){
                points.add(r.getEndIp());
            }
            aRangeList.add(Arrays.asList(r.getStartIp(),r.getEndIp()));
        }
        for(IpRange r:b){
            if (points.indexOf(r.getStartIp())==-1){
                points.add(r.getStartIp());
            }
            if (points.indexOf(r.getEndIp())==-1){
                points.add(r.getEndIp());
            }
            bRangeList.add(Arrays.asList(r.getStartIp(),r.getEndIp()));
        }
        Collections.sort(points, new Comparator<Long>() {
            @Override
            public int compare(Long o1, Long o2) {
                return new Long(o1-o2).intValue();
            }
        });
        for(Long point:points){
            for(int i=0;i<aRangeList.size();i++){
                List<Long> range =aRangeList.get(i);
                if(range.get(0)<point&&range.get(1)>point){
                    aRangeList.remove(i);
                    aRangeList.add(Arrays.asList(range.get(0),point));
                    aRangeList.add(Arrays.asList(point,range.get(1)));
                }
            }
            for(int i=0;i<bRangeList.size();i++){
                List<Long> range =bRangeList.get(i);
                if(range.get(0)<point&&range.get(1)>point){
                    bRangeList.remove(i);
                    bRangeList.add(Arrays.asList(range.get(0),point));
                    bRangeList.add(Arrays.asList(point,range.get(1)));
                }
            }
        }
        boolean removed=false;
        Iterator<List<Long>> ait=aRangeList.iterator();
        while(ait.hasNext()){
            List<Long> rangea =ait.next();
            Iterator<List<Long>> bit=bRangeList.iterator();
            while(bit.hasNext()){
                List<Long> rangeb =bit.next();
                if(rangea.get(0).equals(rangeb.get(0))&&rangea.get(1).equals(rangeb.get(1))){
                    removed=true;
                    ait.remove();
                    bit.remove();
                }
            }
        }

        if(!aRangeList.isEmpty()&&bRangeList.isEmpty()){
            return 1;
        }else if(aRangeList.isEmpty()&&!bRangeList.isEmpty()){
            return 2;
        }else if(!aRangeList.isEmpty()&&!bRangeList.isEmpty()){
            if(removed){
                return 3;
            }else{
                return 4;
            }
        }else{
            return 5;
        }
    }

    /**
     * 批量转换IP地址工具类 返回map
     * @param ipLong
     * @return key为传入long类型 value为ip字符串
     * @Author haoqingshuang
     */
    public static Map<Long,String> batchNumConvertIp(List<Long> ipLong) {
        Map<Long, String> result = new HashMap<>();
        if (ipLong.isEmpty()) {
            return result;
        }
        StringBuffer ipInfo = new StringBuffer();
        for (Long aLong : ipLong) {
            if (StringUtils.isNotBlank(result.get(aLong))) {
                continue;
            }
            ipInfo = new StringBuffer();
            // 直接右移24位
            ipInfo.append((aLong >>> 24));
            ipInfo.append(".");
            // 将高8位置0，然后右移16位
            ipInfo.append(((aLong & 0x00FFFFFF) >>> 16));
            ipInfo.append(".");
            // 将高16位置0，然后右移8位
            ipInfo.append(((aLong & 0x0000FFFF) >>> 8));
            ipInfo.append(".");
            // 将高24位置0
            ipInfo.append((aLong & 0x000000FF));
            result.put(aLong, ipInfo.toString());
        }
        return result;
    }
}

6.WordUtils

import freemarker.template.Configuration;
import freemarker.template.DefaultObjectWrapper;
import freemarker.template.Template;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.*;
import java.net.URLEncoder;
import java.nio.charset.StandardCharsets;
import java.util.Date;
import java.util.Map;

/**
 * 导出word工具类
 */
public class UasWordUtils {

    private static final Logger logger = LoggerFactory.getLogger(UasWordUtils.class);

    public static void exportMillCertificateWord(HttpServletRequest request, HttpServletResponse response, Map map, String title, String ftlFile) throws IOException {
        Configuration cfg = new Configuration();
        cfg.setObjectWrapper(new DefaultObjectWrapper());
        cfg.setNumberFormat("#");
        cfg.setClassForTemplateLoading(UasWordUtils.class, "template");
        Template freemarkerTemplate = cfg.getTemplate(ftlFile, "utf-8");
        File file = null;
        InputStream fin = null;
        ServletOutputStream out = null;
        try {
            // 调用工具类的createDoc方法生成Word文档
            file = createDoc(map, freemarkerTemplate);
            fin = new FileInputStream(file);

            response.setCharacterEncoding("utf-8");
            response.setContentType("application/msword");
            // 设置浏览器以下载的方式处理该文件名
            String fileName = title + DateUtil.ymdhmsFormat(new Date()) + ".doc";
            response.setHeader("Content-Disposition", "attachment;filename="
                    .concat(String.valueOf(URLEncoder.encode(fileName, "UTF-8"))));

            out = response.getOutputStream();
            byte[] buffer = new byte[512];  // 缓冲区
            int bytesToRead = -1;
            // 通过循环将读入的Word文件的内容输出到浏览器中
            while ((bytesToRead = fin.read(buffer)) != -1) {
                out.write(buffer, 0, bytesToRead);
            }
        } catch (Exception e) {
            logger.error("导出word异常：",e);
        } finally {
            if (fin != null) fin.close();
            if (out != null) out.close();
            if (file != null) file.delete(); // 删除临时文件
        }
    }

    private static File createDoc(Map<?, ?> dataMap, Template template) {
        String name = "sellPlan.doc";
        File f = new File(name);
        Template t = template;
        try {
            // 这个地方不能使用FileWriter因为需要指定编码类型否则生成的Word文档会因为有无法识别的编码而无法打开
            Writer w = new OutputStreamWriter(new FileOutputStream(f), StandardCharsets.UTF_8);
            t.process(dataMap, w);
            w.close();
        } catch (Exception ex) {
            logger.error("导出word填充数据异常：",ex);
            ex.printStackTrace();
            throw new RuntimeException(ex);
        }
        return f;
    }
}

 7.离线IP区划定位

import java.io.DataInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.Inet4Address;
import java.net.InetAddress;
import java.net.URISyntaxException;
import java.net.URLDecoder;
import java.net.UnknownHostException;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.Arrays;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
/**
 * ip-地域处理器
* @Title: IPDataHandler.java
* @Description: 基于ipip.net的17monipdb.dat
 */
public class IPDataHandler {
    private DataInputStream inputStream = null;
    private long fileLength = -1;
    private int dataLength = -1;
    private Map<String, String> cacheMap = null;
    private byte[] allData = null;
    
    @SuppressWarnings("deprecation")
    public IPDataHandler(){
        File file = new File(URLDecoder.decode(this.getClass().getResource("").getPath()+"/17monipdb.dat")); 
        try {
        inputStream = new DataInputStream(new FileInputStream(file));
        fileLength = file.length();
        cacheMap = new HashMap<String, String>();
        if (fileLength >Integer.MAX_VALUE) {
        throw new Exception("the filelength over 2GB");
        }
        dataLength = (int) fileLength;
        allData = new byte[dataLength];
        inputStream.read(allData, 0, dataLength);
        dataLength = (int)getbytesTolong(allData, 0, 4,ByteOrder.BIG_ENDIAN);
        } catch (FileNotFoundException e) {
        e.printStackTrace();
        }catch (IOException e) {
        e.printStackTrace();
        }catch(URISyntaxException e){
            e.printStackTrace();
        }catch (Exception e) {
        e.printStackTrace();
        }
    }
    private long getbytesTolong(byte[] bytes, int offerSet,int size,ByteOrder byteOrder){
        if ((offerSet+size) > bytes.length || size <= 0) {
        return -1;
        }
        byte[] b = new byte[size];
        for (int i = 0; i < b.length; i++) {
        b[i] = bytes[offerSet+i];
        }
        ByteBuffer byteBuffer = ByteBuffer.wrap(b);
        byteBuffer.order(byteOrder);
        long temp = -1;
        if (byteBuffer.hasRemaining()) {
        temp = byteBuffer.getInt();
        }
        return temp;
    }
    
    private long ip2long(String ip) throws UnknownHostException {
        InetAddress address = InetAddress.getByName(ip);
        byte[] bytes = address.getAddress();
        long reslut = getbytesTolong(bytes, 0, 4,ByteOrder.BIG_ENDIAN);
        return reslut;
    }
    private int getIntByBytes(byte[] b,int offSet){
        if (b == null || (b.length < (offSet+3))) {
        return -1;
        }
        byte[] bytes = Arrays.copyOfRange(allData, offSet, offSet+3);
        byte[] bs = new byte[4];
        bs[3] = 0;
        for (int i = 0; i < 3;i++) {
        bs[i]=bytes[i];
        }
        return (int)getbytesTolong(bs, 0, 4, ByteOrder.LITTLE_ENDIAN);
    }
    
    public String findGeography(String address){
        if (address == null) {
        return "illegal address";
        }
        if (dataLength < 4 || allData == null) {
        return "illegal ip data";
        }
        String ip = "127.0.0.1";
        try {
        ip = Inet4Address.getByName(address).getHostAddress();
        } catch (UnknownHostException e) {
        e.printStackTrace();
        }
        // String[] ipArray = StringUtils.split(ip, ".");
        // String[] ipArray = ip.split(".");
        //String[] ipArray = {"8", "8", "8", "8"};
        String[] ipArray = ip.split("\\.");
        int ipHeadValue = Integer.parseInt(ipArray[0]);
        if (ipArray.length !=4 || ipHeadValue < 0 || ipHeadValue > 255) {
        return "illegal ip";
        }
        if (cacheMap.containsKey(ip)) {
        return cacheMap.get(ip);
        }
        long numIp = 1;
        try {
        numIp = ip2long(address);
        } catch (UnknownHostException e1) {
        e1.printStackTrace();
        }
        int tempOffSet = ipHeadValue* 4 + 4;
        long start = getbytesTolong(allData, tempOffSet, 4,ByteOrder.LITTLE_ENDIAN);
        int max_len = dataLength - 1028;
        long resultOffSet = 0;
        int resultSize = 0;
        for (start = start*8 + 1024; start < max_len; start+=8) {
        if (getbytesTolong(allData, (int)start+4, 4,ByteOrder.BIG_ENDIAN) >= numIp) {
        resultOffSet = getIntByBytes(allData, (int)(start+4+4));
        resultSize = (char)allData[(int)start+7+4];
        break;
        }
        }
        if (resultOffSet <= 0) {
        return "resultOffSet too small";
        }
        byte[] add = Arrays.copyOfRange(allData, (int)(dataLength+resultOffSet-1024), (int)(dataLength+resultOffSet-1024 + resultSize));
        try {
        if (add == null) {
        cacheMap.put(ip, new String("no data found!!"));
        } else {
        cacheMap.put(ip, new String(add,"UTF-8"));
        }
        } catch (UnsupportedEncodingException e) {
        e.printStackTrace();
        }
        return cacheMap.get(ip);
    }
    
    public static void main(String[] args) {
        IPDataHandler obj = new IPDataHandler();
        System.out.println(obj.findGeography("53.248.9.181"));
        System.out.println(obj.findGeography("223.71.69.202"));
    }
}
    

链接：https://pan.baidu.com/s/1Ok-5WQ8jEk-JgXSG7j42bw?pwd=1tg5 
提取码：1tg5