studio - android widget edittext is deprecated




Beschränken Sie die Textlänge von EditText in Android (10)

Aufgrund der Beobachtung von goto10 habe ich den folgenden Code zusammengestellt, um zu verhindern, dass andere Filter durch Setzen 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 });
    }
}

Was ist der beste Weg, um die EditText eines EditText in Android zu begrenzen?

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


Das funktioniert gut ...

android:maxLength="10"

Dies akzeptiert nur 10 Zeichen.


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

Wenn Sie Eingabefilter im Code zuweisen, werden alle zuvor eingestellten Eingabefilter gelöscht, einschließlich eines Satzes mit android:maxLength . Ich habe dies herausgefunden, als ich versuchte, einen benutzerdefinierten Eingabefilter zu verwenden, um die Verwendung einiger Zeichen zu verhindern, die wir in einem Passwortfeld nicht zulassen. Nach dem Setzen dieses Filters mit setFilters wurde die maxLength nicht mehr beobachtet. Die Lösung bestand darin, maxLength und meinen benutzerdefinierten Filter programmgesteuert zusammenzusetzen. Etwas wie das:

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

Für alle anderen, die sich fragen, wie dies zu erreichen ist, ist hier meine erweiterte EditText Klasse EditTextNumeric .

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

.setMaxValue(int) - .setMaxValue(int) den maximalen Integer-Wert

.setMin(int) - limit minimaler ganzzahliger Wert

.getValue() - get Integer-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;
        }
    }
}

Beispielverwendung:

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, EditText natürlich auch.


Ich hatte viele gute Lösungen gesehen, möchte Ihnen aber eine meiner Meinung nach vollständigere und benutzerfreundlichere Lösung vorstellen, die Folgendes beinhaltet:

1, Länge begrenzen.
2, Wenn Sie mehr eingeben, geben Sie einen Rückruf, um Ihren Toast auszulösen.
3, Cursor kann in der Mitte oder Schwanz sein.
4, Benutzer kann durch Einfügen einer Zeichenfolge eingeben.
5, Überlauf-Eingang immer verwerfen und Ursprung behalten.

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 gemacht habe, ist, wenn der Benutzer einen Teil der aktuellen Eingabe markiert und versucht, eine sehr lange Zeichenfolge einzufügen, weiß ich nicht, wie ich die Hervorhebung wiederherstellen soll.

So wie, maximale Länge ist auf 10 gesetzt, Benutzer eingegeben '12345678', und markieren Sie '345' als Highlight, und versuchen Sie, eine Zeichenfolge von '0000' einfügen, die Begrenzung überschreiten wird.

Wenn ich versuche, edit_text.setSelection (start = 2, end = 4) zu verwenden, um den Ursprungsstatus wiederherzustellen, ist das Ergebnis, dass nur 2 Leerzeichen als '12 345 678 'eingefügt werden, nicht die ursprüngliche Hervorhebung. Ich möchte, dass jemand das löst.


Sie können android: maxLength = "10" im Edittext verwenden (hier ist die Grenze bis zu 10 Zeichen)


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

es ist einfach in xml:

android:maxLength="4"

Wenn Sie 4 Zeichen in xml edit-text eingeben müssen, verwenden Sie dies

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

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

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




maxlength