¿Hay alguna manera de definir un valor mínimo y máximo para EditText en Android?

Quiero definir un valor mínimo y máximo para un EditText .

Por ejemplo: si una persona intenta ingresar un valor de mes en ella, el valor debe estar entre 1-12.

Puedo hacerlo utilizando TextWatcher pero quiero saber si hay alguna otra forma de hacerlo en el archivo de diseño o en otro lugar.

Editar: no quiero limitar el conteo de caracteres. Quiero limitar el valor Por ejemplo, si limito el mes EditText w caracteres cuando ingreso 12, lo aceptará, pero si ingreso 22, no debe aceptarlo mientras estoy ingresando.

Primero haz esta clase:

 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; } } 

Luego usa esto de tu Actividad:

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

Esto le permitirá al usuario ingresar valores del 1 al 12 solamente .

EDITAR:

Establezca su texto de edición con android:inputType="number" .

Gracias.

Hay un pequeño error en el código de Pratik. Por ejemplo, si un valor es 10 y agrega un 1 al comienzo para hacer 110, la función de filtro trataría el nuevo valor como 101.

Vea a continuación una solución para esto:

 @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 ""; } 

Extensión de la respuesta de Pratik y Zac. Zac arregló un pequeño error de Pratik en su respuesta. Pero noté que el código no admite valores negativos, lanzará una NumberFormatException. Para arreglar eso, y permitir que el MIN sea negativo, use el siguiente código.

Agregue esta línea (en negrita) entre las otras dos líneas:

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

if (newVal.equalsIgnoreCase (“-“) && min <0) return null;

int input = 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 ""; } 

De lo que he visto de la solución de @ Patrik y la adición de @ Zac, el código provisto todavía tiene un gran problema:

Si min==3 entonces es imposible escribir cualquier número comenzando con 1 o 2 (ej: 15, 23)
Si min>=10 , es imposible escribir nada ya que cada número tendrá que comenzar con 1,2,3 …

A mi entender, no podemos lograr la limitación mínimo-máximo del valor de EditText con el uso simple de la clase InputFilterMinMax , al menos no para el valor mínimo, porque cuando el usuario está escribiendo un número positivo, el valor va en aumento y podemos fácilmente realice una prueba sobre la marcha para verificar si ha alcanzado el límite o ha salido del rango y bloquee las entradas que no cumplan. Probar el valor mínimo es una historia diferente ya que no podemos estar seguros de si el usuario ha terminado de escribir o no y, por lo tanto, no podemos decidir si debemos bloquear o no.

No es exactamente lo que OP solicitó, pero para fines de validación he combinado un InputFilter para probar valores máximos, con un OnFocusChangeListener para volver a probar el valor mínimo cuando EditText pierde el foco asumiendo que el usuario terminó de escribir y es algo como esto :

 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 ""; } } 

Y 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) 

Luego, en Activity establece InputFilterMax y OnFocusChangeListenerMin para EditText Nota: Puede 2 min y max en onFocusChangeListener .

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

Extendí el código de @Pratik Sharmas para usar objetos BigDecimal en lugar de Ints para que pueda aceptar números más grandes y dar cuenta de cualquier formato en EditText que no sea un número (como el formato de moneda, es decir, espacios, comas y puntos)

EDITAR: tenga en cuenta que esta implementación tiene 2 como las cifras significativas mínimas establecidas en el BigDecimal (ver la constante MIN_SIG_FIG) como lo usé para la moneda, por lo que siempre había 2 números iniciales antes del punto decimal. Altere la constante MIN_SIG_FIG según sea necesario para su propia implementación.

 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; } 

Si necesita un rango con números negativos como -90: 90, puede usar esta solución.

 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; } } 

Hice una forma más simple de establecer un min / max a un Edittext. Uso el teclado aritmético y trabajo con este método:

  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 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()); } } 

El método acepta todos sus valores, pero si el valor de los usuarios no se ajusta a sus límites, se establecerá automáticamente en el límite mínimo / máximo. Por ej. limit limin = 10, limax = 80 si el usuario establece 8, automáticamente 10 se guarda en una variable y EditText se establece en 10.

por favor revisa este código

  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 } 

Utilice el siguiente enlace para obtener más información sobre edittext y edittextfilteres con el observador de texto.

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

Encontré mi propia respuesta. Ya es muy tarde pero quiero compartirlo contigo. Implemento esta interfaz:

 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; } } 

Y luego impleméntelo de esta manera dentro de su actividad:

 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(); } } }); } 

Esta es una respuesta muy simple, si es que algo mejor, por favor dígame.

 @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; } 

Hay algo mal en la respuesta aceptada.

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

Si muevo el cursor hacia la mitad del texto, escriba algo, y la statement anterior producirá un resultado incorrecto. Por ejemplo, primero escriba “12”, luego escriba “0” entre 1 y 2, luego la afirmación mencionada anteriormente producirá “120” en lugar de 102. Modifiqué esta statement a las siguientes declaraciones:

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

Si solo le preocupa el límite máximo, solo agregue la línea siguiente

 android:maxLength="10" 

Si necesita agregar un límite mínimo, puede hacerlo de esta manera; en este caso, el límite mínimo es 7. El usuario está restringido para ingresar caracteres entre el límite mínimo y máximo (entre 8 y 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(); } } 

Si también necesita restringir al usuario para ingresar 01 al inicio, entonces modifique si la condición de esta manera

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

En el método de la llamada final como

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

// todavía tiene algún problema, pero aquí puedes usar min, max en cualquier rango (positivo o negativo)

 // 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 ... } } } }); 

Para agregar a la respuesta de Pratik, aquí hay una versión modificada donde el usuario puede ingresar un mínimo de 2 dígitos también, por ejemplo, 15 a 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; }} 

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

Espero que esto ayude. amablemente no voto down sin motivos.

Sé que ya hay un millón de respuestas a esto, con una aceptada. Sin embargo, hay numerosos errores en la respuesta aceptada y la mayoría del rest simplemente arregla uno (o tal vez dos) de ellos, sin expandirse a todos los casos de uso posibles.

Así que básicamente compilé la mayoría de las correcciones de errores sugeridas en las respuestas de soporte, así como también agregué un método para permitir la entrada continua de números fuera del rango en la dirección de 0 (si el rango no comienza en 0), al menos hasta que sea seguro de que ya no puede estar en el rango. Porque para ser claros, este es el único momento que realmente causa problemas con muchas de las otras soluciones.

Aquí está la solución:

 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(""); } } } 

Tenga en cuenta que algunos casos de entrada son imposibles de manejar “activamente” (es decir, a medida que el usuario los ingresa), por lo que debemos ignorarlos y manejarlos después de que el usuario termine de editar el texto.

Así es cómo puede usarlo:

 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); 

Ahora, cuando el usuario intente ingresar un número más cercano a 0 de lo que permite el rango, ocurrirá una de estas dos cosas:

  1. Si el min y el max tienen el mismo número de dígitos, no se les permitirá ingresar en absoluto una vez que lleguen al último dígito.

  2. Si queda un número fuera del rango en el campo cuando el texto pierde el foco, se ajustará automáticamente al límite más cercano.

Y, por supuesto, el usuario nunca podrá ingresar un valor más allá de 0 de lo que permite el rango, ni es posible que un número así “accidentalmente” esté en el campo de texto por este motivo.

¿Problemas conocidos?)

  1. Esto solo funciona si EditText pierde el foco cuando el usuario EditText con él.

La otra opción es desinfectar cuando el usuario pulsa la tecla “done” / return, pero en muchos o incluso en la mayoría de los casos, esto causa una pérdida de foco de todos modos.

Sin embargo, al cerrar el teclado virtual no se desenfocará automáticamente el elemento. Estoy seguro de que el 99,99% de los desarrolladores de Android lo desearía (y que el manejo del enfoque en los elementos de EditText era un atolladero en general), pero hasta el momento no hay una funcionalidad incorporada para ello. El método más fácil que he encontrado para evitar esto, si es necesario, es extender EditText algo como esto:

 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); } } 

Esto “engañará” al filtro para desinfectar la entrada aunque la vista no haya perdido el foco. Si la vista pasa a perder el foco por sí misma, el saneamiento de la entrada se activará de nuevo, pero nada cambiará ya que ya se ha solucionado.

Clausura

Uf. Eso fue mucho. Lo que originalmente parecía que sería un problema bastante trivialmente fácil terminó descubriendo muchas pequeñas y feas piezas de Android vainilla (al menos en Java). Y una vez más, solo necesita agregar el oyente y extender EditText si su rango no incluye 0 de alguna manera. (Y de manera realista, si su rango no incluye 0 pero comienza en 1 o -1, tampoco tendrá problemas).

Como última nota, esto solo funciona para Ints . Ciertamente hay una forma de implementarlo para trabajar con decimales ( double , float ), pero como ni yo ni el asker original tenemos una necesidad para eso, particularmente no quiero profundizar en eso. Sería muy fácil simplemente usar el filtrado posterior a la finalización junto con las siguientes líneas:

 // 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; 

Solo tendrías que cambiar de int a float (o double ), permitir la inserción de un single . (o , dependiendo del país?), y analizar como uno de los tipos decimales en lugar de un int .

Eso maneja la mayor parte del trabajo de todos modos, por lo que funcionaría de manera muy similar.

esta es la forma en que he usado, está funcionando para números negativos

Primero, crea la clase MinMaxFIlter.java con el siguiente código:

 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; } } } 

Luego, crea y configura tu filtro a tu texto de edición de esta manera:

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

este es mi código max = 100, min = 0

xml

  

Java

 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) { } }); 

@Pratik Sharma

Para admitir números negativos , agregue el siguiente código dentro del método de filtro :

 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; } } 

Luego usa esto de tu Actividad:

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

Establezca su texto de edición con:

 android:inputType="number|numberSigned"