devbox
你好赵伟
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Java身份证正则校验、性别年龄籍贯提取_java身份证信息提取

作者：你好赵伟 | 2024-06-08 20:01:05

赞

踩

java身份证信息提取

共2个文件

IdcardInfoExtractor.java

  1. package cn.com.baidu.utils.identity;
  2.  
  3. import java.text.SimpleDateFormat;  
  4. import java.util.Calendar;  
  5. import java.util.Date;  
  6. import java.util.GregorianCalendar;  
  7. import java.util.HashMap;  
  8. import java.util.Map;  
  9. import java.util.Set;  
  10.   
  11. /**
  12.  * 提取身份证相关信息  
  13.  * ClassName: IdcardInfoExtractor
  14.  * @Description: TODO
  15.  * 创建工具: MyEclipse2014
  16.  * 运行环境: [Tomcat7以上,MySql5.6以上,JDK7以上]
  17.  * @author CBC
  18.  * @date 2018年9月17日
  19.  */
  20. public class IdcardInfoExtractor {  
  21.     // 省份  
  22.     private String province;  
  23.     // 城市  
  24.     private String city;  
  25.     // 区县  
  26.     private String region;  
  27.     // 年份  
  28.     private int year;  
  29.     // 月份  
  30.     private int month;  
  31.     // 日期  
  32.     private int day;  
  33.     // 性别  
  34.     private String gender;  
  35.     // 出生日期  
  36.     private Date birthday;
  37.     // 年龄
  38.     private int age;
  39.     // 年龄
  40.     private boolean isIdCard;
  41.     
  42.     public boolean isIdCard() {
  43. 		return isIdCard;
  44. 	}
  45.  
  46. 	public void setIdCard(boolean isIdCard) {
  47. 		this.isIdCard = isIdCard;
  48. 	}
  49.  
  50. 	@SuppressWarnings("serial")
  51. 	private Map<String, String> cityCodeMap = new HashMap<String, String>() {  
  52.         {  
  53.             this.put("11", "北京");  
  54.             this.put("12", "天津");  
  55.             this.put("13", "河北");  
  56.             this.put("14", "山西");  
  57.             this.put("15", "内蒙古");  
  58.             this.put("21", "辽宁");  
  59.             this.put("22", "吉林");  
  60.             this.put("23", "黑龙江");  
  61.             this.put("31", "上海");  
  62.             this.put("32", "江苏");  
  63.             this.put("33", "浙江");  
  64.             this.put("34", "安徽");  
  65.             this.put("35", "福建");  
  66.             this.put("36", "江西");  
  67.             this.put("37", "山东");  
  68.             this.put("41", "河南");  
  69.             this.put("42", "湖北");  
  70.             this.put("43", "湖南");  
  71.             this.put("44", "广东");  
  72.             this.put("45", "广西");  
  73.             this.put("46", "海南");  
  74.             this.put("50", "重庆");  
  75.             this.put("51", "四川");  
  76.             this.put("52", "贵州");  
  77.             this.put("53", "云南");  
  78.             this.put("54", "西藏");  
  79.             this.put("61", "陕西");  
  80.             this.put("62", "甘肃");  
  81.             this.put("63", "青海");  
  82.             this.put("64", "宁夏");  
  83.             this.put("65", "新疆");  
  84.             this.put("71", "台湾");  
  85.             this.put("81", "香港");  
  86.             this.put("82", "澳门");  
  87.             this.put("91", "国外");  
  88.         }  
  89.     };  
  90.   
  91.     private IdcardValidator validator = null;  
  92.   
  93.     /**
  94.      * 通过构造方法初始化各个成员属性  
  95.      * 
  96.      * <p>Description: </p>
  97.      *
  98.      * @param idcard
  99.      *
  100.      */
  101.     public IdcardInfoExtractor(String idcard) {  
  102.         try {  
  103.             validator = new IdcardValidator();  
  104.             if (validator.isValidatedAllIdcard(idcard)) {  
  105.                 if (idcard.length() == 15) {  
  106.                     idcard = validator.convertIdcarBy15bit(idcard);  
  107.                 }  
  108.                 // 获取省份  
  109.                 String provinceId = idcard.substring(0, 2);  
  110.                 Set<String> key = this.cityCodeMap.keySet();  
  111.                 for (String id : key) {  
  112.                     if (id.equals(provinceId)) {  
  113.                         this.province = this.cityCodeMap.get(id);  
  114.                         break;  
  115.                     }  
  116.                 }  
  117.   
  118.                 // 获取性别  
  119.                 String id17 = idcard.substring(16, 17);  
  120.                 if (Integer.parseInt(id17) % 2 != 0) {  
  121.                     this.gender = "男";  
  122.                 } else {  
  123.                     this.gender = "女";  
  124.                 } 
  125.                 // 获取出生日期  
  126.                 String birthday = idcard.substring(6, 14);  
  127.                 Date birthdate = new SimpleDateFormat("yyyyMMdd").parse(birthday);  
  128.                 this.birthday = birthdate;  
  129.                 GregorianCalendar currentDay = new GregorianCalendar();  
  130.                 currentDay.setTime(birthdate);  
  131.                 this.year = currentDay.get(Calendar.YEAR);  
  132.                 this.month = currentDay.get(Calendar.MONTH) + 1;  
  133.                 this.day = currentDay.get(Calendar.DAY_OF_MONTH);  
  134.                 this.age = getAgeByBirth(this.birthday);
  135.                 this.isIdCard =true;
  136.             }  else{
  137.             	this.isIdCard = false;
  138.             }
  139.         } catch (Exception e) {  
  140.             e.printStackTrace();  
  141.         }  
  142.     }  
  143.     
  144.     /**
  145.      * 通过生日获取年龄
  146.      * @Description: TODO
  147.      * @param @param birthday
  148.      * @param @return   
  149.      * @return int  
  150.      * @throws
  151.      * @author 崔宝铖
  152.      * @date 2019年4月9日
  153.      */
  154.     public static int getAgeByBirth(Date birthday) {
  155.         int age = 0;
  156.         try {
  157.             Calendar now = Calendar.getInstance();
  158.             now.setTime(new Date());// 当前时间
  159.             Calendar birth = Calendar.getInstance();
  160.             birth.setTime(birthday);
  161.  
  162.             if (birth.after(now)) {//如果传入的时间，在当前时间的后面，返回0岁
  163.                 age = 0;
  164.             } else {
  165.                 age = now.get(Calendar.YEAR) - birth.get(Calendar.YEAR);
  166.                 if (now.get(Calendar.DAY_OF_YEAR) > birth.get(Calendar.DAY_OF_YEAR)) {
  167.                     age += 1;
  168.                 }
  169.             }
  170.             return age;
  171.         } catch (Exception e) {//兼容性更强,异常后返回数据
  172.            return 0;
  173.         }
  174.     }
  175.   
  176.     public String getProvince() {  
  177.         return province;  
  178.     }  
  179.   
  180.     public String getCity() {  
  181.         return city;  
  182.     }  
  183.   
  184.     public String getRegion() {  
  185.         return region;  
  186.     }  
  187.   
  188.     public int getYear() {  
  189.         return year;  
  190.     }  
  191.   
  192.     public int getMonth() {  
  193.         return month;  
  194.     }  
  195.   
  196.     public int getDay() {  
  197.         return day;  
  198.     }  
  199.   
  200.     public String getGender() {  
  201.         return gender;  
  202.     }  
  203.   
  204.     public Date getBirthday() {  
  205.         return birthday;  
  206.     } 
  207.     
  208.     public int getAge() {
  209. 		return age;
  210. 	}
  211.  
  212. 	public void setAge(int age) {
  213. 		this.age = age;
  214. 	}
  215.  
  216. 	public Map<String, String> getCityCodeMap() {
  217. 		return cityCodeMap;
  218. 	}
  219.  
  220. 	public void setCityCodeMap(Map<String, String> cityCodeMap) {
  221. 		this.cityCodeMap = cityCodeMap;
  222. 	}
  223.  
  224. 	public IdcardValidator getValidator() {
  225. 		return validator;
  226. 	}
  227.  
  228. 	public void setValidator(IdcardValidator validator) {
  229. 		this.validator = validator;
  230. 	}
  231.  
  232. 	public void setProvince(String province) {
  233. 		this.province = province;
  234. 	}
  235.  
  236. 	public void setCity(String city) {
  237. 		this.city = city;
  238. 	}
  239.  
  240. 	public void setRegion(String region) {
  241. 		this.region = region;
  242. 	}
  243.  
  244. 	public void setYear(int year) {
  245. 		this.year = year;
  246. 	}
  247.  
  248. 	public void setMonth(int month) {
  249. 		this.month = month;
  250. 	}
  251.  
  252. 	public void setDay(int day) {
  253. 		this.day = day;
  254. 	}
  255.  
  256. 	public void setGender(String gender) {
  257. 		this.gender = gender;
  258. 	}
  259.  
  260. 	public void setBirthday(Date birthday) {
  261. 		this.birthday = birthday;
  262. 	}
  263.  
  264. 	@Override  
  265.     public String toString() {  
  266.         return "省份：" + this.province + ",性别：" + this.gender + ",出生日期："  
  267.                 + this.birthday + ",年龄："+this.age;  
  268.     }  
  269.   
  270.     public static void main(String[] args) {  
  271.         String idcard = "123456789101234567";
  272.         IdcardInfoExtractor ie = new IdcardInfoExtractor(idcard);  
  273.         System.out.println(ie.isIdCard);
  274.         System.out.println(ie.toString());
  275.         System.out.println(ie.getProvince());
  276.     }
  277. }

IdcardValidator.java

  1. package cn.com.baidu.utils.identity;
  2.  
  3. /**  
  4.  * 身份证前6位【ABCDEF】为行政区划数字代码（简称数字码）说明（参考《GB/T 2260-2007 中华人民共和国行政区划代码》）：  
  5.  * 该数字码的编制原则和结构分析，它采用三层六位层次码结构，按层次分别表示我国各省（自治区，直辖市，特别行政区）、  
  6.  * 市（地区，自治州，盟）、县（自治县、县级市、旗、自治旗、市辖区、林区、特区）。   
  7.  数字码码位结构从左至右的含义是：   
  8.  第一层为AB两位代码表示省、自治区、直辖市、特别行政区；   
  9.  第二层为CD两位代码表示市、地区、自治州、盟、直辖市所辖市辖区、县汇总码、省（自治区）直辖县级行政区划汇总码，其中：   
  10.  ——01~20、51~70表示市，01、02还用于表示直辖市所辖市辖区、县汇总码；   
  11.  ——21~50表示地区、自治州、盟；   
  12.  ——90表示省（自治区）直辖县级行政区划汇总码。   
  13.  第三层为EF两位表示县、自治县、县级市、旗、自治旗、市辖区、林区、特区，其中：   
  14.  ——01~20表示市辖区、地区（自治州、盟）辖县级市、市辖特区以及省（自治区）直辖县级行政区划中的县级市，01通常表示辖区汇总码；  
  15.  ——21~80表示县、自治县、旗、自治旗、林区、地区辖特区；   
  16.  ——81~99表示省（自治区）辖县级市。   
  17.  */  
  18.   
  19. import java.text.ParseException;  
  20. import java.text.SimpleDateFormat;  
  21. import java.util.Calendar;  
  22. import java.util.Date;  
  23. import java.util.GregorianCalendar;  
  24. import java.util.HashMap;  
  25. import java.util.Map;  
  26. import java.util.regex.Pattern;  
  27.   
  28. /**  
  29.  * <p>  
  30.  * 类说明:身份证合法性校验  
  31.  * </p>  CBC
  32.  * 2018-9-17 18:10:42
  33.  * <p>  
  34.  * --15位身份证号码：第7、8位为出生年份(两位数)，第9、10位为出生月份，第11、12位代表出生日期，第15位代表性别，奇数为男，偶数为女。  
  35.  * --18位身份证号码  
  36.  * ：第7、8、9、10位为出生年份(四位数)，第11、第12位为出生月份，第13、14位代表出生日期，第17位代表性别，奇数为男，偶数为女。  
  37.  * </p>  
  38.  */  
  39. @SuppressWarnings({ "unchecked", "unused", "all" })  
  40. public class IdcardValidator {  
  41.   
  42.     /**  
  43.      * 省，直辖市代码表： { 11:"北京",12:"天津",13:"河北",14:"山西",15:"内蒙古",  
  44.      * 21:"辽宁",22:"吉林",23:"黑龙江",31:"上海",32:"江苏",  
  45.      * 33:"浙江",34:"安徽",35:"福建",36:"江西",37:"山东",41:"河南",  
  46.      * 42:"湖北",43:"湖南",44:"广东",45:"广西",46:"海南",50:"重庆",  
  47.      * 51:"四川",52:"贵州",53:"云南",54:"西藏",61:"陕西",62:"甘肃",  
  48.      * 63:"青海",64:"宁夏",65:"新疆",71:"台湾",81:"香港",82:"澳门",91:"国外"}  
  49.      */  
  50.     protected String codeAndCity[][] = { { "11", "北京" }, { "12", "天津" },  
  51.             { "13", "河北" }, { "14", "山西" }, { "15", "内蒙古" }, { "21", "辽宁" },  
  52.             { "22", "吉林" }, { "23", "黑龙江" }, { "31", "上海" }, { "32", "江苏" },  
  53.             { "33", "浙江" }, { "34", "安徽" }, { "35", "福建" }, { "36", "江西" },  
  54.             { "37", "山东" }, { "41", "河南" }, { "42", "湖北" }, { "43", "湖南" },  
  55.             { "44", "广东" }, { "45", "广西" }, { "46", "海南" }, { "50", "重庆" },  
  56.             { "51", "四川" }, { "52", "贵州" }, { "53", "云南" }, { "54", "西藏" },  
  57.             { "61", "陕西" }, { "62", "甘肃" }, { "63", "青海" }, { "64", "宁夏" },  
  58.             { "65", "新疆" }, { "71", "台湾" }, { "81", "香港" }, { "82", "澳门" },  
  59.             { "91", "国外" } };  
  60.   
  61.     private String cityCode[] = { "11", "12", "13", "14", "15", "21", "22",  
  62.             "23", "31", "32", "33", "34", "35", "36", "37", "41", "42", "43",  
  63.             "44", "45", "46", "50", "51", "52", "53", "54", "61", "62", "63",  
  64.             "64", "65", "71", "81", "82", "91" };  
  65.   
  66.     // 每位加权因子  
  67.     private int power[] = { 7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 2 };  
  68.   
  69.     // 第18位校检码  
  70.     private String verifyCode[] = { "1", "0", "X", "9", "8", "7", "6", "5",  
  71.             "4", "3", "2" };  
  72.   
  73.     /**  
  74.      * 验证所有的身份证的合法性  
  75.      *   
  76.      * @param idcard  
  77.      * @return  
  78.      */  
  79.     public boolean isValidatedAllIdcard(String idcard) {  
  80.         if (idcard.length() == 15) {  
  81.             idcard = this.convertIdcarBy15bit(idcard);  
  82.         }  
  83.         return this.isValidate18Idcard(idcard);  
  84.     }  
  85.   
  86.     /**  
  87.      * <p>  
  88.      * 判断18位身份证的合法性  
  89.      * </p>  
  90.      * 根据〖中华人民共和国国家标准GB11643-1999〗中有关公民身份号码的规定，公民身份号码是特征组合码，由十七位数字本体码和一位数字校验码组成。  
  91.      * 排列顺序从左至右依次为：六位数字地址码，八位数字出生日期码，三位数字顺序码和一位数字校验码。  
  92.      * <p>  
  93.      * 顺序码: 表示在同一地址码所标识的区域范围内，对同年、同月、同 日出生的人编定的顺序号，顺序码的奇数分配给男性，偶数分配 给女性。  
  94.      * </p>  
  95.      * <p>  
  96.      * 1.前1、2位数字表示：所在省份的代码； 2.第3、4位数字表示：所在城市的代码； 3.第5、6位数字表示：所在区县的代码；  
  97.      * 4.第7~14位数字表示：出生年、月、日； 5.第15、16位数字表示：所在地的派出所的代码；  
  98.      * 6.第17位数字表示性别：奇数表示男性，偶数表示女性；  
  99.      * 7.第18位数字是校检码：也有的说是个人信息码，一般是随计算机的随机产生，用来检验身份证的正确性。校检码可以是0~9的数字，有时也用x表示。  
  100.      * </p>  
  101.      * <p>  
  102.      * 第十八位数字(校验码)的计算方法为： 1.将前面的身份证号码17位数分别乘以不同的系数。从第一位到第十七位的系数分别为：7 9 10 5 8 4  
  103.      * 2 1 6 3 7 9 10 5 8 4 2  
  104.      * </p>  
  105.      * <p>  
  106.      * 2.将这17位数字和系数相乘的结果相加。  
  107.      * </p>  
  108.      * <p>  
  109.      * 3.用加出来和除以11，看余数是多少？  
  110.      * </p>  
  111.      * 4.余数只可能有0 1 2 3 4 5 6 7 8 9 10这11个数字。其分别对应的最后一位身份证的号码为1 0 X 9 8 7 6 5 4 3  
  112.      * 2。  
  113.      * <p>  
  114.      * 5.通过上面得知如果余数是2，就会在身份证的第18位数字上出现罗马数字的Ⅹ。如果余数是10，身份证的最后一位号码就是2。  
  115.      * </p>  
  116.      *   
  117.      * @param idcard  
  118.      * @return  
  119.      */  
  120.     public boolean isValidate18Idcard(String idcard) {  
  121.         // 非18位为假  
  122.         if (idcard.length() != 18) {  
  123.             return false;  
  124.         }  
  125.         // 获取前17位  
  126.         String idcard17 = idcard.substring(0, 17);  
  127.         // 获取第18位  
  128.         String idcard18Code = idcard.substring(17, 18);  
  129.         char c[] = null;  
  130.         String checkCode = "";  
  131.         // 是否都为数字  
  132.         if (isDigital(idcard17)) {  
  133.             c = idcard17.toCharArray();  
  134.         } else {  
  135.             return false;  
  136.         }  
  137.   
  138.         if (null != c) {  
  139.             int bit[] = new int[idcard17.length()];  
  140.   
  141.             bit = converCharToInt(c);  
  142.   
  143.             int sum17 = 0;  
  144.   
  145.             sum17 = getPowerSum(bit);  
  146.   
  147.             // 将和值与11取模得到余数进行校验码判断  
  148.             checkCode = getCheckCodeBySum(sum17);  
  149.             if (null == checkCode) {  
  150.                 return false;  
  151.             }  
  152.             // 将身份证的第18位与算出来的校码进行匹配，不相等就为假  
  153.             if (!idcard18Code.equalsIgnoreCase(checkCode)) {  
  154.                 return false;  
  155.             }  
  156.         }  
  157.         return true;  
  158.     }  
  159.   
  160.     /**  
  161.      * 验证15位身份证的合法性,该方法验证不准确，最好是将15转为18位后再判断，该类中已提供。  
  162.      *   
  163.      * @param idcard  
  164.      * @return  
  165.      */  
  166.     public boolean isValidate15Idcard(String idcard) {  
  167.         // 非15位为假  
  168.         if (idcard.length() != 15) {  
  169.             return false;  
  170.         }  
  171.   
  172.         // 是否全都为数字  
  173.         if (isDigital(idcard)) {  
  174.             String provinceid = idcard.substring(0, 2);  
  175.             String birthday = idcard.substring(6, 12);  
  176.             int year = Integer.parseInt(idcard.substring(6, 8));  
  177.             int month = Integer.parseInt(idcard.substring(8, 10));  
  178.             int day = Integer.parseInt(idcard.substring(10, 12));  
  179.   
  180.             // 判断是否为合法的省份  
  181.             boolean flag = false;  
  182.             for (String id : cityCode) {  
  183.                 if (id.equals(provinceid)) {  
  184.                     flag = true;  
  185.                     break;  
  186.                 }  
  187.             }  
  188.             if (!flag) {  
  189.                 return false;  
  190.             }  
  191.             // 该身份证生出日期在当前日期之后时为假  
  192.             Date birthdate = null;  
  193.             try {  
  194.                 birthdate = new SimpleDateFormat("yyMMdd").parse(birthday);  
  195.             } catch (ParseException e) {  
  196.                 e.printStackTrace();  
  197.             }  
  198.             if (birthdate == null || new Date().before(birthdate)) {  
  199.                 return false;  
  200.             }  
  201.   
  202.             // 判断是否为合法的年份  
  203.             GregorianCalendar curDay = new GregorianCalendar();  
  204.             int curYear = curDay.get(Calendar.YEAR);  
  205.             int year2bit = Integer.parseInt(String.valueOf(curYear)  
  206.                     .substring(2));  
  207.   
  208.             // 判断该年份的两位表示法，小于50的和大于当前年份的，为假  
  209.             if ((year < 50 && year > year2bit)) {  
  210.                 return false;  
  211.             }  
  212.   
  213.             // 判断是否为合法的月份  
  214.             if (month < 1 || month > 12) {  
  215.                 return false;  
  216.             }  
  217.   
  218.             // 判断是否为合法的日期  
  219.             boolean mflag = false;  
  220.             curDay.setTime(birthdate); // 将该身份证的出生日期赋于对象curDay  
  221.             switch (month) {  
  222.             case 1:  
  223.             case 3:  
  224.             case 5:  
  225.             case 7:  
  226.             case 8:  
  227.             case 10:  
  228.             case 12:  
  229.                 mflag = (day >= 1 && day <= 31);  
  230.                 break;  
  231.             case 2: // 公历的2月非闰年有28天,闰年的2月是29天。  
  232.                 if (curDay.isLeapYear(curDay.get(Calendar.YEAR))) {  
  233.                     mflag = (day >= 1 && day <= 29);  
  234.                 } else {  
  235.                     mflag = (day >= 1 && day <= 28);  
  236.                 }  
  237.                 break;  
  238.             case 4:  
  239.             case 6:  
  240.             case 9:  
  241.             case 11:  
  242.                 mflag = (day >= 1 && day <= 30);  
  243.                 break;  
  244.             }  
  245.             if (!mflag) {  
  246.                 return false;  
  247.             }  
  248.         } else {  
  249.             return false;  
  250.         }  
  251.         return true;  
  252.     }  
  253.   
  254.     /**  
  255.      * 将15位的身份证转成18位身份证  
  256.      *   
  257.      * @param idcard  
  258.      * @return  
  259.      */  
  260.     public String convertIdcarBy15bit(String idcard) {  
  261.         String idcard17 = null;  
  262.         // 非15位身份证  
  263.         if (idcard.length() != 15) {  
  264.             return null;  
  265.         }  
  266.   
  267.         if (isDigital(idcard)) {  
  268.             // 获取出生年月日  
  269.             String birthday = idcard.substring(6, 12);  
  270.             Date birthdate = null;  
  271.             try {  
  272.                 birthdate = new SimpleDateFormat("yyMMdd").parse(birthday);  
  273.             } catch (ParseException e) {  
  274.                 e.printStackTrace();  
  275.             }  
  276.             Calendar cday = Calendar.getInstance();  
  277.             cday.setTime(birthdate);  
  278.             String year = String.valueOf(cday.get(Calendar.YEAR));  
  279.   
  280.             idcard17 = idcard.substring(0, 6) + year + idcard.substring(8);  
  281.   
  282.             char c[] = idcard17.toCharArray();  
  283.             String checkCode = "";  
  284.   
  285.             if (null != c) {  
  286.                 int bit[] = new int[idcard17.length()];  
  287.   
  288.                 // 将字符数组转为整型数组  
  289.                 bit = converCharToInt(c);  
  290.                 int sum17 = 0;  
  291.                 sum17 = getPowerSum(bit);  
  292.   
  293.                 // 获取和值与11取模得到余数进行校验码  
  294.                 checkCode = getCheckCodeBySum(sum17);  
  295.                 // 获取不到校验位  
  296.                 if (null == checkCode) {  
  297.                     return null;  
  298.                 }  
  299.   
  300.                 // 将前17位与第18位校验码拼接  
  301.                 idcard17 += checkCode;  
  302.             }  
  303.         } else { // 身份证包含数字  
  304.             return null;  
  305.         }  
  306.         return idcard17;  
  307.     }  
  308.   
  309.     /**  
  310.      * 15位和18位身份证号码的基本数字和位数验校  
  311.      *   
  312.      * @param idcard  
  313.      * @return  
  314.      */  
  315.     public boolean isIdcard(String idcard) {  
  316.         return idcard == null || "".equals(idcard) ? false : Pattern.matches(  
  317.                 "(^\\d{15}$)|(\\d{17}(?:\\d|x|X)$)", idcard);  
  318.     }  
  319.   
  320.     /**  
  321.      * 15位身份证号码的基本数字和位数验校  
  322.      *   
  323.      * @param idcard  
  324.      * @return  
  325.      */  
  326.     public boolean is15Idcard(String idcard) {  
  327.         return idcard == null || "".equals(idcard) ? false : Pattern.matches(  
  328.                 "^[1-9]\\d{7}((0\\d)|(1[0-2]))(([0|1|2]\\d)|3[0-1])\\d{3}$",  
  329.                 idcard);  
  330.     }  
  331.   
  332.     /**  
  333.      * 18位身份证号码的基本数字和位数验校  
  334.      *   
  335.      * @param idcard  
  336.      * @return  
  337.      */  
  338.     public boolean is18Idcard(String idcard) {  
  339.         return Pattern  
  340.                 .matches(  
  341.                         "^[1-9]\\d{5}[1-9]\\d{3}((0\\d)|(1[0-2]))(([0|1|2]\\d)|3[0-1])\\d{3}([\\d|x|X]{1})$",  
  342.                         idcard);  
  343.     }  
  344.   
  345.     /**  
  346.      * 数字验证  
  347.      *   
  348.      * @param str  
  349.      * @return  
  350.      */  
  351.     public boolean isDigital(String str) {  
  352.         return str == null || "".equals(str) ? false : str.matches("^[0-9]*$");  
  353.     }  
  354.   
  355.     /**  
  356.      * 将身份证的每位和对应位的加权因子相乘之后，再得到和值  
  357.      *   
  358.      * @param bit  
  359.      * @return  
  360.      */  
  361.     public int getPowerSum(int[] bit) {  
  362.   
  363.         int sum = 0;  
  364.   
  365.         if (power.length != bit.length) {  
  366.             return sum;  
  367.         }  
  368.   
  369.         for (int i = 0; i < bit.length; i++) {  
  370.             for (int j = 0; j < power.length; j++) {  
  371.                 if (i == j) {  
  372.                     sum = sum + bit[i] * power[j];  
  373.                 }  
  374.             }  
  375.         }  
  376.         return sum;  
  377.     }  
  378.   
  379.     /**  
  380.      * 将和值与11取模得到余数进行校验码判断  
  381.      *   
  382.      * @param checkCode  
  383.      * @param sum17  
  384.      * @return 校验位  
  385.      */  
  386.     public String getCheckCodeBySum(int sum17) {  
  387.         String checkCode = null;  
  388.         switch (sum17 % 11) {  
  389.         case 10:  
  390.             checkCode = "2";  
  391.             break;  
  392.         case 9:  
  393.             checkCode = "3";  
  394.             break;  
  395.         case 8:  
  396.             checkCode = "4";  
  397.             break;  
  398.         case 7:  
  399.             checkCode = "5";  
  400.             break;  
  401.         case 6:  
  402.             checkCode = "6";  
  403.             break;  
  404.         case 5:  
  405.             checkCode = "7";  
  406.             break;  
  407.         case 4:  
  408.             checkCode = "8";  
  409.             break;  
  410.         case 3:  
  411.             checkCode = "9";  
  412.             break;  
  413.         case 2:  
  414.             checkCode = "x";  
  415.             break;  
  416.         case 1:  
  417.             checkCode = "0";  
  418.             break;  
  419.         case 0:  
  420.             checkCode = "1";  
  421.             break;  
  422.         }  
  423.         return checkCode;  
  424.     }  
  425.   
  426.     /**  
  427.      * 将字符数组转为整型数组  
  428.      *   
  429.      * @param c  
  430.      * @return  
  431.      * @throws NumberFormatException  
  432.      */  
  433.     public int[] converCharToInt(char[] c) throws NumberFormatException {  
  434.         int[] a = new int[c.length];  
  435.         int k = 0;  
  436.         for (char temp : c) {  
  437.             a[k++] = Integer.parseInt(String.valueOf(temp));  
  438.         }  
  439.         return a;  
  440.     }  
  441.   
  442.     public static void main(String[] args) throws Exception {  
  443.         String idcard15 = "123456789101234";//15位  
  444.         String idcard18 = "123456789101234567";//18位  
  445.         IdcardValidator iv = new IdcardValidator(); 
  446.         System.out.println(iv.isValidatedAllIdcard(idcard15));  
  447.         System.out.println(iv.isValidatedAllIdcard(idcard18));  
  448.         System.out.println(iv.toString());  
  449.     }  
  450. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/你好赵伟/article/detail/690966
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号