PlainDocument com regex

public class RegexPlainDocument extends PlainDocument {
	private String regex;

	public RegexPlainDocument(String regex, String def) {

		if (!def.matches(regex))
			throw new IllegalArgumentException(
					"o segundo argumento não é valido para a regex");
		this.regex = regex;
		try {
			super.insertString(0, def, null);
		} catch (BadLocationException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	@Override
	public void insertString(int offs, String str, AttributeSet a)
			throws BadLocationException {

		char[] crs = str.toCharArray();
		String envio = "";
		for (int i = 0; i < crs.length; i++) {
			String temp = getText(0, offs) + envio + crs[i]
					+ getText(offs, getLength() - offs);
			System.out.println(temp);
			if (temp.matches(regex)) {
				envio += crs[i];
			} else {
				Toolkit.getDefaultToolkit().beep();
			}

		}
		super.insertString(offs, envio, a);
	}

	@Override
	public void remove(int offs, int len) throws BadLocationException {
		for (int i = 0; i < len; i++) {
			String temp = getText(0, offs)
					+ getText(offs + 1, getLength() - (offs + 1));
			System.out.println(temp);

			if (temp.matches(regex)) {
				super.remove(offs, 1);
			} else {
				offs++;
				Toolkit.getDefaultToolkit().beep();
			}
		}

	}
}

public void replace(int offset, int length, String text, AttributeSet attrs)
			throws BadLocationException {
		String temp = getText(0, offset) + text
				+ getText(offset + length, getLength() - (offset + length));

		if (temp.matches(regex)) {
			super.remove(offset, length);
			super.insertString(offset, text, attrs);
		} else {
			Toolkit.getDefaultToolkit().beep();
		}
	}

public class FixedLengthDocument extends PlainDocument 
{
	private int maxLength;  
	  
    public FixedLengthDocument(int maxlen) { // Determino a quantidade de informações poderão ser digitadas 
        super();  
          
        if (maxlen <= 0)  
            throw new IllegalArgumentException("You must specify a maximum length!");  
          
        maxLength = maxlen;  
    }  
  
    @Override  
    public void insertString(int offset, String str, AttributeSet attr)   
    throws BadLocationException {  
        if (str == null || getLength() == maxLength)  
            return;  
  
        int totalLen = (getLength() + str.length());  
        if (totalLen <= maxLength) {  
            super.insertString(offset, str, attr);  
            return;  
        }  
          
        String newStr = str.substring(0, (maxLength - getLength()));  
        super.insertString(offset, newStr, attr);  
    }  

}

public class IntegerDocument extends FixedLengthDocument{
	public IntegerDocument(int maxlen) {  
        super(maxlen);  
    }  
  
    @Override  
    public void insertString(int offset, String str, AttributeSet attr)  
            throws BadLocationException {  
        if (str == null)  
            return;  
          
        try {  
            Integer.parseInt(str);  
        } catch (Exception e) {  
            return;  
        }  
          
        super.insertString(offset, str, attr);  
    }  

}