我想为EditText.
例如：如果有人尝试在其中输入月份值，则该值必须在 1-12 之间。
我可以通过使用来做到这一点，TextWatcher但我想知道在布局文件或其他地方是否有其他方法可以做到这一点。
编辑：我不想限制字符数。我想限制价值。例如，如果我EditText在输入 12 时限制月份 w 字符，它将接受它，但如果我输入 22，它在我输入时不能接受它。
问问题
148861 次
28 回答
304
首先做这个类：
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 的值。
编辑 ：
用 . 设置您的编辑文本android:inputType="number"。
谢谢。
于 2013-01-08T10:18:46.637 回答
95
Pratik 的代码有一个小错误。例如，如果一个值为 10，并且您在开头添加一个 1 以得到 110，则过滤器函数会将新值视为 101。
请参阅下面的解决方法：
@Override
public CharSequence filter(CharSequence source, int start, int end, Spanned dest, int dstart, int dend) {
try {
// Removes string that is to be replaced from destination
// and adds the new string in.
String newVal = dest.subSequence(0, dstart)
// Note that below "toString()" is the only required:
+ source.subSequence(start, end).toString()
+ dest.subSequence(dend, dest.length());
int input = Integer.parseInt(newVal);
if (isInRange(min, max, input))
return null;
} catch (NumberFormatException nfe) { }
return "";
}
于 2013-09-28T22:05:55.897 回答
12
在我所看到的@Patrik 的解决方案和@Zac 的补充中，提供的代码仍然存在一个大问题：
如果min==3那么就不可能输入任何以 1 或 2 开头的数字（例如：15、23）
如果min>=10那么就不可能输入任何数字，因为每个数字都必须以 1、2、3 开头......
在我的理解中，我们无法EditText通过简单地使用 class 来实现 an 值的 min-max 限制InputFilterMinMax，至少对于 min 值来说不是，因为当用户输入一个正数时，该值会增长，我们可以轻松地执行即时测试以检查它是否达到限制或超出范围并阻止不符合要求的条目。测试最小值是另一回事，因为我们无法确定用户是否已完成输入，因此无法决定是否应该阻止。
这不完全是 OP 所要求的，但出于验证目的，我在我的解决方案中组合了一个InputFilter来测试最大值，并在假设用户完成输入OnFocusChangeListener的情况下失去焦点时重新测试最小值EditText，它是这样的：
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
}
}
}
}
}
然后在 Activity 中设置InputFilterMax和OnFocusChangeListenerMin注意EditText
：您可以在 2 中设置 min 和 max onFocusChangeListener。
mQteEditText.setOnFocusChangeListener( new OnFocusChangeListenerMin('20');
mQteEditText.setFilters(new InputFilter[]{new InputFilterMax(getActivity(),'50')});
于 2015-02-26T12:55:09.590 回答
12
如果有人需要 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"
于 2019-11-27T10:11:15.617 回答
9
Pratik 和 Zac 答案的扩展。Zac 在他的回答中修复了 Pratik 的一个小错误。但我注意到代码不支持负值，它会抛出 NumberFormatException。要解决此问题并允许 MIN 为负数，请使用以下代码。
在其他两行之间添加这一行（粗体）：
newVal = newVal.substring(0, dstart) + source.toString()+ newVal.substring(dstart, newVal.length());
if(newVal.equalsIgnoreCase("-") && min < 0)return 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 "";
}
于 2016-08-05T16:23:09.687 回答
5
我扩展了@Pratik Sharmas 代码以使用 BigDecimal 对象而不是整数，以便它可以接受更大的数字，并考虑 EditText 中不是数字的任何格式（如货币格式，即空格、逗号和句点）
编辑：请注意，此实现在 BigDecimal 上设置了 2 作为最小有效数字（请参阅 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;
}
于 2014-07-30T10:10:36.597 回答
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;
}
}
于 2015-04-12T15:20:35.850 回答
5
我找到了自己的答案。现在很晚了，但我想和你分享。我实现了这个接口：
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();
}
}
});
}
这是一个非常简单的答案，如果有更好的请告诉我。
于 2015-08-05T18:00:33.763 回答
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);
于 2017-09-15T09:57:09.653 回答
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。
于 2014-08-18T15:19:10.860 回答
3
我知道已经有一百万个答案，其中一个被接受了。但是，已接受的答案中有许多错误，其余大多数只是修复其中一个（或可能两个），而没有扩展到所有可能的用例。
因此，我基本上编译了支持答案中建议的大多数错误修复，并添加了一种方法以允许在 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 的数字时，会发生以下两种情况之一：
如果
min和max具有相同的位数，则一旦到达最后一位，就根本不允许输入。如果文本失去焦点时字段中留下了超出范围的数字，则会自动调整到最近的边界。
当然，用户将永远不会被允许输入一个比范围允许的值更远离 0 的值，因此，这样的数字也不可能“意外”出现在文本字段中。
已知的问题？）
- 这仅
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);
}
}
即使视图实际上并没有失去焦点，这也会“欺骗”过滤器来清理输入。如果视图后来碰巧失去了自己的焦点，输入卫生将再次触发，但由于它已经被修复，所以什么都不会改变。
结束
唷。那是很多。最初看起来这将是一个非常简单的问题，最终发现了许多丑陋的普通 Android（至少在 Java 中）。再一次，如果您的范围不以某种方式包含 0 ，您只需要添加侦听器并扩展。EditText（实际上，如果您的范围不包括 0，而是从 1 或 -1 开始，您也不会遇到问题。）
最后一点，这仅适用于ints。当然有一种方法可以实现它以使用小数（double, float），但由于我和最初的提问者都不需要它，我并不特别想深入了解它。简单地使用完成后过滤以及以下几行将非常容易：
// 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;
您只需从更改int为float（或double），允许插入单个.（或,，取决于国家/地区？），并解析为十进制类型之一而不是int.
无论如何，它处理了大部分工作，所以它的工作方式非常相似。
于 2018-02-16T13:17:04.113 回答
2
如果您只关心最大限制，那么只需添加以下行
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 条件
if (!(number.startsWith("01")) || number.length() < 8 || number.length() >10 ) {
.
.
.
}
在结束调用方法如
....else if (!(Helper.isValidMobilePhone(textMobileNo))){
Helper.setEditTextError(etMobileNo,"Invalid Mobile Number");
}......
于 2015-03-01T09:08:55.350 回答
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;
}
于 2016-06-28T08:55:40.763 回答
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) {
""
}
}
于 2018-12-25T19:35:04.910 回答
2
@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 "";
}
祝你今天过得愉快！
于 2020-03-24T03:07:35.697 回答
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 的更多详细信息。
于 2013-01-08T10:37:06.853 回答
1
这是我的代码 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) {
}
});
于 2018-05-16T04:02:50.760 回答
1
@Pratik 夏尔马
要支持负数，请在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"
于 2018-08-22T21:00:28.783 回答
1
首先创建一个方法如下
private InputFilter inRange(int min, int max) {
return new InputFilter(){
@Override
public CharSequence filter(CharSequence source, int start1, int end, Spanned dest, int dstart, int dend) {
try {
int input = Integer.parseInt(dest.toString() + source.toString());
if (input < min || input > max){
return "";
} else {
return null;
}
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
};
}
像这样使用它：
edittext1.setFilters(new InputFilter[]{inRange(3,60)});
edittext2.setFilters(new InputFilter[]{inRange(1,100)});
您可以制作更多文件管理器并像这样添加：
edittext1.setFilters(new InputFilter[]{filter1(somevalue),filter2(somevalue)});
于 2021-03-21T10:48:36.100 回答
1
这里的许多解决方案都很棒，但我想提供一个更快的替代方案，如果您只是在寻找一种防止溢出的方法，这可能就足够了：
android:maxLength="9"
这将确保您不会在非小数的 32 位整数上出现溢出。所以这里的最小值是-99999999，最大值是999999999。
于 2021-04-16T19:19:50.650 回答
1
在科特林：
class InputFilterMinMax(private val min: Float, private val max: Float) : InputFilter {
override fun filter(source: CharSequence, start: Int, end: Int, dest: Spanned, dstart: Int, dend: Int): CharSequence? {
try {
val input = (dest.subSequence(0, dstart).toString() + source + dest.subSequence(dend, dest.length)).toFloat()
if (isInRange(min, max, input)) return null
} catch (e: NumberFormatException) {
e.printStackTrace()
}
return ""
}
private fun isInRange(a: Float, b: Float, c: Float): Boolean {
return if (b > a) c in a..b else c in b..a
}
}
于 2021-08-15T09:51:39.563 回答
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 ...
}
}
}
});
于 2016-04-08T08:01:27.063 回答
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());
希望这可以帮助。请不要无缘无故投反对票。
于 2016-05-24T09:56:24.087 回答
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 = new EditText(context);
editext.setInputType(InputType.TYPE_CLASS_NUMBER | InputType.TYPE_NUMBER_FLAG_SIGNED);
eInt.setFilters(new InputFilter[]{new MinMaxFilter(min, max)});
于 2018-03-19T14:20:07.853 回答
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。因此，显然您需要自己计算 min max 或任何过滤器逻辑。但至少你可以将过滤器逻辑非常简洁和简短地直接写入 EditText。
希望这可以帮助
于 2019-01-22T02:06:45.900 回答
0
为了定义 EditText 的最小值，我使用了这个：
if (message.trim().length() >= 1 && message.trim().length() <= 12) {
// do stuf
} else {
// Too short or too long
}
于 2019-08-01T21:03:45.503 回答
0
我在做一个宠物项目时偶然发现了这个问题。我在这里阅读了一些答案，我可能在我的代码中采用了其中的一两个。
坏消息：我设法用一种非常肮脏的方式做到了这一点（你会明白为什么）。还有一些我没有费心去解决的错误（我是在凌晨 2 点写的），比如如果min值为 10，你将无法输入一个数字开头。
好消息：我已经设法摆脱了@nnyerges 提到的前导零错误，仅使用InputFilter向下到只有一个 0，即如果min值为 0。但是，InputFilter当用户删除后跟零的第一个数字，例如，如果首先用户输入1000但随后删除1，它将变为000。那很丑陋，这就是我对TextChangedListener/的肮脏丑陋使用的地方TextWatcher。（我知道 OP 已经说过他可以使用 来做到这一点TextWatcher，但无论如何。 ）使用 the 的
另一个限制（或者我的限制？）InputFilter是当inputTypeis时numberDecimal，这意味着用户可以输入小数点分隔符。示例案例：范围是0 - 100，用户输入99.99, 用户然后删除分隔符，我们有9999. 我们不想这样，对吗？
我也让它适应负值。
我的代码中的一些功能，不管你喜欢与否，包括修剪无关紧要的 s，例如如果用户从中0删除，只要它在定义的范围内，它就会修剪前导s，因此最终结果将是 32。第二，当用户尝试删除负号 ( ) 或小数分隔符 ( ) 时，它会检查删除后的结果数字是否仍在范围内。如果不是，那么它将恢复到最后一个值。换句话说，不允许用户进行这种删除。但是，如果您希望在发生这种情况时将新值设置为or ，您也可以这样做。1100320-.minmax
注意：我懒得连本地化都麻烦了，所以使用逗号作为小数分隔符的人将不得不自己手动更改它。
第二个注意事项：代码非常混乱，可能有一些或很多冗余检查，所以要注意。另外，如果您有任何建议，请随时发表评论，因为我也想改进它。我将来可能需要使用它。谁知道？
无论如何，它来了。
import android.text.InputFilter;
import android.text.Spanned;
import android.util.Log;
public class InputFilterMinMax implements InputFilter {
private double min, max;
public InputFilterMinMax(double min, double max) {
this.min = min;
this.max = max;
}
public InputFilterMinMax(String min, String max) {
this.min = Double.parseDouble(min);
this.max = Double.parseDouble(max);
}
@Override
public CharSequence filter(CharSequence source, int start, int end, Spanned dest, int dstart, int dend) {
try {
String lastVal = dest.toString();
String newVal = lastVal.substring(0, dstart) + source.toString() + lastVal.substring(dstart);
String strInput = source.toString();
double input;
if (strInput.equals("-") && (lastVal.length() == 0 || lastVal.equals("0"))) {
return null;
} else {
input = Double.parseDouble(newVal);
}
if (isInRange(min, max, input)) {
try {
if (lastVal.equals("0") && strInput.equals("0") && !strInput.equals(".")) {
Log.d("Checkpoint 1", "Can't put 0 again.");
return "";
} else if (strInput.equals("0")) {
if (dstart == 0) {
if (lastVal.substring(0, 1).equals("0")) {
Log.d("Checkpoint 2", "Can't put 0 again.");
return "";
} else if (!lastVal.substring(0, 1).equals(".")) {
Log.d("Checkpoint 3", "Can't put 0 in front of them.");
return "";
}
} else {
if (lastVal.substring(0, 1).equals("0") && dstart == 1) {
Log.d("Checkpoint 4", "Can't put 0 again.");
return "";
} else if (lastVal.substring(0, 1).equals("-")) {
if (Double.parseDouble(lastVal) == 0) {
if (!lastVal.contains(".")) {
Log.d("Checkpoint 5", "Can't put 0 here.");
return "";
} else {
if (dstart <= lastVal.indexOf(".")) {
Log.d("Checkpoint 6", "Can't put 0 here.");
return "";
}
}
} else {
if (lastVal.indexOf("0") == 1 && (dstart == 1 || dstart == 2)) {
Log.d("Checkpoint 7", "Can't put 0 here.");
return "";
} else if ((!lastVal.substring(1, 2).equals("0") && !lastVal.substring(1, 2).equals(".")) && dstart == 1) {
Log.d("Checkpoint 8", "Can't put 0 here.");
return "";
}
}
}
}
}
/**
* If last value is a negative that equals min value,
* and user tries to input a decimal separator at the
* very end, ignore it, because they won't be able to
* input anything except 0 after that anyway.
*/
if (strInput.equals(".") && lastVal.substring(0,1).equals("-")
&& Double.parseDouble(lastVal) == min && dstart == lastVal.length()) {
return "";
}
} catch (Exception e) {
}
return null;
}
} catch (Exception ignored) {
ignored.printStackTrace();
}
return "";
}
private boolean isInRange(double a, double b, double c) {
return b > a ? c >= a && c <= b : c >= b && c <= a;
}
}
现在，真正肮脏的部分：
import androidx.appcompat.app.AppCompatActivity;
import android.os.Bundle;
import android.text.Editable;
import android.text.InputFilter;
import android.text.TextWatcher;
import android.util.Log;
import android.widget.EditText;
public class MainActivity extends AppCompatActivity implements TextWatcher {
private EditText editInput;
/**
* Var to store old value in case the new value is either
* out of range or invalid somehow. This was because I
* needed a double value for my app, which means I can
* enter a dot (.), and that could mean trouble if I decided
* to delete that dot, e.g. assume the range is 0 - 100.
* At first I enter 99.99, the InputFilter would allow that,
* but what if somewhere down the line I decided to delete
* the dot/decimal separator for "fun"?
* Wow, now I have 9999.
* Also, when I delete negative notation, it can produce
* the same problem.
*/
private String oldVal;
private int min, max;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
editInput = findViewById(R.id.edt_input);
editInput.addTextChangedListener(this);
min = -1600;
max = 1500;
editInput.setFilters(new InputFilter[]{new InputFilterMinMax(min, max)});
}
@Override
public void beforeTextChanged(CharSequence s, int start, int count, int after) {
oldVal = saveOldValue(s, start);
}
@Override
public void onTextChanged(CharSequence s, int start, int before, int count) {
}
@Override
public void afterTextChanged(Editable s) {
validateChange(editInput, oldVal);
}
private String saveOldValue(CharSequence s, int start) {
String oldVal = s.toString();
if (oldVal.contains(".") && start == oldVal.indexOf(".") && start != oldVal.length() - 1) {
return oldVal;
} else if (oldVal.contains("-") && start == oldVal.indexOf("-") && start != oldVal.length() - 1) {
return oldVal;
}
return null;
}
private void validateChange(EditText editText, String oldVal) {
String strNewVal = editText.getText().toString().trim();
boolean isChanged = false;
if (strNewVal.indexOf("0") == 0 || (strNewVal.indexOf("-") == 0 && strNewVal.indexOf("0") == 1)) {
if (strNewVal.contains(".")) {
while ((strNewVal.indexOf("0") == 0 && strNewVal.indexOf(".") != 1 && strNewVal.length() > 2) ||
(strNewVal.indexOf("0") == 1 && strNewVal.indexOf(".") != 2 && strNewVal.length() > 3)) {
Log.d("Trimming 0", "");
strNewVal = strNewVal.replaceFirst("0", "");
isChanged = true;
}
} else if (!strNewVal.contains(".")) {
while (strNewVal.indexOf("0") == 0 && strNewVal.length() > 1) {
Log.d("Trimming 0", "");
strNewVal = strNewVal.replaceFirst("0", "");
isChanged = true;
}
if (Double.parseDouble(strNewVal) > max) {
editText.setText(oldVal); // Or, you can set it to max values here.
return;
}
}
}
if (strNewVal.indexOf(".") == 0) {
strNewVal = "0" + strNewVal;
isChanged = true;
}
try {
double newVal = Double.parseDouble(strNewVal);
Log.d("NewVal: ", String.valueOf(newVal));
if (newVal > max || newVal < min) {
Log.d("Over Limit", "Let's Reset");
editText.setText(oldVal); // Or, you can set it to min or max values here.
}
} catch (NumberFormatException e) {
e.printStackTrace();
}
if (isChanged) {
editText.setText(strNewVal);
}
}
}
于 2020-10-28T19:13:25.240 回答
-1
这是我对 Pratik Sharma 的回答的看法Kotlin，Double如果有人需要的话
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
}
}
于 2019-10-31T14:31:53.623 回答