Separador de Miles en un JTextField Java [SOLUCIONADO]

El trabajar con JTextField en Java a veces puede parecer una tarea minuciosa, pero se vuelve más desafiante cuando queremos implementar funciones más complejas como la de separación de miles. Nuestro enfoque principal será cómo implementar un separador de miles en un JTextField en Java para mejorar la legibilidad y la experiencia del usuario.

Esta práctica común en la programación de interfaces de usuario mejora la precisión de los datos ingresados, reduce los errores del usuario y sobre todo facilita que los números largos sean más legibles. La forma en que presentamos los datos a los usuarios puede tener un gran impacto en su capacidad para comprender la información.

import javax.swing.*;
import javax.swing.text.*;
import java.text.*;

public class MyNumberField extends JTextField {
    public MyNumberField() {
        setDocument(new PlainDocument() {
            public void insertString(int offset, String str, AttributeSet attr) throws BadLocationException {
                StringBuilder sb = new StringBuilder();
                int length = getLength();
                sb.append(getText(0, length));
                sb.insert(offset, str);

                if(!sb.toString().isEmpty()) {
                    try {
                        DecimalFormat df = (DecimalFormat) DecimalFormat.getNumberInstance();
                        df.parse(sb.toString());
                        super.insertString(offset, str, attr);
                    }catch(Exception e) { }
                } else {
                    super.insertString(offset, str, attr);
                }
            }

            public void remove(int offs, int len) throws BadLocationException {
                int length = getLength();
                String currentText = getText(0, length);
                StringBuilder sb = new StringBuilder(currentText);
                sb.delete(offs, offs + len);

                if(!sb.toString().isEmpty()) {
                    try {
                        DecimalFormat df = (DecimalFormat) DecimalFormat.getNumberInstance();
                        df.parse(sb.toString());
                        super.remove(offs, len);
                    } catch(Exception e) { }
                } else {
                    super.remove(offs, len);
                }
            }
        });
        setFocusTraversalKeysEnabled(false);
        addFocusListener(new java.awt.event.FocusAdapter() {
            public void focusGained(java.awt.event.FocusEvent evt) {
                SwingUtilities.invokeLater(() -> selectAll());
            }
            public void focusLost(java.awt.event.FocusEvent evt) {
                setValue(getValue());
            }
        });
    }

    public Long getValue() {
        Long number;
        if(getText().isEmpty()) return 0L;
        try {
            number = Long.parseLong(getText().replaceAll(",", ""));
        } catch (NumberFormatException e) {
            number = Long.parseLong(getText().replaceAll(",", "").split("\.")[0]);
        }
        return number;
    }

    public void setValue(Long value) {
        setText(NumberFormat.getNumberInstance().format(value));
    }
}

En el código proporcionado, la clase MyNumberField hereda de JTextField. La funcionalidad del separador de miles se implementa sobrescribiendo los métodos insertString y remove del documento enlazado al JTextField. En ambos casos, se utiliza un objeto DecimalFormat para determinar si el texto en el JTextField modificado representa un número válido antes de proceder con la modificación.

Lo más importante a destacar aquí, es que cualquier entrada en este JTextField se formatea como un número con separadores de miles. Esto permite una experiencia fluida y comprensible para el usuario, no importa qué tipo de número estén ingresando.

La implementación de este tratamiento de números en un JTextField permite demostrar cómo podemos aprovechar la flexibilidad y la funcionalidad de Java para mejorar la experiencia del usuario. Con la buena práctica de programación y la atención a los detalles, siempre podemos hacer que nuestras aplicaciones sean más útiles e intuitivas para nuestros usuarios.

Todos estos conceptos y líneas de código están disponibles para cada desarrollador de Java que quiera implementar un guión perfectamente operativo de separación de miles en aplicaciones con interfaz gráfica y campos JTextField.

El éxito radica en su flexibilidad y adaptabilidad en tantos contextos: ya sea para una aplicación de contabilidad simple que requiera que sus usuarios ingresen cantidades enormes con exactitud, para una plataforma de compras en línea que quiera que su interfaz de usuario sea la más amigable posible, o incluso para un proyecto escolar que tenga como objetivo demostrar las diferentes técnicas de programación en Java.

Esperamos que este artículo te ayude a aprender y entender más sobre cómo implementar un separador de miles en un JTextField y cómo puedes mejorarlo y adaptarlo a tus necesidades propias. No dudes en dar un paso adelante y seguir explorando más funciones y personalizaciones para JTextField en Java, y sobre todo, sigue codificando.