[JAVA] Exemple de code source de la fonction de restriction d'entrée de JTextField (Exemple de validation: valeur numérique de 1 à 30)

Mise en garde

Modifiez les valeurs de lowerLimit et upperLimit et utilisez-les. Quel que soit le caractère que vous saisissez, vous ne pouvez saisir que les nombres demi-largeur 1 à 30. DocumentFilter est préférable de créer une classe interne.

• Peut-être que cet algorithme peut être appliqué à d'autres langues.

Code source

Example

JTextField textField = new JTextField();
((PlainDocument)textField.getDocument()).setDocumentFilter(new DocumentFilter() {
    /**
     *Limité de 1 à 30 lors de la saisie des nombres
     * @param fb
     * @param offset position du curseur
     * @param length Nombre de caractères de remplacement
     * @chaîne de remplacement de texte param
     * @param attrs fb.getDocument().getDefaultRootElement().getAttributes()Pareil que
     */
    @Override 
    public void replace(FilterBypass fb, int offset, int length, String text, AttributeSet attrs)
      throws BadLocationException
        int lowerLimit = 1;
        int upperLimit = 30;

        int valueInput = 0;
        try {
            valueInput = Integer.parseInt(text);
        } catch(Exception ex) {
            //Les valeurs d'entrée autres que les valeurs numériques ne peuvent pas être entrées
            return;
        }
        //Si la valeur d'entrée est un nombre pleine largeur, elle est automatiquement convertie en nombre demi-largeur.
        text = String.valueOf(valueInput);
        //Quand aucun caractère n'a été entré à l'origine
        if(fb.getDocument().getLength() == 0) {
            //Seuls les caractères 1 à 9 peuvent être saisis
            if(valueInput != 0) {
                super.insertString(fb, offset, text, attrs);
            }
            return;
        }

        //Quand les caractères ont été saisis à l'origine
        } else {
            //Calcul de la valeur après saisie
            String strAlready = fb.getDocument.getText(0, fb.getDocument().getLength());
            int valueAlready = Integer.parseInt(strAlready);
            int valueTotal = 0;
            if(offset == 0) {
                // Input Left
                valueTotal = (int) (valueInput * Math.pow(10, strAlready.length()) + valueAlready);
            } else if(offset == strAlready.length()) {
                // Input Right
                valueTotal = (int) (valueAlready * 10 + valueInput);
            } else {
                // Input Mid
                int valueLeft  = (int) ( Integer.parseInt(strAlready.substring(0, offset))
                                        * Math.pow(10, strAlready.length()-offset+1) );
                int valueAdd   = (int) ( valueInput * Math.pow(10, strAlready.length()-offset) );
                int valueRight = Integer.parseInt( strAlready.substring(offset, strAlready.length()) );
                valueTotal = valueLeft + valueAdd + valueRight;
            }
            //Limiter les valeurs d'entrée de 1 à 30
            if(valueTotal > upperLimit) {
                //Valeur après saisie>Valeur maximum
                super.remove(fb, 0, strAlready.length()); //Supprimer tous les caractères d'origine
                if(valueInput != 0) {
                    super.insertString(fb, 0, String.valueOf(valueInput), attrs); //Réglage de la valeur d'entrée
                } else {
                    super.insertString(fb, 0, String.valueOf(upperLimit), attrs); //Réglage de la valeur maximale
                }
            } else if(valueTotal < lowerLimit) {
                super.replace(fb, 0, strAlready.length(), String.valueOf(lowerLimit), attrs); //Réglage de la valeur minimale
            } else {
                super.replace(fb, offset, length, text, attrs); //Remplacer l'appel de traitement de la méthode lorsque la valeur d'origine est entrée
            }
        }
    }

    /**
     *Lors de la suppression d'une valeur, une valeur inférieure à 1 ne peut pas être saisie.
     * @param fb
     * @param offset position du curseur
     * @param length Nombre de caractères à supprimer
     */
    @Override 
    public void remove(FilterBypass fb, int offset, int length) throws BadLocationException {
        int lowerLimit = 1;

        String strBefore = fb,getDocument.getText(0, fb.getDocument().getLength());
        String strAfter  = strBefore.substring(0, offset)
                           + strBefore.substring(offset+length, fb.getDocument().getLength());
        int afterValue = 0;
        try {
            afterValue = Integer.parseInt(strAfter);
        } catch(Exception ex) {
            //Puisque la valeur d'entrée est contrôlée, aucune erreur ne doit se produire.
        }
        //Impossible de définir une valeur inférieure à 1
        if(strAfter.length() == 0 || afterValue < lowerLimit) {
            //Si aucune valeur n'est entrée ou si une valeur inférieure à la valeur minimale est définie, la valeur minimale est définie.
            super.replace(fb, 0, strBefore.length(), String.valueOf(lowerLimit), fb.getDocument().getDefaultRootElement().getAttributes());
        } else {
           //Appelez le traitement de la méthode de suppression lors de la suppression de la valeur d'origine
           super.remove(fb, offset, length);
        }
    }
});

Pourquoi j'ai écrit ça

Je ne l'ai écrit nulle part.