When using JFormattedTextField to work with MaskFormatter for data input, the string length directly obtained through the getText() method often contains formatted mask characters (such as brackets, spaces, hyphens, etc.), which makes it impossible to accurately determine the number of characters actually entered by the user. This article will introduce in detail two effective methods: removing these mask characters through string processing, thereby obtaining the accurate length of the user's actual input content, and performing effective data verification to ensure the legality of the input.

Length issues between JFormattedTextField and MaskFormatter

JFormattedTextField is a component in Swing used to format input, which is usually used in conjunction with MaskFormatter to force users to enter data in a specific format (such as phone numbers, dates, etc.). However, when the user enters data, the string obtained by calling the ftf.getText() method will contain all characters defined by the MaskFormatter, including the part filled with placeholders when the user does not enter, and the formatted characters themselves (such as (, ), -, spaces).

For example, for phone number format (###) ###-######, getText() may return a string containing all mask characters even if the user enters only a part of the number. When all numbers are entered, such as (123) 456-7890, the getText().length() will be 14. If we need to verify that the user has entered all 10 digits, it is obviously inaccurate to check length() directly.

Solution: Remove mask characters to get the true length

In order to accurately obtain the character length actually entered by the user, we need to post-process the string returned by JFormattedTextField to remove the masked characters. The following are two commonly used methods:

Method 1: Remove all space characters

If the mask contains spaces and these spaces are the main factor affecting the length of the length, you can get a string length closer to the actual input by removing all spaces.

 import javax.swing.*;
import javax.swing.text.MaskFormatter;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.text.ParseException;

public class PhoneBookValidator extends JFrame implements ActionListener {

    private JFormattedTextField phoneField;
    private JTextField nameField;
    private JButton createButton;
    private JTextArea messageArea;

    public PhoneBookValidator() throws ParseException {
        setTitle("Telbook Verification Example");
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setSize(400, 300);
        setLayout(null);
        setResizable(false);

        JLabel nameLabel = new JLabel("name:");
        nameLabel.setBounds(30, 20, 80, 25);
        add(nameLabel);

        nameField = new JTextField();
        nameField.setBounds(100, 20, 200, 25);
        add(nameField);

        JLabel phoneLabel = new JLabel("Tel:");
        phoneLabel.setBounds(30, 60, 80, 25);
        add(phoneLabel);

        MaskFormatter phoneMask = new MaskFormatter("(###) ###-####");
        // Allow placeholders to be retained when incomplete input is not complete. If full input is required to submit, it can be set to false
        // phoneMask.setPlaceholderCharacter('_'); 
        phoneField = new JFormattedTextField(phoneMask);
        phoneField.setBounds(100, 60, 200, 25);
        add(phoneField);

        createButton = new JButton("Create Contact");
        createButton.setBounds(100, 120, 150, 30);
        createButton.addActionListener(this);
        add(createButton);

        messageArea = new JTextArea();
        messageArea.setBounds(30, 170, 340, 80);
        messageArea.setEditable(false);
        messageArea.setLineWrap(true);
        messageArea.setWrapStyleWord(true);
        add(messageArea);

        setVisible(true);
    }

    @Override
    public void actionPerformed(ActionEvent e) {
        if (e.getSource() == createButton) {
            String name = nameField.getText().trim();
            String phoneRaw = phoneField.getText();

            // 1. Remove all space characters String phoneNoSpaces = phoneRaw.replaceAll("\\s ", ""); 

            // For mask (###) ###-#####, after removing the space, the expected full length is 13 (10 digits, 2 brackets, 1 hyphen)
            // If the user does not fully enter, phoneNoSpaces will still contain placeholder and mask characters.
            // For example, input (123) 456-7890 has a length of 14, and after removing the space, it is (123) 456-7890 has a length of 13.
            // Verify that the length is equal to the expected full length and does not include placeholders.

            if (name.isEmpty()) {
                messageArea.setText("Error: Name cannot be empty!");
                return;
            }

            // Check whether the phone number is complete// Here it is assumed that after removing the space, the complete phone number should be 13 and does not contain the placeholder for the mask (such as #)
            // For more accurate verification, please refer to method 2 if (phoneNoSpaces.length()  {
            try {
                new PhoneBookValidator();
            } catch (ParseException e) {
                e.printStackTrace();
            }
        });
    }
}

Note: This method removes only spaces. If your mask contains other non-numeric characters (such as brackets, hyphens), these characters will still be retained in the string. Therefore, you need to judge the desired length based on the complete form of the mask. For example, for (###) ###-#####, the full string length should be 13 after removing the space. This method is suitable for situations where you want to keep some of the formatted characters for verification.

Method 2: Only numeric characters are preserved

This is the most recommended method because it is able to completely strip away all non-digit mask characters, leaving only the numbers actually entered by the user. This is very effective for verifying pure numeric inputs (such as phone number, ID number).

 import javax.swing.*;
import javax.swing.text.MaskFormatter;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.text.ParseException;

// ... (The rest of the PhoneBookValidator class remains unchanged)

    @Override
    public void actionPerformed(ActionEvent e) {
        if (e.getSource() == createButton) {
            String name = nameField.getText().trim();
            String phoneRaw = phoneField.getText();

            // 2. Only the numeric characters String phoneDigitsOnly = phoneRaw.replaceAll("[^0-9] ", "");

            // For phone numbers, we expect to enter 10 digits// If the user does not enter completely, the length of phoneDigitsOnly will be less than 10.

            if (name.isEmpty()) {
                messageArea.setText("Error: Name cannot be empty!");
                return;
            }

            // Check whether the phone number is complete (10 digits)
            if (phoneDigitsOnly.length() != 10) {
                messageArea.setText("Error: Phone number must be 10 digits!");
            } else {
                messageArea.setText("Contact created successfully!\nName: " name "\nTel: " phoneDigitsOnly); // Show pure digital phone}
        }
    }

// ... (The main method remains unchanged)

Note: This method uses the regular expression [^0-9] to match one or more non-numeric characters and replaces them with an empty string. In this way, no matter the mask contains spaces, brackets, hyphens or other symbols, it will be removed, and only a pure numeric string is left. This method is the most accurate and is suitable for scenarios where the number of numbers needs to be strictly verified.

Summarize

When JFormattedTextField is used in conjunction with MaskFormatter, getting getText().length() directly cannot accurately reflect the number of characters actually entered by the user. Through the replaceAll() method of the string, we can effectively remove the mask characters, thereby obtaining the true length of the user's actual input content.

• replaceAll("\\s ", "") : Suitable for scenarios where spaces need to be removed but other format characters (such as brackets and hyphens) are retained for verification. The verification needs to be judged based on the expected complete format length.
• replaceAll("[^0-9] ", "") : This is the most recommended method, which can completely extract the pure digital part of the user input, and is suitable for scenarios where strict verification of the number of digital digits is required. When checking, you only need to determine whether the length of the extracted numeric string is in line with expectations.

In practical applications, it is recommended to choose the most appropriate string processing method to ensure the accuracy of data verification based on specific business needs and MaskFormatter definition.

The above is the detailed content of JFormattedTextField Accurate acquisition and verification of input content length. For more information, please follow other related articles on the PHP Chinese website!