Existe-t-il un moyen de définir une valeur minimale et maximale pour EditText dans Android?

Je veux définir une valeur min et max pour un EditText .

Par exemple: si une personne tente d’entrer une valeur mensuelle, la valeur doit être comprise entre 1 et 12.

Je peux le faire en utilisant TextWatcher mais je veux savoir s’il existe un autre moyen de le faire dans un fichier de mise en page ou ailleurs.

Edit: Je ne veux pas limiter le nombre de caractères. Je veux limiter la valeur. Par exemple, si je limite les caractères du mois EditText w quand j’entre 12, il l’acceptera mais si j’entre 22, il ne doit pas l’accepter pendant que j’entre.

Faites d’abord cette classe:

 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(Ssortingng min, Ssortingng 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.toSsortingng() + source.toSsortingng()); 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; } } 

Ensuite, utilisez ceci de votre activité:

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

Cela permettra à l'utilisateur d'entrer des valeurs de 1 à 12 seulement .

MODIFIER :

Définissez votre edittext avec android:inputType="number" .

Merci.

Il y a une petite erreur dans le code de Pratik. Par exemple, si une valeur est 10 et que vous ajoutez un 1 au début pour obtenir 110, la fonction de filtre traiterait la nouvelle valeur comme 101.

Voir ci-dessous pour un correctif à ceci:

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

Extension de la réponse de Pratik et Zac. Zac a corrigé un petit bug de Pratik dans sa réponse. Mais j’ai remarqué que le code ne supporte pas les valeurs négatives, il lancera une exception NumberFormatException. Pour résoudre ce problème et autoriser le MIN à être négatif, utilisez le code suivant.

Ajoutez cette ligne (en gras) entre les deux autres lignes:

newVal = newVal.subssortingng (0, dstart) + source.toSsortingng () + newVal.subssortingng (dstart, newVal.length ());

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

int input = Integer.parseInt (newVal);

 public CharSequence filter(CharSequence source, int start, int end, Spanned dest, int dstart, int dend) { try { // Remove the ssortingng out of destination that is to be replaced Ssortingng newVal = dest.toSsortingng().subssortingng(0, dstart) + dest.toSsortingng().subssortingng(dend, dest.toSsortingng().length()); // Add the new ssortingng in newVal = newVal.subssortingng(0, dstart) + source.toSsortingng() + newVal.subssortingng(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 ce que j’ai vu de la solution de @ Pasortingk et de l’ajout de @ Zac, le code fourni a toujours un gros problème:

Si min==3 alors il est impossible de taper un nombre commençant par 1 ou 2 (ex: 15, 23)
Si min>=10 il est impossible de taper quelque chose car chaque nombre devra commencer par 1,2,3 …

À ma connaissance, nous ne pouvons pas atteindre la limitation min-max de la valeur d’un EditText utilisant simplement la classe InputFilterMinMax , du moins pas pour la valeur min, car lorsque l’utilisateur tape un nombre positif, la valeur augmente et nous pouvons facilement Effectuez un test à la volée pour vérifier s’il a atteint la limite ou sortez de la plage et bloquez les entrées non conformes. Tester la valeur min est une histoire différente car nous ne pouvons pas être sûrs que l’utilisateur ait fini de taper ou non et ne peut donc pas décider si nous devons ou non bloquer.

Ce n’est pas exactement ce que OP a demandé mais à des fins de validation j’ai combiné dans ma solution un InputFilter pour tester les valeurs max, avec un OnFocusChangeListener pour OnFocusChangeListener à nouveau la valeur min lorsque le EditText perd le focus en supposant que l’utilisateur a fini de taper :

 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(Ssortingng max) { this.max = Integer.parseInt(max); } @Override public CharSequence filter(CharSequence source, int start, int end, Spanned dest, int dstart, int dend) { try { Ssortingng replacement = source.subSequence(start, end).toSsortingng(); Ssortingng newVal = dest.toSsortingng().subssortingng(0, dstart) + replacement +dest.toSsortingng().subssortingng(dend, dest.toSsortingng().length()); int input = Integer.parseInt(newVal); if (input<=max) return null; } catch (NumberFormatException nfe) { } //Maybe notify user that the value is not good return ""; } } 

Et 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(Ssortingng min) { this.min = Integer.parseInt(min); } @Override public void onFocusChange(View v, boolean hasFocus) { if(!hasFocus) { Ssortingng val = ((EditText)v).getText().toSsortingng(); if(!TextUtils.isEmpty(val)){ if(Integer.valueOf(val) 

Ensuite, dans Activity, définissez InputFilterMax et OnFocusChangeListenerMin sur EditText Remarque: Vous pouvez 2 à la fois min et max dans onFocusChangeListener .

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

J’ai étendu le code @Pratik Sharmas pour utiliser des objects BigDecimal au lieu de ints afin qu’il puisse accepter des nombres plus importants et prendre en compte tout formatage dans le texte d’édition qui n’est pas un nombre (comme la mise en forme des espaces, des virgules et des points)

EDIT: notez que cette implémentation a 2 comme nombre significatif minimum défini sur le BigDecimal (voir la constante MIN_SIG_FIG) comme je l’ai utilisé pour la devise, donc il y avait toujours 2 nombres avant le point décimal. Modifiez la constante MIN_SIG_FIG si nécessaire pour votre propre implémentation.

 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(Ssortingng min, Ssortingng 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 = formatSsortingngToBigDecimal(dest.toSsortingng() + source.toSsortingng()); 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 vous avez besoin d’une plage avec des nombres négatifs comme -90: 90, vous pouvez utiliser cette solution.

 public class InputFilterMinMax implements InputFilter { private int min, max; public InputFilterMinMax(int min, int max) { this.min = min; this.max = max; } public InputFilterMinMax(Ssortingng min, Ssortingng 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 { Ssortingng ssortingngInput = dest.toSsortingng() + source.toSsortingng(); int value; if (ssortingngInput.length() == 1 && ssortingngInput.charAt(0) == '-') { value = -1; } else { value = Integer.parseInt(ssortingngInput); } 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; } } 

J’ai fait un moyen plus simple de définir un min / max sur un Edittext. J’utilise le clavier arithmétique et je travaille avec cette méthode:

  private int limit(EditText x,int z,int limin,int limax){ if( x.getText().toSsortingng()==null || x.getText().toSsortingng().length()==0){ x.setText(Integer.toSsortingng(limin)); return z=0; } else{ z = Integer.parseInt(x.getText().toSsortingng()); 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()); } } 

La méthode accepte toutes vos valeurs, mais si la valeur des utilisateurs ne respecte pas vos limites, elle sera automatiquement définie sur la limite min / max. Pour ex. limit limin = 10, limax = 80 si l'utilisateur définit 8, automatiquement 10 est enregistré dans une variable et EditText est défini sur 10.

s’il vous plaît vérifier ce code

  Ssortingng pass = EditText.getText().toSsortingng(); 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 } 

Utilisez le lien ci-dessous pour plus de détails sur edittext et les edittextfilteres avec observateur de texte.

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

J’ai trouvé ma propre réponse. Il est très tard maintenant mais je veux le partager avec vous. Je mets en oeuvre cette interface:

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

Et ensuite, implémentez-le de cette manière dans votre activité:

 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) { Ssortingng str = s.toSsortingng(); 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(); } } }); } 

Ceci est une réponse très simple, s’il vous plaît mieux me le dire.

 @Override public CharSequence filter(CharSequence source, int start, int end, Spanned dest, int dstart, int dend) { try { Ssortingng prefix = dest.toSsortingng().subssortingng(0, dstart); Ssortingng insert = source.toSsortingng(); Ssortingng suffix = dest.toSsortingng().subssortingng(dend); Ssortingng input_ssortingng = prefix + insert + suffix; int input = Integer.parseInt(input_ssortingng); if (isInRange(min, max, input) || input_ssortingng.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; } 

Il y a quelque chose qui ne va pas dans la réponse acceptée.

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

Si je déplace le curseur au milieu du texte, puis tapez quelque chose, alors l’instruction ci-dessus produira un résultat incorrect. Par exemple, tapez “12” en premier, puis tapez “0” entre 1 et 2, puis l’instruction mentionnée ci-dessus produira “120” au lieu de 102. J’ai modifié cette instruction pour obtenir des instructions ci-dessous:

 Ssortingng destSsortingng = dest.toSsortingng(); Ssortingng inputSsortingng = destSsortingng.subssortingng(0, dstart) + source.toSsortingng() + destSsortingng.subssortingng(dstart); int input = Integer.parseInt(inputSsortingng); 

Si vous êtes seulement préoccupé par la limite maximale, ajoutez simplement la ligne ci-dessous dans

 android:maxLength="10" 

Si vous avez besoin d’append une limite minimum, vous pouvez faire comme cela dans ce cas.

 public final static boolean isValidCellPhone(Ssortingng number){ if (number.length() < 8 || number.length() >10 ) { return false; } else { return android.util.Patterns.PHONE.matcher(number).matches(); } } 

Si vous avez également besoin de restreindre l’utilisateur pour entrer 01 au début, modifiez si condition comme ceci

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

À la fin de l’appel méthode comme

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

// a toujours un problème mais ici vous pouvez utiliser min, max à n’importe quelle plage (positive ou négative)

 // in filter calss @Override public CharSequence filter(CharSequence source, int start, int end, Spanned dest, int dstart, int dend) { try { // Remove the ssortingng out of destination that is to be replaced int input; Ssortingng newVal = dest.toSsortingng() + source.toSsortingng(); if (newVal.length() == 1 && newVal.charAt(0) == '-') { input = min; //allow } else { newVal = dest.toSsortingng().subssortingng(0, dstart) + dest.toSsortingng().subssortingng(dend, dest.toSsortingng().length()); // Add the new ssortingng in newVal = newVal.subssortingng(0, dstart) + source.toSsortingng() + newVal.subssortingng(dstart, newVal.length()); input = Integer.parseInt(newVal); } //int input = Integer.parseInt(dest.toSsortingng() + source.toSsortingng()); 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" : Ssortingng.valueOf(min), max >-10 ? Ssortingng.valueOf(max) :"0" )}); //and at same time must check range in the TextWatcher() et.addTextChangedListener(new TextWatcher() { @Override public void afterTextChanged (Editable editable) { Ssortingng tmpstr = et.getText().toSsortingng(); if (!tmpstr.isEmpty() && !tmpstr.equals("-") ) { int datavalue = Integer.parseInt(tmpstr); if ( datavalue >= min || datavalue <= max) { // accept data ... } } } }); 

Pour append à la réponse de Pratik, voici une version modifiée dans laquelle l’utilisateur peut saisir 2 chiffres minimum également, par exemple, 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(Ssortingng min, Ssortingng 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.toSsortingng()); int input = Integer.parseInt(dest.toSsortingng() + source.toSsortingng()); 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; }} 

ajouté: if (end == 1) min = Integer.parseInt (source.toSsortingng ());

J'espère que cela t'aides. veuillez ne pas prendre note sans raisons.

Je sais qu’il y a déjà un million de réponses, dont une acceptée. Cependant, il y a de nombreux bogues dans la réponse acceptée et la plupart des autres corrigent un (ou peut-être deux) d’entre eux sans développer tous les cas d’utilisation possibles.

J’ai donc compilé la plupart des corrections de bogues suggérées dans les réponses de support et ajouté une méthode pour permettre la saisie continue de nombres en dehors de la plage dans la direction de 0 (si la plage ne commence pas à 0), au moins certain qu’il ne peut plus être dans la gamme. Parce que pour être clair, c’est le seul moment qui pose vraiment problème avec beaucoup d’autres solutions.

Voici le correctif:

 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 ssortingng that will result from the attempted input Ssortingng destSsortingng = dest.toSsortingng(); Ssortingng inputSsortingng = destSsortingng.subssortingng(0, dstart) + source.toSsortingng() + destSsortingng.subssortingng(dstart); // Don't prevent - sign from being entered first if min is negative if (inputSsortingng.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 Ssortingng.valueOf(n).replace("-", "").length(); } private void sanitizeValues(EditText valueText) { try { int value = Integer.parseInt(valueText.getText().toSsortingng()); // 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(Ssortingng.valueOf(value)); } } catch (NumberFormatException nfe) { valueText.setText(""); } } } 

Notez que certains cas d’entrée sont impossibles à gérer “activement” (c.-à-d. Que l’utilisateur le saisit), nous devons donc les ignorer et les gérer une fois que l’utilisateur a fini de modifier le texte.

Voici comment vous pourriez l’utiliser:

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

Maintenant, lorsque l’utilisateur essaie de saisir un nombre plus proche de 0 que la plage ne le permet, une des deux choses suivantes se produit:

  1. Si min et max ont le même nombre de chiffres, ils ne seront pas autorisés à le saisir une fois qu’ils atteindront le chiffre final.

  2. Si un nombre en dehors de la plage est laissé dans le champ lorsque le texte perd le focus, il sera automatiquement ajusté à la limite la plus proche.

Et bien sûr, l’utilisateur ne sera jamais autorisé à entrer une valeur plus éloignée de 0 que la plage ne le permet, et il est impossible qu’un nombre comme celui-ci soit “accidentellement” dans le champ de texte pour cette raison.

Problèmes connus?)

  1. Cela ne fonctionne que si EditText perd le focus lorsque l’utilisateur en a fini avec.

L’autre option est la désinfection lorsque l’utilisateur appuie sur la touche “done” / return, mais dans la plupart des cas, la plupart du temps, cela entraîne une perte de concentration.

Cependant, la fermeture du clavier logiciel ne détourne pas automatiquement l’élément. Je suis sûr que 99,99% des développeurs Android souhaiteraient le faire (et que la gestion du focus sur les éléments EditText était moins un bourbier en général), mais pour le moment, il n’ya pas de fonctionnalité intégrée pour cela. La méthode la plus simple que j’ai trouvée pour contourner cela, si vous en avez besoin, est d’étendre quelque chose comme ceci:

 public class EditTextCloseEvent extends AppCompatEditText { public EditTextCloseEvent(Context context) { super(context); } public EditTextCloseEvent(Context context, AtsortingbuteSet attrs) { super(context, attrs); } public EditTextCloseEvent(Context context, AtsortingbuteSet 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); } } 

Cela va “tromper” le filtre pour qu’il assainisse l’entrée même si la vue n’a pas réellement perdu le focus. Si la vue perd le focus par la suite, l’assainissement des entrées se déclenchera à nouveau, mais rien ne changera car il a déjà été corrigé.

Fermeture

Ouf. C’était beaucoup. Ce qui semblait à l’origine être un problème assez facile à résoudre a fini par révéler de nombreux petits morceaux d’Android (au moins en Java). Et encore une fois, il vous suffit d’append l’écouteur et d’étendre EditText si votre plage n’inclut pas 0 d’une certaine manière. (Et de façon réaliste, si votre plage n’inclut pas 0 mais commence à 1 ou -1, vous ne rencontrerez pas non plus de problèmes.)

En dernier lieu, cela ne fonctionne que pour les ints . Il y a certainement un moyen de l’implémenter pour travailler avec des décimales ( double , float ), mais comme ni moi ni le demandeur d’origine n’en avons besoin, je ne veux pas particulièrement approfondir tout cela. Il serait très facile d’utiliser simplement le filtrage post-achèvement avec les lignes suivantes:

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

Vous devez seulement changer d' int pour float (ou double ), permettre l'insertion d'un seul . (ou , selon le pays?), et parsingr comme l'un des types décimaux au lieu d'un int .

Cela gère la plupart du travail de toute façon, de sorte que cela fonctionnerait très similaire.

voici comment j’ai utilisé, ça marche pour le nombre négatif

Tout d’abord, créez la classe MinMaxFIlter.java avec le code suivant:

 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(Ssortingng minValue, Ssortingng 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; Ssortingng provi = dest.toSsortingng() + source.toSsortingng(); if("-".equals(provi.subssortingng(0,1))){ if(provi.length()>1) { provi = provi.subssortingng(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; } } } 

Ensuite, créez et définissez votre filtre sur votre edittext comme ceci:

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

c’est mon code 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.toSsortingng()); 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

Pour les nombres négatifs de support, ajoutez le code suivant dans la méthode de filtrage :

 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(Ssortingng min, Ssortingng 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.toSsortingng() + source.toSsortingng()).equals("-")) { source = "-1"; } input = Integer.parseInt(dest.toSsortingng() + source.toSsortingng()); 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; } } 

Ensuite, utilisez ceci de votre activité:

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

Définissez votre edittext avec:

 android:inputType="number|numberSigned"