有没有一种方法可以在Android中为EditText定义最小值和最大值?


133

我想为定义一个最小值和最大值EditText

例如:如果有人尝试在其中输入月份值,则该值必须介于1到12之间。

我可以使用来做,TextWatcher但是我想知道布局文件或其他地方是否还有其他方法可以做到。

编辑:我不想限制字符数。我想限制值。例如,如果我EditText在输入12时限制月份w字符,它将接受它,但是如果输入22,它在输入时一定不能接受。


有人应该为所有这些类型的输入筛选器建立一个库/集合。这样,每个人都可以一起工作并对其进行测试。而不是每个人都做自己的事。
Zapnologica

使用此编辑文本过滤器可以解决您的问题。过滤器
Taras Smakula

Answers:


286

首先上这个课:

package com.test;

import android.text.InputFilter;
import android.text.Spanned;

public class InputFilterMinMax implements InputFilter {

    private int min, max;

    public InputFilterMinMax(int min, int max) {
        this.min = min;
        this.max = max;
    }

    public InputFilterMinMax(String min, String max) {
        this.min = Integer.parseInt(min);
        this.max = Integer.parseInt(max);
    }

    @Override
    public CharSequence filter(CharSequence source, int start, int end, Spanned dest, int dstart, int dend) {   
        try {
            int input = Integer.parseInt(dest.toString() + source.toString());
            if (isInRange(min, max, input))
                return null;
        } catch (NumberFormatException nfe) { }     
        return "";
    }

    private boolean isInRange(int a, int b, int c) {
        return b > a ? c >= a && c <= b : c >= b && c <= a;
    }
}

然后在您的Activity中使用它:

EditText et = (EditText) findViewById(R.id.myEditText);
et.setFilters(new InputFilter[]{ new InputFilterMinMax("1", "12")});

这将允许用户输入1到12之间的值

编辑:

使用设置您的edittext android:inputType="number"

您可以在https://www.techcompose.com/how-to-set-minimum-and-maximum-value-in-edittext-in-android-app-development/中找到更多详细信息。

谢谢。


1
@mertaydin当然。试试看,然后让我知道是否需要我的帮助。谢谢。
2013年

12
啊,我需要帮助。我在1930年和1999年之间写值时遇到问题。当我写1时,它控制着值,而1不在1930年和1999年之间,因此它不接受。
mertaydin

1
@mertaydin嘿,抱歉,我的工作有点忙。我花了一些时间对此进行研究,我认为我需要对应用在过滤器类中的算法进行修改。完成后,我会更新您的信息。
Pratik Sharma 2013年

1
中的某些字符source将替换中的某些字符dest。我认为您应该模拟替换,并获得最终结果,然后进行验证。
SD

3
@Pratik夏尔马,当我从1900年进入至2000这不起作用,你可以建议一些
著名

89

Pratik的代码中有一个小错误。例如,如果值是10,而您在开始时添加1使其等于110,则过滤器函数会将新值视为101。

参见下面的修复方法:

@Override
public CharSequence filter(CharSequence source, int start, int end, Spanned dest, int dstart, int dend) {
    try {
        // Remove the string out of destination that is to be replaced
        String newVal = dest.toString().substring(0, dstart) + dest.toString().substring(dend, dest.toString().length());
        // Add the new string in
        newVal = newVal.substring(0, dstart) + source.toString() + newVal.substring(dstart, newVal.length());
        int input = Integer.parseInt(newVal);
        if (isInRange(min, max, input))
            return null;
    } catch (NumberFormatException nfe) { }
    return "";
}

谢谢,这对我帮助很大!
joschplusa

4
我认为这很清楚,直言String replacement = source.subSequence(start, end).toString(); String newVal = dest.subSequence(0, dstart).toString() + replacement + dest.subSequence(dend, dest.length()).toString();
Sven Jacobs

1
+1。此解决方案比接受的方法更正确。要检查它例如尝试使用InputFilterMinMaxselectAllOnFocus选项启用,并比较结果。
Sash0k 2014年

1
为什么不这样String newVal= dest.toString().substring(0, dstart) + source.toString().substring(start, end) + dest.toString().substring(dend, dest.toString().length());,看起来更干净清晰。
Shishir Gupta 2014年

5
正如OP @mertaydin在对@Patrick的回答的评论中所提到的那样,该解决方案仍然存在一个重大缺陷,我想知道为什么尚未报告该解决方案:如果min==3那样,则不可能键入任何以1或2开头的数字(例如:
15,23

10

在我对@Patrik的解决方案和@Zac的添加的了解中,提供的代码仍然存在很大的问题:

如果那样的min==3话,就不可能输入任何以1或2开头的数字(例如:15、23)。
如果那样的min>=10话,就不可能输入任何数字,因为每个数字都必须以1,2,3开头。

以我的理解,我们不能通过EditText简单使用该类来达到的最大-最小限制InputFilterMinMax,至少不能达到最小的最小值,因为当用户键入一个正数时,该值会不断增长,并且我们可以轻松地执行即时测试以检查其是否已达到限制或超出范围,并阻止不符合要求的条目。测试最小值是另一回事,因为我们无法确定用户是否已完成输入,因此无法决定是否应阻止。

这不完全是OP所要求的,但出于验证目的,我在解决方案中结合使用InputFilter来测试最大值,并在假设用户完成键入OnFocusChangeListenerEditText失去焦点时重新测试最小值。

package test;


import android.text.InputFilter;

import android.text.Spanned;

public class InputFilterMax implements InputFilter {

private int max;

public InputFilterMax(int max) {
    this.max = max;
}

public InputFilterMax(String max) {
    this.max = Integer.parseInt(max);
}

@Override
public CharSequence filter(CharSequence source, int start, int end, Spanned dest, int dstart, int dend) {   
    try {
        String replacement = source.subSequence(start, end).toString(); 

        String newVal = dest.toString().substring(0, dstart) + replacement +dest.toString().substring(dend, dest.toString().length());

        int input = Integer.parseInt(newVal);

        if (input<=max)
            return null;
    } catch (NumberFormatException nfe) { }   
//Maybe notify user that the value is not good      
return "";
}
}

OnFocusChangeListenerMin

package test;

import android.text.TextUtils;
import android.view.View;
import android.view.View.OnFocusChangeListener;

public class OnFocusChangeListenerMin implements OnFocusChangeListener {

private int min;

public OnFocusChangeListenerMin(int min) {
    this.min = min;
}

public OnFocusChangeListenerMin(String min) {
    this.min = Integer.parseInt(min);
}


@Override
public void onFocusChange(View v, boolean hasFocus) {
    if(!hasFocus) {
        String val = ((EditText)v).getText().toString();
        if(!TextUtils.isEmpty(val)){
            if(Integer.valueOf(val)<min){
                //Notify user that the value is not good
            }

        }
    }
}
}

然后在“活动”中设置要 注意的InputFilterMax和:您可以同时输入min和max 。OnFocusChangeListenerMinEditTextonFocusChangeListener

mQteEditText.setOnFocusChangeListener( new OnFocusChangeListenerMin('20');
mQteEditText.setFilters(new InputFilter[]{new InputFilterMax(getActivity(),'50')});

OnFocusChangeListenerMin无法正常工作,它将所有值都从零开始
EminenT 2015年

1
您介意详细一点吗?您是什么意思将所有值从零开始
Guerneen4

来自代码OnFocusChangeListenerMin的代码必须工作在20以上,如问题bu所述,它接受所有小于20的值,例如0,1、2,------ 19等
EminenT 2015年

您找到解决方案了吗?
EminenT

我已使用OnFoncusChangeListener进行验证,在我的情况下,我在EditText上显示错误,由Toast通知用户该值不好,并邀请他输入新值。 if(Integer.valueOf(val)<min){ //Notify user that the value is not good } 您可以在此处执行所需操作,并通知用户并将EditText设置为空白,我不知道这是否回答了您的问题
Guerneen4 2015年

9

扩展了Pratik和Zac的答案。Zac修复了Pratik的一个小错误。但是我注意到代码不支持负值,它将引发NumberFormatException。要解决此问题,并使MIN为负,请使用以下代码。

在其他两行之间添加以下行(粗体):

newVal = newVal.substring(0,dstart)+ source.toString()+ newVal.substring(dstart,newVal.length());

if(newVal.equalsIgnoreCase(“-”)&& min <0)返回null;

int输入= Integer.parseInt(newVal);

public CharSequence filter(CharSequence source, int start, int end, Spanned dest, int dstart, int dend) {
    try {
        // Remove the string out of destination that is to be replaced
        String newVal = dest.toString().substring(0, dstart) + dest.toString().substring(dend, dest.toString().length());
        // Add the new string in
        newVal = newVal.substring(0, dstart) + source.toString() + newVal.substring(dstart, newVal.length());
        //****Add this line (below) to allow Negative values***// 
        if(newVal.equalsIgnoreCase("-") && min < 0)return null;
        int input = Integer.parseInt(newVal);
        if (isInRange(min, max, input))
            return null;
    } catch (NumberFormatException nfe) {
        nfe.printStackTrace();
    }
    return "";
}

5

如果您需要负数范围(例如-90:90),则可以使用此解决方案。

public class InputFilterMinMax implements InputFilter {

private int min, max;

public InputFilterMinMax(int min, int max) {
    this.min = min;
    this.max = max;
}

public InputFilterMinMax(String min, String max) {
    this.min = Integer.parseInt(min);
    this.max = Integer.parseInt(max);
}

@Override
public CharSequence filter(CharSequence source, int start, int end, Spanned dest, int dstart, int dend) {
    try {
        String stringInput = dest.toString() + source.toString();
        int value;
        if (stringInput.length() == 1 && stringInput.charAt(0) == '-') {
            value = -1;
        } else {
            value = Integer.parseInt(stringInput);
        }
        if (isInRange(min, max, value))
            return null;
    } catch (NumberFormatException nfe) {
    }
    return "";
}

private boolean isInRange(int min, int max, int value) {
    return max > min ? value >= min && value <= max : value >= max && value <= min;
}
}

5

我扩展了@Pratik Sharmas代码,使其使用BigDecimal对象而不是int,以便它可以接受更大的数字,并说明EditText中不是数字的任何格式(例如货币格式,即空格,逗号和句点)

编辑:请注意,此实现将2作为在BigDecimal上设置的最低有效数字(请参见MIN_SIG_FIG常数),因为我将其用于货币,因此在小数点前始终有2个前导数字。根据您自己的实现,更改MIN_SIG_FIG常量。

public class InputFilterMinMax implements InputFilter {
private static final int MIN_SIG_FIG = 2;
private BigDecimal min, max;

public InputFilterMinMax(BigDecimal min, BigDecimal max) {
    this.min = min;
    this.max = max;
}

public InputFilterMinMax(String min, String max) {
    this.min = new BigDecimal(min);
    this.max = new BigDecimal(max);
}

@Override
public CharSequence filter(CharSequence source, int start, int end, Spanned dest, int dstart,
        int dend) {
    try {
        BigDecimal input = formatStringToBigDecimal(dest.toString()
                + source.toString());

        if (isInRange(min, max, input)) {

            return null;
        }
    } catch (NumberFormatException nfe) {

    }
    return "";
}

private boolean isInRange(BigDecimal a, BigDecimal b, BigDecimal c) {
    return b.compareTo(a) > 0 ? c.compareTo(a) >= 0 && c.compareTo(b) <= 0
            : c.compareTo(b) >= 0 && c.compareTo(a) <= 0;
}

public static BigDecimal formatStringToBigDecimal(String n) {

    Number number = null;
    try {
        number = getDefaultNumberFormat().parse(n.replaceAll("[^\\d]", ""));

        BigDecimal parsed = new BigDecimal(number.doubleValue()).divide(new BigDecimal(100), 2,
                BigDecimal.ROUND_UNNECESSARY);
        return parsed;
    } catch (ParseException e) {
        return new BigDecimal(0);
    }
}

private static NumberFormat getDefaultNumberFormat() {
    NumberFormat nf = NumberFormat.getInstance(Locale.getDefault());
    nf.setMinimumFractionDigits(MIN_SIG_FIG);
    return nf;
}

4

我找到了自己的答案。现在已经很晚了,但我想和大家分享。我实现此接口:

import android.text.TextWatcher;


public abstract class MinMaxTextWatcher implements TextWatcher {
    int min, max;
    public MinMaxTextWatcher(int min, int max) {
        super();
        this.min = min;
        this.max = max;
    }

}

然后在您的活动中以这种方式实现它:

private void limitEditText(final EditText ed, int min, int max) {
    ed.addTextChangedListener(new MinMaxTextWatcher(min, max) {
        @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) {
            String str = s.toString();
            int n = 0;
            try {
                n = Integer.parseInt(str);
                if(n < min) {
                    ed.setText(min);
                    Toast.makeText(getApplicationContext(), "Minimum allowed is " + min, Toast.LENGTH_SHORT).show();
                }
                else if(n > max) {
                    ed.setText("" + max);
                    Toast.makeText(getApplicationContext(), "Maximum allowed is " + max, Toast.LENGTH_SHORT).show();
                }
            }
            catch(NumberFormatException nfe) {
                ed.setText("" + min);
                Toast.makeText(getApplicationContext(), "Bad format for number!" + max, Toast.LENGTH_SHORT).show();
            }
        }
    });
}

这是一个非常简单的答案,如果有更好的答案,请告诉我。


int n = 0; 是多余的。由于n的默认值为0。
肯尼达比里

1
为什么int n = 0在这里是多余的?它是局部变量,而不是实例变量。
User12111111

4

接受的答案有问题。

int input = Integer.parseInt(dest.toString() + source.toString());

如果我将光标移到文本的中间,然后键入一些内容,则以上语句将产生错误的结果。例如,首先键入“ 12”,然后在1和2之间键入“ 0”,然后上述语句将产生“ 120”而不是102。我将该语句修改为以下语句:

String destString = dest.toString();
  String inputString = destString.substring(0, dstart) + source.toString() + destString.substring(dstart);
  int input = Integer.parseInt(inputString);

4

Kotlin(如果有需要)(使用实用程序)

class InputFilterMinMax: InputFilter {
    private var min:Int = 0
    private var max:Int = 0
    constructor(min:Int, max:Int) {
        this.min = min
        this.max = max
    }
    constructor(min:String, max:String) {
        this.min = Integer.parseInt(min)
        this.max = Integer.parseInt(max)
    }
    override fun filter(source:CharSequence, start:Int, end:Int, dest: Spanned, dstart:Int, dend:Int): CharSequence? {
        try
        {
            val input = Integer.parseInt(dest.toString() + source.toString())
            if (isInRange(min, max, input))
                return null
        }
        catch (nfe:NumberFormatException) {}
        return ""
    }
    private fun isInRange(a:Int, b:Int, c:Int):Boolean {
        return if (b > a) c in a..b else c in b..a
    }
}

然后在您的Kotlin课堂上使用它

percentage_edit_text.filters = arrayOf(Utilities.InputFilterMinMax(1, 100))

此EditText允许1到100。

然后从您的XML使用它

android:inputType="number"

我使用返回源并为我工作==> if(isInRange(min,max,input))返回源
Muzafferus

3

我采用了一种更简单的方法来将最小/最大设置为Edittext。我使用算术键盘,并且使用此方法:

 private int limit(EditText x,int z,int limin,int limax){

    if( x.getText().toString()==null || x.getText().toString().length()==0){
        x.setText(Integer.toString(limin));
        return z=0;
    }
    else{
        z = Integer.parseInt(x.getText().toString());
         if(z <limin || z>limax){
             if(z<10){
                 x.setText(Integer.toString(limin));
                return  z=0;
             }
            else{
                x.setText(Integer.toString(limax));
                return z=limax;
            }

         }
         else
            return z = Integer.parseInt(x.getText().toString());
    }
 }

该方法接受您的所有值,但是如果用户的值不符合您的限制,它将自动设置为最小/最大限制。对于前。limit limin = 10,limax = 80(如果用户设置为8),则自动将10保存到变量中,将EditText设置为10。


3

我知道已经有100万个答案,其中一个已经被接受。但是,公认的答案中存在许多错误,其余大多数仅修复了其中一个(或两个),而没有扩展到所有可能的用例。

因此,我基本上编译了支持答案中建议的大多数错误修复程序,并添加了一种方法,以允许在0方向(如果范围不是从0开始)连续输入超出范围的数字,至少直到确定它不再在范围内。因为要明确,这是唯一真正使许多其他解决方案引起麻烦的时间。

解决方法是:

public class InputFilterIntRange implements InputFilter, View.OnFocusChangeListener {

    private final int min, max;

    public InputFilterIntRange(int min, int max) {
        if (min > max) {
            // Input sanitation for the filter itself
            int mid = max;
            max = min;
            min = mid;
        }
        this.min = min;
        this.max = max;
    }

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

        // Determine the final string that will result from the attempted input
        String destString = dest.toString();
        String inputString = destString.substring(0, dstart) + source.toString() + destString.substring(dstart);

        // Don't prevent - sign from being entered first if min is negative
        if (inputString.equalsIgnoreCase("-") && min < 0) return null;

        try {
            int input = Integer.parseInt(inputString);
            if (mightBeInRange(input))
                return null;
        } catch (NumberFormatException nfe) {}

        return "";
    }

    @Override
    public void onFocusChange(View v, boolean hasFocus) {

        // Since we can't actively filter all values
        // (ex: range 25 -> 350, input "15" - could be working on typing "150"),
        // lock values to range after text loses focus
        if (!hasFocus) {
            if (v instanceof EditText) sanitizeValues((EditText) v);
        }
    }

    private boolean mightBeInRange(int value) {
        // Quick "fail"
        if (value >= 0 && value > max) return false;
        if (value >= 0 && value >= min) return true;
        if (value < 0 && value < min) return false;
        if (value < 0 && value <= max) return true;

        boolean negativeInput = value < 0;

        // If min and max have the same number of digits, we can actively filter
        if (numberOfDigits(min) == numberOfDigits(max)) {
            if (!negativeInput) {
                if (numberOfDigits(value) >= numberOfDigits(min) && value < min) return false;
            } else {
                if (numberOfDigits(value) >= numberOfDigits(max) && value > max) return false;
            }
        }

        return true;
    }

    private int numberOfDigits(int n) {
        return String.valueOf(n).replace("-", "").length();
    }

    private void sanitizeValues(EditText valueText) {
        try {
            int value = Integer.parseInt(valueText.getText().toString());
            // If value is outside the range, bring it up/down to the endpoint
            if (value < min) {
                value = min;
                valueText.setText(String.valueOf(value));
            } else if (value > max) {
                value = max;
                valueText.setText(String.valueOf(value));
            }
        } catch (NumberFormatException nfe) {
            valueText.setText("");
        }
    }

}

请注意,某些输入案例无法“主动”处理(即,在用户输入时),因此我们必须忽略它们,并在用户完成文本编辑后对其进行处理。

这是您可能会使用的方式:

EditText myEditText = findViewById(R.id.my_edit_text);
InputFilterIntRange rangeFilter = new InputFilterIntRange(25, 350);
myEditText.setFilters(new InputFilter[]{rangeFilter});

// Following line is only necessary if your range is like [25, 350] or [-350, -25].
// If your range has 0 as an endpoint or allows some negative AND positive numbers, 
// all cases will be handled pre-emptively.
myEditText.setOnFocusChangeListener(rangeFilter);

现在,当用户尝试输入比范围允许的数字更接近于0的数字时,将发生以下两种情况之一:

  1. 如果minmax具有相同的数字位数,则当他们到达最后一位数字时将完全不允许输入。

  2. 如果文本失去焦点时,如果在字段中留下了超出范围的数字,则会自动将其调整为最接近的边界。

当然,绝不会允许用户输入比范围允许的值更远离0的值,并且由于这个原因,这样的数字也不可能“偶然地”出现在文本字段中。

已知的问题?)

  1. 这仅EditText在用户处理完焦点后失去焦点时才起作用。

另一个选项是在用户敲击“完成” /返回键时进行消毒,但是在许多甚至大多数情况下,这仍然会导致失去焦点。

但是,关闭软键盘不会自动使元素失去焦点。我敢肯定,有99.99%的Android开发人员希望这样做(而且对EditText元素的关注处理通常不太像泥潭),但是到目前为止,还没有内置功能。如果需要,我发现解决此问题的最简单方法是扩展EditText以下内容:

public class EditTextCloseEvent extends AppCompatEditText {

    public EditTextCloseEvent(Context context) {
        super(context);
    }

    public EditTextCloseEvent(Context context, AttributeSet attrs) {
        super(context, attrs);
    }

    public EditTextCloseEvent(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);
    }

    @Override
    public boolean onKeyPreIme(int keyCode, KeyEvent event) {
        if (event.getKeyCode() == KeyEvent.KEYCODE_BACK) {
            for (InputFilter filter : this.getFilters()) {
                if (filter instanceof InputFilterIntRange)
                    ((InputFilterIntRange) filter).onFocusChange(this, false);
            }
        }
        return super.dispatchKeyEvent(event);
    }
}

即使视图实际上并没有失去焦点,这也会“欺骗”过滤器以清理输入。如果视图碰巧后来失去了对自身的关注,则输入卫生条件将再次触发,但是由于它已被固定,因此没有任何变化。

闭幕

ew。好多 最初看起来像是一个非常简单的问题,但最终却发现了许多丑陋的香草Android小块(至少在Java中是如此)。再一次,如果您的范围不包含0则只需要添加侦听器并扩展即可EditText(实际上,如果您的范围不包括0但从1或-1开始,那么您也不会遇到问题。)

最后一点,这仅适用于ints。当然是有它实现与小数的工作方式(doublefloat),但由于无论是我还是原来的提问者有需要,我并不特别希望得到所有的深入到它。简单地使用完成后过滤以及以下几行将非常容易:

// Quick "fail"
if (value >= 0 && value > max) return false;
if (value >= 0 && value >= min) return true;
if (value < 0 && value < min) return false;
if (value < 0 && value <= max) return true;

您只需要从更改intfloat(或double),允许插入单个.(或,,取决于国家?),然后解析为十进制类型之一而不是int

无论如何,这可以处理大部分工作,因此它的工作方式非常相似。


2
@Override
public CharSequence filter(CharSequence source, int start, int end, Spanned dest, int dstart, int dend) {
    try {
        String prefix = dest.toString().substring(0, dstart);
        String insert = source.toString();
        String suffix = dest.toString().substring(dend);
        String input_string = prefix + insert + suffix;
        int input = Integer.parseInt(input_string);

        if (isInRange(min, max, input) || input_string.length() < String.valueOf(min).length())
            return null;
    } catch (NumberFormatException nfe) { }
    return "";
}

private boolean isInRange(int a, int b, int c) {
    return b > a ? c >= a && c <= b : c >= b && c <= a;
}

2

关于Kotlin的非常简单的示例:

import android.text.InputFilter
import android.text.Spanned

class InputFilterRange(private var range: IntRange) : InputFilter {

    override fun filter(source: CharSequence, start: Int, end: Int, dest: Spanned, dstart: Int, dend: Int) = try {
        val input = Integer.parseInt(dest.toString() + source.toString())
        if (range.contains(input)) null else ""
    } catch (nfe: NumberFormatException) {
        ""
    }
}

1

请检查此代码

    String pass = EditText.getText().toString(); 
    if(TextUtils.isEmpty(pass) || pass.length < [YOUR MIN LENGTH]) 
    { 
       EditText.setError("You must have x characters in your txt"); 
        return; 
    }

    //continue processing



edittext.setOnFocusChangeListener( new OnFocusChangeListener() {

       @Override
       public void onFocusChange(View v, boolean hasFocus) {
          if(hasFocus) {
           // USE your code here 
  }

使用下面的链接可获取有关edittext和带有文本监视程序的edittextfilteres的更多详细信息。

http://www.mobisoftinfotech.com/blog/android/android-edittext-setfilters-example-numeric-text-field-patterns-and-length-restriction/


输入值时,OP希望对其进行验证。我想您所提供的解决方案中输入值之后
MysticMagicϡ

我不是发问者。我只是对您的回答感到怀疑,所以我正在澄清它。
MysticMagicϡ

我不想检查字符数。我认为您正在尝试检查此代码中的计数:if(TextUtils.isEmpty(pass)|| pass.length <[YOUR MIN LENGTH])我只是限制了价值,例如,用户必须在1-12不是13,14等,所以12,13,14,直到99是2个字符的长度。
mertaydin

嗨,@ mertaydin,您是否尝试过我提供给您的链接..看到该示例..可能就是您想要的。当你进入它会让看表的文本..
itsrajesh4uguys

好的,谢谢,我将尝试您的答案和@Pratik Sharma的答案。
mertaydin

1

如果您仅关注最大限制,则只需在

android:maxLength="10" 

如果您需要添加最小限制,则可以在这种情况下这样做(最小限制为7)。用户只能在最小和最大限制之间输入字符(介于8到10之间)。

public final static boolean isValidCellPhone(String number){
        if (number.length() < 8 || number.length() >10 ) {
            return false;
        } else {

           return android.util.Patterns.PHONE.matcher(number).matches();
        }
    }

如果您还需要限制用户在开始时输入01,然后按以下方式修改条件

if (!(number.startsWith("01")) || number.length() < 8 || number.length() >10 ) {  
.
.
.
}

最后调用方法如

   ....else if (!(Helper.isValidMobilePhone(textMobileNo))){
                        Helper.setEditTextError(etMobileNo,"Invalid Mobile Number");
                    }......

2
这不是vlaue,即长度
portfoliobuilder

1

@普拉蒂夏尔玛

对于支持负数,请在filter方法内添加以下代码:

package ir.aboy.electronicarsenal;

import android.text.InputFilter;
import android.text.Spanned;

public class InputFilterMinMax implements InputFilter {

  private int min, max;
  int input;

  InputFilterMinMax(int min, int max) {
    this.min = min;
    this.max = max;
  }

  public InputFilterMinMax(String min, String max) {
    this.min = Integer.parseInt(min);
    this.max = Integer.parseInt(max);
  }

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

      if ((dest.toString() + source.toString()).equals("-")) {
        source = "-1";
      }

      input = Integer.parseInt(dest.toString() + source.toString());
      if (isInRange(min, max, input))
        return null;

    } catch (NumberFormatException ignored) {
    }
    return "";
  }

  private boolean isInRange(int a, int b, int c) {
    return b > a ? c >= a && c <= b : c >= b && c <= a;
  }

}

然后在您的Activity中使用它:

findViewById(R.id.myEditText).setFilters(new InputFilter[]{ new InputFilterMinMax(1, 12)});

设置您的edittext:

android:inputType="number|numberSigned"

0

//仍然存在一些问题,但是您可以在任何范围(正或负)中使用最小值,最大值

// in filter calss
 @Override
 public CharSequence filter(CharSequence source, int start, int end, Spanned dest, int dstart, int dend) {
        try {
            // Remove the string out of destination that is to be replaced
            int input;
            String newVal = dest.toString() + source.toString();
            if (newVal.length() == 1 && newVal.charAt(0) == '-') {
                input = min; //allow
            }
            else {
                newVal = dest.toString().substring(0, dstart) + dest.toString().substring(dend, dest.toString().length());
                // Add the new string in
                newVal = newVal.substring(0, dstart) + source.toString() + newVal.substring(dstart, newVal.length());
                input = Integer.parseInt(newVal);
            }

            //int input = Integer.parseInt(dest.toString() + source.toString());

            if (isInRange(min, max, input))
                return null;
        } catch (NumberFormatException nfe) {
        }
        return "";
    }

//also the filler must set as below: in the edit createview
// to allow enter number and backspace.
et.setFilters(new InputFilter[]{new InputFilterMinMax(min >= 10 ?  "0" : String.valueOf(min), max >-10 ? String.valueOf(max) :"0" )});



//and at same time must check range in the TextWatcher()
et.addTextChangedListener(new
 TextWatcher() {

      @Override
      public void afterTextChanged (Editable editable)
      {
         String tmpstr = et.getText().toString();
         if (!tmpstr.isEmpty() && !tmpstr.equals("-") ) {
             int datavalue = Integer.parseInt(tmpstr);
             if ( datavalue >= min || datavalue <= max) {
               // accept data ...     
             }
         }
      }
 });

0

为了增加Pratik的答案,这是一个修改后的版本,用户还可以输入至少2位数字,例如15到100:

 import android.text.InputFilter;
 import android.text.Spanned;

public class InputFilterMinMax implements InputFilter {

    private int min, max;

    public InputFilterMinMax(int min, int max) {
        this.min = min;
        this.max = max;
    }

    public InputFilterMinMax(String min, String max) {
        this.min = Integer.parseInt(min);
        this.max = Integer.parseInt(max);
    }

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

        try {
            if(end==1)
                min=Integer.parseInt(source.toString());
            int input = Integer.parseInt(dest.toString() + source.toString());
            if (isInRange(min, max, input))
                return null;
        } catch (NumberFormatException nfe) {
        }
        return "";
    }

    private boolean isInRange(int a, int b, int c) {

        return b > a ? c >= a && c <= b : c >= b && c <= a;
    }}

添加:if(end == 1)min = Integer.parseInt(source.toString());

希望这可以帮助。请不要无故拒绝投票。


0

这是我使用的方式,它适用于负数

首先,使用以下代码创建MinMaxFIlter.java类:

import android.text.InputFilter;
import android.text.Spanned;
import android.util.Log;

/**
* Created by 21 on 4/5/2016.
*/
public class MinMaxFilter implements InputFilter {

private double mIntMin, mIntMax;

public MinMaxFilter(double minValue, double maxValue) {
    this.mIntMin = minValue;
    this.mIntMax = maxValue;
}

public MinMaxFilter(String minValue, String maxValue) {
    this.mIntMin = Double.parseDouble(minValue);
    this.mIntMax = Double.parseDouble(maxValue);
}

@Override
public CharSequence filter(CharSequence source, int start, int end, Spanned dest, int dstart, int dend) {
    try {
        Boolean isNeg = false;
        String provi = dest.toString() + source.toString();
        if("-".equals(provi.substring(0,1))){
            if(provi.length()>1) {
                provi = provi.substring(1, provi.length());
                isNeg = true;
            }
            else{
                if("".equals(source)){
                    return null;
                }
                return "-";
            }
        }

        double input = Double.parseDouble(provi); 
        if(isNeg){input = input * (-1);}

        if (isInRange(mIntMin, mIntMax, input)) {
            return null;
        }
    } catch (Exception nfe) {}
    return "";
}

private boolean isInRange(double a, double b, double c) {
    if((c>=a && c<=b)){
        return true;
    }
    else{
        return false;
    }
}
}

然后,创建过滤器并将其设置为您的edittext,如下所示:

EditText edittext = new EditText(context);
editext.setInputType(InputType.TYPE_CLASS_NUMBER | InputType.TYPE_NUMBER_FLAG_SIGNED);
eInt.setFilters(new InputFilter[]{new MinMaxFilter(min, max)});

0

这是我的代码max = 100,min = 0

XML文件

<TextView
                    android:id="@+id/txt_Mass_smallWork"
                    android:layout_width="match_parent"
                    android:layout_height="wrap_content"
                    android:textColor="#000"
                    android:textSize="20sp"
                    android:textStyle="bold" />

爪哇

EditText ed = findViewById(R.id.txt_Mass_smallWork);
    ed.addTextChangedListener(new TextWatcher() {
        @Override
        public void beforeTextChanged(CharSequence charSequence, int i, int i1, int i2) {`

        }

        @Override
        public void onTextChanged(CharSequence charSequence, int i, int i1, int i2) {
            if(!charSequence.equals("")) {
                int massValue = Integer.parseInt(charSequence.toString());
                if (massValue > 10) {
                    ed.setFilters(new InputFilter[]{new InputFilter.LengthFilter(2)});
                } else {
                    ed.setFilters(new InputFilter[]{new InputFilter.LengthFilter(3)});
                }
            }
        }

        @Override
        public void afterTextChanged(Editable editable) {

        }
    });

0

您可以使用InputFilter做到这一点。显然,这只是您可以使用的输入过滤器接口。在以令人讨厌的方式创建扩展输入过滤器的新类之前,您可以将此快捷方式与内部类接口实例化结合使用。

因此,您只需执行以下操作:

EditText subTargetTime = (EditText) findViewById(R.id.my_time);
subTargetTime.setFilters( new InputFilter[] {
                new InputFilter() {
                    @Override
                    public CharSequence filter(CharSequence source, int start, int end, Spanned dest, int dstart, int dend) {
                        int t = Integer.parseInt(source.toString());
                        if(t <8) { t = 8; }
                        return t+"";

                    }
                }
        });

在此示例中,我检查EditText的值是否大于8。如果不是,则应将其设置为8。因此,很显然,您需要自己自己决定max max或任何过滤器逻辑。但是至少您可以将过滤器逻辑编写得很整齐,简短,直接写入EditText。

希望这可以帮助


0

为了定义EditText的最小值,我使用了以下方法:

if (message.trim().length() >= 1 && message.trim().length() <= 12) {
  // do stuf
} else {
  // Too short or too long
}

0

@Patrik的代码有一个不错的主意,但有很多错误。@Zac和@Anthony B(负数解决方案)解决了其中一些问题,但是@Zac的代码仍然存在3个市长错误:

1. 如果用户删除了EditText中的所有条目,则无法再次键入任何数字。.当然,可以使用每个字段上的EditText更改的侦听器来控制它,但是它将消除为每个字段使用通用InputFilter类的好处。应用中的EditText。

2. @ Guernee4说过,如果例如min = 3,则不可能键入任何以1开头的数字。

3. 例如,如果min = 0,则可以键入希望具有的多个零,这将使结果不美观。或者,无论最小值是多少,用户都可以将光标放置在第一个数字的左侧,左侧放置一堆前导零,也不太好用。

我想出了@Zac代码的这些小变化来解决这3个错误。关于错误3,我仍然无法完全删除左侧的所有前导零。它始终可以是一个,但在那种情况下为00、01、0100等,比000000、001、000100等更有效。等等。

这是代码:

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

            // Using @Zac's initial solution
            String lastVal = dest.toString().substring(0, dstart) + dest.toString().substring(dend);
            String newVal = lastVal.substring(0, dstart) + source.toString() + lastVal.substring(dstart);
            int input = Integer.parseInt(newVal);

            // To avoid deleting all numbers and avoid @Guerneen4's case
            if (input < min && lastVal.equals("")) return String.valueOf(min);

            // Normal min, max check
            if (isInRange(min, max, input)) {

                // To avoid more than two leading zeros to the left
                String lastDest = dest.toString();
                String checkStr = lastDest.replaceFirst("^0+(?!$)", "");
                if (checkStr.length() < lastDest.length()) return "";

                return null;
            }
        } catch (NumberFormatException ignored) {}
        return "";
    }

祝你今天愉快!


-1

这是我对Pratik Sharma的回答的看法KotlinDouble如果有人需要的话

class InputFilterMinMax : InputFilter {

private var min: Double = MIN_LIMIT
private var max: Double = MIN_LIMIT

constructor(min: Int, max: Int) {
    this.min = min.toDouble()
    this.max = max.toDouble()
}

constructor(min: String, max: String) {
    this.min = min.toDouble()
    this.max = max.toDouble()
}

constructor(min: Double, max: Double) {
    this.min = min
    this.max = max
}

override fun filter(
    source: CharSequence,
    start: Int,
    end: Int,
    dest: Spanned,
    dstart: Int,
    dend: Int
): CharSequence? {
    try {
        val input = (dest.toString() + source.toString()).toDouble()
        if (isInRange(min, max, input))
            return null
    } catch (nfe: NumberFormatException) {
        Timber.e(nfe)
    }

    return ""
}

private fun isInRange(a: Double, b: Double, c: Double): Boolean {
    return if (b > a) c in a..b else c in b..a
}
}

此输入过滤器是错误的,它会忽略文本的开始,结束,dstart,dend索引,因此,如果您通过在中间插入一个字符来更改编辑文本,则它将无法正常工作
Radu
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.