Java Academy · Lección

Conteo y filtrado de chars

Tareas prácticas con char

Conteo y filtrado de chars es una lección gratuita de Java Academy en CoddyKit. Esta es la lección 4 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Java Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Java Academy incluye 4 lecciones en total.

Contar con un bucle

Para contar caracteres, mantenga una variable contador y súmele 1 cada vez que se cumpla una condición.

Inicie el contador en 0, recorra cada char e increméntelo cuando el char supere la comprobación.

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

Conteo de vocales

Aquí contamos las vocales comprobando cada carácter con el conjunto de vocales.

Primero convertimos el carácter a minúsculas para que 'A' y 'a' se cuenten de la misma 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);
    }
}

Conteo de dígitos

Para contar cuántos dígitos aparecen en un String, use Character.isDigit dentro del bucle.

Esto omite automáticamente las letras y los símbolos, por lo que el contador solo aumenta para los 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);
    }
}

Conteo de letras

Sustituya la comprobación por Character.isLetter para contar caracteres alfabéticos.

La estructura permanece igual: recorrer, comprobar e incrementar. Solo cambia la condición.

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

Conteo de un carácter específico

Para contar un carácter específico, compare cada carácter mediante ==.

Esto cuenta cuántas veces aparece la letra 'a' en el 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);
    }
}

Filtrado de caracteres

Filtrar significa crear un nuevo String que conserve únicamente los caracteres que desea.

Aquí conservamos las letras y los dígitos, y eliminamos los espacios y la puntuación añadiéndolos a un 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);
    }
}

Uso de StringBuilder

Construir un String con += dentro de un bucle largo es lento porque cada paso crea un String nuevo.

StringBuilder es más rápido: añada los caracteres y llame a toString() al 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());
    }
}

Eliminación de espacios en blanco

Un filtro habitual elimina espacios, tabulaciones y saltos de línea mediante Character.isWhitespace.

Conserve cada carácter que no sea un espacio en blanco para juntar el 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 y después contar

Puede combinar estas ideas: filtre para obtener un String limpio y después mida su longitud.

Aquí contamos únicamente las letras filtrando y leyendo 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());
    }
}

Conteo de mayúsculas y minúsculas

Puede llevar varios contadores a la vez. Aquí contamos por separado las letras mayúsculas y minúsculas.

Cada carácter pasa por dos comprobaciones independientes, lo que incrementa el contador correspondiente.

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 qué es importante filtrar

Contar y filtrar son tareas habituales: validar contraseñas, limpiar la entrada del usuario o contabilizar tipos de caracteres.

El mismo patrón de recorrer y comprobar sirve para todas ellas. Cambie únicamente la condición para adaptarla a su objetivo.

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

Comprobación rápida

Compruebe lo que ha aprendido sobre contar y filtrar caracteres.

Resumen

Para contar, se usa un contador que se incrementa cuando un carácter supera una comprobación como isDigit o ==.

El filtrado crea un nuevo String que conserva únicamente los caracteres deseados, idealmente con StringBuilder para mejorar la velocidad. Cambie la condición para contar vocales, letras o dígitos, o para eliminar espacios en blanco.

Preguntas frecuentes

¿La lección «Conteo y filtrado de chars» es gratis?

Sí — el texto completo de «Conteo y filtrado de chars» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Java Academy, actualiza a CoddyKit PRO. El curso de Java Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Conteo y filtrado de chars»?

Tareas prácticas con char Practicas Java Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Java Academy?

No se requiere experiencia previa. Java Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 4 de 4.

¿Cuánto tiempo toma la lección «Conteo y filtrado de chars»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Java Academy?

Sí. Cada lección de Java Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a Java Academy