Textfeld soll nur Zahlen erlauben

[Matrixmaster]

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]

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]

Einfach noch VK_COMMA erlauben.

 

[Matrixmaster]

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

 

[FatFire]

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]

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

 

[HannsW]

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]

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]

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]

VK_PERIOD entspricht '.'

 

[spinnerboy]

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

 

[alderwaran]

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]

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]

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 diggaa1984s Link in der 5. Antwort, sehr lohnenswert!). Für Quick&Dirty ist der KeyListener (für dieses Problem) gut, aber mehr nicht.

 

[spinnerboy]

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]

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]

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]

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]

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]

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]

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)

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]

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]

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]

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]

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]

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]

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