A resposta usual para isso é "use um DocumentListener
". No entanto, eu sempre acho essa interface complicada. Sinceramente, a interface está com excesso de engenharia. Ele possui três métodos, para inserção, remoção e substituição de texto, quando ele precisa apenas de um método: substituição. (Uma inserção pode ser vista como uma substituição de nenhum texto por algum texto, e uma remoção pode ser vista como uma substituição de algum texto sem texto.)
Normalmente, tudo o que você deseja saber é quando o texto na caixa foi alterado , portanto, umDocumentListener
implementação possui os três métodos que chamam um método.
Portanto, criei o seguinte método utilitário, que permite usar um método mais simples ChangeListener
do que um DocumentListener
. (Ele usa a sintaxe lambda do Java 8, mas você pode adaptá-lo ao Java antigo, se necessário.)
/**
* Installs a listener to receive notification when the text of any
* {@code JTextComponent} is changed. Internally, it installs a
* {@link DocumentListener} on the text component's {@link Document},
* and a {@link PropertyChangeListener} on the text component to detect
* if the {@code Document} itself is replaced.
*
* @param text any text component, such as a {@link JTextField}
* or {@link JTextArea}
* @param changeListener a listener to receieve {@link ChangeEvent}s
* when the text is changed; the source object for the events
* will be the text component
* @throws NullPointerException if either parameter is null
*/
public static void addChangeListener(JTextComponent text, ChangeListener changeListener) {
Objects.requireNonNull(text);
Objects.requireNonNull(changeListener);
DocumentListener dl = new DocumentListener() {
private int lastChange = 0, lastNotifiedChange = 0;
@Override
public void insertUpdate(DocumentEvent e) {
changedUpdate(e);
}
@Override
public void removeUpdate(DocumentEvent e) {
changedUpdate(e);
}
@Override
public void changedUpdate(DocumentEvent e) {
lastChange++;
SwingUtilities.invokeLater(() -> {
if (lastNotifiedChange != lastChange) {
lastNotifiedChange = lastChange;
changeListener.stateChanged(new ChangeEvent(text));
}
});
}
};
text.addPropertyChangeListener("document", (PropertyChangeEvent e) -> {
Document d1 = (Document)e.getOldValue();
Document d2 = (Document)e.getNewValue();
if (d1 != null) d1.removeDocumentListener(dl);
if (d2 != null) d2.addDocumentListener(dl);
dl.changedUpdate(null);
});
Document d = text.getDocument();
if (d != null) d.addDocumentListener(dl);
}
Ao contrário da adição de um ouvinte diretamente ao documento, isso lida com o caso (incomum) de instalar um novo objeto de documento em um componente de texto. Além disso, ele soluciona o problema mencionado na resposta de Jean-Marc Astesana , onde o documento às vezes dispara mais eventos do que o necessário.
De qualquer forma, esse método permite substituir um código irritante que se parece com isso:
someTextBox.getDocument().addDocumentListener(new DocumentListener() {
@Override
public void insertUpdate(DocumentEvent e) {
doSomething();
}
@Override
public void removeUpdate(DocumentEvent e) {
doSomething();
}
@Override
public void changedUpdate(DocumentEvent e) {
doSomething();
}
});
Com:
addChangeListener(someTextBox, e -> doSomething());
Código liberado para domínio público. Diverta-se!