JTextField Text Validation

Check out these 2 classes:

package free.util;

import javax.swing.text.PlainDocument;
import javax.swing.text.AttributeSet;
import javax.swing.text.BadLocationException;
import javax.swing.text.AbstractDocument;
import java.awt.Toolkit;


/**
 * A PlainDocument extension which allows to disallow certain changes,
 * by implementing the isChangeAccepted(String, String) method and returning
 * false. A beep is emitted when an attempt to make an unacceptable change is
 * made.
 */

public abstract class StrictPlainDocument extends PlainDocument{



  public StrictPlainDocument(){
    super();
  }



  protected StrictPlainDocument(AbstractDocument.Content c){
    super(c);
  }



  /**
   * Overrides PlainDocument.insertString(int, String, AttributeSet) to
   * check whether the change is accepted before applying the change.
   */

  public void insertString(int offs, String str, AttributeSet a) throws BadLocationException{
    String oldString = getText(0,getLength());
    String newString = new StringBuffer(oldString).insert(offs,str).toString();

    if (isChangeAccepted(oldString,newString))
      super.insertString(offs,str,a);
    else
      Toolkit.getDefaultToolkit().beep();
  }



  /**
   * Returns true if the change from the old text to the new text is acceptable,
   * returns false otherwise.
   */

  public abstract boolean isChangeAccepted(String oldText, String newText);


}





package free.util;


/**
 * A StrictPlainModel which only allows inputting an integer value in a certain
 * range.
 */

public class IntegerStrictPlainDocument extends StrictPlainDocument{

 
  /**
   * The minimum allowed value.
   */

  private final long minValue;



  /**
   * The maximum allowed value.
   */

  private final long maxValue;



  /**
   * The radix of the input.
   */

  private final int radix;




  /**
   * Creates a new IntegerStrictPlainDocument which will only allow inputting
   * integer values in the given radix in the range [minValue..maxValue].
   *
   * @param minValue The minimum allowed value.
   * @param maxValue The maximum allowed value.
   * @param radix The radix of the input.
   */

  public IntegerStrictPlainDocument(long minValue, long maxValue, int radix){
    this.minValue = minValue;
    this.maxValue = maxValue;
    this.radix = radix;
  }




  /**
   * Creates a new IntegerStrictPlainDocument which will only allow inputting
   * integer values in the range [minValue..maxValue].
   *
   * @param minValue The minimum allowed value.
   * @param maxValue The maximum allowed value.
   */

  public IntegerStrictPlainDocument(long minValue, long maxValue){
    this(minValue, maxValue, 10);
  }




  /**
   * Returns true if the new text represents an integer in the correct range when
   * parsed using the appropriate radix, returns false otherwise.
   */

  public boolean isChangeAccepted(String oldText, String newText){
    try{
      long val = Long.parseLong(newText,getRadix());
      if ((val<getMinValue())||(val>getMaxValue()))
        return false;
      else
        return true;
    } catch (NumberFormatException e){
        return false;
      }
  }




  /**
   * Returns the radix used by this IntegerStrictPlainDocument to parse the text.
   */
 
  public int getRadix(){
    return radix;
  }




  /**
   * Returns the minimal allowed value.
   */

  public long getMinValue(){
    return minValue;
  }



  /**
   * Returns the maximal allowed value.
   */

  public long getMaxValue(){
    return maxValue;
  }

 

}


You can use IntegerStrictPlainDocument with new IntegerStrictPlainDocument(Long.MIN_VALUE,Long.MAX_VALUE,2) for what you want.


Sasha Maryanovsky.

Thanks for the points :)