# Textfeld soll nur Zahlen erlauben



## Matrixmaster (13. Jul 2009)

Stehe vor folgendem Problem ....ich möchte in Textfeldern nur Zahlen erlauben aber auch Kommas (sprich Dezimalzahlen)

derzeit sieht es so aus:


```
txt1.addKeyListener(new KeyAdapter() {
			    public void keyTyped(KeyEvent e) {
			      char c = e.getKeyChar();      
			      if (!((Character.isDigit(c) ||
			         (c == KeyEvent.VK_BACK_SPACE) ||
			         (c == KeyEvent.VK_DELETE)))) {
			           getToolkit().beep();
			           e.consume();
			      }
			    }
			  });
```

wie kann ich nun außerdem auch Kommata erlauben ?


----------



## FatFire (13. Jul 2009)

Genauso wie mit Backspace und Delete, nur mit VK_COMMA?
Wobei ich vorher auch noch abprüfen würde, ob nicht vielleicht schon ein Komma drin ist.


----------



## Landei (13. Jul 2009)

Einfach noch VK_COMMA erlauben.


----------



## Matrixmaster (13. Jul 2009)

ok hatte ich mich falsch ausgedrückt...es sollen Komma(Punkte) erlaubt sein welche ich für Berechnungen von Doublewerte benötige


----------



## FatFire (13. Jul 2009)

Was jetzt, Komma oder Punkte? Soll beides erlaubt sein? Punkt ist VK_PERIOD. Wenn Du beides haben willst, beides erlauben und Komma vor dem Parsen eben in Punkt umwandeln. Oder soll beides in Komma oder Punkt umgewandelt werden? Dann änder das KeyEvent in das benötigte um...ich hab das Problem immer noch nicht verstanden, fürchte ich.

Gruß FatFire


----------



## diggaa1984 (13. Jul 2009)

ich verweis auch einfach mal auf die FAQ .. vielleicht findst das ja interessanter ^^
JTextfield: Dokumentarten


----------



## HannsW (13. Jul 2009)

Matrixmaster hat gesagt.:


> Stehe vor folgendem Problem ....ich möchte in Textfeldern nur Zahlen erlauben aber auch Kommas (sprich Dezimalzahlen)
> 
> wie kann ich nun außerdem auch Kommata erlauben ?



Wenn Du Dr kein Document schreiben willst, dann z.B
primitiv so:

```
// char c = e.getKeyChar();      
			      switch ( e.getKeyChar() ){
                              case '0':
                              case '1':
                              //usw OHNE break !!!
                              case '9';
                              case ',':
                              case '.':
                              case andererErlaubeterChar:
                                      break;
                              default:
			           getToolkit().beep();
			           e.consume();
                              }
```

Damit bekommst Du aber Probleme mit den Decimalpunkten. Es wäre z.b folgende
Eingabe nach obigen Code erlaubt:





> 1..2.,32



Hanns


----------



## Matrixmaster (13. Jul 2009)

Sorry aber bin echter Java Neuling. VK_PERIOD funzt einwandfrei. Hatte einfach mal damit begonnen nen kleinen Taschenrechner zu basteln welche unter anderem 3 Textfelder beinhalten.Nun wollte ich einfach nen Schritt weitergehen und nur Zahlen + Kommapunkte(Dezimalzahlen) für die Eingabe zulassen. Irgendwie muss man ja mal beginnen wenn man die Programmiersprache erlernen möchte Jedenfalls nochmal danke.


----------



## Gast2 (13. Jul 2009)

How to Use Formatted Text Fields (The Java™ Tutorials > Creating a GUI with JFC/Swing > Using Swing Components)

http://www.java-forum.org/awt-swing-swt/85104-die-eingabe-einem-jtextfield-beschraenken.html

http://www.java-forum.org/java-basics-anfaenger-themen/83493-jtextfield-darf-nur-zahlen-annehmen.html


----------



## HannsW (13. Jul 2009)

VK_PERIOD entspricht '.'


----------



## spinnerboy (7. Jun 2010)

Hallo, welches VK_ braucht man um nur große buchstaben zu erlauben?


----------



## alderwaran (7. Jun 2010)

spinnerboy hat gesagt.:


> Hallo, welches VK_ braucht man um nur große buchstaben zu erlauben?



ich glaube das wird über einen eventhandler auf dem textfeld gemacht der kleine buchstaben einfach in große umwandelt. Java 2 Platform SE 5.0


----------



## Ebenius (7. Jun 2010)

Vielleicht hilft's ja, wenn ich auch nochmal dagegen argumentiere. Auf keinen Fall sollte man KeyEvents dafür misbrauchen. Ansonsten funktioniert plötzlich Copy&Paste nicht mehr, unter Linux kann ich weiterhin über die Maus den Selection-Buffer einfügen und noch viele andere Probleme tauchen auf, an die ich gar nicht gedacht habe.

*Wenn es ein JTextField sein soll, dann geht nur ein angepasstes Dokument.*

Ebenius


----------



## KrokoDiehl (7. Jun 2010)

Ich unterstreiche _Ebenius_' Aussage. Ich hatte es bei einem Projekt auch mal über einen _KeyListener _gemacht und musste es am Ende doch wieder alles wegmachen und neu über eigene Dokumente gehen (an dieser Stelle ein Verweis auf _diggaa1984_s Link in der 5. Antwort, sehr lohnenswert!). Für Quick&Dirty ist der _KeyListener _ (für dieses Problem) gut, aber mehr nicht.


----------



## spinnerboy (7. Jun 2010)

alderwaran hat gesagt.:


> ich glaube das wird über einen eventhandler auf dem textfeld gemacht der kleine buchstaben einfach in große umwandelt. Java 2 Platform SE 5.0



ich glaube mich sehr schlecht ausgedrückt zu haben, trotzdem danke für die schnelle antwort!
also ich möchte nicht nur kleine buchstaben in große umwandeln, sondern auch nur buchstaben zulassen, sodass man zahlen und sonderzeichen garnicht eingeben kann. gibt es dafür auch


```
if (!((Character.isDigit(c) ||
                     (c == KeyEvent.VK_hier der code für nur großbuchstaben oder buchstaben)
```


----------



## Ebenius (7. Jun 2010)

DocumentFilter: 
	
	
	
	





```
/* (@)NumberTextFieldTestGui.java */

/* Copyright 2010 Sebastian Haufe

 * Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at

       [url]http://www.apache.org/licenses/LICENSE-2.0[/url]

 * Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License. */

package com.ebenius;

import java.awt.BorderLayout;

import javax.swing.*;
import javax.swing.text.*;

/**
 * @author Sebastian Haufe
 */
public class NumberTextFieldTestGui {

  /** Creates the GUI. Call on EDT, only! */
  static void createAndShowGui() {
    final PlainDocument doc = new PlainDocument();
    doc.setDocumentFilter(new DocumentFilter() {

      @Override
      public void insertString(
            FilterBypass fb,
            int offset,
            String string,
            AttributeSet attr) throws BadLocationException {
        super.insertString(fb, offset, filterInputString(string), attr);
      }

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

      private String filterInputString(String string) {
        StringBuilder sb = null;
        for (int i = 0; i < string.length(); i++) {
          final char input = string.charAt(i);
          final char accepted = toAcceptedCharacter(input);
          if (input != accepted && sb == null) {
            sb = new StringBuilder(string.length());
            if (i > 0) {
              sb.append(string, 0, i - 1);
            }
          }

          if (sb != null && accepted != '\u0000') {
            sb.append(accepted);
          }
        }

        return sb == null ? string : sb.toString();
      }

      private char toAcceptedCharacter(char c) {
        return Character.isLowerCase(c)
              ? Character.toUpperCase(c)
              : Character.isUpperCase(c) ? c : '\u0000';
      }
    });

    final JPanel contentPane = new JPanel(new BorderLayout(6, 6));
    contentPane.add(new JTextField(doc, "0", 12));

    final JFrame f = new JFrame("Test Frame: NumberTextFieldTestGui"); //$NON-NLS-1$
    f.setContentPane(contentPane);
    f.pack();
    f.setLocationRelativeTo(null);
    f.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
    f.setVisible(true);
  }

  /** @param args ignored */
  public static void main(String[] args) {
    SwingUtilities.invokeLater(new Runnable() {

      public void run() {
        createAndShowGui();
      }
    });
  }
}
```
Nachtrag: Der Klassenname ergibt natürlich für den letzten Fall keinen Sinn, ich ändere es trotzdem einfach mal nicht ab. 

Ebenius


----------



## spinnerboy (8. Jun 2010)

tut mir leid, aber ich denke das ist nicht das, was ich suche. ich will doch nur das einfache "VK_*großbuchstabencode*" wissen xDD


----------



## Ebenius (8. Jun 2010)

Was Du möchtest verstehe ich tatsächlich nicht. Die VK-Codes sind Codes für *Tasten*. Ich habe auf meiner Tastatur eine Taste für ein [c]a[/c]. Die selbe Taste nutze ich auch für das [c]A[/c]. Da es die selbe Taste ist, ist auch der VK-Code der gleiche. Und nu?

Ebenius


----------



## Shulyn (9. Jun 2010)

wie wäre es mit einem Documentlistener?
Dazu sehr schön zu Lesen...
How to Write a Document Listener (The Java™ Tutorials > Creating a GUI With JFC/Swing > Writing Event Listeners)

Dazu dann :
Document listeners should not modify the contents of the document; The change is already complete by the time the listener is notified of the change. Instead, write a custom document that overrides the insertString or remove methods, or both. See Listening for Changes on a Document for details. 

Text Component Features (The Java™ Tutorials > Creating a GUI With JFC/Swing > Using Swing Components)


----------



## Shulyn (9. Jun 2010)

spinnerboy hat gesagt.:


> tut mir leid, aber ich denke das ist nicht das, was ich suche. ich will doch nur das einfache "VK_*großbuchstabencode*" wissen xDD



Es gibt keinen Großbuchstaben Code.
Großbuchstabe A :

VK_SHIFT PRESSED
VK_A PRESSED
VK_A RELEASED
VK_SHIFT RELEASED

Bzw. Jede VK_KEY kann immer noch n Modifer haben, wie Shift, oder Alt usw.
Diese VK_KEY + Modifer ergeben dann ein ZeichenCode (Int) welcher je nach Zeichentafel (ASCII) ein echtes Zeichen wiederspiegelt. Aufpassen musst du auch auf den Ländercode. Kennst bestimmt das Z / Y problem ;-)

Schau mal in die Klassen :
KeyEvent  KeyEvent (Java 2 Platform SE v1.4.2)
AwtKeyStroke   AWTKeyStroke (Java 2 Platform SE 5.0)


----------



## spinnerboy (9. Jun 2010)

Shulyn hat gesagt.:


> Es gibt keinen Großbuchstaben Code.
> Großbuchstabe A :
> 
> VK_SHIFT PRESSED
> ...



juhu, danke! das hilft mir weiter! muss ich halt nur für jeden einzelnen buchstaben extra machen aber mit copy&paste ist das ja einfach! nochmal vielen dank!


----------



## andiv (9. Jun 2010)

Ich hab den Thread jetzt nur überflogen, aber warum benutzt du denn nicht wie vorgeschlagen ein JFormattedTextField mit einem passenden DecimalFormat? Da musst du nur geschätzte 3 Zeilen schreiben und hast eine einfache, zuverlässige und flexible Lösung um nur Eingaben in einem von dir bestimmten Format zuzulassen.


----------



## Gast2 (9. Jun 2010)

andiv hat gesagt.:


> Ich hab den Thread jetzt nur überflogen, aber warum benutzt du denn nicht wie vorgeschlagen ein JFormattedTextField mit einem passenden DecimalFormat? Da musst du nur geschätzte 3 Zeilen schreiben und hast eine einfache, zuverlässige und flexible Lösung um nur Eingaben in einem von dir bestimmten Format zuzulassen.



DecimalFormat für Text?


----------



## andiv (9. Jun 2010)

Matrixmaster hat gesagt.:


> Stehe vor folgendem Problem ....ich möchte in Textfeldern nur Zahlen erlauben aber auch Kommas (sprich Dezimalzahlen)



Sorry, wusste nicht, dass die Anforderung mittlerweile zu Text gewechselt ist.


----------



## spinnerboy (10. Jun 2010)

ich beantworte mal eben die frage


> warum benutzt du denn nicht wie vorgeschlagen ein JFormattedTextField mit einem passenden DecimalFormat? Da musst du nur geschätzte 3 Zeilen schreiben und hast eine einfache, zuverlässige und flexible Lösung um nur Eingaben in einem von dir bestimmten Format zuzulassen.



weil ich ein absoluter einsteiger bin und grade NICHTS verstanden habe
mfg, spinnerboy^^


----------



## Gast2 (10. Jun 2010)

spinnerboy hat gesagt.:


> ich beantworte mal eben die frage
> 
> 
> weil ich ein absoluter einsteiger bin und grade NICHTS verstanden habe
> mfg, spinnerboy^^



Lesen?
How to Use Formatted Text Fields (The Java™ Tutorials > Creating a GUI With JFC/Swing > Using Swing Components)


----------



## Gast2 (11. Jun 2010)

Also ich würde sowas hier machen

```
import java.awt.BorderLayout;
import java.text.ParseException;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.regex.PatternSyntaxException;

import javax.swing.JButton;
import javax.swing.JFormattedTextField;
import javax.swing.JFrame;
import javax.swing.UIManager;
import javax.swing.UnsupportedLookAndFeelException;
import javax.swing.text.AttributeSet;
import javax.swing.text.BadLocationException;
import javax.swing.text.DefaultFormatter;
import javax.swing.text.PlainDocument;
 
public class Test111 extends JFrame  {
    public Test111() {
        super("");
        
        RegexFormatter formatter = new RegexFormatter("[^0-9]+");
        formatter.setAllowsInvalid(false);
       
        
        final JFormattedTextField formattedTextField = new JFormattedTextField(formatter);
        formattedTextField.setDocument(new PlainDocument(){
        	
        	@Override
        	public void replace(int offset, int length, String text,
        			AttributeSet attrs) throws BadLocationException {
        		text = text.toUpperCase();
        		super.replace(offset, length, text, attrs);
        	}
        });
        
        add(formattedTextField , BorderLayout.CENTER);
        pack();
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setLocationRelativeTo(null);
    }
    
    public class RegexFormatter extends DefaultFormatter {
    	  private Pattern pattern;
    	  private Matcher matcher;

    	  public RegexFormatter() {
    	    super();
    	  }

    	  /**
    	   * Creates a regular expression based AbstractFormatter.
    	   * pattern specifies the regular expression that will be used
    	   * to determine if a value is legal.
    	   */
    	  public RegexFormatter(String pattern) throws PatternSyntaxException {
    	    this();
    	    setPattern(Pattern.compile(pattern));
    	  }

    	  /**
    	   * Creates a regular expression based AbstractFormatter.
    	   * pattern specifies the regular expression that will be used
    	   * to determine if a value is legal.
    	   */
    	  public RegexFormatter(Pattern pattern) {
    	    this();
    	    setPattern(pattern);
    	  }

    	  /**
    	   * Sets the pattern that will be used to determine if a value is legal.
    	   */
    	  public void setPattern(Pattern pattern) {
    	    this.pattern = pattern;
    	  }

    	  /**
    	   * Returns the Pattern used to determine if a value is legal.
    	   */
    	  public Pattern getPattern() {
    	    return pattern;
    	  }

    	  /**
    	   * Sets the Matcher used in the most recent test if a value is
    	   * legal.
    	   */
    	  protected void setMatcher(Matcher matcher) {
    	    this.matcher = matcher;
    	  }

    	  /**
    	   * Returns the Matcher from the most test.
    	   */
    	  protected Matcher getMatcher() {
    	    return matcher;
    	  }

    	  /**
    	   * Parses text returning an arbitrary Object. Some formatters
    	   * may return null.
    	   * 
    	   * If a Pattern has been specified and the text completely
    	   * matches the regular expression this will invoke setMatcher.
    	   * 
    	   * @throws ParseException
    	   *           if there is an error in the conversion
    	   * @param text
    	   *          String to convert
    	   * @return Object representation of text
    	   */
    	  public Object stringToValue(String text) throws ParseException {
    	    Pattern pattern = getPattern();

    	    if (pattern != null) {
    	      Matcher matcher = pattern.matcher(text);

    	      if (matcher.matches()) {
    	        setMatcher(matcher);
    	        return super.stringToValue(text);
    	      }
    	      throw new ParseException("Pattern did not match", 0);
    	    }
    	    return text;
    	  }
    	  
    	}
     
    
    
    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, UnsupportedLookAndFeelException {
		UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
		new Test111().setVisible(true);
    }
    
}
```


----------

