Java Academy · Lekcja

Zliczanie i filtrowanie znaków

Praktyczne zadania z typem char

Zliczanie i filtrowanie znaków to bezpłatna lekcja Java Academy na CoddyKit. To lekcja 4 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Java Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Java Academy zawiera 4 lekcji w sumie.

Liczenie za pomocą pętli

Aby policzyć znaki, należy użyć zmiennej licznika i zwiększać ją o 1 za każdym razem, gdy warunek zostanie spełniony.

Licznik należy ustawić na 0, przejść przez każdy char i zwiększyć jego wartość, gdy char przejdzie sprawdzian.

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

Liczenie samogłosek

Tutaj liczymy samogłoski, porównując każdy znak z zestawem samogłosek.

Najpierw zamieniamy znak na małą literę, dzięki czemu zarówno 'A', jak i 'a' są liczone w ten sam sposób.

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

Liczenie cyfr

Aby policzyć, ile cyfr występuje w obiekcie String, należy użyć Character.isDigit wewnątrz pętli.

Ta metoda automatycznie pomija litery i symbole, więc licznik zwiększa się tylko dla cyfr.

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

Liczenie liter

Zamiast tego można użyć Character.isLetter, aby liczyć znaki alfabetyczne.

Struktura pozostaje taka sama: pętla, sprawdzenie i zwiększenie licznika. Zmienia się tylko warunek.

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

Liczenie konkretnego znaku

Aby policzyć wystąpienia konkretnego znaku, należy porównać każdy znak za pomocą ==.

Ten kod liczy, ile razy litera 'a' występuje w tekście.

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

Filtrowanie znaków

Filtrowanie polega na utworzeniu nowego obiektu String, który zawiera tylko wybrane znaki.

W tym przypadku zachowujemy litery i cyfry, usuwając spacje oraz znaki interpunkcyjne przez dołączanie znaków do wynikowego obiektu String.

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

Używanie StringBuilder

Tworzenie obiektu String za pomocą += w długiej pętli jest powolne, ponieważ każdy krok tworzy nowy obiekt String.

StringBuilder działa szybciej: należy dołączać znaki, a na końcu wywołać toString().

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

Usuwanie białych znaków

Popularny filtr usuwa spacje, tabulatory i znaki nowej linii za pomocą Character.isWhitespace.

Należy zachować każdy znak, który nie jest białym znakiem, aby usunąć przerwy w tekście.

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

Najpierw filtrowanie, potem liczenie

Można połączyć oba pomysły: najpierw odfiltrować znaki i utworzyć uporządkowany obiekt String, a następnie zmierzyć jego długość.

Tutaj liczymy tylko litery, filtrując tekst i odczytując wartość 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());
    }
}

Liczenie wielkich i małych liter

Można jednocześnie prowadzić kilka liczników. Tutaj osobno liczymy wielkie i małe litery.

Każdy znak przechodzi przez dwa niezależne sprawdzenia, a zwiększany jest licznik odpowiadający wynikowi sprawdzenia.

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

Dlaczego filtrowanie ma znaczenie

Liczenie i filtrowanie to codzienne zadania: sprawdzanie haseł, oczyszczanie danych wprowadzanych przez użytkownika czy zliczanie typów znaków.

Ten sam schemat pętli i sprawdzania obsługuje je wszystkie. Aby dopasować go do celu, wystarczy zmienić warunek.

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

Szybki test

Sprawdź swoją wiedzę na temat liczenia i filtrowania znaków.

Podsumowanie

Liczenie wykorzystuje licznik, który zwiększa się, gdy znak przejdzie test, taki jak isDigit lub ==.

Filtrowanie tworzy nowy obiekt String zawierający tylko wybrane znaki. Dla większej wydajności najlepiej użyć StringBuilder. Zmieniając warunek, można liczyć samogłoski, litery lub cyfry albo usuwać białe znaki.

Często zadawane pytania

Czy lekcja „Zliczanie i filtrowanie znaków” jest bezpłatna?

Tak — pełny tekst „Zliczanie i filtrowanie znaków” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Java Academy, przejdź na CoddyKit PRO. Kurs Java Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Zliczanie i filtrowanie znaków”?

Praktyczne zadania z typem char Ćwiczysz Java Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Java Academy?

Nie wymagamy żadnego doświadczenia. Java Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 4 z 4.

Ile czasu zajmuje lekcja „Zliczanie i filtrowanie znaków”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Java Academy?

Tak. Każda lekcja Java Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do Java Academy