Java Academy · Lezione

Conteggio e filtro dei caratteri

Esercizi pratici con char

Conteggio e filtro dei caratteri è una lezione Java Academy gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Java Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Java Academy include 4 lezioni in totale.

Contare con un ciclo

Per contare i caratteri, mantenga una variabile contatore e aggiunga 1 ogni volta che una condizione risulta soddisfatta.

Inizializzi il contatore a 0, scorra ogni char e lo incrementi quando il char supera il test.

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

Conteggio delle vocali

Qui contiamo le vocali verificando ogni carattere rispetto all'insieme delle vocali.

Prima convertiamo il carattere in minuscolo, così sia 'A' sia 'a' vengono conteggiati allo stesso modo.

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);
    }
}

Conteggio delle cifre

Per contare quante cifre compaiono in una String, usi Character.isDigit all'interno del ciclo.

In questo modo lettere e simboli vengono ignorati automaticamente, quindi il contatore aumenta solo per i numeri.

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);
    }
}

Conteggio delle lettere

Sostituisca il controllo con Character.isLetter per contare invece i caratteri alfabetici.

La struttura rimane la stessa: iterare, verificare e incrementare. Cambia solo la condizione.

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);
    }
}

Conteggio di un carattere specifico

Per contare un carattere specifico, confronti ogni carattere usando ==.

In questo modo si conta quante volte compare la lettera 'a' nel testo.

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);
    }
}

Filtraggio dei caratteri

Filtrare significa costruire una nuova String che mantenga solo i caratteri desiderati.

Qui manteniamo lettere e cifre, eliminando spazi e punteggiatura, aggiungendoli a una String risultato.

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);
    }
}

Uso di StringBuilder

Costruire una String con += all'interno di un ciclo lungo è lento, perché a ogni passaggio viene creata una nuova String.

StringBuilder è più veloce: aggiunga i caratteri e poi chiami toString() alla fine.

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());
    }
}

Rimozione degli spazi bianchi

Un filtro comune elimina spazi, tabulazioni e nuove righe usando Character.isWhitespace.

Mantenga ogni carattere che non sia uno spazio bianco, così da compattare il testo.

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());
    }
}

Filtrare e poi contare

Può combinare le due idee: filtri il testo per ottenere una String pulita, quindi ne misuri la lunghezza.

Qui contiamo solo le lettere filtrandole e leggendo 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());
    }
}

Conteggio di maiuscole e minuscole

Può gestire più contatori contemporaneamente. Qui contiamo separatamente le lettere maiuscole e minuscole.

Ogni carattere viene sottoposto a due controlli indipendenti, incrementando il contatore corrispondente.

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);
    }
}

Perché il filtraggio è importante

Contare e filtrare sono operazioni comuni: servono per validare le password, pulire l'input dell'utente o contare i diversi tipi di caratteri.

Lo stesso schema di ciclo e verifica gestisce tutti questi casi. Cambi solo la condizione in base al suo obiettivo.

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

Verifica rapida

Verifichi di aver compreso il conteggio e il filtraggio dei caratteri.

Riepilogo

Per contare si usa un contatore, incrementato quando un carattere supera un controllo come isDigit o ==.

Il filtraggio costruisce una nuova String mantenendo solo i caratteri desiderati, idealmente con StringBuilder per una maggiore velocità. Cambi la condizione per contare vocali, lettere e cifre oppure rimuovere gli spazi bianchi.

Domande Frequenti

La lezione «Conteggio e filtro dei caratteri» è gratuita?

Sì — il testo completo di «Conteggio e filtro dei caratteri» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Java Academy, passa a CoddyKit PRO. Il corso Java Academy include 4 lezioni in totale.

Cosa imparerò in «Conteggio e filtro dei caratteri»?

Esercizi pratici con char Eserciti Java Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Java Academy?

Non è richiesta alcuna esperienza precedente. Java Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.

Quanto tempo richiede la lezione «Conteggio e filtro dei caratteri»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Java Academy?

Sì. Ogni lezione Java Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a Java Academy