使用TextWatcher实现EditView的度分秒控制输入。

最新推荐文章于 2021-05-25 14:09:59 发布
最新推荐文章于 2021-05-25 14:09:59 发布
阅读量831 收藏
点赞数
分类专栏： 移动开发 文章标签： EditView TextWatche 控制输入
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wkkyo/article/details/51206317
版权

项目中有个需求要求在EditView内只能进行度分秒的控制输入，看到参考其他软件的实现效果，自己实现了一下。
这里写图片描述
输入的时候会自动限定在经纬度数值范围之内，当光标在引号位置时输入无效并自动跳过。

这个效果需要使用TextWatcher。

TextWatcher接口有三个方法，在输入框内容修改的时候会依次执行

beforeTextChanged(CharSequences, int start, int count, int after);

s是修改之前输入框的内容
start是新内容插入的位置
count是对影响原有内容的长度，插入操作的时候通常为0
after是插入新内容的长度

onTextChanged(CharSequences, int start, int before, int count);

start是改变内容的开始位置
before是改变前的内容数量
count是改变内容的长度

afterTextChanged(Editables);

s是改变后的内容

根据这三个方法我们可以在内容插入的时候对内容进行修改，然后再次调用setText来实现输入框的限制输入，但是需要注意在调用setText后会重新执行这三个方法，可能导致死循环，因此在满足条件的时候就不要再调用setText了。

我们的要求是限制输入为度分秒,不多说,直接上代码

import java.util.regex.Matcher;
import java.util.regex.Pattern;

import android.text.Editable;
import android.text.TextWatcher;
import android.widget.EditText;

/**
 * 度分秒输入控制器，可以将输入控制在经度、纬度、角度范围之内。
 * @author Wkkyo
 * @date 2016-4-19
 * @version 1.0.0
 * @code
 * <code>
 * EditView editView = findViewById(R.id.editView);
 * editView.addTextChangedListener(new DMSTextWatcher(editView,0));
 * </code>
 * 
 */
public final class DMSTextWatcher implements TextWatcher{

    private String oldText;

    private boolean backspace = true;

    private int watchType = 0;

    private final String MAX_VALUE_N = "90:00:00.00000";

    private final String MAX_VALUE_E = "180:00:00.00000";

    private final String MAX_VALUE_A = "360:00:00.00000";

    private final String DEFAULT_VALUE_N = "00:00:00.00000N";

    private final String DEFAULT_VALUE_E = "000:00:00.00000E";

    private final String DEFAULT_VALUE_A = "000:00:00.00000";

    private EditText mEditText;

    private Pattern mPattern;

    //纬度正则
    private final static String regExNE  = "(^([0-8][0-9]):([0-5][0-9]):([0-5][0-9])(\\.{1})([0-9]{5})" +
            "(N|S)$)|(^([0-8][0-9]):([6][0]):([0-5][0-9])(\\.{1})([0-9]{5})(N|S)$)|(^([0-8]" +
            "[0-9]):([0-5][0-9]):(60)(\\.{1})([0]{5})(N|S)$)|(^([0-8][0-9]):([6][0]):([6]" +
            "[0])(\\.{1})([0]{5})(N|S)$)|(^90:00:00.00000(N|S)$)";

    //经度正则
    private final static String regExEW = "(^([0][0-9][0-9]):([0-5][0-9]):([0-5][0-9])(\\.{1})([0-9]{5})(E|W)$)|(^(0[0-9]" +
            "[0-9]):([6][0]):([0-5][0-9])(\\.{1})([0-9]{5})(E|W)$)|(^(0[0-9][0-9]):([0-5][0-9]):(60)(\\.{1})" +
            "([0]{5})(E|W)$)|(^(0[0-9][0-9]):([6][0]):([6][0])(\\.{1})([0]{5})(E|W)$)|(^([1][0-7][0-9]):" +
            "([0-5][0-9]|60):([0-5][0-9])(\\.{1})([0-9]{5})(E|W)$)|(^([1][0-7][0-9]):([0-5][0-9]|60):" +
            "(60)(\\.{1})(0{5})(E|W)$)|(^180:00:00.00000(E|W)$)";

    //角度正则
    private final static String regEx = "(^(([0-2][0-9][0-9])|([0-3][0-5][0-9])):([0-5][0-9]|60):([0-5][0-9])(\\.{1})" +
            "([0-9]{5})$)|(^(([0-2][0-9][0-9])|([0-3][0-5][0-9])):([0-5][0-9]|60):(60)(\\.{1})(0{5})$)" +
            "|(^([0-3][0-5][0-9]):([6][0]):([0-5][0-9])(\\.{1})([0-9]{5})$)|(^([0-3][0-5][0-9]):(60):(60)" +
            "(\\.{1})([0]{5})$)|(^([0-3][0-5][0-9]):([0-5][0-9]):(60)(\\.{1})([0]{5})$)|(^([0-3][0-5][0-9])" +
            ":([0-5][0-9]):([0-5][0-9])(\\.{1})([0-9]{5})$)|(^360:00:00.00000$)";

    /**
     * 构造方法。
     * @param editText 需要控制的输入框。默认采用纬度控制，纬度最大值90:00:00.00000。
     */
    public DMSTextWatcher(EditText editText) {
        this(editText,0,null);
    }

    /**
     * 构造方法。
     * @param editText 需要控制的输入框。
     * @param type 控制方式，经度-1、纬度-0、角度-2。
     * <li>0-纬度控制，纬度最大值90:00:00.00000</li>
     * <li>1-经度控制，经度最大值180:00:00.00000</li>
     * <li>2-角度控制，经度最大值360:00:00.00000</li>
     */
    public DMSTextWatcher(EditText editText,int type) {
        this(editText,type,null);
    }

    /**
     * 构造方法。
     * @param editText 需要控制的输入框。默认采用纬度控制，纬度最大值90:00:00.00000。
     * @param defaultValue 默认值。
     */
    public DMSTextWatcher(EditText editText,String defaultValue) {
        this(editText,0,defaultValue);
    }

    /**
     * 构造方法。
     * @param editText 需要控制的输入框。
     * @param type 控制方式，经度-1、纬度-0、角度-2。
     * <li>0-纬度控制，纬度最大值90:00:00.00000</li>
     * <li>1-经度控制，经度最大值180:00:00.00000</li>
     * <li>2-角度控制，经度最大值360:00:00.00000</li>
     * @param defaultValue 默认值。
     */
    public DMSTextWatcher(EditText editText,int type,String defaultValue) {
        this.mEditText = editText;
        watchType = type;
        if(watchType == 0){
            this.mPattern = Pattern.compile(regExNE);
            if(defaultValue != null){
                Matcher matcher = mPattern.matcher(defaultValue);
                if(matcher.find()){
                    this.mEditText.setText(defaultValue);
                }else{
                    this.mEditText.setText(DEFAULT_VALUE_N);
                }
            }else{
                this.mEditText.setText(DEFAULT_VALUE_N);
            }
        }else if(watchType == 1){
            this.mPattern = Pattern.compile(regExEW);
            if(defaultValue != null){
                Matcher matcher = mPattern.matcher(defaultValue);
                if(matcher.find()){
                    this.mEditText.setText(defaultValue);
                }else{
                    this.mEditText.setText(DEFAULT_VALUE_E);
                }
            }else{
                this.mEditText.setText(DEFAULT_VALUE_E);
            }
        }else if(watchType == 2){
            this.mPattern = Pattern.compile(regEx);
            if(defaultValue != null){
                Matcher matcher = mPattern.matcher(defaultValue);
                if(matcher.find()){
                    this.mEditText.setText(defaultValue);
                }else{
                    this.mEditText.setText(DEFAULT_VALUE_A);
                }
            }else{
                this.mEditText.setText(DEFAULT_VALUE_A);
            }
        }
    }

    @Override
    public void onTextChanged(CharSequence s, int start, int before, int count) {
//      KLog.d("onTextChanged :"+s+"    "+start+"---"+before+"---"+count);
        if(watchType == 0){
            onNSTextChanged(s,start,before,count);
        }else if(watchType == 1){
            onEWTextChanged(s,start,before,count);
        }else if(watchType == 2){
            onAngleTextChanged(s,start,before,count);
        }
    }

    @Override
    public void beforeTextChanged(CharSequence s, int start, int count,int after) {
//      KLog.d("beforeTextChanged :"+s+"    "+start+"---"+after+"---"+count);
        if(backspace){
            oldText = new String(s.toString());
        }else{
            backspace = true;
        }
    }

    @Override
    public void afterTextChanged(Editable s) {
//      KLog.d("afterTextChanged :"+s);
    }

    private void onNSTextChanged(CharSequence s, int start, int before, int count){
        StringBuilder str = new StringBuilder(s.toString());
        if(oldText != null && str.length() < oldText.length()){
            if(start == 2 || start == 5 || start == 8 || start == 14){
                str = new StringBuilder(oldText);
            }else{
                str.insert(start, "0");
            }
            mEditText.setTextKeepState(str);
            oldText = null;
        }else{
            Matcher m = mPattern.matcher(str);
            if(!m.find()){
                StringBuilder oldStr = new StringBuilder(str.toString().substring(0,start)+str.substring(start+1));
                if(count > 1){
                    str = new StringBuilder(MAX_VALUE_N);
                    str.append(oldStr.charAt(14) == 'N'?"N":"S");
                }else{
                    if(start == 2 || start == 5 || start == 8){
                        str = oldStr;
                    }else if(start == 14 || start == 15){
                        start = 14;
                        if(oldStr.charAt(14) == 'N'){
                            oldStr.replace(start, start+1, "S");
                        }else{
                            oldStr.replace(start, start+1, "N");
                        }
                        str = oldStr;
                        mEditText.setSelection(start);
                    }else{
                        String ch = str.substring(start, start+1);
                        str = new StringBuilder(oldStr);
                        str = str.replace(start, start+1, ch);
                        if(start == 0){
                            if(ch.equals("9")){
                                str = new StringBuilder(MAX_VALUE_N);
                                str.append(oldStr.charAt(14) == 'N'?"N":"S");
                            }
                        }else if(start == 3 || start == 6){
                            if("6789".indexOf(ch) > -1){
                                str = str.replace(start, start+1, "6");
                                str = str.replace(start+1, start+2, "0");
                                if(start == 6){
                                    str = str.replace(start+3, start+8, "00000");
                                }
                            }
                        }
                        m = mPattern.matcher(str);
                        m.reset();
                        if(!m.find()){
                            str = oldStr;
                        }
                    }
                }
                backspace = false;
                oldText = null;
                mEditText.setTextKeepState(str);
            }
        }
    }

    private void onEWTextChanged(CharSequence s, int start, int before, int count){
        StringBuilder str = new StringBuilder(s.toString());
        if(oldText != null && str.length() < oldText.length()){
            if(start == 3 || start == 6 || start == 9 || start == 15){
                str = new StringBuilder(oldText);
            }else{
                str.insert(start, "0");
            }
            mEditText.setTextKeepState(str);
            oldText = null;
        }else{          
            Matcher m = mPattern.matcher(str);
            if(!m.find()){
                StringBuilder oldStr = new StringBuilder(str.toString().substring(0,start)+str.substring(start+1));
                if(count > 1){
                    str = new StringBuilder(MAX_VALUE_E);
                    str.append(oldStr.charAt(15) == 'W'?"W":"E");
                }else{
                    if(start == 3 || start == 6 || start == 9){
                        str = oldStr;
                    }else if(start == 15 || start == 16){
                        start = 15;
                        if(oldStr.charAt(15) == 'E'){
                            oldStr.replace(start, start+1, "W");
                        }else{
                            oldStr.replace(start, start+1, "E");
                        }
                        str = oldStr;
                        mEditText.setSelection(start);
                    }else{
                        String ch = str.substring(start, start+1);
                        str = new StringBuilder(oldStr);
                        str = str.replace(start, start+1, ch);
                        if(start == 0){
                            if("23456789".indexOf(ch) > -1){
                                str = new StringBuilder(MAX_VALUE_E);
                                str.append(oldStr.charAt(15) == 'W'?"W":"E");
                            }
                            if("1".indexOf(ch) > -1 && (str.charAt(1) == '9' || str.charAt(1) == '8')){
                                str = new StringBuilder(MAX_VALUE_E);
                                str.append(oldStr.charAt(15) == 'W'?"W":"E");
                            }
                        }else if(start == 1){
                            if(("89").indexOf(ch) > -1 && str.charAt(0) == '1'){
                                str = new StringBuilder(MAX_VALUE_E);
                                str.append(oldStr.charAt(15) == 'W'?"W":"E");
                            }
                        }else if(start == 4 || start == 7){
                            if("6789".indexOf(ch) > -1){
                                str = str.replace(start, start+1, "6");
                                str = str.replace(start+1, start+2, "0");
                                if(start == 7){
                                    str = str.replace(start+3, start+8, "00000");
                                }
                            }
                        }
                        m = mPattern.matcher(str);
                        m.reset();
                        if(!m.find()){
                            str = oldStr;
                        }
                    }
                }
                backspace = false;
                oldText = null;
                mEditText.setTextKeepState(str);
            }
        }
    }

    private void onAngleTextChanged(CharSequence s, int start, int before, int count){
        StringBuilder str = new StringBuilder(s.toString());
        if(oldText != null && str.length() < oldText.length()){
            if(start == 3 || start == 6 || start == 9 || start == 15){
                str = new StringBuilder(oldText);
            }else{
                str.insert(start, "0");
            }
            mEditText.setTextKeepState(str);
            oldText = null;
        }else{          
            Matcher m = mPattern.matcher(str);
            if(!m.find()){
                StringBuilder oldStr = new StringBuilder(str.toString().substring(0,start)+str.substring(start+1));
                if(count > 1){
                    str = new StringBuilder(MAX_VALUE_A);
                }else{
                    if(start == 3 || start == 6 || start == 9){
                        str = oldStr;
                    }else if(start == 15){
                        start = 15;
                        str = oldStr;
                        mEditText.setSelection(start);
                    }else{
                        String ch = str.substring(start, start+1);
                        str = new StringBuilder(oldStr);
                        str = str.replace(start, start+1, ch);
                        if(start == 0){
                            if("456789".indexOf(ch) > -1){
                                str = new StringBuilder(MAX_VALUE_A);
                            }
                            if("3".indexOf(ch) > -1 && ("6789".indexOf(str.charAt(1)) > -1)){
                                str = new StringBuilder(MAX_VALUE_A);
                            }
                        }else if(start == 1){
                            if(("6789").indexOf(ch) > -1 && str.charAt(0) == '3'){
                                str = new StringBuilder(MAX_VALUE_A);
                            }
                        }else if(start == 4 || start == 7){
                            if("6789".indexOf(ch) > -1){
                                str = str.replace(start, start+1, "6");
                                str = str.replace(start+1, start+2, "0");
                                if(start == 7){
                                    str = str.replace(start+3, start+8, "00000");
                                }
                            }
                        }
                        m = mPattern.matcher(str);
                        m.reset();
                        if(!m.find()){
                            str = oldStr;
                        }
                    }
                }
                backspace = false;
                oldText = null;
                mEditText.setTextKeepState(str);
            }
        }
    }
}

我实现了三种类型的现在，分别对应纬度、经度和角度，在构造方法里通过参数判断，使用也很简单

EditView editView = findViewById(R.id.editView);
editView.addTextChangedListener(new DMSTextWatcher(editView,0));

后来发现有个InputFilter接口似乎也能实现这个效果，时间有限，以后有空再研究。

隔壁小王同学
关注
专栏目录
EditText用TextWatcher实时限制和修正
CSDN_SUSAN的博客
12-12 635
文章目录1. 需求2. 解决方案2.1 解决思路分析2.2 解决代码实现 1. 需求 产品经理要求EditText输入名字限制： 不能有除“空格，下划线，字母，数字，中文”的其他字符。 不能超过10个字符。 名字第一个字符不能为空格。 输入错误时，要实时检查提示并将非法字符替换为空字符。 2. 解决方案 2.1 解决思路分析 使用正则表达式匹配字符输入是否符合要求。 使用TextWatche...
使用EditText+ListView并结合TextWatcher实现输入关键字筛选数据
09-06
简单说下这个demo的实现，点击一个button，弹出一个类似spinner的界面，包含一个edittext和listview，当在输入框中键入关键字时，下面的listview所显示的数据可以随之进行筛选，点击...主要用到了TextWatcher这个知识点
EditView的监听者TextWatcher
Fling_Pig的博客
04-14 545
在开发过程中，我们常常会对EditText里面输入的内容做一些限制，这是我们经常用到TextWatcher。 wsc_send_cost.addTextChangedListener(new TextWatcher() { private String temp; @Override public void onTextChanged(CharSequence s, int sta
editView 输入框停留的时间
05-30 500
package com.cardvalue.sys.widget; import java.text.SimpleDateFormat; import java.util.Date; import java.util.HashMap; import java.util.Map; import android.content.Context; import android.content.res.
Android： EditText设置属性和设置输入规则
weixin_30340745的博客
10-19 297
1.EditText输入限制规则 在xml:EditText 设置属性 android:digits="ABCDE123&*" ABCDE123&*是你的限制规则 例如：android:digits="0123456789abc" 规则是只能输入英文字母（小写）abc和数字 2.EditTex输入的文字为密码形式 （1）在xml中设置 android:pa...
android 角度转成度分秒
涐好囧的专栏
10-16 644
传入角度 /** 角度转换成度分秒 */ private String getFormatter(double dou) { double degree = dou; double minute = (degree - (int) degree) * 60; double second = (minute - (int) minute) * 60; NumberFormat m
Android开发中给EditText控件添加TextWatcher监听实现对输入字数的限制(推荐)
09-01
这可以通过在EditText控件中添加TextWatcher监听器来实现对输入字数的限制。TextWatcher接口是Android SDK中用于监听文本变化的接口，它包含三个方法：beforeTextChanged、onTextChanged和afterTextChanged，分别...
TextWatcher-Implementation:Android Studio Canary上的TextWatcher实现
03-13
Android Studio TextWatcher实现 TextWatcher是一个界面，可用于对文本进行可编辑的操作。 此实现使用三种公共方法： afterTextChanged(Editable s) beforeTextChanged(CharSequence s, int start, int count, ...
textwatcher实现身份证籍贯信息的自动填充
12-01
本示例应用了TextWatcher来实现身份证籍贯信息的自动填充功能，提升了用户体验。 首先，我们需要理解身份证号码的结构。中国的身份证号码由18位数字组成，其中前6位代表了出生地的行政区域代码。通过这个代码，我们...
Android的edittext在弹出框中实现输入自动千分位分隔和金额限制
04-13
自己做的一个自定义控件，里面主要是自定以弹出框，对edittext的回调处理和edittext输入时自动千分位分隔和金额限制
经纬度输入控件V1.1
02-04
在于GIS相关的软件中经常要输入经纬度数值，而基于MFC Edit控件的经纬度输入控件需 要创建三个Edit编辑框，来分别输入度、分、秒数值，并且需要分别进行输入范围和有效 性的检验。该基于BCGControlBar的经纬度输入控件实现了在一个输入窗口中分别按照度 、分、秒三个值域来输入经纬度数值，并同时进行了输入分有效性和输入范围的检验。经 纬度中的度、分、秒字段均通过数字键盘直接输入数值，也可通过微调按钮或者键盘的上 下键进行数字的增减，你可以通过左右键进行度、分、秒输入域的切换。该控件可以设置 度的输入范围，默认的度范围是0~89。该1.1版本修复了键盘直接输入数值的逻辑问题。 In the GIS-related software often have to enter the latitude and longitude values, and MFC Edit control based on the latitude and longitude input controls need to create three Edit edit box to enter the degrees, minutes and seconds values, and the need for input range and validity of the test. The BCGControlBar-based latitude and longitude input control realizes the input of the latitude and longitude values in degrees,minutes,and seconds in one input window, and simultaneously verifies the validity of the input points and the input range.The degrees, minutes, and seconds fields can be entered directly through the numeric keypad, also can be fine-tuning button or the keyboard up and down keys to increase or decrease the number, you can use left and right keys for degrees, minutes and seconds to switch the input field. The control can set the input range of degree, the default range is 0 ~ 89.The 1.1 version fixes the logic of keyboard input values directly.
经纬度输入控件
02-01
该经纬度输入控件实现了度、分、秒形式 的经纬度输入功能，经纬度中的度、分、 秒字段均可通过微调按钮或者键盘的上下 键进行数字的增减，你可以通过左右键进 行度、分、秒输入域的切换。该控件可以 设置度的输入范围，默认的度范围是0~89 。 The latitude and longitude input control to achieve the latitude and longitude input in degrees, minutes and seconds, latitude and longitude of degrees, minutes, seconds field can be fine-tuning button or the keyboard up and down keys to increase or decrease the number,you can use left and right keys to switch the input fields of degrees, minutes and seconds.The control can set the degree of input range, the default range is 0 ~ 89.
Android 强大的输入框（TextFieldBoxes）
72的博客
07-31 2546
作者：I_Gisvity 链接：https://www.jianshu.com/p/bc867ebca3ca 来源：简书 简书著作权归作者所有，任何形式的转载都请联系作者获得授权并注明出处。 安装 在你的项目中加入以下依赖： Gradle: allprojects { repositories { ... maven { url 'https:...
Android四方形输入框、密码框
Daxue_haha的博客
08-31 5140
Android四方形输入框、密码框 一、自定义view继承EditText，代码中控制输入框的个数和是否为可见密码格式 package com.example.testcostumview.inputbox; import android.content.Context; import android.graphics.Canvas; import android.g...
Android 开发之拦截EditText的输入内容，定制输入内容
weixin_30553837的博客
06-15 449
1.EditText作为一个比较成熟的View，在Android的应用开发中得到极为广泛的使用。在某些特殊情况下，我们可能需要定制EditText的输入内容， 只允许指定功能的输入，例如输入一个”ddd:mm:ssssss“格式的度分秒角度。 一些错误的思路有： （1）OnKeyListener，实现EditText的OnKeyListener并不能拦截EditText的输入，OnKeyLi...
【Android】设置EditText输入类型和内容长度
qq_30885821的博客
09-24 4141
设置EditText输入类型主要有两种方法，一种是使用EditText的setInputType()方法，另一种是在布局文件中使用android:inputType属性来设置。 （1）使用EditText的setInputType()方法设置输入类型： EditText editText; //输入类型为没有指定明确的类型的特殊内容类型 editText.setInputType(InputType.TYPE_NULL); //输入类型为普通文本 editText
android 坐标度分秒转换工具,经纬度格式转换定位工具
weixin_39744606的博客
05-25 1782
经纬度格式转换定位工具由西西给大家带来，这款软件也是专为地理爱好者所准备，是不是常常为经纬度而烦恼了，有了这个格式转换工具可以随意的转换了，赶紧来下载经纬度格式转换定位工具试试吧！功能介绍1、体积小巧，占用内存少2、功能使用、操作便捷3、无需安装，下载解压就可以使用4、具有经纬度转换、查询、定位三重功能5、自由切换，快速切换到需要的功能界面使用方法运行EXE打开软件，软件界面可以让您选择模式，一种...
Android TextWatcher三个回调详解，监听EditText的输入
热门推荐
LittleFogCat的专栏
11-29 4万+
TextWatcher是一个监听字符变化的类。当我们调用EditText的addTextChangedListener(TextWatcher)方法之后，就可以监听EditText的输入了。 本文分析了TextWatcher三个抽象回调方法的参数，并附上例子来说明如何使用TextWatcher。
Android EditView 输入的时候实现输入表情
最新发布
05-24
要在Android的EditText中实现输入表情，可以使用EmojiCompat库来处理。EmojiCompat库是Android提供的一个支持Emoji的库，可以帮助我们在不同版本的Android设备上显示统一的Emoji表情。 首先，在build.gradle文件中...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值