Come limitare il numero di caratteri in JTextField?

Question

Come limitare il numero di caratteri immessi in un JTextField?

Supponiamo di voler inserire diciamo 5 caratteri max. Dopo di che non è possibile inserire caratteri.

Answer 1

http://www.rgagnon.com/javadetails/java-0198.html

import javax.swing.text.PlainDocument 

public class JTextFieldLimit extends PlainDocument { 
    private int limit; 

    JTextFieldLimit(int limit) { 
    super(); 
    this.limit = limit; 
    } 

    public void insertString(int offset, String str, AttributeSet attr) throws BadLocationException { 
    if (str == null) return; 

    if ((getLength() + str.length()) <= limit) { 
     super.insertString(offset, str, attr); 
    } 
    } 
} 

Poi

import java.awt.*; 
import javax.swing.*; 

public class DemoJTextFieldWithLimit extends JApplet{ 
    JTextField textfield1; 
    JLabel label1; 

    public void init() { 
    getContentPane().setLayout(new FlowLayout()); 
    // 
    label1 = new JLabel("max 10 chars"); 
    textfield1 = new JTextField(15); 
    getContentPane().add(label1); 
    getContentPane().add(textfield1); 
    textfield1.setDocument 
     (new JTextFieldLimit(10)); 
    } 
} 

(primo risultato da Google)

Answer 2

Se vuoi avere tutto in un unico pezzo di codice, allora si può mescolare la risposta di Tim con la l'approccio di esempio trovato sull'API per JTextField, e otterrete qualcosa del genere:

public class JTextFieldLimit extends JTextField { 
    private int limit; 

    public JTextFieldLimit(int limit) { 
     super(); 
     this.limit = limit; 
    } 

    @Override 
    protected Document createDefaultModel() { 
     return new LimitDocument(); 
    } 

    private class LimitDocument extends PlainDocument { 

     @Override 
     public void insertString(int offset, String str, AttributeSet attr) throws BadLocationException { 
      if (str == null) return; 

      if ((getLength() + str.length()) <= limit) { 
       super.insertString(offset, str, attr); 
      } 
     }  

    } 

} 

Quindi non è necessario aggiungere un documento a JTextFieldLimit perché JTextFieldLimit ha già la funzionalità all'interno.

Answer 3

Leggere la sezione dell'esercitazione di Swing su Implementing a DocumentFilter per una soluzione più aggiornata.

Questa soluzione funzionerà con qualsiasi documento, non solo con PlainDocument.

Questa è una soluzione più corrente di quella accettata.

Answer 4

Basta provare questo:

textfield.addKeyListener(new java.awt.event.KeyAdapter() { 
    public void keyTyped(java.awt.event.KeyEvent evt) { 
     if(textfield.getText().length()>=5&&!(evt.getKeyChar()==KeyEvent.VK_DELETE||evt.getKeyChar()==KeyEvent.VK_BACK_SPACE)) { 
      getToolkit().beep(); 
      evt.consume(); 
     } 
    } 
}); 

Answer 5

import java.awt.KeyboardFocusManager; 
import javax.swing.InputVerifier; 
import javax.swing.JTextField; 
import javax.swing.text.AbstractDocument; 
import javax.swing.text.AttributeSet; 
import javax.swing.text.BadLocationException; 
import javax.swing.text.DocumentFilter; 
import javax.swing.text.DocumentFilter.FilterBypass; 

/** 
* 
* @author Igor 
*/ 
public class CustomLengthTextField extends JTextField { 

    protected boolean upper = false; 
    protected int maxlength = 0; 

    public CustomLengthTextField() { 
     this(-1); 
    } 

    public CustomLengthTextField(int length, boolean upper) { 
     this(length, upper, null); 
    } 

    public CustomLengthTextField(int length, InputVerifier inpVer) { 
     this(length, false, inpVer); 
    } 

    /** 
    * 
    * @param length - maksimalan length 
    * @param upper - turn it to upercase 
    * @param inpVer - InputVerifier 
    */ 
    public CustomLengthTextField(int length, boolean upper, InputVerifier inpVer) { 
     super(); 
     this.maxlength = length; 
     this.upper = upper; 
     if (length > 0) { 
      AbstractDocument doc = (AbstractDocument) getDocument(); 
      doc.setDocumentFilter(new DocumentSizeFilter()); 
     } 
     setInputVerifier(inpVer); 
    } 

    public CustomLengthTextField(int length) { 
     this(length, false); 
    } 

    public void setMaxLength(int length) { 
     this.maxlength = length; 
    } 

    class DocumentSizeFilter extends DocumentFilter { 

     public void insertString(FilterBypass fb, int offs, String str, AttributeSet a) 
       throws BadLocationException { 

      //This rejects the entire insertion if it would make 
      //the contents too long. Another option would be 
      //to truncate the inserted string so the contents 
      //would be exactly maxCharacters in length. 
      if ((fb.getDocument().getLength() + str.length()) <= maxlength) { 
       super.insertString(fb, offs, str, a); 
      } 
     } 

     public void replace(FilterBypass fb, int offs, 
       int length, 
       String str, AttributeSet a) 
       throws BadLocationException { 

      if (upper) { 
       str = str.toUpperCase(); 
      } 

      //This rejects the entire replacement if it would make 
      //the contents too long. Another option would be 
      //to truncate the replacement string so the contents 
      //would be exactly maxCharacters in length. 
      int charLength = fb.getDocument().getLength() + str.length() - length; 

      if (charLength <= maxlength) { 
       super.replace(fb, offs, length, str, a); 
       if (charLength == maxlength) { 
        focusNextComponent(); 
       } 
      } else { 
       focusNextComponent(); 
      } 
     } 

     private void focusNextComponent() { 
      if (CustomLengthTextField.this == KeyboardFocusManager.getCurrentKeyboardFocusManager().getFocusOwner()) { 
       KeyboardFocusManager.getCurrentKeyboardFocusManager().focusNextComponent(); 
      } 
     } 
    } 
} 

Answer 6

Grande questione, ed è strano che il toolkit dell'oscillazione non include questa funzionalità in modo nativo per JTextFields. Ma, ecco una grande risposta dal mio corso Udemy.com "Learn Java come un bambino":

txtGuess = new JTextField(); 
txtGuess.addKeyListener(new KeyAdapter() { 
    public void keyTyped(KeyEvent e) { 
     if (txtGuess.getText().length() >= 3) // limit textfield to 3 characters 
      e.consume(); 
    } 
}); 

Questo limita il numero di caratteri in un campo di testo Guessing Game a 3 caratteri, sovrascrivendo l'evento keyTyped e controllo per vedere se il campo di testo ha già 3 caratteri - se è così, stai "consumando" l'evento chiave (e) in modo che non venga elaborato normalmente.

Answer 7

Ho risolto questo problema utilizzando il seguente segmento di codice:

private void jTextField1KeyTyped(java.awt.event.KeyEvent evt) { 
    boolean max = jTextField1.getText().length() > 4; 
    if (max){ 
     evt.consume(); 
    }   
}