Feb 22

We’ve all got code riddled with System.out.println() messages. We should use a logging framework, but often we’re in a rush and we end up writing to stdout because its simpler at the time.

If there are too many System.out.println() calls and we want to stop them going to the console then we can redirect stdout and stderr to a different stream using the setOut() and setErr() methods provided by the System class.

If we want to instead have them written to a Swing text component such as a JTextArea or JTextPane then what we need is an OutputStream subclass that will write to the text component.

The following code shows how that can achieved, resulting in System.out.println() call writing to your designated JTextComponent.

import java.io.IOException;
import java.io.OutputStream;
import java.io.PrintStream;

import javax.swing.SwingUtilities;
import javax.swing.text.BadLocationException;
import javax.swing.text.Document;
import javax.swing.text.JTextComponent;

public class RedirectOutput {

	private JTextComponent textComponent;
	public static void sendTo(JTextComponent textComponent) {
		new RedirectOutput(textComponent).redirectSystemStreams();
	private RedirectOutput(JTextComponent textComponent) {
		this.textComponent = textComponent;
	private void updateTextComponent(final String text) {
		SwingUtilities.invokeLater(new Runnable() {
			public void run() {
				Document doc = textComponent.getDocument();
				try {
					doc.insertString(doc.getLength(), text, null);
				} catch (BadLocationException e) {
					throw new RuntimeException(e);
				textComponent.setCaretPosition(doc.getLength() - 1);

	private void redirectSystemStreams() {
		OutputStream out = new OutputStream() {
			public void write(final int b) throws IOException {
				updateTextComponent(String.valueOf((char) b));

			public void write(byte[] b, int off, int len) throws IOException {
				updateTextComponent(new String(b, off, len));

			public void write(byte[] b) throws IOException {
				write(b, 0, b.length);

		System.setOut(new PrintStream(out, true));
		System.setErr(new PrintStream(out, true));


written by objects \\ tags: , , , , , , ,

Feb 07

To restrict the number of characters that the user can enter into a text field can be achieved by either using a JFormattedTextField or using a custom Document with any JTextComponent.

To implement this using a JFormattedTextFiled is simply a matter of specifying the appropriate MaskFormatter to meet your requiremenets.

JTextField field = new JFormattedTextField(new MaskFormatter("***"));

The following class gives an example of how a custom Document can be implemented for use in any text component.

public class FixedSizeDocument extends PlainDocument
   private int max = 10;
   public FixedSizeDocument(int max) 
        this.max = max; 

   public void insertString(int offs, String str, AttributeSet a)
      throws BadLocationException
      // check string being inserted does not exceed max length
      if (getLength()+str.length()>max)
         // If it does, then truncate it
         str = str.substring(0, max - getLength());
      super.insertString(offs, str, a);

You can then use this class with your JTextField for example using the following

field.setDocument(new FixedSizeDocument(5));

written by objects \\ tags: , , , , ,