Java 身份证工具类

1. import java.text.ParseException;    
2. import java.text.SimpleDateFormat;    
3. import java.util.Calendar;    
4. import java.util.Date;    
5. import java.util.HashMap;    
6. import java.util.Map;    
7.     
8. import org.apache.commons.lang.StringUtils;    
9.     
10. /**  
11.  * 身份证工具类  
12.  *   
13.  * @author June  
14.  * @version 1.0, 2010-06-17  
15.  */    
16. public class IdcardUtils extends StringUtils {    
17.     
18.     /** 中国公民身份证号码最小长度。 */    
19.     public static final int CHINA_ID_MIN_LENGTH = 15;    
20.     
21.     /** 中国公民身份证号码最大长度。 */    
22.     public static final int CHINA_ID_MAX_LENGTH = 18;    
23.     
24.     /** 省、直辖市代码表 */    
25.     public static final String cityCode[] = {    
26.             "11", "12", "13", "14", "15", "21", "22", "23", "31", "32", "33", "34", "35", "36", "37", "41",    
27.             "42", "43", "44", "45", "46", "50", "51", "52", "53", "54", "61", "62", "63", "64", "65", "71",    
28.             "81", "82", "91"    
29.     };    
30.     
31.     /** 每位加权因子 */    
32.     public static final int power[] = {    
33.             7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 2    
34.     };    
35.     
36.     /** 第18位校检码 */    
37.     public static final String verifyCode[] = {    
38.             "1", "0", "X", "9", "8", "7", "6", "5", "4", "3", "2"    
39.     };    
40.     /** 最低年限 */    
41.     public static final int MIN = 1930;    
42.     public static Map<String, String> cityCodes = new HashMap<String, String>();    
43.     /** 台湾身份首字母对应数字 */    
44.     public static Map<String, Integer> twFirstCode = new HashMap<String, Integer>();    
45.     /** 香港身份首字母对应数字 */    
46.     public static Map<String, Integer> hkFirstCode = new HashMap<String, Integer>();    
47.     static {    
48.         cityCodes.put("11", "北京");    
49.         cityCodes.put("12", "天津");    
50.         cityCodes.put("13", "河北");    
51.         cityCodes.put("14", "山西");    
52.         cityCodes.put("15", "内蒙古");    
53.         cityCodes.put("21", "辽宁");    
54.         cityCodes.put("22", "吉林");    
55.         cityCodes.put("23", "黑龙江");    
56.         cityCodes.put("31", "上海");    
57.         cityCodes.put("32", "江苏");    
58.         cityCodes.put("33", "浙江");    
59.         cityCodes.put("34", "安徽");    
60.         cityCodes.put("35", "福建");    
61.         cityCodes.put("36", "江西");    
62.         cityCodes.put("37", "山东");    
63.         cityCodes.put("41", "河南");    
64.         cityCodes.put("42", "湖北");    
65.         cityCodes.put("43", "湖南");    
66.         cityCodes.put("44", "广东");    
67.         cityCodes.put("45", "广西");    
68.         cityCodes.put("46", "海南");    
69.         cityCodes.put("50", "重庆");    
70.         cityCodes.put("51", "四川");    
71.         cityCodes.put("52", "贵州");    
72.         cityCodes.put("53", "云南");    
73.         cityCodes.put("54", "西藏");    
74.         cityCodes.put("61", "陕西");    
75.         cityCodes.put("62", "甘肃");    
76.         cityCodes.put("63", "青海");    
77.         cityCodes.put("64", "宁夏");    
78.         cityCodes.put("65", "新疆");    
79.         cityCodes.put("71", "台湾");    
80.         cityCodes.put("81", "香港");    
81.         cityCodes.put("82", "澳门");    
82.         cityCodes.put("91", "国外");    
83.         twFirstCode.put("A", 10);    
84.         twFirstCode.put("B", 11);    
85.         twFirstCode.put("C", 12);    
86.         twFirstCode.put("D", 13);    
87.         twFirstCode.put("E", 14);    
88.         twFirstCode.put("F", 15);    
89.         twFirstCode.put("G", 16);    
90.         twFirstCode.put("H", 17);    
91.         twFirstCode.put("J", 18);    
92.         twFirstCode.put("K", 19);    
93.         twFirstCode.put("L", 20);    
94.         twFirstCode.put("M", 21);    
95.         twFirstCode.put("N", 22);    
96.         twFirstCode.put("P", 23);    
97.         twFirstCode.put("Q", 24);    
98.         twFirstCode.put("R", 25);    
99.         twFirstCode.put("S", 26);    
100.         twFirstCode.put("T", 27);    
101.         twFirstCode.put("U", 28);    
102.         twFirstCode.put("V", 29);    
103.         twFirstCode.put("X", 30);    
104.         twFirstCode.put("Y", 31);    
105.         twFirstCode.put("W", 32);    
106.         twFirstCode.put("Z", 33);    
107.         twFirstCode.put("I", 34);    
108.         twFirstCode.put("O", 35);    
109.         hkFirstCode.put("A", 1);    
110.         hkFirstCode.put("B", 2);    
111.         hkFirstCode.put("C", 3);    
112.         hkFirstCode.put("R", 18);    
113.         hkFirstCode.put("U", 21);    
114.         hkFirstCode.put("Z", 26);    
115.         hkFirstCode.put("X", 24);    
116.         hkFirstCode.put("W", 23);    
117.         hkFirstCode.put("O", 15);    
118.         hkFirstCode.put("N", 14);    
119.     }    
120.     
121.     /**  
122.      * 将15位身份证号码转换为18位  
123.      *   
124.      * @param idCard  
125.      *            15位身份编码  
126.      * @return 18位身份编码  
127.      */    
128.     public static String conver15CardTo18(String idCard) {    
129.         String idCard18 = "";    
130.         if (idCard.length() != CHINA_ID_MIN_LENGTH) {    
131.             return null;    
132.         }    
133.         if (isNum(idCard)) {    
134.             // 获取出生年月日    
135.             String birthday = idCard.substring(6, 12);    
136.             Date birthDate = null;    
137.             try {    
138.                 birthDate = new SimpleDateFormat("yyMMdd").parse(birthday);    
139.             } catch (ParseException e) {    
140.                 e.printStackTrace();    
141.             }    
142.             Calendar cal = Calendar.getInstance();    
143.             if (birthDate != null)    
144.                 cal.setTime(birthDate);    
145.             // 获取出生年(完全表现形式,如：2010)    
146.             String sYear = String.valueOf(cal.get(Calendar.YEAR));    
147.             idCard18 = idCard.substring(0, 6) + sYear + idCard.substring(8);    
148.             // 转换字符数组    
149.             char[] cArr = idCard18.toCharArray();    
150.             if (cArr != null) {    
151.                 int[] iCard = converCharToInt(cArr);    
152.                 int iSum17 = getPowerSum(iCard);    
153.                 // 获取校验位    
154.                 String sVal = getCheckCode18(iSum17);    
155.                 if (sVal.length() > 0) {    
156.                     idCard18 += sVal;    
157.                 } else {    
158.                     return null;    
159.                 }    
160.             }    
161.         } else {    
162.             return null;    
163.         }    
164.         return idCard18;    
165.     }    
166.     
167.     /**  
168.      * 验证身份证是否合法  
169.      */    
170.     public static boolean validateCard(String idCard) {    
171.         String card = idCard.trim();    
172.         if (validateIdCard18(card)) {    
173.             return true;    
174.         }    
175.         if (validateIdCard15(card)) {    
176.             return true;    
177.         }    
178.         String[] cardval = validateIdCard10(card);    
179.         if (cardval != null) {    
180.             if (cardval[2].equals("true")) {    
181.                 return true;    
182.             }    
183.         }    
184.         return false;    
185.     }    
186.     
187.     /**  
188.      * 验证18位身份编码是否合法  
189.      *   
190.      * @param idCard 身份编码  
191.      * @return 是否合法  
192.      */    
193.     public static boolean validateIdCard18(String idCard) {    
194.         boolean bTrue = false;    
195.         if (idCard.length() == CHINA_ID_MAX_LENGTH) {    
196.             // 前17位    
197.             String code17 = idCard.substring(0, 17);    
198.             // 第18位    
199.             String code18 = idCard.substring(17, CHINA_ID_MAX_LENGTH);    
200.             if (isNum(code17)) {    
201.                 char[] cArr = code17.toCharArray();    
202.                 if (cArr != null) {    
203.                     int[] iCard = converCharToInt(cArr);    
204.                     int iSum17 = getPowerSum(iCard);    
205.                     // 获取校验位    
206.                     String val = getCheckCode18(iSum17);    
207.                     if (val.length() > 0) {    
208.                         if (val.equalsIgnoreCase(code18)) {    
209.                             bTrue = true;    
210.                         }    
211.                     }    
212.                 }    
213.             }    
214.         }    
215.         return bTrue;    
216.     }    
217.     
218.     /**  
219.      * 验证15位身份编码是否合法  
220.      *   
221.      * @param idCard  
222.      *            身份编码  
223.      * @return 是否合法  
224.      */    
225.     public static boolean validateIdCard15(String idCard) {    
226.         if (idCard.length() != CHINA_ID_MIN_LENGTH) {    
227.             return false;    
228.         }    
229.         if (isNum(idCard)) {    
230.             String proCode = idCard.substring(0, 2);    
231.             if (cityCodes.get(proCode) == null) {    
232.                 return false;    
233.             }    
234.             String birthCode = idCard.substring(6, 12);    
235.             Date birthDate = null;    
236.             try {    
237.                 birthDate = new SimpleDateFormat("yy").parse(birthCode.substring(0, 2));    
238.             } catch (ParseException e) {    
239.                 e.printStackTrace();    
240.             }    
241.             Calendar cal = Calendar.getInstance();    
242.             if (birthDate != null)    
243.                 cal.setTime(birthDate);    
244.             if (!valiDate(cal.get(Calendar.YEAR), Integer.valueOf(birthCode.substring(2, 4)),    
245.                     Integer.valueOf(birthCode.substring(4, 6)))) {    
246.                 return false;    
247.             }    
248.         } else {    
249.             return false;    
250.         }    
251.         return true;    
252.     }    
253.     
254.     /**  
255.      * 验证10位身份编码是否合法  
256.      *   
257.      * @param idCard 身份编码  
258.      * @return 身份证信息数组  
259.      *         <p>  
260.      *         [0] - 台湾、澳门、香港 [1] - 性别(男M,女F,未知N) [2] - 是否合法(合法true,不合法false)  
261.      *         若不是身份证件号码则返回null  
262.      *         </p>  
263.      */    
264.     public static String[] validateIdCard10(String idCard) {    
265.         String[] info = new String[3];    
266.         String card = idCard.replaceAll("[\\(|\\)]", "");    
267.         if (card.length() != 8 && card.length() != 9 && idCard.length() != 10) {    
268.             return null;    
269.         }    
270.         if (idCard.matches("^[a-zA-Z][0-9]{9}{1}quot;)) { // 台湾    
271.             info[0] = "台湾";    
272.             System.out.println("11111");    
273.             String char2 = idCard.substring(1, 2);    
274.             if (char2.equals("1")) {    
275.                 info[1] = "M";    
276.                 System.out.println("MMMMMMM");    
277.             } else if (char2.equals("2")) {    
278.                 info[1] = "F";    
279.                 System.out.println("FFFFFFF");    
280.             } else {    
281.                 info[1] = "N";    
282.                 info[2] = "false";    
283.                 System.out.println("NNNN");    
284.                 return info;    
285.             }    
286.             info[2] = validateTWCard(idCard) ? "true" : "false";    
287.         } else if (idCard.matches("^[1|5|7][0-9]{6}\\(?[0-9A-Z]\\)?{1}quot;)) { // 澳门    
288.             info[0] = "澳门";    
289.             info[1] = "N";    
290.             // TODO    
291.         } else if (idCard.matches("^[A-Z]{1,2}[0-9]{6}\\(?[0-9A]\\)?{1}quot;)) { // 香港    
292.             info[0] = "香港";    
293.             info[1] = "N";    
294.             info[2] = validateHKCard(idCard) ? "true" : "false";    
295.         } else {    
296.             return null;    
297.         }    
298.         return info;    
299.     }    
300.     
301.     /**  
302.      * 验证台湾身份证号码  
303.      *   
304.      * @param idCard  
305.      *            身份证号码  
306.      * @return 验证码是否符合  
307.      */    
308.     public static boolean validateTWCard(String idCard) {    
309.         String start = idCard.substring(0, 1);    
310.         String mid = idCard.substring(1, 9);    
311.         String end = idCard.substring(9, 10);    
312.         Integer iStart = twFirstCode.get(start);    
313.         Integer sum = iStart / 10 + (iStart % 10) * 9;    
314.         char[] chars = mid.toCharArray();    
315.         Integer iflag = 8;    
316.         for (char c : chars) {    
317.             sum = sum + Integer.valueOf(c + "") * iflag;    
318.             iflag--;    
319.         }    
320.         return (sum % 10 == 0 ? 0 : (10 - sum % 10)) == Integer.valueOf(end) ? true : false;    
321.     }    
322.     
323.     /**  
324.      * 验证香港身份证号码(存在Bug，部份特殊身份证无法检查)  
325.      * <p>  
326.      * 身份证前2位为英文字符，如果只出现一个英文字符则表示第一位是空格，对应数字58 前2位英文字符A-Z分别对应数字10-35  
327.      * 最后一位校验码为0-9的数字加上字符"A"，"A"代表10  
328.      * </p>  
329.      * <p>  
330.      * 将身份证号码全部转换为数字，分别对应乘9-1相加的总和，整除11则证件号码有效  
331.      * </p>  
332.      *   
333.      * @param idCard 身份证号码  
334.      * @return 验证码是否符合  
335.      */    
336.     public static boolean validateHKCard(String idCard) {    
337.         String card = idCard.replaceAll("[\\(|\\)]", "");    
338.         Integer sum = 0;    
339.         if (card.length() == 9) {    
340.             sum = (Integer.valueOf(card.substring(0, 1).toUpperCase().toCharArray()[0]) - 55) * 9    
341.                     + (Integer.valueOf(card.substring(1, 2).toUpperCase().toCharArray()[0]) - 55) * 8;    
342.             card = card.substring(1, 9);    
343.         } else {    
344.             sum = 522 + (Integer.valueOf(card.substring(0, 1).toUpperCase().toCharArray()[0]) - 55) * 8;    
345.         }    
346.         String mid = card.substring(1, 7);    
347.         String end = card.substring(7, 8);    
348.         char[] chars = mid.toCharArray();    
349.         Integer iflag = 7;    
350.         for (char c : chars) {    
351.             sum = sum + Integer.valueOf(c + "") * iflag;    
352.             iflag--;    
353.         }    
354.         if (end.toUpperCase().equals("A")) {    
355.             sum = sum + 10;    
356.         } else {    
357.             sum = sum + Integer.valueOf(end);    
358.         }    
359.         return (sum % 11 == 0) ? true : false;    
360.     }    
361.     
362.     /**  
363.      * 将字符数组转换成数字数组  
364.      *   
365.      * @param ca  
366.      *            字符数组  
367.      * @return 数字数组  
368.      */    
369.     public static int[] converCharToInt(char[] ca) {    
370.         int len = ca.length;    
371.         int[] iArr = new int[len];    
372.         try {    
373.             for (int i = 0; i < len; i++) {    
374.                 iArr[i] = Integer.parseInt(String.valueOf(ca[i]));    
375.             }    
376.         } catch (NumberFormatException e) {    
377.             e.printStackTrace();    
378.         }    
379.         return iArr;    
380.     }    
381.     
382.     /**  
383.      * 将身份证的每位和对应位的加权因子相乘之后，再得到和值  
384.      *   
385.      * @param iArr  
386.      * @return 身份证编码。  
387.      */    
388.     public static int getPowerSum(int[] iArr) {    
389.         int iSum = 0;    
390.         if (power.length == iArr.length) {    
391.             for (int i = 0; i < iArr.length; i++) {    
392.                 for (int j = 0; j < power.length; j++) {    
393.                     if (i == j) {    
394.                         iSum = iSum + iArr[i] * power[j];    
395.                     }    
396.                 }    
397.             }    
398.         }    
399.         return iSum;    
400.     }    
401.     
402.     /**  
403.      * 将power和值与11取模获得余数进行校验码判断  
404.      *   
405.      * @param iSum  
406.      * @return 校验位  
407.      */    
408.     public static String getCheckCode18(int iSum) {    
409.         String sCode = "";    
410.         switch (iSum % 11) {    
411.         case 10:    
412.             sCode = "2";    
413.             break;    
414.         case 9:    
415.             sCode = "3";    
416.             break;    
417.         case 8:    
418.             sCode = "4";    
419.             break;    
420.         case 7:    
421.             sCode = "5";    
422.             break;    
423.         case 6:    
424.             sCode = "6";    
425.             break;    
426.         case 5:    
427.             sCode = "7";    
428.             break;    
429.         case 4:    
430.             sCode = "8";    
431.             break;    
432.         case 3:    
433.             sCode = "9";    
434.             break;    
435.         case 2:    
436.             sCode = "x";    
437.             break;    
438.         case 1:    
439.             sCode = "0";    
440.             break;    
441.         case 0:    
442.             sCode = "1";    
443.             break;    
444.         }    
445.         return sCode;    
446.     }    
447.     
448.     /**  
449.      * 根据身份编号获取年龄  
450.      *   
451.      * @param idCard  
452.      *            身份编号  
453.      * @return 年龄  
454.      */    
455.     public static int getAgeByIdCard(String idCard) {    
456.         int iAge = 0;    
457.         if (idCard.length() == CHINA_ID_MIN_LENGTH) {    
458.             idCard = conver15CardTo18(idCard);    
459.         }    
460.         String year = idCard.substring(6, 10);    
461.         Calendar cal = Calendar.getInstance();    
462.         int iCurrYear = cal.get(Calendar.YEAR);    
463.         iAge = iCurrYear - Integer.valueOf(year);    
464.         return iAge;    
465.     }    
466.     
467.     /**  
468.      * 根据身份编号获取生日  
469.      *   
470.      * @param idCard 身份编号  
471.      * @return 生日(yyyyMMdd)  
472.      */    
473.     public static String getBirthByIdCard(String idCard) {    
474.         Integer len = idCard.length();    
475.         if (len < CHINA_ID_MIN_LENGTH) {    
476.             return null;    
477.         } else if (len == CHINA_ID_MIN_LENGTH) {    
478.             idCard = conver15CardTo18(idCard);    
479.         }    
480.         return idCard.substring(6, 14);    
481.     }    
482.     
483.     /**  
484.      * 根据身份编号获取生日年  
485.      *   
486.      * @param idCard 身份编号  
487.      * @return 生日(yyyy)  
488.      */    
489.     public static Short getYearByIdCard(String idCard) {    
490.         Integer len = idCard.length();    
491.         if (len < CHINA_ID_MIN_LENGTH) {    
492.             return null;    
493.         } else if (len == CHINA_ID_MIN_LENGTH) {    
494.             idCard = conver15CardTo18(idCard);    
495.         }    
496.         return Short.valueOf(idCard.substring(6, 10));    
497.     }    
498.     
499.     /**  
500.      * 根据身份编号获取生日月  
501.      *   
502.      * @param idCard  
503.      *            身份编号  
504.      * @return 生日(MM)  
505.      */    
506.     public static Short getMonthByIdCard(String idCard) {    
507.         Integer len = idCard.length();    
508.         if (len < CHINA_ID_MIN_LENGTH) {    
509.             return null;    
510.         } else if (len == CHINA_ID_MIN_LENGTH) {    
511.             idCard = conver15CardTo18(idCard);    
512.         }    
513.         return Short.valueOf(idCard.substring(10, 12));    
514.     }    
515.     
516.     /**  
517.      * 根据身份编号获取生日天  
518.      *   
519.      * @param idCard  
520.      *            身份编号  
521.      * @return 生日(dd)  
522.      */    
523.     public static Short getDateByIdCard(String idCard) {    
524.         Integer len = idCard.length();    
525.         if (len < CHINA_ID_MIN_LENGTH) {    
526.             return null;    
527.         } else if (len == CHINA_ID_MIN_LENGTH) {    
528.             idCard = conver15CardTo18(idCard);    
529.         }    
530.         return Short.valueOf(idCard.substring(12, 14));    
531.     }    
532.     
533.     /**  
534.      * 根据身份编号获取性别  
535.      *   
536.      * @param idCard 身份编号  
537.      * @return 性别(M-男，F-女，N-未知)  
538.      */    
539.     public static String getGenderByIdCard(String idCard) {    
540.         String sGender = "N";    
541.         if (idCard.length() == CHINA_ID_MIN_LENGTH) {    
542.             idCard = conver15CardTo18(idCard);    
543.         }    
544.         String sCardNum = idCard.substring(16, 17);    
545.         if (Integer.parseInt(sCardNum) % 2 != 0) {    
546.             sGender = "M";    
547.         } else {    
548.             sGender = "F";    
549.         }    
550.         return sGender;    
551.     }    
552.     
553.     /**  
554.      * 根据身份编号获取户籍省份  
555.      *   
556.      * @param idCard 身份编码  
557.      * @return 省级编码。  
558.      */    
559.     public static String getProvinceByIdCard(String idCard) {    
560.         int len = idCard.length();    
561.         String sProvince = null;    
562.         String sProvinNum = "";    
563.         if (len == CHINA_ID_MIN_LENGTH || len == CHINA_ID_MAX_LENGTH) {    
564.             sProvinNum = idCard.substring(0, 2);    
565.         }    
566.         sProvince = cityCodes.get(sProvinNum);    
567.         return sProvince;    
568.     }    
569.     
570.     /**  
571.      * 数字验证  
572.      *   
573.      * @param val  
574.      * @return 提取的数字。  
575.      */    
576.     public static boolean isNum(String val) {    
577.         return val == null || "".equals(val) ? false : val.matches("^[0-9]*{1}quot;);    
578.     }    
579.     
580.     /**  
581.      * 验证小于当前日期 是否有效  
582.      *   
583.      * @param iYear  
584.      *            待验证日期(年)  
585.      * @param iMonth  
586.      *            待验证日期(月 1-12)  
587.      * @param iDate  
588.      *            待验证日期(日)  
589.      * @return 是否有效  
590.      */    
591.     public static boolean valiDate(int iYear, int iMonth, int iDate) {    
592.         Calendar cal = Calendar.getInstance();    
593.         int year = cal.get(Calendar.YEAR);    
594.         int datePerMonth;    
595.         if (iYear < MIN || iYear >= year) {    
596.             return false;    
597.         }    
598.         if (iMonth < 1 || iMonth > 12) {    
599.             return false;    
600.         }    
601.         switch (iMonth) {    
602.         case 4:    
603.         case 6:    
604.         case 9:    
605.         case 11:    
606.             datePerMonth = 30;    
607.             break;    
608.         case 2:    
609.             boolean dm = ((iYear % 4 == 0 && iYear % 100 != 0) || (iYear % 400 == 0))    
610.                     && (iYear > MIN && iYear < year);    
611.             datePerMonth = dm ? 29 : 28;    
612.             break;    
613.         default:    
614.             datePerMonth = 31;    
615.         }    
616.         return (iDate >= 1) && (iDate <= datePerMonth);    
617.     }    
618. }