Java: Swing: JFormattedTextField y MaskFormatter

Estas máscaras se usan junto con los JFormattedTextField que son los campos donde el usuario va a escribir lo que se le solicita.

Primero vamos a crear nuestra máscara, para ello importamos la librería:

import javax.swing.text.MaskFormatter;

Y vamos a crear nuestro método de la máscara:

// Mascara para nuestra contraseña
 private MaskFormatter mascara() {
     // Inicializamos el objeto
     MaskFormatter mascara = new MaskFormatter();
     // Entramos en un try/catch por alguna eventualidad
     try {
         // Creamos el formato de nuestra contraseña
         // # -> un número U -> letra mayúscula L -> letra minúscula
         // * -> cualquier caracter ' -> caracteres de escape
         // A -> cualquier letra o número ? -> cualquier caracter
         // H -> cualquier caracter hexagonal (0-9, a-f or A-F).
         mascara = new MaskFormatter("A#####");
     } catch (ParseException e) {
         // Algún error que pueda ocurrir
         e.printStackTrace();
     }
     return mascara;
 }

Como podrán apreciar existen varios "caracteres" reservador para las diferentes combinaciones que queremos hacer, ese método es para los carnet de mi Universidad, una letra y luego cinco números. Además es necesario que esté en un Try/catch por cualquier excepción (acá se explican como funciona un try/catch).

Por cierto para este try/catch tienen que importar esto:

import java.text.ParseException;

Ya con nuestra máscara creada vamos a hacer el campo de texto que tiene ese formato específico para esto importamos la librería:

import javax.swing.JFormattedTextField;

Y nuestro método sería este:

 // Espacio para ingresar el nombre de usuario
 private JFormattedTextField jtaContrasenia(MaskFormatter mascara) {
     // Se inicializa el objeto
     JFormattedTextField contrasenia = new JFormattedTextField(mascara);
     // Asignamos posición y tamaño
     contrasenia.setBounds(200, 80, 150, 20);
     // Le colocamos un texto emergente
     contrasenia.setToolTipText("Formato de la contrasenia: (a-z)#####, ejemplo: A13455 ");
     return contrasenia;
 }

Este método recibe una mascara que es la que creamos anteriormente, se la enviamos en el constructor de la clase cuando añadimos el JFormattedTextField al JFrame, sería así:

add(jtaContrasenia(mascara()));

Y con eso ya aplicamos la mascara en nuestro campo de texto y hacemos que el usuario ingrese justo lo que nosotros deseamos, hay que tener en cuenta que si el usuario no llena, en este caso los seis espacios, cuando se quiera hacer una acción con lo que esté escrito hasta el momento trabajaria con un vacío ( "" ), y puede causar malestares en el programa si no se hacen las validaciones necesarias.

La clase final sería esta:

package Parapublicar;

import java.text.ParseException;

import javax.swing.JFormattedTextField;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JTextField;
import javax.swing.text.MaskFormatter;

@SuppressWarnings("serial")
public class Mascaras extends JFrame {

    public Mascaras() {
        add(ingresarContrasenia());
        add(ingresarUsuario());
        add(jtaUsuario());
        // Le enviamos la mascara a nuestro JFormattedTextField
        add(jtaContrasenia(mascara()));
        inicializador();
    }

    // Inicializador de la Ventana
    private void inicializador() {
        setSize(400, 200);
        setLayout(null);
        setTitle("Login");
        setLocationRelativeTo(null);
        setVisible(true);
        setResizable(false);
        setDefaultCloseOperation(EXIT_ON_CLOSE);
    }

    // Texto que indica donde va el nombre de Usuario
    private JLabel ingresarUsuario() {
        JLabel usuario = new JLabel("Nombre de Usuario: ");
        usuario.setBounds(30, 30, 200, 20);
        return usuario;
    }

    // Texto que indica donde va la contraña
    private JLabel ingresarContrasenia() {
        JLabel contrasenia = new JLabel("Contrasenia: ");
        contrasenia.setBounds(30, 80, 200, 20);
        return contrasenia;
    }

    // Espacio para ingresar el nombre de usuario
    private JTextField jtaUsuario() {
        JTextField usuario = new JTextField();
        usuario.setBounds(200, 30, 150, 20);
        usuario.setToolTipText("Ingrese Nombre de Usuario");
        return usuario;
    }

    // Espacio para ingresar el nombre de usuario
    private JFormattedTextField jtaContrasenia(MaskFormatter mascara) {
        // Se inicializa el objeto
        JFormattedTextField contrasenia = new JFormattedTextField(mascara);
        // Asignamos posición y tamaño
        contrasenia.setBounds(200, 80, 150, 20);
        // Le colocamos un texto emergente
        contrasenia.setToolTipText("Ingrese la contrasenia");
        return contrasenia;
    }

    // Mascara para nuestra contraseña
    private MaskFormatter mascara() {
        // Inicializamos el objeto
        MaskFormatter mascara = new MaskFormatter();
        // Entramos en un try/catch por alguna eventualidad
        try {
            // Creamos el formato de nuestra contraseña
            // # -> un número U -> letra mayúscula L -> letra minúscula
            // * -> cualquier caracter ' -> caracteres de escape
            // A -> cualquier letra o número ? -> cualquier caracter
            // H -> cualquier caracter hexagonal (0-9, a-f or A-F).
            mascara = new MaskFormatter("A#####");
       } catch (ParseException e) {
           // Algún error que pueda ocurrir
           e.printStackTrace();
       }
       return mascara;
    }

    public static void main(String[] args) {
        new Mascaras();
   }

}

Documentación de Java sobre las máscaras:  https://docs.oracle.com/javase/8/docs/api/javax/swing/text/MaskFormatter.html
Documentación de Java sobre JFormattedTextField:  https://docs.oracle.com/javase/8/docs/api/javax/swing/JFormattedTextField.html

Conclusiones

Utilizar máscaras puede ser de gran utilidad en diversas aplicaciones, debido a que ayudan a validar que es lo que el usuario esta digitando.

Siempre que se utilice una máscara se le debe mostrar al usuario el formato correspondiente que se desea que introduzca en el campo, debido a que esto hará que el usuario tenga una mejor noción de que es lo que se solicita.