android-edittext hint - Beschränken Sie die Textlänge von EditText in Android




get listener (13)

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

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


Answers

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

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

Dadurch wird die maximale Länge des Widget " EditText auf 6 Zeichen begrenzt.


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.


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

Ich hatte dieses Problem und ich denke, wir vermissen eine gut erklärte Art, dies programmatisch zu tun, ohne die bereits gesetzten Filter zu verlieren.

Festlegen der Länge in XML:

Wie die akzeptierte Antwort richtig sagt, wenn Sie eine feste Länge für einen EditText definieren wollen, die Sie zukünftig nicht mehr ändern werden, definieren Sie einfach in Ihrem EditText XML:

android:maxLength="10" 

Festlegen der Länge programmgesteuert

Heres das Problem, um die Länge programmgesteuert InputFilter , müssen Sie einen InputFilter aber sobald Sie es einstellen, verschwinden alle anderen Filter (zB maxLines, inputType, usw.). Um zu vermeiden, dass vorherige Filter verloren gehen, müssen Sie die zuvor angewendeten Filter abrufen, die maxLength-Funktion 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);

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

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

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

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.


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


Das funktioniert gut ...

android:maxLength="10"

Dies akzeptiert nur 10 Zeichen.


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

Fügen Sie folgenden Code in der Klassendatei hinzu:

final TelephonyManager tm = (TelephonyManager) getBaseContext()
            .getSystemService(SplashActivity.TELEPHONY_SERVICE);
    final String tmDevice, tmSerial, androidId;
    tmDevice = "" + tm.getDeviceId();
    Log.v("DeviceIMEI", "" + tmDevice);
    tmSerial = "" + tm.getSimSerialNumber();
    Log.v("GSM devices Serial Number[simcard] ", "" + tmSerial);
    androidId = "" + android.provider.Settings.Secure.getString(getContentResolver(),
            android.provider.Settings.Secure.ANDROID_ID);
    Log.v("androidId CDMA devices", "" + androidId);
    UUID deviceUuid = new UUID(androidId.hashCode(),
            ((long) tmDevice.hashCode() << 32) | tmSerial.hashCode());
    String deviceId = deviceUuid.toString();
    Log.v("deviceIdUUID universally unique identifier", "" + deviceId);
    String deviceModelName = android.os.Build.MODEL;
    Log.v("Model Name", "" + deviceModelName);
    String deviceUSER = android.os.Build.USER;
    Log.v("Name USER", "" + deviceUSER);
    String devicePRODUCT = android.os.Build.PRODUCT;
    Log.v("PRODUCT", "" + devicePRODUCT);
    String deviceHARDWARE = android.os.Build.HARDWARE;
    Log.v("HARDWARE", "" + deviceHARDWARE);
    String deviceBRAND = android.os.Build.BRAND;
    Log.v("BRAND", "" + deviceBRAND);
    String myVersion = android.os.Build.VERSION.RELEASE;
    Log.v("VERSION.RELEASE", "" + myVersion);
    int sdkVersion = android.os.Build.VERSION.SDK_INT;
    Log.v("VERSION.SDK_INT", "" + sdkVersion);

Hinzufügen in AndroidManifest.xml:

<uses-permission android:name="android.permission.READ_PHONE_STATE" />




android android-edittext maxlength