How to Automatically add thousand separators as number is input in EditText

Question

Im creating a convertor application, I want to set the EditText so that when the user is inputting the number to be converted, a thousand separator (,) should be added autom

Answer 1

The answers here lack a method to handle actual user input, such as deleting characters or copying and pasting. This is an EditText field. If you want to add formatting in, you need to support editing that formatted value.

This implementation still has a deficiency depending on your use case. I didn't care about decimal values and assumed I would only be handling whole numbers. There's enough of how to handle that on this page and how to handle actual internationalization that I'll leave that as an exercise to the reader. If you need to do that, it shouldn't be too difficult to add "." to the regular expression to keep the decimal; you'll just have to be careful to acknowledge the numeral string still has a non numerical character.

This is designed to be used throughout multiple activities. New it once, give it your edit text and your data model and ignore it. The model binding can be removed if you don't need it.

public class EditNumberFormatter implements TextWatcher {

    private EditText watched;
    private Object model;
    private Field field;
    private IEditNumberFormatterListener listener;

    private ActiveEdit activeEdit;

    /**
     * Binds an EditText to a data model field (Such as a room entity's public variable)
     * Whenever the edit text is changed, the text is formatted to the local numerical format.
     *
     * Handles copy/paste/backspace/select&delete/typing
     *
     * @param model An object with a public field to bind to
     * @param fieldName A field defined on the object
     * @param watched The edit text to watch for changes
     * @param listener Another object that wants to know after changes & formatting are done.
     */
    public EditNumberFormatter(Object model, String fieldName, EditText watched, IEditNumberFormatterListener listener) {

        this.model = model;
        this.watched = watched;
        this.listener = listener;

        try {
            field = model.getClass().getDeclaredField(fieldName);
        } catch(Exception e) { }

        watched.addTextChangedListener(this);
    }

    @Override
    public void beforeTextChanged(CharSequence s, int start, int count, int after) {
        activeEdit = new ActiveEdit(s.toString(), start, count);
    }

    @Override
    public void onTextChanged(CharSequence s, int start, int before, int count) {
        activeEdit.recordChangedText(s.toString(),count);
    }

    @Override
    public void afterTextChanged(Editable s) {
        this.watched.removeTextChangedListener(this);

        activeEdit.processEdit(); // Override the user's edit of the formatted string with what the user intended to do to the numeral.

        watched.setText(activeEdit.getCurrentFormattedString());
        watched.setSelection(activeEdit.getCursorPosition());
        updateDataModel(activeEdit.getCurrentRawValue());

        listener.FormatUpdated(watched.getId(), activeEdit.getCurrentRawValue(), activeEdit.getCurrentFormattedString());

        this.watched.addTextChangedListener(this);
    }

    private void updateDataModel(int rawValue) {
        try {
            field.set(model, rawValue);
        } catch (IllegalAccessException e) { }
    }

    /**
     * Tracks the active editing of an EditText formatted for integer input
     */
    private class ActiveEdit {

        private String priorFormattedString;
        private String currentFormattedString;
        private String currentNumericalString;
        private int currentRawValue;

        private boolean removal;
        private boolean addition;

        private int changeStart;
        private int removedCount;
        private int additionCount;

        private int numeralCountBeforeSelection;
        private int numeralCountAdded;
        private int numeralCountRemoved;

        /**
         * Call in beforeEdit to begin recording changes
         *
         * @param beforeEdit string before edit began
         * @param start start position of edit
         * @param removed number of characters removed
         */
        public ActiveEdit(String beforeEdit, int start, int removed) {
            removal = (removed > 0);

            priorFormattedString = beforeEdit;
            changeStart = start;
            removedCount = removed;

            numeralCountBeforeSelection = countNumerals(priorFormattedString.substring(0, changeStart));
            numeralCountRemoved = countNumerals(priorFormattedString.substring(changeStart, changeStart + removedCount));
        }

        /**
         * Call in onTextChanged to record new text and how many characters were added after changeStart
         *
         * @param afterEdit new string after user input
         * @param added how many characters were added (same start position as before)
         */
        public void recordChangedText(String afterEdit, int added) {
            addition = (added > 0);
            additionCount = added;
            numeralCountAdded = countNumerals(afterEdit.substring(changeStart, changeStart + additionCount));

            currentNumericalString = afterEdit.replaceAll("[^0-9]", "");
        }

        /**
         * Re-process the edit for our particular formatting needs.
         */
        public void processEdit() {
            forceRemovalPastFormatting();
            finalizeEdit();
        }

        /**
         * @return Integer value of the field after an edit.
         */
        public int getCurrentRawValue() {
            return currentRawValue;
        }

        /**
         * @return Formatted number after an edit.
         */
        public String getCurrentFormattedString() {
            return currentFormattedString;
        }

        /**
         * @return Cursor position after an edit
         */
        public int getCursorPosition() {
            int numeralPosition = numeralCountBeforeSelection + numeralCountAdded;
            return positionAfterNumeralN(currentFormattedString,numeralPosition);
        }

        /**
         * If a user deletes a value, but no numerals are deleted, then delete the numeral proceeding
         * their cursor. Otherwise, we'll just add back the formatting character.
         *
         * Assumes formatting uses a single character and not multiple formatting characters in a row.
         */
        private void forceRemovalPastFormatting() {
            if (removal && (!addition) && (numeralCountRemoved == 0)) {
                String before = currentNumericalString.substring(0, numeralCountBeforeSelection - 1);
                String after = currentNumericalString.substring(numeralCountBeforeSelection);

                currentNumericalString =  before + after;
                numeralCountRemoved++;
                numeralCountBeforeSelection--;
            }
        }

        /**
         * Determine the result of the edit, including new display value and raw value
         */
        private void finalizeEdit() {
            currentFormattedString = "";
            currentRawValue = 0;
            if (currentNumericalString.length() == 0) {
                return; // There is no entry now.
            }
            try {
                currentRawValue = Integer.parseInt(currentNumericalString);
            } catch (NumberFormatException nfe) {
                abortEdit();  // Value is not an integer, return to previous state.
                return;
            }
            currentFormattedString = String.format("%,d", currentRawValue);
        }

        /**
         * Current text, same as the old text.
         */
        private void abortEdit() {
            currentFormattedString = priorFormattedString;
            currentNumericalString = currentFormattedString.replaceAll("[^0-9]", "");
            numeralCountRemoved = 0;
            numeralCountAdded = 0;
            try {
                currentRawValue = Integer.parseInt(currentNumericalString);
            } catch (Exception e) { currentRawValue = 0; }
        }

        /**
         * Determine how many numerical characters exist in a string
         * @param s
         * @return the number of numerical characters in the string
         */
        private int countNumerals(String s) {
            String newString = s.replaceAll("[^0-9]", "");
            return newString.length();
        }

        /**
         * Determine how to place a cursor after the Nth Numeral in a formatted string.
         * @param s - Formatted string
         * @param n - The position of the cursor should follow the "Nth" number in the string
         * @return the position of the nth character in a formatted string
         */
        private int positionAfterNumeralN(String s, int n) {
            int numeralsFound = 0;

            if (n == 0) {
                return 0;
            }

            for (int i = 0; i < s.length(); i++) {
                if(s.substring(i,i+1).matches("[0-9]")) {
                    if(++numeralsFound == n) {
                        return i + 1;
                    }
                }
            }
            return s.length();
        }
    }
}

At a highlevel, what that does is:

• Determine which numbers were actually in the string after it was edited
• Process the edit to the numeral version of the string if the numbers weren't edited
• Convert the numeral back to a formatted string
• Determine, where the cursor should be based on where editing began and how much text was added

It also nicely handles edge cases like completely deleted input, integer overflow and erroneous input.