Java Academy · Aula

Contando e filtrando chars

Tarefas práticas com char

Contando e filtrando chars é uma aula grátis de Java Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Java Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Java Academy inclui 4 aulas no total.

Contando com um laço

Para contar caracteres, mantenha uma variável contadora e adicione 1 sempre que uma condição for satisfeita.

Comece o contador em 0, percorra todos os caracteres e incremente-o quando o caractere passar no teste.

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

Contagem de Vogais

Aqui contamos as vogais verificando cada caractere em relação ao conjunto de vogais.

Convertemos primeiro o caractere para minúsculas, para que tanto 'A' quanto 'a' sejam contados da mesma forma.

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

Contagem de Dígitos

Para contar quantos dígitos aparecem em uma String, use Character.isDigit dentro do laço.

Isso ignora letras e símbolos automaticamente, fazendo com que seu contador cresça apenas para números.

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

Contagem de Letras

Substitua por Character.isLetter para contar caracteres alfabéticos.

A estrutura continua a mesma: laço, teste e incremento. Apenas a condição muda.

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

Contagem de um Caractere Específico

Para contar um caractere específico, compare cada caractere usando ==.

Isso conta quantas vezes a letra 'a' aparece no texto.

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

Filtragem de Caracteres

Filtrar significa criar uma nova String que mantém apenas os caracteres desejados.

Aqui mantemos letras e dígitos, removendo espaços e pontuação ao anexá-los a uma String de resultado.

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

Usando StringBuilder

Criar uma String com += em um laço longo é lento, porque cada etapa cria uma nova String.

StringBuilder é mais rápido: anexe os caracteres e depois chame toString() no final.

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

Removendo Espaços em Branco

Um filtro comum remove espaços, tabulações e quebras de linha usando Character.isWhitespace.

Mantenha cada caractere que não seja um espaço em branco para juntar o texto.

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

Filtrar e Depois Contar

Você pode combinar as ideias: filtre para obter uma String limpa e depois meça seu comprimento.

Aqui contamos apenas as letras filtrando o texto e lendo 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());
    }
}

Contagens de Maiúsculas e Minúsculas

Você pode acompanhar vários contadores ao mesmo tempo. Aqui contamos separadamente as letras maiúsculas e minúsculas.

Cada caractere passa por duas verificações independentes, incrementando o contador correspondente.

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

Por que a Filtragem é Importante

Contar e filtrar são tarefas comuns: validar senhas, limpar dados de entrada do usuário ou contabilizar tipos de caracteres.

O mesmo padrão de laço e teste resolve todas elas. Altere apenas a condição para adaptá-la ao seu objetivo.

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

Verificação Rápida

Teste sua compreensão sobre a contagem e a filtragem de caracteres.

Recapitulação

A contagem usa um contador que você incrementa quando um caractere passa em um teste como isDigit ou ==.

A filtragem cria uma nova String mantendo apenas os caracteres desejados, de preferência com StringBuilder para obter mais velocidade. Altere a condição para contar vogais, letras, dígitos ou remover espaços em branco.

Perguntas Frequentes

A aula “Contando e filtrando chars” é grátis?

Sim — o texto completo de “Contando e filtrando chars” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Java Academy, atualize para CoddyKit PRO. O curso de Java Academy inclui 4 aulas no total.

O que vou aprender em “Contando e filtrando chars”?

Tarefas práticas com char Você pratica Java Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Java Academy?

Nenhuma experiência prévia é necessária. Java Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Contando e filtrando chars”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Java Academy?

Sim. Cada aula de Java Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Java Academy