1. 设置 整数或小数 以及相关位数

1.1 过程中 设置校验规则

设置相关位数

    1.1.1 设置4位正整数
     et.setFilters(new InputFilter[]{new InputFilter.LengthFilter(4)}); //限制输入位数(4);/*设置最多四位*/
     String digits = "0123456789";
     et.setKeyListener(DigitsKeyListener.getInstance(digits));
    1.1.2 默认四位小数
        et.addTextChangedListener(new MoneyTextWatcher(et));//MoneyTextWatcher 见下面

    1.1.3  输入数字 xml
    android:inputType="number"
   1.1.4  输入数字 和小数点 xml
   android:inputType="number|numberDecimal"

  android java代码设置EditText输入格式参数对应Description列
  setInputType(XXXXXXXX)或者setRawInputType(XXXXXXXX)
  需要注意XML部分参数值在Java代码中设置时要达到相同效果可能java中参数需要由多个参数组合使用。如
  XML中设置android:inputType="numberDecimal"在Java代码中仅设置  
   setInputType(EditorInfo.TYPE_NUMBER_FLAG_DECIMAL);是不能生效的，必须设置
   setInputType(EditorInfo.TYPE_CLASS_NUMBER|EditorInfo.TYPE_NUMBER_FLAG_DECIMAL);


   1.1.5 输入字符和数字  xml
   android:digits="0123456789qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM"
    电话
    android:digits="1234567890+-"

    1.1.6 设置过滤器
    private InputFilter mInputFilter = new InputFilter() {
        Pattern emoji = Pattern.compile("[\ud83c\udc00-\ud83c\udfff]|[\ud83d\udc00-\ud83d\udfff]|[\u2600-\u27ff]", Pattern.UNICODE_CASE | Pattern.CASE_INSENSITIVE);

        @Override
        public CharSequence filter(CharSequence source, int start, int end, Spanned dest, int dstart, int dend) {
            Matcher emojiMatcher = emoji.matcher(source);
            if (emojiMatcher.find()) {
                MyToast.showShort("不支持输入表情");
                return "";
            }
            return null;
        }
    };

    /**
     * 设置editText过滤器
     *
     * @param editText
     */
    private void setEditTextFilter(EditText editText) {
        InputFilter[] oldFilters = editText.getFilters();
        int oldFiltersLength = oldFilters.length;
        InputFilter[] newFilters = new InputFilter[oldFiltersLength + 1];
        if (oldFiltersLength > 0) {
            System.arraycopy(oldFilters, 0, newFilters, 0, oldFiltersLength);
        }
        //添加新的过滤规则
        newFilters[oldFiltersLength] = mInputFilter;
        editText.setFilters(newFilters);
    }

1.1.7 设置监听
   et.addTextChangedListener(new TextWatcher() {
            @Override
            public void beforeTextChanged(CharSequence s, int start, int count, int after) {
            }

            @Override
            public void onTextChanged(CharSequence s, int start, int before, int count) {
            }

            @Override
            public void afterTextChanged(Editable s) {
                int len = s.length();
                tv.setText(len + "/500");
            }
        });
  

1.2 提交 设置校验规则

1.2.1  匹配数字和汉字
    public String stringFilter(String str) throws PatternSyntaxException {
        //只允许数字和汉字
        String regEx = "[^\u4E00-\u9FA5]";
        Pattern p = Pattern.compile(regEx);
        Matcher m = p.matcher(str);
        return m.replaceAll("").trim();
    }
    方式一：  比较两个值是否相同
      String s = stringFilter(other_name);
      if (!other_name.equals(s)) {
          MyToast.showShort("只能输入汉字");
          return;
       }
1.2.2 字符多少比较
    /*名字的比较 是否符合规则  名字 3-27 个字符  1个汉字 2个字符*/
    public static boolean isMatchName(String str ,int limit,int max) {
        if (str != null) {
            try {
                byte[] bytes = str.getBytes("gbk");
                if (bytes.length >= limit && bytes.length <= max) {
                    return true;
                } else {
                    return false;
                }
            } catch (UnsupportedEncodingException e) {
                e.printStackTrace();
            }
        }
        return false;
    }
1.2.3 去除末尾逗号
    /*去除末尾的逗号*/
    public String getStingLastNoDouHao(String str) {
        if (TextUtils.isEmpty(str)) {
            return "";
        }
        if (str.endsWith(",")) {
            return str.substring(0, str.length() - 1);
        } else {
            return str;
        }
    }

3. 其他属性

    android:editable：是否可编辑

  Android中TextVIew一些属性 

android:layout_gravity="center_vertical"
设置控件显示的位置：默认top，这里居中显示，还有bottom

android:hint="请输入数字！"
设置显示在空间上的提示信息

android:numeric="integer"
设置只能输入整数，如果是小数则是：decimal

android:singleLine="true"
设置单行输入，一旦设置为true，则文字不会自动换行。

android:password="true"
设置只能输入密码

android:gravity="top"
EditText设置，这一行就可以让光标处于第一行了，若不设置默认就居中
TextView则在最顶上

android:textColor = "#ff8c00"
字体颜色

android:textStyle="bold"
字体，bold, italic, bolditalic

android:textSize="20dip"
大小

android:capitalize = "characters"
以大写字母写

android:textAlign="center"
EditText没有这个属性，但TextView有

android:autoText：自动拼写帮助

android:editable：是否可编辑

android:textColorHighlight="#cccccc"
被选中文字的底色，默认为蓝色

android:textColorHint="#ffff00"
设置提示信息文字的颜色，默认为灰色

android:textScaleX="1.5"
控制字与字之间的间距

android:typeface="monospace"
字型，normal, sans, serif, monospace

android:background="@null"
空间背景，这里没有，指透明，将EditText自定义的背景去掉

android:imeOptions="actionDone"
设置软键盘的Enter键

android:layout_weight="1"
权重，控制控件之间的地位,在控制控件显示的大小时蛮有用的。

android:textAppearance="?android:attr/textAppearanceLargeInverse"

android:ellipsize="end" 自动隐藏尾部溢出数据，一般用于文字内容过长一行无法全部显示时

android:typeface="monospace" 字型，normal, sans, serif, monospace android:background="@null" 空间背景，这里没有，指透明

android:layout_weight="1" 权重，控制控件之间的地位,在控制控件显示的大小时蛮有用的。

android:textAppearance="?android:attr/textAppearanceLargeInverse" 文字外观，这里引用的是系统自带的一个外观，？表示系统是否有这种外观，否则使用默认的外观。不知道这样理解对不对？ 通过EditText的layout xml文件中的相关属性来实现:

1. 密码框属性 android:password="true" 这条可以让EditText显示的内容自动为星号，输入时内容会在1秒内变成*字样。

2. 纯数字 android:numeric="true" 这条可以让输入法自动变为数字输入键盘，同时仅允许0-9的数字输入

3. 仅允许 android:capitalize="cwj1987" 这样仅允许接受输入cwj1987，一般用于密码验证 下面是一些扩展的风格属性

6.在EditText中软键盘的调起、关闭

（1）EditTex有焦点（focusable为true）阻止输入法弹出

editText.setOnTouchListener(new OnTouchListener(){

public boolean onTouch(View view,MotionEvent event){

editText.setInputType(Input.TYPE_NULL);//关闭软键盘

return false;

}});

(2)EditText无焦点（focusable=false)时阻挡输入法弹出

InputMethodManager imm=(InputMethodManager)getSystemService(INPUT_METHOD_SERVICE);

imm.hideSoftInputFromWindow(editText.getWindowToken(),0);

(3)调用数字键盘并设置输入类型和键盘为英文

editText.setInputType(InputType.TYPE_CLASS_NUMBER);//调用数字键盘

editText.setInputType(InputType.TYPE_TEXT_FLAG_MULTI_LINE);//英文

（4）键盘永远不会弹出

android:focusable="false"// 键盘永不弹出

7.软键盘的调起导致原来的界面被挤上去，或者导致界面下面的tab导航被挤上去，解决方法如下

使用Mainfest中的Activity的android:windowSfotInputMdoe的“adjustPan"属性

另外注意：有关软键盘的问题可参考android:windowSoftInputMode中的属性，下面可防止toolbar与EditText共用出现的toolBar拉伸现象。

android:windowSoftInputMode="stateVisible|adjustPan|stateHidden" 
8.光标详解

editText.requestFocusFromTouch();//让光标放入到点击位置

editText.requestFocus();//默认方式获得焦点

editText editor=(EditText)getCurrentView();//光标插入

int cursor=editor.getSelectionStart();//光标插入

editor.getText().inset(cursor,delta);

其他

1. 小数点限制
 /**
 * edittext限制2位数
 */
import android.text.Editable;
import android.text.TextWatcher;
import android.widget.EditText;
public class MoneyTextWatcher implements TextWatcher {
    private EditText editText;
    private int digits = 4;

    public MoneyTextWatcher(EditText et) {
        editText = et;
    }
    public MoneyTextWatcher setDigits(int d) {
        digits = d;
        return this;
    }
    @Override
    public void beforeTextChanged(CharSequence s, int start, int count, int after) {    }
    @Override
    public void onTextChanged(CharSequence s, int start, int before, int count) {
        //删除“.”后面超过2位后的数据
        if (s.toString().contains(".")) {
            if (s.length() - 1 - s.toString().indexOf(".") > digits) {
                s = s.toString().subSequence(0,
                        s.toString().indexOf(".") + digits+1);
                editText.setText(s);
                editText.setSelection(s.length()); //光标移到最后
            }
        }
        //如果"."在起始位置,则起始位置自动补0
        if (s.toString().trim().substring(0).equals(".")) {
            s = "0" + s;
            editText.setText(s);
            editText.setSelection(2);
        }
        //如果起始位置为0,且第二位跟的不是".",则无法后续输入
        if (s.toString().startsWith("0")
                && s.toString().trim().length() > 1) {
            if (!s.toString().substring(1, 2).equals(".")) {
                editText.setText(s.subSequence(0, 1));
                editText.setSelection(1);
                return;
            }
        }
    }
    @Override
    public void afterTextChanged(Editable s) {  }
}
2. android:inputType 类型
android:inputType="none"--输入普通字符

android:inputType="text"--输入普通字符

android:inputType="textCapCharacters"--输入普通字符

android:inputType="textCapWords"--单词首字母大小

android:inputType="textCapSentences"--仅第一个字母大小

android:inputType="textAutoCorrect"--前两个自动完成

android:inputType="textAutoComplete"--前两个自动完成

android:inputType="textMultiLine"--多行输入

android:inputType="textImeMultiLine"--输入法多行（不一定支持）

android:inputType="textNoSuggestions"--不提示

android:inputType="textUri"--URI格式

android:inputType="textEmailAddress"--电子邮件地址格式

android:inputType="textEmailSubject"--邮件主题格式

android:inputType="textShortMessage"--短消息格式

android:inputType="textLongMessage"--长消息格式

android:inputType="textPersonName"--人名格式

android:inputType="textPostalAddress"--邮政格式

android:inputType="textPassword"--密码格式

android:inputType="textVisiblePassword"--密码可见格式

android:inputType="textWebEditText"--作为网页表单的文本格式

android:inputType="textFilter"--文本筛选格式

android:inputType="textPhonetic"--拼音输入格式

android:inputType="number"--数字格式

android:inputType="numberSigned"--有符号数字格式

android:inputType="numberDecimal"--可以带小数点的浮点格式

android:inputType="phone"--拨号键盘

android:inputType="datetime"

android:inputType="date"--日期键盘

android:inputType="time"--时间键盘

3. 正则
public class RegexUtils {

    private RegexUtils() {
        throw new UnsupportedOperationException("u can't instantiate me...");
    }


    /**
     * 验证手机号（简单）
     *
     * @param input 待验证文本
     * @return {@code true}: 匹配<br>{@code false}: 不匹配
     */
    public static boolean isMobileSimple(CharSequence input) {
        return isMatch(RegexConstants.REGEX_MOBILE_SIMPLE, input);
    }

    /**
     * 验证手机号（精确）
     *
     * @param input 待验证文本
     * @return {@code true}: 匹配<br>{@code false}: 不匹配
     */
    public static boolean isMobileExact(CharSequence input) {
        return isMatch(RegexConstants.REGEX_MOBILE_EXACT, input);
    }

    /**
     * 验证电话号码
     *
     * @param input 待验证文本
     * @return {@code true}: 匹配<br>{@code false}: 不匹配
     */
    public static boolean isTel(CharSequence input) {
        return isMatch(RegexConstants.REGEX_TEL, input);
    }

    /**
     * 验证身份证号码15位
     *
     * @param input 待验证文本
     * @return {@code true}: 匹配<br>{@code false}: 不匹配
     */
    public static boolean isIDCard15(CharSequence input) {
        return isMatch(RegexConstants.REGEX_ID_CARD15, input);
    }

    /**
     * 验证身份证号码18位
     *
     * @param input 待验证文本
     * @return {@code true}: 匹配<br>{@code false}: 不匹配
     */
    public static boolean isIDCard18(CharSequence input) {
        return isMatch(RegexConstants.REGEX_ID_CARD18, input);
    }

    /**
     * 验证邮箱
     *
     * @param input 待验证文本
     * @return {@code true}: 匹配<br>{@code false}: 不匹配
     */
    public static boolean isEmail(CharSequence input) {
        return isMatch(RegexConstants.REGEX_EMAIL, input);
    }

    /**
     * 验证URL
     *
     * @param input 待验证文本
     * @return {@code true}: 匹配<br>{@code false}: 不匹配
     */
    public static boolean isURL(CharSequence input) {
        return isMatch(RegexConstants.REGEX_URL, input);
    }

    /**
     * 验证汉字
     *
     * @param input 待验证文本
     * @return {@code true}: 匹配<br>{@code false}: 不匹配
     */
    public static boolean isZh(CharSequence input) {
        return isMatch(RegexConstants.REGEX_ZH, input);
    }

    /**
     * 验证用户名
     * <p>取值范围为a-z,A-Z,0-9,"_",汉字，不能以"_"结尾,用户名必须是6-20位</p>
     *
     * @param input 待验证文本
     * @return {@code true}: 匹配<br>{@code false}: 不匹配
     */
    public static boolean isUsername(CharSequence input) {
        return isMatch(RegexConstants.REGEX_USERNAME, input);
    }
  public static boolean isUser(CharSequence input) {
        return isMatch(RegexConstants.REGEX_USER, input);
    }

    /**
     * 验证yyyy-MM-dd格式的日期校验，已考虑平闰年
     *
     * @param input 待验证文本
     * @return {@code true}: 匹配<br>{@code false}: 不匹配
     */
    public static boolean isDate(CharSequence input) {
        return isMatch(RegexConstants.REGEX_DATE, input);
    }

    /**
     * 验证IP地址
     *
     * @param input 待验证文本
     * @return {@code true}: 匹配<br>{@code false}: 不匹配
     */
    public static boolean isIP(CharSequence input) {
        return isMatch(RegexConstants.REGEX_IP, input);
    }

    /**
     * 判断是否匹配正则
     *
     * @param regex 正则表达式
     * @param input 要匹配的字符串
     * @return {@code true}: 匹配<br>{@code false}: 不匹配
     */
    public static boolean isMatch(String regex, CharSequence input) {
        return input != null && input.length() > 0 && Pattern.matches(regex, input);
    }

    /**
     * 获取正则匹配的部分
     *
     * @param regex 正则表达式
     * @param input 要匹配的字符串
     * @return 正则匹配的部分
     */
    public static List<String> getMatches(String regex, CharSequence input) {
        if (input == null) return null;
        List<String> matches = new ArrayList<>();
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(input);
        while (matcher.find()) {
            matches.add(matcher.group());
        }
        return matches;
    }

    /**
     * 获取正则匹配分组
     *
     * @param input 要分组的字符串
     * @param regex 正则表达式
     * @return 正则匹配分组
     */
    public static String[] getSplits(String input, String regex) {
        if (input == null) return null;
        return input.split(regex);
    }

    /**
     * 替换正则匹配的第一部分
     *
     * @param input       要替换的字符串
     * @param regex       正则表达式
     * @param replacement 代替者
     * @return 替换正则匹配的第一部分
     */
    public static String getReplaceFirst(String input, String regex, String replacement) {
        if (input == null) return null;
        return Pattern.compile(regex).matcher(input).replaceFirst(replacement);
    }

    /**
     * 替换所有正则匹配的部分
     *
     * @param input       要替换的字符串
     * @param regex       正则表达式
     * @param replacement 代替者
     * @return 替换所有正则匹配的部分
     */
    public static String getReplaceAll(String input, String regex, String replacement) {
        if (input == null) return null;
        return Pattern.compile(regex).matcher(input).replaceAll(replacement);
    }

    /**
     * 验证 数字
     *
     * @param input 待验证文本
     * @return {@code true}: 匹配<br>{@code false}: 不匹配
     */
    public static boolean isNUM(CharSequence input) {
        return isMatch(RegexConstants.REGEX_NUMBER, input);
    }

    /**
     * 验证手机号 电话（简单）
     *
     * @param input 待验证文本
     * @return {@code true}: 匹配<br>{@code false}: 不匹配
     * 港澳台  008 开头 13-14  位
     */
    public static boolean isTelSimple(CharSequence input) {
       String s=input.toString().replace("-","");
        if(s.startsWith("008")){
            return isMatch(RegexConstants.REGEX_MOBILE_SIMPLE_TEL_TWO, s);
        }
        return isMatch(RegexConstants.REGEX_MOBILE_SIMPLE_TEL, s);
    }

    /**
     * 验证 输入正 数字
     *
     * @param input 待验证文本
     * @return {@code true}: 匹配<br>{@code false}: 不匹配
     */
    public static boolean isIntegerNUM(CharSequence input) {
        return isMatch(RegexConstants.REGEX_NOT_NEGATIVE_INTEGER, input);
    }
}


public final class RegexConstants {


    /**
     * 正则：手机号（简单）
     */
    public static final String REGEX_MOBILE_SIMPLE = "^[1]\\d{10}$";
    /**
     * 正则：11位数字（简单） 电话号码
     */
    public static final String REGEX_MOBILE_SIMPLE_TEL= "^\\d{11}$";
    public static final String REGEX_MOBILE_SIMPLE_TEL_TWO= "^\\d{13,14}$";
    /**
     * 正则：手机号（精确）
     * <p>移动：134(0-8)、135、136、137、138、139、147、150、151、152、157、158、159、178、182、183、184、187、188</p>
     * <p>联通：130、131、132、145、155、156、175、176、185、186</p>
     * <p>电信：133、153、173、177、180、181、189</p>
     * <p>全球星：1349</p>
     * <p>虚拟运营商：170</p>
     */
    public static final String REGEX_MOBILE_EXACT  = "^((13[0-9])|(14[5,7])|(15[0-3,5-9])|(166)|(17[0,3,5-8])|(18[0-9])|(19[0-9])|(147))\\d{8}$";
    /**
     * 正则：电话号码
     */
    public static final String REGEX_TEL           = "^0\\d{2,3}[- ]?\\d{7,8}";
    /**
     * 正则：身份证号码15位
     */
    public static final String REGEX_ID_CARD15     = "^[1-9]\\d{7}((0\\d)|(1[0-2]))(([0|1|2]\\d)|3[0-1])\\d{3}$";
    /**
     * 正则：身份证号码18位
     */
    public static final String REGEX_ID_CARD18     = "^[1-9]\\d{5}[1-9]\\d{3}((0\\d)|(1[0-2]))(([0|1|2]\\d)|3[0-1])\\d{3}([0-9Xx])$";
    /**
     * 正则：邮箱
     */
    public static final String REGEX_EMAIL         = "^\\w+([-+.]\\w+)*@\\w+([-.]\\w+)*\\.\\w+([-.]\\w+)*$";
    /**
     * 正则：URL
     */
    public static final String REGEX_URL           = "[a-zA-z]+://[^\\s]*";
    /**
     * 正则：汉字
     */
    public static final String REGEX_ZH            = "^[\\u4e00-\\u9fa5]+$";
    /**
     * 正则：用户名，取值范围为a-z,A-Z,0-9,"_",汉字，不能以"_"结尾,用户名必须是6-20位
     */
    public static final String REGEX_USERNAME      = "^[\\w\\u4e00-\\u9fa5]{6,20}(?<!_)$";

    /**
     * 正则：用户名，取值范围为a-z,A-Z,0-9,"_",汉字，不能以"_"结尾,用户名必须是6-20位
     */
    public static final String REGEX_USER      = "^[a-zA-z0-9]{6,20}(?<!_)$";
    /**
     * 正则：用户名，取值范围为a-z,A-Z,0-9,"_",汉字，不能以"_"结尾,用户名必须是6-20位
     */
    public static final String REGEX_PASSWORD      = "^[\\w\\u4e00-\\u9fa5]{6,12}(?<!_)$";
    /**
     * 正则：yyyy-MM-dd格式的日期校验，已考虑平闰年
     */
    public static final String REGEX_DATE          = "^(?:(?!0000)[0-9]{4}-(?:(?:0[1-9]|1[0-2])-(?:0[1-9]|1[0-9]|2[0-8])|(?:0[13-9]|1[0-2])-(?:29|30)|(?:0[13578]|1[02])-31)|(?:[0-9]{2}(?:0[48]|[2468][048]|[13579][26])|(?:0[48]|[2468][048]|[13579][26])00)-02-29)$";
    /**
     * 正则：IP地址
     */
    public static final String REGEX_IP            = "((2[0-4]\\d|25[0-5]|[01]?\\d\\d?)\\.){3}(2[0-4]\\d|25[0-5]|[01]?\\d\\d?)";

    ///////////////////////////////////////////////////////////////////////////
    // 以下摘自http://tool.oschina.net/regex
    ///////////////////////////////////////////////////////////////////////////

    /**
     * 正则：双字节字符(包括汉字在内)
     */
    public static final String REGEX_DOUBLE_BYTE_CHAR     = "[^\\x00-\\xff]";
    /**
     * 正则：空白行
     */
    public static final String REGEX_BLANK_LINE           = "\\n\\s*\\r";
    /**
     * 正则：QQ号
     */
    public static final String REGEX_TENCENT_NUM          = "[1-9][0-9]{4,}";
    /**
     * 正则：中国邮政编码
     */
    public static final String REGEX_ZIP_CODE             = "[1-9]\\d{5}(?!\\d)";
    /**
     * 正则：正整数
     */
    public static final String REGEX_POSITIVE_INTEGER     = "^[1-9]\\d*$";
    /**
     * 正则：负整数
     */
    public static final String REGEX_NEGATIVE_INTEGER     = "^-[1-9]\\d*$";
    /**
     * 正则：整数
     */
    public static final String REGEX_INTEGER              = "^-?[1-9]\\d*$";
    /**
     * 正则：非负整数(正整数 + 0)
     */
    public static final String REGEX_NOT_NEGATIVE_INTEGER = "^[1-9]\\d*|0$";
    /**
     * 正则：非正整数（负整数 + 0）
     */
    public static final String REGEX_NOT_POSITIVE_INTEGER = "^-[1-9]\\d*|0$";
    /**
     * 正则：正浮点数
     */
    public static final String REGEX_POSITIVE_FLOAT       = "^[1-9]\\d*\\.\\d*|0\\.\\d*[1-9]\\d*$";
    /**
     * 正则：负浮点数
     */
    public static final String REGEX_NEGATIVE_FLOAT       = "^-[1-9]\\d*\\.\\d*|-0\\.\\d*[1-9]\\d*$";
    /**
     * 正则数字 带小数点
     */
    public static final String REGEX_NUMBER       = "([1-9]\\d*\\.?\\d*)|(0\\.\\d*[1-9])|0";
    /**
     * 正则纯数字
     */
    public static final String REGEX_NUMBER_ONLY       = "^\\d+$";
}
4. 身份证校验
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.GregorianCalendar;
import java.util.HashMap;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
 * Created by houyongliang on 2017/8/2.
 */

public class IdcardUtils {
    /*********************************** 身份证验证开始 ****************************************/
/**
 * 身份证号码验证 1、号码的结构 公民身份号码是特征组合码，由十七位数字本体码和一位校验码组成。排列顺序从左至右依次为：六位数字地址码，
 * 八位数字出生日期码，三位数字顺序码和一位数字校验码。 2、地址码(前六位数）
 * 表示编码对象常住户口所在县(市、旗、区)的行政区划代码，按GB/T2260的规定执行。 3、出生日期码（第七位至十四位）
 * 表示编码对象出生的年、月、日，按GB/T7408的规定执行，年、月、日代码之间不用分隔符。 4、顺序码（第十五位至十七位）
 * 表示在同一地址码所标识的区域范围内，对同年、同月、同日出生的人编定的顺序号， 顺序码的奇数分配给男性，偶数分配给女性。 5、校验码（第十八位数）
 * （1）十七位数字本体码加权求和公式 S = Sum(Ai * Wi), i = 0, ... , 16 ，先对前17位数字的权求和
 * Ai:表示第i位置上的身份证号码数字值 Wi:表示第i位置上的加权因子 Wi: 7 9 10 5 8 4 2 1 6 3 7 9 10 5 8 4
 * 2 （2）计算模 Y = mod(S, 11) （3）通过模得到对应的校验码 Y: 0 1 2 3 4 5 6 7 8 9 10 校验码: 1 0
 * X 9 8 7 6 5 4 3 2
 */
    /**
     * 功能：身份证的有效验证
     *
     * @param IDStr
     * 身份证号 [url=home.php?mod=space&uid=7300]@return[/url] 有效：返回""
     * 无效：返回String信息
     */
    public static boolean IDCardValidate(String IDStr) {
        @SuppressWarnings("unused")
        String errorInfo = "";// 记录错误信息
        String[] ValCodeArr = { "1", "0", "X", "9", "8", "7", "6", "5", "4",
                "3", "2" };
        String[] Wi = { "7", "9", "10", "5", "8", "4", "2", "1", "6", "3", "7",
                "9", "10", "5", "8", "4", "2" };
        String Ai = "";
// ================ 号码的长度 15位或18位 ================
        if (IDStr.length() != 15 && IDStr.length() != 18) {
            errorInfo = "身份证号码长度应该为15位或18位。";
            return false;
        }
// =======================(end)========================
// ================ 数字 除最后以为都为数字 ================
        if (IDStr.length() == 18) {
            Ai = IDStr.substring(0, 17);
        } else if (IDStr.length() == 15) {
            Ai = IDStr.substring(0, 6) + "19" + IDStr.substring(6, 15);
        }
        if (isNumeric(Ai) == false) {
            errorInfo = "身份证15位号码都应为数字 ; 18位号码除最后一位外，都应为数字。";
            return false;
        }
// =======================(end)========================
// ================ 出生年月是否有效 ================
        String strYear = Ai.substring(6, 10);// 年份
        String strMonth = Ai.substring(10, 12);// 月份
        String strDay = Ai.substring(12, 14);// 月份
        if (isDate(strYear + "-" + strMonth + "-" + strDay) == false) {
            errorInfo = "身份证生日无效。";
            return false;
        }
        GregorianCalendar gc = new GregorianCalendar();
        SimpleDateFormat s = new SimpleDateFormat("yyyy-MM-dd");
        try {
            if ((gc.get(Calendar.YEAR) - Integer.parseInt(strYear)) > 150
                    || (gc.getTime().getTime() - s.parse(
                    strYear + "-" + strMonth + "-" + strDay).getTime()) < 0) {
                errorInfo = "身份证生日不在有效范围。";
                return false;
            }
        } catch (NumberFormatException e) {
            e.printStackTrace();
        } catch (java.text.ParseException e) {
            e.printStackTrace();
        }
        if (Integer.parseInt(strMonth) > 12 || Integer.parseInt(strMonth) == 0) {
            errorInfo = "身份证月份无效";
            return false;
        }
        if (Integer.parseInt(strDay) > 31 || Integer.parseInt(strDay) == 0) {
            errorInfo = "身份证日期无效";
            return false;
        }
// =====================(end)=====================
// ================ 地区码时候有效 ================
        Map<String, String> h = GetAreaCode();
        if (h.get(Ai.substring(0, 2)) == null) {
            errorInfo = "身份证地区编码错误。";
            return false;
        }
// ==============================================
// ================ 判断最后一位的值 ================
        int TotalmulAiWi = 0;
        for (int i = 0; i < 17; i++) {
            TotalmulAiWi = TotalmulAiWi
                    + Integer.parseInt(String.valueOf(Ai.charAt(i)))
                    * Integer.parseInt(Wi[i]);
        }
        int modValue = TotalmulAiWi % 11;
        String strVerifyCode = ValCodeArr[modValue];
        Ai = Ai + strVerifyCode;
        if (IDStr.length() == 18) {
            if (Ai.equals(IDStr) == false) {
                errorInfo = "身份证无效，不是合法的身份证号码";
                return false;
            }
        }
// =====================(end)=====================
        return true;
    }
    /**
     * 功能：设置地区编码
     *
     * @return Hashtable 对象
     */
    private static Map<String, String> GetAreaCode() {
        Map<String, String> hashtable = new HashMap<String, String>();
        hashtable.put("11", "北京");
        hashtable.put("12", "天津");
        hashtable.put("13", "河北");
        hashtable.put("14", "山西");
        hashtable.put("15", "内蒙古");
        hashtable.put("21", "辽宁");
        hashtable.put("22", "吉林");
        hashtable.put("23", "黑龙江");
        hashtable.put("31", "上海");
        hashtable.put("32", "江苏");
        hashtable.put("33", "浙江");
        hashtable.put("34", "安徽");
        hashtable.put("35", "福建");
        hashtable.put("36", "江西");
        hashtable.put("37", "山东");
        hashtable.put("41", "河南");
        hashtable.put("42", "湖北");
        hashtable.put("43", "湖南");
        hashtable.put("44", "广东");
        hashtable.put("45", "广西");
        hashtable.put("46", "海南");
        hashtable.put("50", "重庆");
        hashtable.put("51", "四川");
        hashtable.put("52", "贵州");
        hashtable.put("53", "云南");
        hashtable.put("54", "西藏");
        hashtable.put("61", "陕西");
        hashtable.put("62", "甘肃");
        hashtable.put("63", "青海");
        hashtable.put("64", "宁夏");
        hashtable.put("65", "新疆");
        hashtable.put("71", "台湾");
        hashtable.put("81", "香港");
        hashtable.put("82", "澳门");
        hashtable.put("91", "国外");
        return hashtable;
    }
    /**
     * 功能：判断字符串是否为数字
     *
     * @param str
     * @return
     */
    private static boolean isNumeric(String str) {
        Pattern pattern = Pattern.compile("[0-9]*");
        Matcher isNum = pattern.matcher(str);
        if (isNum.matches()) {
            return true;
        } else {
            return false;
        }
    }
    /**
     * 功能：判断字符串是否为日期格式
     *
     * @param=
     * @return
     */
    public static boolean isDate(String strDate) {
        String regxStr = "^((\\d{2}(([02468][048])|([13579][26]))[\\-\\/\\s]?((((0?[13578])|(1[02]))[\\-\\/\\s]?((0?[1-9])|([1-2][0-9])|(3[01])))|(((0?[469])|(11))[\\-\\/\\s]?((0?[1-9])|([1-2][0-9])|(30)))|(0?2[\\-\\/\\s]?((0?[1-9])|([1-2][0-9])))))|(\\d{2}(([02468][1235679])|([13579][01345789]))[\\-\\/\\s]?((((0?[13578])|(1[02]))[\\-\\/\\s]?((0?[1-9])|([1-2][0-9])|(3[01])))|(((0?[469])|(11))[\\-\\/\\s]?((0?[1-9])|([1-2][0-9])|(30)))|(0?2[\\-\\/\\s]?((0?[1-9])|(1[0-9])|(2[0-8]))))))(\\s(((0?[0-9])|([1-2][0-3]))\\:([0-5]?[0-9])((\\s)|(\\:([0-5]?[0-9])))))?$";
        Pattern pattern = Pattern.compile(regxStr);
        Matcher m = pattern.matcher(strDate);
        if (m.matches()) {
            return true;
        } else {
            return false;
        }
    }
/*********************************** 身份证验证结束 ****************************************/

}

  EditText动态设置输入类型与过滤器的使用
在项目中，出于需要对 EditText 的长度以及输入类型进行动态改变，自己通过设置 EditText 类中的 setInputType 与 setFilters 方法来实现这一功能。

例子一：设置纯数字类型，并且限制数字长度。
// 设置输入的类型为数字
// 等价于xml中属性 android:inputType="number"
editText.setInputType(InputType.TYPE_CLASS_NUMBER);

// 限制输入长度限制(当前设置为5)
// 使用系统自带的InputFilter接口类中的LengthFilter子类来完成的
editText.setFilters(new InputFilter[] {new InputFilter.LengthFilter(5)});
1
2
3
4
5
6
7
例子二：设置带小数类型，限制小点前后数字长度。
// 设置输入的类型为带小数类型
// 等价于xml中属性 android:inputType="numberDecimal"
editText.setInputType(InputType.TYPE_CLASS_NUMBER|InputType.TYPE_NUMBER_FLAG_DECIMAL);

// 限制小点前后数字长度(当前设置为前5后2)
// 通过实现InputFilter接口来完成长度的限制
editText.setFilters(new InputFilter[] {new DecimalInputFilter(5, 2)});
1
2
3
4
5
6
7
DecimalInputFilter 类的实现
import android.text.InputFilter;
import android.text.Spanned;
import android.text.TextUtils;

/**
 * Created by sky on 16-9-2.
 */
public class DecimalInputFilter implements InputFilter {

    private String mRegularExpression;

    public DecimalInputFilter() {
        this(5);
    }

    public DecimalInputFilter(int firstLength) {
        this(firstLength, 2);
    }

    public DecimalInputFilter(int firstLength, int lastLength) {
        mRegularExpression = String.format("(\\d{0,%d}(\\.\\d{0,%d})?)", firstLength, lastLength);
    }

    @Override
    public CharSequence filter(CharSequence source, int start, int end, Spanned dest, int dstart, int dend) {

        boolean delete = false;
        StringBuilder builder = new StringBuilder(dest);

        if (TextUtils.isEmpty(source)) {
            delete = true;
            builder.delete(dstart, dend);
        } else {
            builder.insert(dstart, source);
        }

        String value = builder.toString();

        return value.matches(mRegularExpression) ? null : delete ? "." : "";
    }
}

如何设置EditText，使得只能输入数字或者某些字母呢？

一、设置EditText，只输入数字：

方法1：直接生成DigitsKeyListener对象就可以了。

et_1.setKeyListener(new
DigitsKeyListener(false,true));
 

方法2：在EditText中设置属性，android:numeric="integer"即只能输入整数，如下

  android:numeric="integer"
方法3：新建一个char[]，在里面添加允许输入的字符。如下

复制代码
 1  etCoustom.setKeyListener(new NumberKeyListener() {
 2             @Override
 3             protected char[] getAcceptedChars() {
 4                 char[] numberChars={'1','2','3','4','5','6','7','8','9','0'};
 5                 return numberChars;
 6             }
 7 
 8             @Override
 9             public int getInputType() {
10                 return android.text.InputType.TYPE_CLASS_PHONE;
11             }
12         });
复制代码
二、设置EditText只能输入某些字母，如下面设置edtitext只能输入A—N,a—n这些字母。方法如下：

复制代码
editText.setKeyListener(new
NumberKeyListener(){

protected char[] getAcceptedChars()

{

char[]
numberChars[]={'a,'b','c','d','e','f','A','B','C','D'};

return numberChars;

}

});
复制代码
 

另外：设置小数等各种类型的东西可以参考我的另外的随笔：【android EditText中的inputType】