Akzeptiere nur zahlen und einen Punkt in Java TextField

JTextField txField = new DoubleJTextField();

Erstellen Sie eine Datei DoubleJTextField.java und glücklich sein

public class DoubleJTextField extends JTextField {
    public DoubleJTextField(){
        addKeyListener(new KeyAdapter() {
            public void keyTyped(KeyEvent e) {
                char ch = e.getKeyChar();

                if (!isNumber(ch) && !isValidSignal(ch) && !validatePoint(ch)  && ch != '\b') {
                    e.consume();
                }
            }
        });

    }

    private boolean isNumber(char ch){
        return ch >= '0' && ch <= '9';
    }

    private boolean isValidSignal(char ch){
        if( (getText() == null || "".equals(getText().trim()) ) && ch == '-'){
            return true;
        }

        return false;
    }

    private boolean validatePoint(char ch){
        if(ch != '.'){
            return false;
        }

        if(getText() == null || "".equals(getText().trim())){
            setText("0.");
            return false;
        }else if("-".equals(getText())){
            setText("-0.");
        }

        return true;
    }
}

Verwenden Sie nicht immer einen KeyListener für diese. Dein code oben hat zwei gravierende Fehler, bedingt durch die Verwendung von einem KeyListener. Erstens wird es verpassen, jeder text wird eingefügt. Immer, wenn ich ein Feld Filter, die aus nicht-Ziffern, die ich immer versuchen, fügen Sie etwas text, nur so zum Spaß. Neun mal von zehn, der text wird akzeptiert, weil Sie verwendet einen key-listener.

Sekunde, die Sie nicht herausfiltern Modifikatoren. Wenn der Benutzer versucht, Ihre Arbeit zu speichern durch die Eingabe von Ctrl-s, während Sie in diesem Feld, Ihre key-listener verbraucht der Veranstaltung. Und wenn Ihre Anwendung ordnet, sagen wir, ein control-5 oder alt + 5 shortcut auf einige Maßnahmen, diese KeyListener hinzufügen eine 5 auf dem Feld, wenn Sie geben es, obwohl der Benutzer gar nicht versucht, zu geben ein Zeichen. Sie doch herausfinden, dass Sie benötigt, um übergeben Sie die "backspace" - Taste, aber das ist nicht alles, was Sie brauchen, um passieren. Ihre Pfeil-Tasten funktionieren nicht. Weder wird Ihr Funktionstasten. Sie beheben können all diese Probleme, aber es beginnt zu viel Arbeit.

Gibt es eine Dritte Nachteil, aber es zeigt nur, wenn Sie passen Sie Ihre Anwendung zu einem fremden alphabet, besonders eine, die mehrere Tastenanschläge zu generieren, die ein einzelnes Zeichen, wie die chinesische. Diese Alphabete machen KeyListeners nutzlos.

Das Problem ist dieses. Sie müssen filter-Zeichen, aber KeyListeners nicht über die Zeichen, Sie sind über die Tastenanschläge, die sind nicht das gleiche: Nicht alle Tastenanschläge erzeugen Zeichen, und nicht alle Zeichen werden erzeugt, indem Tastatureingaben. Sie brauchen einen Ansatz, der sich mit Zeichen, nachdem Sie erzeugt wurden, und nach geändert Tastatureingaben haben bereits herausgefiltert wurden.

Der einfachste Ansatz ist die Verwendung eines JFormattedTextField, aber ich habe noch nie mochte diesen Ansatz, da es ja nicht formatieren, oder während der Eingabe gefiltert. So anstelle, werde ich einen DocumentFilter. DocumentFilters nicht betreiben auf Tastatureingaben, operieren Sie auf die text-strings, wie Sie eingefügt, um Ihre JTextField-Datenmodell. Also alle control-Tasten, Pfeil-und Funktionstasten und so erreichen nicht einmal den DocumentFilter. Alle eingefügten text geht durch den DocumentFilter, zu. Und Sprachen, dass Sie drei Tastenanschläge zu generieren, die ein einzelnes Zeichen, das DocumentFilter nicht aufgerufen wird, bis das Zeichen generiert wird. Hier ist, wie es aussieht:

    ptoMinimoField = new JTextField();
    ptoMinimoField.setBounds(348, 177, 167, 20); //Don't do this! See below.
    contentPanel.add(ptoMinimoField);
    ptoMinimoField.setColumns(10);

    PlainDocument document = (PlainDocument) ptoMinimoField.getDocument();
    document.setDocumentFilter(new DigitFilter());
}

Den DigitFilter-Klasse sieht wie folgt aus:

public class DigitFilter extends DocumentFilter {
    @Override
    public void insertString(FilterBypass fb, int offset, String text, 
            AttributeSet attr) throws BadLocationException {
        super.insertString(fb, offset, revise(text), attr);
    }

    @Override
    public void replace(FilterBypass fb, int offset, int length, String text,
                        AttributeSet attrs) throws BadLocationException {
        super.replace(fb, offset, length, revise(text), attrs);
    }

    private String revise(String text) {
        StringBuilder builder = new StringBuilder(text);
        int index = 0;
        while (index < builder.length()) {
            if (accept(builder.charAt(index))) {
                index++;
            } else {
                //Don't increment index here, or you'll skip the next character!
                builder.deleteCharAt(index);
            }
        }
        return builder.toString();
    }

    /**
     * Determine if the character should remain in the String. You may
     * override this to get any matching criteria you want. 
     * @param c The character in question
     * @return true if it's valid, false if it should be removed.
     */
    public boolean accept(final char c) {
        return Character.isDigit(c) || c == '.';
    }
}

Könnten Sie schreiben, diese als innere Klasse, aber ich eine separate Klasse, so können Sie überschreiben Sie die accept () - Methode zu verwenden Kriterien, die Sie wollen. Sie können auch feststellen, dass ich nicht testen kann für zahlen, die durch das schreiben dieses:

(c < '0') || (c > '9')

Statt, so mache ich das:

Character.isDigit()

Dies ist schneller, sauberer, und arbeitet mit ausländischen Nummerierung Systeme. Ich weiß auch nicht brauchen, Ihre Prüfung für das backspace-Zeichen, '\b'. Ich vermute, dass Ihre ersten KeyListener war das herausfiltern der "backspace" - Taste, das war der erste Hinweis darauf, dass es der falsche Ansatz.

Und auf einem nicht verwandten note, nicht zu schwer-code Ihrer Komponente Positionen. Weitere Informationen zur Verwendung des LayoutManagers. Sie sind einfach zu bedienen, und Sie werden Ihren code viel einfacher zu pflegen.

Geben Sie die doppelte Anzahl der JTextField in java

private boolean dot = false;
private void txtMarkKeyTyped(java.awt.event.KeyEvent evt) {                                 
    char vChar = evt.getKeyChar();
    if (txtMark.getText().equals(""))
        dot = false;
    if (dot == false){
        if (vChar == '.') dot = true;
        else if (!(Character.isDigit(vChar)
                || (vChar == KeyEvent.VK_BACK_SPACE)
                || (vChar == KeyEvent.VK_DELETE))) {
                evt.consume();
        }
    } else {
        if (!(Character.isDigit(vChar)
                || (vChar == KeyEvent.VK_BACK_SPACE)
                || (vChar == KeyEvent.VK_DELETE))) {
                evt.consume();
        }
    }
}

Gerade Recht-klicken Sie auf "TextField" /events /key /keytyped

if(!Character.isDigit(evt.getKeyChar())){
            evt.consume();}

vielleicht helfen können, die Sie für die Filterung keytyped nur Anzahl und dot

public void filterHanyaAngkaDot(java.awt.event.KeyEvent evt){
      char c = evt.getKeyChar();
      if (! ((Character.isDigit(c) ||
              (c == KeyEvent.VK_BACK_SPACE) ||
              (c == KeyEvent.VK_DELETE))
              )&& c==KeyEvent.VK_COMMA
              )
      {
          evt.consume();
      }
 }

Ich habe mit dieser Lösung, es ist einfach und effizient:

                jtextfield.addKeyListener(new KeyAdapter() {
                public void keyTyped(KeyEvent e) {
                    char vChar = e.getKeyChar();
                    if (!(Character.isDigit(vChar)
                            || (vChar == KeyEvent.VK_BACK_SPACE)
                            || (vChar == KeyEvent.VK_DELETE))) {
                        e.consume();
                    }
                }
            });

JTextField textField = new JTextField();
textField.setColumns(10);

textField.addKeyListener(new KeyAdapter() {
    @Override
    public void KeyTyped(KeyEvent e) {
        if (!(e.getKeyChar() >= '0' && e.getKeyChar() <= '9')) {
            e.consume();
        }
    }
})

dies ist die einfachste Methode, die ich bis jetzt gefunden habe, und es funktioniert ohne Fehler