Java Academy · Lekcja

Parsowanie liczb z danych wejściowych

Konwertowanie tekstu na liczby

Parsowanie liczb z danych wejściowych to bezpłatna lekcja Java Academy na CoddyKit. To lekcja 3 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.

Wiersze zawsze są napisami

readLine() zawsze zwraca String, nawet gdy użytkownik wpisze 42. Aby wykonywać działania matematyczne, należy parsować ten tekst i zamienić go na liczbę.

Java udostępnia do tego celu metody pomocnicze, takie jak Integer.parseInt i Double.parseDouble.

Integer.parseInt

Integer.parseInt(String) konwertuje tekst taki jak "42" na wartość int równą 42.

Po sparsowaniu można dodawać tę wartość, mnożyć ją lub porównywać tak jak każdą inną liczbę.

String text = "42";
int n = Integer.parseInt(text);
System.out.println(n + 1);

Działający przykład parsowania

Oto kompletny, działający program, który parsuje zapisany na stałe napis i podwaja jego wartość.

Nie odczytuje danych z System.in, więc uruchamia się od razu i wyświetla wynik.

public class Main {
    public static void main(String[] args) {
        String text = "21";
        int n = Integer.parseInt(text);
        System.out.println("Doubled: " + (n * 2));
    }
}

Najpierw odczytywanie, potem parsowanie

Rzeczywisty wzorzec wygląda następująco: należy odczytać wiersz, a następnie go sparsować. Ten program odczytuje jedną liczbę z konsoli i wyświetla jej kwadrat.

Ponieważ czeka na dane z System.in, nie można go tutaj uruchomić automatycznie, ale jest to wzorzec stosowany na co dzień.

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br =
            new BufferedReader(new InputStreamReader(System.in));
        int n = Integer.parseInt(br.readLine());
        System.out.println("Square: " + (n * n));
    }
}

Usuwanie białych znaków przed parsowaniem

Zbędne spacje uniemożliwiają parsowanie. Integer.parseInt(" 42 ") zgłasza błąd, ale Integer.parseInt(" 42 ".trim()) działa.

Dobrym zwyczajem jest wywołanie trim() dla wiersza przed jego sparsowaniem.

String raw = "  7  ";
int n = Integer.parseInt(raw.trim());
System.out.println(n);

Parsowanie liczb dziesiętnych

W przypadku liczb dziesiętnych należy użyć Double.parseDouble. Konwertuje ono tekst taki jak "3.14" na wartość double.

Dostępna jest również metoda Long.parseLong do obsługi bardzo dużych liczb całkowitych, które przekraczają zakres int.

public class Main {
    public static void main(String[] args) {
        double pi = Double.parseDouble("3.14");
        System.out.println(pi * 2);
    }
}

Kilka liczb w jednym wierszu

Często jeden wiersz zawiera kilka liczb rozdzielonych spacjami, na przykład "10 20 30". Należy użyć split(" "), aby podzielić go na tablicę tokenów typu String.

Następnie każdy token należy sparsować osobno.

String[] parts = "10 20 30".split(" ");
int a = Integer.parseInt(parts[0]);
int b = Integer.parseInt(parts[1]);
System.out.println(a + b);

Sumowanie liczb po podzieleniu wiersza

Ten działający program dzieli wiersz i dodaje wszystkie liczby w pętli.

Napis jest zapisany na stałe, dlatego program działa bez danych wejściowych, ale w rzeczywistym użyciu konsolowym należy zastąpić go wywołaniem br.readLine().

public class Main {
    public static void main(String[] args) {
        String line = "5 8 2 10";
        String[] parts = line.split(" ");
        int sum = 0;
        for (String p : parts) {
            sum += Integer.parseInt(p);
        }
        System.out.println("Sum: " + sum);
    }
}

Błędne dane wejściowe powodują wyjątek

Jeśli tekst nie jest poprawną liczbą — na przykład "hello" lub pusty napis — parseInt zgłasza wyjątek NumberFormatException.

Można temu zapobiec za pomocą konstrukcji try/catch, aby program nie kończył działania z powodu błędnych danych wejściowych.

try {
    int n = Integer.parseInt("hello");
} catch (NumberFormatException e) {
    System.out.println("Not a number!");
}

Bezpieczne parsowanie w praktyce

Oto działający program, który poprawnie obsługuje błędne dane wejściowe zamiast kończyć działanie z powodu błędu.

Blok catch wyświetla przyjazny komunikat, gdy tekstu nie można zamienić na liczbę.

public class Main {
    public static void main(String[] args) {
        String input = "12x";
        try {
            int n = Integer.parseInt(input);
            System.out.println(n);
        } catch (NumberFormatException e) {
            System.out.println("Invalid number: " + input);
        }
    }
}

Lista kontrolna parsowania

Podczas zamiany danych wejściowych na liczby:

Integer.parseInt służy do liczb całkowitych, a Double.parseDouble do liczb dziesiętnych.
Najpierw należy usunąć zbędne spacje za pomocą trim().
split(" ") służy do rozdzielania wielu liczb znajdujących się w jednym wierszu.
Dla bezpieczeństwa należy użyć konstrukcji try/catch.

Szybki test

Zastanów się, co dzieje się, gdy analiza składniowa kończy się niepowodzeniem.

Podsumowanie

Dowiedział się Pan, że wiersze wejściowe są ciągami znaków, które analizuje się za pomocą Integer.parseInt lub Double.parseDouble. Używał Pan trim() i split(" "), a dla bezpieczeństwa obsługiwał Pan wyjątek NumberFormatException.

Następnie: prawidłowe zamykanie strumieni.

Często zadawane pytania

Czy lekcja „Parsowanie liczb z danych wejściowych” jest bezpłatna?

Tak — pełny tekst „Parsowanie liczb z danych wejściowych” 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 „Parsowanie liczb z danych wejściowych”?

Konwertowanie tekstu na liczby Ć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 3 z 4.

Ile czasu zajmuje lekcja „Parsowanie liczb z danych wejściowych”?

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