值更改监听器到JTextField

小开

最佳答案

向底层Document中添加侦听器，底层Document是自动为您创建的。

// Listen for changes in the text
textField.getDocument().addDocumentListener(new DocumentListener() {
public void changedUpdate(DocumentEvent e) {
warn();
}
public void removeUpdate(DocumentEvent e) {
warn();
}
public void insertUpdate(DocumentEvent e) {
warn();
}


public void warn() {
if (Integer.parseInt(textField.getText())<=0){
JOptionPane.showMessageDialog(null,
"Error: Please enter number bigger than 0", "Error Message",
JOptionPane.ERROR_MESSAGE);
}
}
});

小开

注意，当用户修改字段时，DocumentListener有时会接收两个事件。例如，如果用户选择了整个字段内容，然后按下一个键，您将收到一个removeUpdate(所有内容都被删除)和一个insertUpdate。就你的情况而言，我不认为这是问题，但一般来说，这是问题。不幸的是，似乎没有办法跟踪textField的内容没有子类化JTextField。下面是一个提供"text"属性的类的代码:

package net.yapbam.gui.widget;


import javax.swing.JTextField;
import javax.swing.text.AttributeSet;
import javax.swing.text.BadLocationException;
import javax.swing.text.PlainDocument;


/** A JTextField with a property that maps its text.
* <br>I've found no way to track efficiently the modifications of the text of a JTextField ... so I developed this widget.
* <br>DocumentListeners are intended to do it, unfortunately, when a text is replace in a field, the listener receive two events:<ol>
* <li>One when the replaced text is removed.</li>
* <li>One when the replacing text is inserted</li>
* </ul>
* The first event is ... simply absolutely misleading, it corresponds to a value that the text never had.
* <br>Anoter problem with DocumentListener is that you can't modify the text into it (it throws IllegalStateException).
* <br><br>Another way was to use KeyListeners ... but some key events are throw a long time (probably the key auto-repeat interval)
* after the key was released. And others events (for example a click on an OK button) may occurs before the listener is informed of the change.
* <br><br>This widget guarantees that no "ghost" property change is thrown !
* @author Jean-Marc Astesana
* <BR>License : GPL v3
*/


public class CoolJTextField extends JTextField {
private static final long serialVersionUID = 1L;


public static final String TEXT_PROPERTY = "text";


public CoolJTextField() {
this(0);
}


public CoolJTextField(int nbColumns) {
super("", nbColumns);
this.setDocument(new MyDocument());
}


@SuppressWarnings("serial")
private class MyDocument extends PlainDocument {
private boolean ignoreEvents = false;


@Override
public void replace(int offset, int length, String text, AttributeSet attrs) throws BadLocationException {
String oldValue = CoolJTextField.this.getText();
this.ignoreEvents = true;
super.replace(offset, length, text, attrs);
this.ignoreEvents = false;
String newValue = CoolJTextField.this.getText();
if (!oldValue.equals(newValue)) CoolJTextField.this.firePropertyChange(TEXT_PROPERTY, oldValue, newValue);
}


@Override
public void remove(int offs, int len) throws BadLocationException {
String oldValue = CoolJTextField.this.getText();
super.remove(offs, len);
String newValue = CoolJTextField.this.getText();
if (!ignoreEvents && !oldValue.equals(newValue)) CoolJTextField.this.firePropertyChange(TEXT_PROPERTY, oldValue, newValue);
}
}

小开

我知道这涉及到一个非常老的问题，然而，它也给我带来了一些问题。正如kleopatra在上面的注释中回应的那样，我用JFormattedTextField解决了这个问题。然而，解决方案需要更多的工作，但更整洁。

在默认情况下，JFormattedTextField不会在字段中的每个文本更改后触发属性更改。JFormattedTextField的默认构造函数不创建格式化程序。

然而，要执行OP建议的操作，您需要使用格式化程序，它将在字段的每次有效编辑之后调用commitEdit()方法。commitEdit()方法是根据我所看到的触发属性更改的方法，如果没有格式化器，这将在焦点更改或按下enter键时默认触发。

创建一个默认格式化器(DefaultFormatter)对象，通过其构造函数或setter方法传递给JFormattedTextField。默认格式化器的一个方法是setCommitsOnValidEdit(boolean commit)，它设置格式化器在每次文本被更改时触发commitEdit()方法。然后可以使用PropertyChangeListener和propertyChange()方法获取该值。

小开

你甚至可以使用“MouseExited”来控制。例子:< / p >

 private void jtSoMauMouseExited(java.awt.event.MouseEvent evt) {
// TODO add your handling code here:
try {
if (Integer.parseInt(jtSoMau.getText()) > 1) {
//auto update field
SoMau = Integer.parseInt(jtSoMau.getText());
int result = SoMau / 5;


jtSoBlockQuan.setText(String.valueOf(result));
}
} catch (Exception e) {


}


}

小开

使用KeyListener(在任意键上触发)而不是ActionListener(在进入时触发)

小开

它是Codemwnci的更新版本。他的代码很好，除了错误信息外，其他方面都很好。为了避免错误，必须更改条件语句。

  // Listen for changes in the text
textField.getDocument().addDocumentListener(new DocumentListener() {
public void changedUpdate(DocumentEvent e) {
warn();
}
public void removeUpdate(DocumentEvent e) {
warn();
}
public void insertUpdate(DocumentEvent e) {
warn();
}


public void warn() {
if (textField.getText().length()>0){
JOptionPane.showMessageDialog(null,
"Error: Please enter number bigger than 0", "Error Massage",
JOptionPane.ERROR_MESSAGE);
}
}
});

小开

通常的答案是“使用DocumentListener”。然而，我总是觉得这个界面很麻烦。说实话，这个界面被过度设计了。它有三种方法，用于插入、删除和替换文本，而它只需要一种方法:替换。(插入可以看作是用一些文本替换了没有文本，删除可以看作是用没有文本替换了一些文本。)

通常你只需要知道当框中的文本发生变化时，所以典型的DocumentListener实现有三个方法调用一个方法。

因此，我创建了下面的实用程序方法，它让你使用更简单的ChangeListener而不是DocumentListener。(它使用Java 8的lambda语法，但如果需要，您可以根据旧Java对其进行调整。)

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

与直接向文档添加侦听器不同，这可以处理在文本组件上安装新文档对象的情况(不常见)。此外，它还解决了Jean-Marc Astesana的回答中提到的问题，即文档有时会触发比所需的更多事件。

不管怎样，这个方法可以让你替换看起来像这样烦人的代码:

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

:

addChangeListener(someTextBox, e -> doSomething());

代码发布到公共领域。玩得开心!

小开

我对WindowBuilder是全新的，事实上，几年之后才回到Java，但我实现了“一些东西”，然后我想我应该查一下，遇到了这个线程。

我正在测试这个，所以，基于对这一切的新手，我确信我一定遗漏了一些东西。

下面是我所做的，其中“runTxt”是一个文本框，“runName”是类的数据成员:

public void focusGained(FocusEvent e) {
if (e.getSource() == runTxt) {
System.out.println("runTxt got focus");
runTxt.selectAll();
}
}


public void focusLost(FocusEvent e) {
if (e.getSource() == runTxt) {
System.out.println("runTxt lost focus");
if(!runTxt.getText().equals(runName))runName= runTxt.getText();
System.out.println("runText.getText()= " + runTxt.getText() + "; runName= " + runName);
}
}

似乎比这里到目前为止简单得多，而且似乎是有效的，但是，因为我正在写这篇文章，我很高兴听到任何被忽视的陷阱。用户可以输入&离开文本框w/o作出改变?我认为你所做的一切都是不必要的任务。

小开

只需创建一个扩展DocumentListener并实现所有DocumentListener方法的接口:

@FunctionalInterface
public interface SimpleDocumentListener extends DocumentListener {
void update(DocumentEvent e);


@Override
default void insertUpdate(DocumentEvent e) {
update(e);
}
@Override
default void removeUpdate(DocumentEvent e) {
update(e);
}
@Override
default void changedUpdate(DocumentEvent e) {
update(e);
}
}

然后:

jTextField.getDocument().addDocumentListener(new SimpleDocumentListener() {
@Override
public void update(DocumentEvent e) {
// Your code here
}
});

或者你甚至可以使用lambda表达式:

jTextField.getDocument().addDocumentListener((SimpleDocumentListener) e -> {
// Your code here
});

小开

DocumentFilter吗?它给了你操纵的能力。

[__abc0]

对不起。我使用Jython (Java中的Python) -但是很容易理解

# python style
# upper chars [ text.upper() ]


class myComboBoxEditorDocumentFilter( DocumentFilter ):
def __init__(self,jtext):
self._jtext = jtext


def insertString(self,FilterBypass_fb, offset, text, AttributeSet_attrs):
txt = self._jtext.getText()
print('DocumentFilter-insertString:',offset,text,'old:',txt)
FilterBypass_fb.insertString(offset, text.upper(), AttributeSet_attrs)


def replace(self,FilterBypass_fb, offset, length, text, AttributeSet_attrs):
txt = self._jtext.getText()
print('DocumentFilter-replace:',offset, length, text,'old:',txt)
FilterBypass_fb.replace(offset, length, text.upper(), AttributeSet_attrs)


def remove(self,FilterBypass_fb, offset, length):
txt = self._jtext.getText()
print('DocumentFilter-remove:',offset, length, 'old:',txt)
FilterBypass_fb.remove(offset, length)


// (java style ~example for ComboBox-jTextField)
cb = new ComboBox();
cb.setEditable( true );
cbEditor = cb.getEditor();
cbEditorComp = cbEditor.getEditorComponent();
cbEditorComp.getDocument().setDocumentFilter(new myComboBoxEditorDocumentFilter(cbEditorComp));

小开

textBoxName.getDocument().addDocumentListener(new DocumentListener() {
@Override
public void insertUpdate(DocumentEvent e) {
onChange();
}


@Override
public void removeUpdate(DocumentEvent e) {
onChange();
}


@Override
public void changedUpdate(DocumentEvent e) {
onChange();
}
});

但我不会只是将用户(可能是意外)在键盘上触摸的任何东西解析为Integer。你应该捕获抛出的任何__abc1，并确保JTextField不是空的。

小开

如果我们使用可运行的方法SwingUtilities.invokeLater()，而使用文档侦听器应用程序有时会卡住，需要时间更新结果(根据我的实验)。我们也可以使用KeyReleased事件作为文本字段更改监听器，如前面提到的在这里。

usernameTextField.addKeyListener(new KeyAdapter() {
public void keyReleased(KeyEvent e) {
JTextField textField = (JTextField) e.getSource();
String text = textField.getText();
textField.setText(text.toUpperCase());
}
});

小开

这里是@Boann的答案的Kotlin移植，这是一个很好的解决方案，对我来说一直很有效。

import java.beans.*
import javax.swing.*
import javax.swing.event.*
import javax.swing.text.*


/**
* Installs a listener to receive notification when the text of this
* [JTextComponent] is changed. Internally, it installs a [DocumentListener] on the
* text component's [Document], and a [PropertyChangeListener] on the text component
* to detect if the `Document` itself is replaced.
*
* @param changeListener a listener to receive [ChangeEvent]s when the text is changed;
* the source object for the events will be the text component
*/
fun JTextComponent.addChangeListener(changeListener: ChangeListener) {
val dl: DocumentListener = object : DocumentListener {
private var lastChange = 0
private var lastNotifiedChange = 0
override fun insertUpdate(e: DocumentEvent) = changedUpdate(e)
override fun removeUpdate(e: DocumentEvent) = changedUpdate(e)
override fun changedUpdate(e: DocumentEvent) {
lastChange++
SwingUtilities.invokeLater {
if (lastNotifiedChange != lastChange) {
lastNotifiedChange = lastChange
changeListener.stateChanged(ChangeEvent(this))
}
}
}
}
addPropertyChangeListener("document") { e: PropertyChangeEvent ->
(e.oldValue as? Document)?.removeDocumentListener(dl)
(e.newValue as? Document)?.addDocumentListener(dl)
dl.changedUpdate(null)
}
document?.addDocumentListener(dl)
}

你可以在任何文本组件上使用它，如下所示:

myTextField.addChangeListener { event -> myEventHandler(event) }

就像他的代码一样，也是公有领域。

小开

一种优雅的方法是将侦听器添加到插入符号位置，因为每次键入/删除内容时它都会更改，然后只需将旧值与当前值进行比较。

String oldVal = ""; // empty string or default value
JTextField tf = new JTextField(oldVal);


tf.addCaretListener(e -> {
String currentVal = tf.getText();


if(!currentVal.equals(oldVal)) {
oldVal = currentVal;
System.out.println("Change"); // do something
}
});

(此事件也被触发每次用户只是点击进入TextField)。