it-swarm.com.de

Textlänge von EditText in Android begrenzen

Wie kann die Textlänge eines EditText in Android am besten begrenzt werden?

Gibt es eine Möglichkeit, dies über XML zu tun?

637
hpique

Dokumentation

Beispiel

Android:maxLength="10"
1263
Austin Hanson

verwenden Sie einen Eingabefilter, um die maximale Länge einer Textansicht zu begrenzen.

TextView editEntryView = new TextView(...);
InputFilter[] filterArray = new InputFilter[1];
filterArray[0] = new InputFilter.LengthFilter(8);
editEntryView.setFilters(filterArray);
320
jerry
EditText editText = new EditText(this);
int maxLength = 3;    
editText.setFilters(new InputFilter[] {new InputFilter.LengthFilter(maxLength)});
189
Emran Hamza

Ein Hinweis für Personen, die bereits einen benutzerdefinierten Eingabefilter verwenden und auch die maximale Länge begrenzen möchten:

Wenn Sie Eingabefilter im Code zuweisen, werden alle zuvor festgelegten Eingabefilter gelöscht, einschließlich eines mit Android:maxLength festgelegten. Ich habe dies herausgefunden, als ich versucht habe, einen benutzerdefinierten Eingabefilter zu verwenden, um die Verwendung einiger Zeichen zu verhindern, die in einem Kennwortfeld nicht zulässig sind. Nach dem Setzen dieses Filters mit setFilters wurde die maxLength nicht mehr beobachtet. Die Lösung bestand darin, maxLength und meinen benutzerdefinierten Filter programmgesteuert zusammenzustellen. Etwas wie das:

myEditText.setFilters(new InputFilter[] {
        new PasswordCharFilter(), new InputFilter.LengthFilter(20)
});
64
goto10
TextView tv = new TextView(this);
tv.setFilters(new InputFilter[]{ new InputFilter.LengthFilter(250) });
36
ramo2712

Für alle anderen, die sich fragen, wie dies erreicht werden kann, ist hier meine erweiterte EditText-Klasse EditTextNumeric.

.setMaxLength(int) - legt die maximale Anzahl von Stellen fest

.setMaxValue(int) - Maximaler ganzzahliger Wert begrenzen

.setMin(int) - minimalen ganzzahligen Wert begrenzen

.getValue() - Ermittelt einen ganzzahligen Wert

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

Anwendungsbeispiel:

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

Alle anderen Methoden und Attribute, die für EditText gelten, funktionieren natürlich auch.

Aufgrund der Beobachtung von goto10 habe ich den folgenden Code zusammengestellt, um zu verhindern, dass andere Filter durch Einstellen der maximalen Länge verloren gehen:

/**
 * 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
Tim Gallagher
//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()});
15
Kishore Reddy

Ich hatte dieses Problem und ich denke, wir vermissen eine gut erläuterte Möglichkeit, dies programmgesteuert zu tun, ohne die bereits festgelegten Filter zu verlieren.

Einstellen der Länge in XML:

Wenn Sie eine feste Länge für einen EditText definieren möchten, den Sie in Zukunft nicht mehr ändern werden, definieren Sie dies einfach in Ihrem EditText-XML:

Android:maxLength="10" 

Länge programmgesteuert einstellen

Um die Länge programmgesteuert einzustellen, müssen Sie InputFilter einstellen.

Problem für Java ist: Wenn Sie es einmal eingestellt haben, verschwinden alle anderen Filter (z. B. maxLines, inputType usw.). Um zu vermeiden, dass frühere Filter verloren gehen, müssen Sie die zuvor angewendeten Filter abrufen, die maximale Länge hinzufügen und die Filter wie folgt auf EditText zurücksetzen:

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

Kotlin Obwohl es für alle einfacher ist, müssen Sie den Filter auch zu den bereits vorhandenen hinzufügen, aber Sie können dies mit einem einfachen Befehl erreichen:

editText.filters += InputFilter.LengthFilter(maxLength)
12
Ricardo

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)
10
João Carlos

Sie können dies auch erreichen, indem Sie der XML-Datei die folgende Definition hinzufügen:

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

Dies begrenzt die maximale Länge des Widgets EditText auf 6 Zeichen.

8
user2586194

Ab material.io können Sie TextInputEditText in Kombination mit TextInputLayout verwenden:

<com.google.Android.material.textfield.TextInputLayout
    Android:layout_width="match_parent"
    Android:layout_height="wrap_content"
    app:counterEnabled="true"
    app:counterMaxLength="1000"
    app:passwordToggleEnabled="false">

    <com.google.Android.material.textfield.TextInputEditText
        Android:id="@+id/edit_text"
        Android:hint="@string/description"
        Android:layout_width="match_parent"
        Android:layout_height="wrap_content"
        Android:maxLength="1000"
        Android:gravity="top|start"
        Android:inputType="textMultiLine|textNoSuggestions"/>

</com.google.Android.material.textfield.TextInputLayout>

Sie können ein Passwort EditText mit drawable konfigurieren:

password example

Oder Sie können die Textlänge mit/ohne Zähler begrenzen:

counter example

Abhängigkeit:

implementation 'com.google.Android.material:material:1.1.0-alpha02'
4
RonTLV

XML

Android:maxLength="10"

Programmatisch:

int maxLength = 10;
InputFilter[] filters = new InputFilter[1];
filters[0] = new InputFilter.LengthFilter(maxLength);
yourEditText.setFilters(filters);

Hinweis: Intern analysieren EditText & TextView den Wert von Android:maxLength in XML und wenden ihn mit InputFilter.LengthFilter() an.

Siehe: TextView.Java # L1564

3
nhoxbypass

Das funktioniert gut ...

Android:maxLength="10"

dies akzeptiert nur 10 Zeichen.

2
Sanjay Kumaar

Dies ist eine benutzerdefinierte EditText-Klasse, mit der der Längenfilter zusammen mit anderen Filtern verwendet werden kann. Dank der Antwort von Tim Gallagher (unten)

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
Gal Rom

es ist ganz einfach in xml:

Android:maxLength="4"

wenn du 4 Zeichen in xml edit-text setzen musst, benutze dies

<EditText
    Android:id="@+id/edtUserCode"
    Android:layout_width="wrap_content"
    Android:layout_height="wrap_content"
    Android:maxLength="4"
    Android:hint="Enter user code" />
2
Navadip Patel

Ich hatte viele gute Lösungen gesehen, möchte aber eine meiner Meinung nach umfassendere und benutzerfreundlichere Lösung nennen, die Folgendes umfasst:

1, Länge begrenzen.
2, Wenn Sie mehr eingeben, rufen Sie zurück, um Ihren Toast auszulösen.
3, Cursor kann sich in der Mitte oder am Ende befinden.
4, Benutzer kann durch Einfügen einer Zeichenfolge eingeben.
5, Überlaufeingang immer verwerfen und Origin beibehalten.

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

Was ich nicht getan habe, ist, wenn der Benutzer einen Teil der aktuellen Eingabe hervorhebt und versucht, eine sehr lange Zeichenfolge einzufügen, kann ich die Hervorhebung nicht wiederherstellen.

Beispiel: Die maximale Länge ist auf 10 festgelegt. Der Benutzer hat '12345678' eingegeben und '345' als Hervorhebung markiert. Versuchen Sie, eine Zeichenfolge von '0000' einzufügen, die die Beschränkung überschreitet.

Wenn ich versuche, edit_text.setSelection (start = 2, end = 4) zum Wiederherstellen des Origin-Status zu verwenden, wird als Ergebnis nur 2 Leerzeichen als '12 345 678 'eingefügt, nicht die Origin-Hervorhebung. Ich möchte, dass jemand das löst.

1
hyyou2010

Sie können Android:maxLength="10" im EditText verwenden (hier sind maximal 10 Zeichen zulässig).

1
Jocelin

Versuchen Sie dies für Java programmgesteuert:

myEditText(new InputFilter[] {new InputFilter.LengthFilter(CUSTOM_MAX_LEN)});
0
reza_khalafi