Question Limiter la longueur du texte de EditText dans Android


Quel est le meilleur moyen de limiter la longueur du texte d'un EditText dans Android?

Existe-t-il un moyen de le faire via xml?


551
2017-07-19 21:55


origine


Réponses:


Documentation

Exemple

android:maxLength="10"

1104
2017-07-19 21:57



utilisez un filtre d'entrée pour limiter la longueur maximale d'une vue de texte.

TextView editEntryView = new TextView(...);
InputFilter[] filterArray = new InputFilter[1];
filterArray[0] = new InputFilter.LengthFilter(8);
editEntryView.setFilters(filterArray);

291
2017-11-10 15:23



EditText editText = new EditText(this);
int maxLength = 3;    
editText.setFilters(new InputFilter[] {new InputFilter.LengthFilter(maxLength)});

164
2018-01-21 06:18



Une note aux personnes qui utilisent déjà un filtre d'entrée personnalisé et aussi vouloir limiter la longueur maximale:

Lorsque vous affectez des filtres d'entrée dans le code, tous les filtres d'entrée précédemment définis sont effacés, y compris un jeu avec android:maxLength. J'ai trouvé ceci en essayant d'utiliser un filtre d'entrée personnalisé pour empêcher l'utilisation de certains caractères que nous n'autorisons pas dans un champ de mot de passe. Après avoir défini ce filtre avec setFilters, le paramètre maxLength n'a plus été observé. La solution consistait à définir ensemble maxLength et mon filtre personnalisé. Quelque chose comme ça:

myEditText.setFilters(new InputFilter[] {
        new PasswordCharFilter(), new InputFilter.LengthFilter(20)
});

60
2018-05-23 15:57



TextView tv = new TextView(this);
tv.setFilters(new InputFilter[]{ new InputFilter.LengthFilter(250) });

33
2018-01-08 07:58



Pour tous ceux qui se demandent comment y parvenir, voici mon extension EditText classe EditTextNumeric.

.setMaxLength(int) - Définit le nombre maximum de chiffres

.setMaxValue(int) - limite la valeur entière maximale

.setMin(int) - limite la valeur entière minimale

.getValue() - Obtenir une valeur entière

import android.content.Context;
import android.text.InputFilter;
import android.text.InputType;
import android.widget.EditText;

public class EditTextNumeric extends EditText {
    protected int max_value = Integer.MAX_VALUE;
    protected int min_value = Integer.MIN_VALUE;

    // constructor
    public EditTextNumeric(Context context) {
        super(context);
        this.setInputType(InputType.TYPE_CLASS_NUMBER);
    }

    // checks whether the limits are set and corrects them if not within limits
    @Override
    protected void onTextChanged(CharSequence text, int start, int before, int after) {
        if (max_value != Integer.MAX_VALUE) {
            try {
                if (Integer.parseInt(this.getText().toString()) > max_value) {
                    // change value and keep cursor position
                    int selection = this.getSelectionStart();
                    this.setText(String.valueOf(max_value));
                    if (selection >= this.getText().toString().length()) {
                        selection = this.getText().toString().length();
                    }
                    this.setSelection(selection);
                }
            } catch (NumberFormatException exception) {
                super.onTextChanged(text, start, before, after);
            }
        }
        if (min_value != Integer.MIN_VALUE) {
            try {
                if (Integer.parseInt(this.getText().toString()) < min_value) {
                    // change value and keep cursor position
                    int selection = this.getSelectionStart();
                    this.setText(String.valueOf(min_value));
                    if (selection >= this.getText().toString().length()) {
                        selection = this.getText().toString().length();
                    }
                    this.setSelection(selection);
                }
            } catch (NumberFormatException exception) {
                super.onTextChanged(text, start, before, after);
            }
        }
        super.onTextChanged(text, start, before, after);
    }

    // set the max number of digits the user can enter
    public void setMaxLength(int length) {
        InputFilter[] FilterArray = new InputFilter[1];
        FilterArray[0] = new InputFilter.LengthFilter(length);
        this.setFilters(FilterArray);
    }

    // set the maximum integer value the user can enter.
    // if exeeded, input value will become equal to the set limit
    public void setMaxValue(int value) {
        max_value = value;
    }
    // set the minimum integer value the user can enter.
    // if entered value is inferior, input value will become equal to the set limit
    public void setMinValue(int value) {
        min_value = value;
    }

    // returns integer value or 0 if errorous value
    public int getValue() {
        try {
            return Integer.parseInt(this.getText().toString());
        } catch (NumberFormatException exception) {
            return 0;
        }
    }
}

Exemple d'utilisation:

final EditTextNumeric input = new EditTextNumeric(this);
input.setMaxLength(5);
input.setMaxValue(total_pages);
input.setMinValue(1);

Toutes les autres méthodes et attributs qui s'appliquent à EditText, bien sûr, travaille aussi.


21
2018-01-25 21:19



En raison de l'observation de goto10, j'ai rassemblé le code suivant pour éviter de perdre d'autres filtres en définissant la longueur maximale:

/**
 * This sets the maximum length in characters of an EditText view. Since the
 * max length must be done with a filter, this method gets the current
 * filters. If there is already a length filter in the view, it will replace
 * it, otherwise, it will add the max length filter preserving the other
 * 
 * @param view
 * @param length
 */
public static void setMaxLength(EditText view, int length) {
    InputFilter curFilters[];
    InputFilter.LengthFilter lengthFilter;
    int idx;

    lengthFilter = new InputFilter.LengthFilter(length);

    curFilters = view.getFilters();
    if (curFilters != null) {
        for (idx = 0; idx < curFilters.length; idx++) {
            if (curFilters[idx] instanceof InputFilter.LengthFilter) {
                curFilters[idx] = lengthFilter;
                return;
            }
        }

        // since the length filter was not part of the list, but
        // there are filters, then add the length filter
        InputFilter newFilters[] = new InputFilter[curFilters.length + 1];
        System.arraycopy(curFilters, 0, newFilters, 0, curFilters.length);
        newFilters[curFilters.length] = lengthFilter;
        view.setFilters(newFilters);
    } else {
        view.setFilters(new InputFilter[] { lengthFilter });
    }
}

17
2018-05-26 20:59



Une autre façon d'y parvenir consiste à ajouter la définition suivante au fichier XML:

<EditText
    android:id="@+id/input"
    android:layout_width="0dp"
    android:layout_height="wrap_content"
    android:inputType="number"
    android:maxLength="6"
    android:hint="@string/hint_gov"
    android:layout_weight="1"/>

Cela limitera la longueur maximale de EditText widget à 6 caractères.


8
2017-07-16 07:07