Limiter la longueur du texte de L'EditText sur Android

Quelle est la meilleure façon de limiter la longueur de texte d'un EditText sur Android?

y a-t-il un moyen de le faire via xml?

562
demandé sur hpique 2010-07-20 01:55:42

16 réponses

Documentation

exemple

android:maxLength="10"
1132
répondu Austin Hanson 2015-12-15 16:48:52

utiliser un filtre d'entrée pour limiter la longueur maximale d'un affichage de texte.

TextView editEntryView = new TextView(...);
InputFilter[] filterArray = new InputFilter[1];
filterArray[0] = new InputFilter.LengthFilter(8);
editEntryView.setFilters(filterArray);
295
répondu jerry 2013-10-28 12:56:27
EditText editText = new EditText(this);
int maxLength = 3;    
editText.setFilters(new InputFilter[] {new InputFilter.LengthFilter(maxLength)});
169
répondu Emran Hamza 2013-06-13 14:27:05

une note pour les personnes qui utilisent déjà un filtre d'entrée personnalisé et aussi veulent limiter la longueur maximale:

lorsque vous assignez 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 ensemble avec android:maxLength . J'ai découvert cela lors de la tentative d'utiliser un filtre d'entrée pour empêcher l'utilisation de certains caractères que nous n'autorisons pas dans un champ de mot de passe. Après avoir réglé ce filtre avec setFilters le maxLength n'était pas plus observée. La solution était de mettre maxLength et mon filtre personnalisé Ensemble programmatiquement. Quelque chose comme ceci:

myEditText.setFilters(new InputFilter[] {
        new PasswordCharFilter(), new InputFilter.LengthFilter(20)
});
61
répondu goto10 2017-10-19 19:09:54
TextView tv = new TextView(this);
tv.setFilters(new InputFilter[]{ new InputFilter.LengthFilter(250) });
33
répondu ramo2712 2017-10-19 19:11:01

pour tous ceux qui se demandent comment y parvenir, voici ma classe étendue EditText 151930920" .

.setMaxLength(int) - définit le nombre maximal de chiffres

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

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

.getValue() - obtenir la 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'usage:

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 le travail aussi.

22
répondu Martynas Januškauskas 2016-03-16 15:48:02

grâce à l'observation de goto10, j'ai mis en place le code suivant pour protéger contre la perte d'autres filtres avec le réglage de 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
répondu Tim Gallagher 2014-07-07 09:09:14
//Set Length filter. Restricting to 10 characters only
editText.setFilters(new InputFilter[]{new InputFilter.LengthFilter(MAX_LENGTH)});

//Allowing only upper case characters
editText.setFilters(new InputFilter[]{new InputFilter.AllCaps()});

//Attaching multiple filters
editText.setFilters(new InputFilter[]{new InputFilter.LengthFilter(MAX_LENGTH), new InputFilter.AllCaps()});
10
répondu Kishore Reddy 2018-01-06 08:02:39

une autre façon d'y parvenir est d'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 du widget EditText à 6 caractères.

8
répondu user2586194 2017-10-19 19:12:10

j'ai eu ce problème et je considère que nous manquons une façon bien expliquée de faire cela programmatically sans perdre les filtres déjà mis.

paramétrage de la longueur en XML:

comme la réponse acceptée indique correctement, si vous voulez définir une longueur fixe à un texte D'édition que vous ne changerez pas plus loin dans le futur, il suffit de définir dans votre texte D'édition XML:

android:maxLength="10" 

Réglage de la longueur par programmation

Heres le problème, pour définir la longueur programmatically vous aurez besoin de définir un InputFilter mais une fois que vous l'avez défini tous les autres filtres disparaissent (par exemple maxLines, inputType, etc). Pour éviter de perdre les filtres précédents, vous devez obtenir ces filtres appliqués précédemment, ajouter le maxLength, et remettre les filtres à L'EditText comme suit:

InputFilter[] editFilters = editText.getFilters();
InputFilter[] newFilters = new InputFilter[editFilters.length + 1];
System.arraycopy(editFilters, 0, newFilters, 0, editFilters.length);
newFilters[editFilters.length] = new InputFilter.LengthFilter(10); //the desired length
editText.setFilters(newFilters);
7
répondu Ricardo 2017-09-27 14:44:41

Xml

android:maxLength="10"

Java:

InputFilter[] editFilters = editText.getFilters();
InputFilter[] newFilters = new InputFilter[editFilters.length + 1];
System.arraycopy(editFilters, 0, newFilters, 0, editFilters.length);
newFilters[editFilters.length] = new InputFilter.LengthFilter(maxLength);
editText.setFilters(newFilters);

Kotlin:

editText.filters += InputFilter.LengthFilter(maxLength)
5
répondu João Carlos 2018-08-24 13:41:53

il s'agit d'une classe EditText personnalisée qui permet à Length filter de vivre avec d'autres filtres. Merci à la réponse de Tim Gallagher (ci-dessous)

import android.content.Context;
import android.text.InputFilter;
import android.util.AttributeSet;
import android.widget.EditText;


public class EditTextMultiFiltering extends EditText{

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

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

    public EditTextMultiFiltering(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
    }

    public void setMaxLength(int length) {
        InputFilter curFilters[];
        InputFilter.LengthFilter lengthFilter;
        int idx;

        lengthFilter = new InputFilter.LengthFilter(length);

        curFilters = this.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;
            this.setFilters(newFilters);
        } else {
            this.setFilters(new InputFilter[] { lengthFilter });
        }
    }
}
2
répondu Gal Rom 2015-08-18 08:52:28

c'façon simple en xml:

android:maxLength="4"

si u a besoin de définir 4 caractères dans xml edit-text alors, utilisez ce

<EditText
    android:id="@+id/edtUserCode"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:maxLength="4"
    android:hint="Enter user code" />
2
répondu Navadip Patel 2017-09-05 13:00:41

ça marche très bien...

android:maxLength="10"

n'accepte que les caractères 10 .

2
répondu Sanjay Kumaar 2017-09-05 13:10:30

j'avais vu beaucoup de bonnes solutions, mais je voudrais donner un ce que je pense comme solution plus complète et facile à utiliser, qui comprennent:

1, Longueur limite.

2, Si entrée plus, donner un rappel pour déclencher votre toast.

3, curseur peut être au milieu ou la queue.

4, L'utilisateur peut entrer par coller une chaîne de caractères.

5, toujours rejeter l'entrée de débordement et garder l'origine.

public class LimitTextWatcher implements TextWatcher {

    public interface IF_callback{
        void callback(int left);
    }

    public IF_callback if_callback;

    EditText editText;
    int maxLength;

    int cursorPositionLast;
    String textLast;
    boolean bypass;

    public LimitTextWatcher(EditText editText, int maxLength, IF_callback if_callback) {

        this.editText = editText;
        this.maxLength = maxLength;
        this.if_callback = if_callback;
    }

    @Override
    public void beforeTextChanged(CharSequence s, int start, int count, int after) {

        if (bypass) {

            bypass = false;

        } else {

            StringBuilder stringBuilder = new StringBuilder();
            stringBuilder.append(s);
            textLast = stringBuilder.toString();

            this.cursorPositionLast = editText.getSelectionStart();
        }
    }

    @Override
    public void onTextChanged(CharSequence s, int start, int before, int count) {

    }

    @Override
    public void afterTextChanged(Editable s) {
        if (s.toString().length() > maxLength) {

            int left = maxLength - s.toString().length();

            bypass = true;
            s.clear();

            bypass = true;
            s.append(textLast);

            editText.setSelection(this.cursorPositionLast);

            if (if_callback != null) {
                if_callback.callback(left);
            }
        }

    }

}


edit_text.addTextChangedListener(new LimitTextWatcher(edit_text, MAX_LENGTH, new LimitTextWatcher.IF_callback() {
    @Override
    public void callback(int left) {
        if(left <= 0) {
            Toast.makeText(MainActivity.this, "input is full", Toast.LENGTH_SHORT).show();
        }
    }
}));

ce que j'ai échoué à faire est, si l'utilisateur surligner une partie de l'entrée courante et essayer de coller une très longue chaîne, Je ne sais pas comment restaurer le surlignage.

comme, la longueur maximale est fixée à 10, l'Utilisateur a entré '12345678', et marquer '345' comme highlight, et essayer de coller une chaîne de '0000' qui dépassera la limite.

quand j'essaie d'utiliser edit_text.setSelection (start=2, end=4) pour restaurer l'état d'origine, le résultat est, il suffit insérez 2 espaces comme "12 345 678", pas le surlignage d'origine. J'aimerais que quelqu'un à résoudre.

1
répondu hyyou2010 2017-10-25 02:21:05

vous pouvez utiliser android:maxLength=" 10 " dans l'edittext.(Ici la limite est de 10 caractères)

1
répondu Jocelin 2018-04-30 08:29:09