0Pricing
Java Academy · Leçon

Compter et filtrer les caractères

Des exercices pratiques sur char.

Compter et filtrer les caractères est une leçon Java Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Java Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Java Academy comprend 4 leçons au total.

Compter avec une boucle

Pour compter des caractères, conservez une variable compteur et ajoutez 1 chaque fois qu’une condition est satisfaite.

Initialisez le compteur à 0, parcourez chaque char et augmentez-le lorsque le char réussit votre vérification.

int count = 0;
for (char c : "hello".toCharArray()) {
    count++;
}

Compter les voyelles

Ici, nous comptons les voyelles en vérifiant chaque caractère par rapport à l’ensemble des voyelles.

Nous convertissons d’abord le caractère en minuscules afin que 'A' et 'a' soient comptés de la même manière.

public class Main {
    public static void main(String[] args) {
        String text = "Java Rocks";
        int vowels = 0;
        for (char c : text.toCharArray()) {
            char low = Character.toLowerCase(c);
            if (low == 'a' || low == 'e' || low == 'i' || low == 'o' || low == 'u') {
                vowels++;
            }
        }
        System.out.println(vowels);
    }
}

Compter les chiffres

Pour compter le nombre de chiffres présents dans une String, utilisez Character.isDigit dans la boucle.

Cette méthode ignore automatiquement les lettres et les symboles, de sorte que votre compteur n’augmente que pour les chiffres.

public class Main {
    public static void main(String[] args) {
        String text = "abc123x9";
        int digits = 0;
        for (char c : text.toCharArray()) {
            if (Character.isDigit(c)) digits++;
        }
        System.out.println(digits);
    }
}

Compter les lettres

Remplacez-la par Character.isLetter pour compter plutôt les caractères alphabétiques.

La structure reste la même : boucle, vérification et incrémentation. Seule la condition change.

public class Main {
    public static void main(String[] args) {
        String text = "a1 b2 c3";
        int letters = 0;
        for (char c : text.toCharArray()) {
            if (Character.isLetter(c)) letters++;
        }
        System.out.println(letters);
    }
}

Compter un caractère précis

Pour compter un caractère précis, comparez chaque caractère avec ==.

Cette méthode compte le nombre de fois où la lettre 'a' apparaît dans le texte.

public class Main {
    public static void main(String[] args) {
        String text = "banana";
        int aCount = 0;
        for (char c : text.toCharArray()) {
            if (c == 'a') aCount++;
        }
        System.out.println(aCount);
    }
}

Filtrer les caractères

Le filtrage consiste à créer une nouvelle String qui ne conserve que les caractères souhaités.

Ici, nous conservons les lettres et les chiffres, et supprimons les espaces et la ponctuation en les ajoutant à une String de résultat.

public class Main {
    public static void main(String[] args) {
        String text = "a-b 1!2";
        String clean = "";
        for (char c : text.toCharArray()) {
            if (Character.isLetterOrDigit(c)) clean += c;
        }
        System.out.println(clean);
    }
}

Utiliser StringBuilder

Construire une String avec += dans une longue boucle est lent, car chaque étape crée une nouvelle String.

StringBuilder est plus rapide : ajoutez les caractères, puis appelez toString() à la fin.

public class Main {
    public static void main(String[] args) {
        String text = "H e l l o";
        StringBuilder sb = new StringBuilder();
        for (char c : text.toCharArray()) {
            if (!Character.isWhitespace(c)) sb.append(c);
        }
        System.out.println(sb.toString());
    }
}

Supprimer les espaces blancs

Un filtre courant supprime les espaces, les tabulations et les sauts de ligne à l’aide de Character.isWhitespace.

Conservez chaque caractère qui n’est pas un espace blanc afin de resserrer le texte.

public class Main {
    public static void main(String[] args) {
        String text = " J a v a ";
        StringBuilder sb = new StringBuilder();
        for (char c : text.toCharArray()) {
            if (!Character.isWhitespace(c)) sb.append(c);
        }
        System.out.println(sb.toString());
    }
}

Filtrer puis compter

Vous pouvez combiner ces idées : filtrez pour obtenir une String propre, puis mesurez sa longueur.

Ici, nous comptons uniquement les lettres en filtrant et en lisant length().

public class Main {
    public static void main(String[] args) {
        String text = "a1b2c3";
        StringBuilder sb = new StringBuilder();
        for (char c : text.toCharArray()) {
            if (Character.isLetter(c)) sb.append(c);
        }
        System.out.println(sb.length());
    }
}

Compter les majuscules et les minuscules

Vous pouvez suivre plusieurs compteurs à la fois. Ici, nous comptons séparément les lettres majuscules et minuscules.

Chaque caractère passe par deux vérifications indépendantes, ce qui augmente le compteur correspondant.

public class Main {
    public static void main(String[] args) {
        String text = "JavaCode";
        int upper = 0, lower = 0;
        for (char c : text.toCharArray()) {
            if (Character.isUpperCase(c)) upper++;
            if (Character.isLowerCase(c)) lower++;
        }
        System.out.println(upper + " " + lower);
    }
}

Pourquoi le filtrage est important

Compter et filtrer sont des tâches courantes : vérifier des mots de passe, nettoyer les entrées utilisateur ou dénombrer les types de caractères.

Le même schéma boucle-vérification permet de toutes les réaliser. Il suffit de modifier la condition selon votre objectif.

if (Character.isDigit(c)) {
    count++;
}

Vérification rapide

Vérifiez votre compréhension du comptage et du filtrage des caractères.

Récapitulatif

Le comptage utilise un compteur que vous incrémentez lorsqu’un caractère réussit une vérification comme isDigit ou ==.

Le filtrage crée une nouvelle String qui ne conserve que les caractères souhaités, idéalement avec StringBuilder pour gagner en rapidité. Modifiez la condition pour compter les voyelles, les lettres, les chiffres ou supprimer les espaces blancs.

Questions Fréquemment Posées

La leçon « Compter et filtrer les caractères » est-elle gratuite ?

Oui — le texte complet de « Compter et filtrer les caractères » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Java Academy, passe à CoddyKit PRO. Le cours Java Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Compter et filtrer les caractères » ?

Des exercices pratiques sur char. Tu pratiques Java Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Java Academy ?

Aucune expérience préalable n'est requise. Java Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « Compter et filtrer les caractères » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Java Academy ?

Oui. Chaque leçon Java Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Le type primitif char
  2. Méthodes utilitaires pour les caractères
  3. Parcourir les caractères
  4. Compter et filtrer les caractères
← Retour à Java Academy