Formatowanie ciągów Java

Formatowanie łańcucha, pozwala na wkładanie innych znaków, podstępów lub wartości liczbowych, w określony sposób. Rozważ kod: string str = string.format („Jest %s, %s, %s i %s.„,„ Orange ”,„ banan ”,„ gruszka ”,„ cytryna ”);
System.na zewnątrz.println (str);

Wyjście to:

Jest pomarańcza, banan, gruszka i cytryna.

Istnieje pięć argumentów w tej statycznej metodzie Format () klasy String. Pierwszym argumentem jest główny ciąg zainteresowań, którego treść ma cztery symbole zastępcze, z których każdy jest %s. Razem reszta argumentów jest określana jako lista argumentów. Wszystko jest równe, pierwszy argument na liście argumentów odpowiada pierwszemu symbolom zastępczym w ciągu głównego (od lewej). Drugi argument na liście odpowiada drugiego symbolika zastępczego w głównym ciągu. Trzeci argument na liście argumentów odpowiada trzecim symbolom zastępczym w głównym ciągu i tak dalej. Na wyjściu symbole zastępcze są zastępowane odpowiednimi argumentami w określony sposób z listy argumentów.

Rozważa się tutaj pięć argumentów. Pierwszy nie jest częścią rozważanej listy argumentów. W rzeczywistości nazywa się to ciągami formatu, choć wciąż ma być sformatowany. To zawsze ciąg. Reszta argumentów, tworząc listę argumentów, może być różnych typów, niekoniecznie ciągów. UWAGA: Tutaj nazywa się symbol zastępczy.

Wszystkie powyższe argumenty można zastąpić zmiennymi, jak pokazuje następujący segment kodu:

String a = „Orange”, b = „banana”, c = „pear”, d = „cytryna”;
Ciąg fmtstr = "Jest %s, %s, %s i %s.";
String str = string.format (fmtstr, a, b, c, d);
System.na zewnątrz.println (str);

W tym artykule wyjaśniono podstawy formatowania ciągu w Javie za pomocą specyfikatorów formatu.

Składnia specyfikacji formatu

Składnia dla specyfikatora formatu jest:

%[argument_index $] [flagi] [szerokość] [.Precision] Konwersja

Musi zacząć od znaku procentowego, %. Musi zakończyć się postacią zwaną konwersją. W powyższym kodzie każdy specyfikator składa się z % i „s”. „S” to konwersja. „S” oznacza ciąg. Reszta parametrów, wskazana w nawiasach kwadratowych w składni, są opcjonalne i są wyjaśnione poniżej.

argument_index $
Argument_index to liczba dziesiętna. Zaczyna się od 1. Może to wynosić 1 $, 2 $, 3 $ itp. Normalne korespondencje dla specyfikatorów i argumentów na liście argumentów są następujące: Pierwszy specyfikator po lewej stronie, w ciągu formatu, odpowiada pierwszemu argumentowi na liście argumentów (od lewej); Drugi specyfikator z lewej, w ciągu formatu, odpowiada drugiego argumentu na liście argumentów; Trzeci specyfikator z lewej, w ciągu formatu, odpowiada trzecim argumentowi na liście argumentów; i tak dalej. Argument_index może być użyty do zmiany tego zamówienia. Poniższy segment kodu odwraca kolejność:

String str = string.Format („tutaj: %4 $ C, %3 $ C, %2 $ C i %1 $ C”, „1”, „2”, „3”, „4”);
System.na zewnątrz.println (str);

Wyjście to:

Tutaj: 4, 3, 2 i 1

„C” w specyfikatoru odpowiada postaci na liście argumentów. Normalne zamówienie wynosi 1 $, 2 $, 3 $, 4 $. Ponieważ zamówienie zostało odwrócone w ciągu formatu, więc wyjście wyszło w odwrotnej kolejności.

Konwersja

Konwersja w formatowaniu ciągów jest znakiem specjalnym. Każdy specyfikator formatu z jego konwersją odpowiada argumentowi na liście argumentów. Konwersja to postać. Poniższa tabela zawiera konwersje i ich znaczenia:

Postacie konwersji i ich znaczenia

Konwersja	Oznaczający
B	Do sformatowania argumentu, który jest logiczny
C	Do sformatowania argumentu, który jest znakiem Unicode
S	Do sformatowania argumentu, który jest ciągiem
D	Do sformatowania argumentu, który jest liczbą dziesiętną
F	Do sformatowania argumentu, który jest liczbą z punktem dziesiętnym
%	Do drukowania tylko % dla argumentu „ %”
N	Aby spowodować resztę tekstu po prawej stronie, przejść na następny wiersz na wyjściu

Użycie „s” i „c” zostało zilustrowane powyżej. Reszta meta-znaków konwersji zostanie zilustrowana w tym rozdziale.

Znak konwersji B
Poniższy segment kodu pokazuje, w jaki sposób specyfikator formatu dla bool jest zastąpiony wartością logiczną odpowiedniego argumentu:

String str = string.Format („To %B, że minął.", PRAWDA);
System.na zewnątrz.println (str);

Wyjście to:

To prawda, że ​​przeszedł.

Zauważ, że argument, prawda, nie jest w cytatach.

Znak konwersji D
Poniższy segment kodu pokazuje, w jaki sposób specyfikator formatu dla całkowitej liczby dziesiętnej jest zastąpiony wartością odpowiedniego argumentu:

String str = string.Format („Mam %d Pół.", 5);
System.na zewnątrz.println (str);

Wyjście to:

Mam 5 długopisów.

Zwróć uwagę, że argument, 5, nie jest w cytatach, ponieważ nie jest postacią.

Znak konwersji F
Poniższy segment kodu pokazuje, w jaki sposób specyfikator formatu dla liczby o punkcie dziesiętnym jest zastąpiony odpowiednią wartością argumentu:

String str = string.Format („%F jest niewłaściwą frakcją.", 2.5);
System.na zewnątrz.println (str);

Najpierw zauważ, że argument, 2.5, nie jest w cytatach, ponieważ nie jest to ciąg. Wyjście to:

2.500000 to niewłaściwa część.

2.5 zostało sformatowane do 2.500000, domyślne formatowanie. Może być ograniczony do 2.5 Jak podano - patrz poniżej.

Znaki % konwersji
Ponieważ do identyfikacji specyfikatora formatu używany jest symbol procentowy, należy opracować schemat, aby mieć % symbolu jako zwykłego znaku w ciągu formatu. Schemat jest prosty: mieć % argumentu postaci na liście argumentów. Następnie użyj znaku % konwersji w pozycji w ciągu formatu, gdzie powinien pojawić się procentowy symbol. Poniższy segment kodu to ilustruje:

String str = string.format („Jest 100 %%.„,„%”);
System.na zewnątrz.println (str);

Wyjście to:

To jest 100%.

Specyfikator formatu to %%. Pierwszy %pary, %% jest to, co identyfikuje specyfikator. Drugi % to charakter konwersji. Jako argument % jest w pojedynczych cytatach.

Znak konwersji N
Aby sprawić, że reszta tekstu po prawej stronie ciąg formatu trafił na następny wiersz na wyjściu, użyj n. n jest znakiem konwersji, który ma być używany w specyfikatorze formatu. Ilustracja:

String str = string.format („Pierwsze zdanie.%wyroku nsecond.",'\N');
System.na zewnątrz.println (str);

Wyjście to:

Pierwsze zdanie.
Drugie zdanie.

.Parametr precyzyjny specyfikatora formatu

Ten parametr wskazuje liczbę miejsc dziesiętnych dla liczby z miejscami dziesiętnymi. Jest to liczba całkowita poprzedzona punktem. Jak zauważono powyżej, oczekiwana liczba miejsc dziesiętnych dla 2.5 to jedna postać; ale użyto 6 znaków, dając 2.500000. Poniższy segment kodu ogranicza to do 3 miejsc po przecinku:

String str = string.format("%.3F to niewłaściwa część.", 2.5);
System.na zewnątrz.println (str);

Wyjście to:

2.500 to niewłaściwa część.

Kod precyzyjny tutaj jest .3 .

Parametr szerokości specyfikatora formatu

Szerokość to minimalna liczba znaków wymiany w ciągu formatu. Niektóre typy argumentów zastępują specyfikator formatu ich oczekiwanej szerokości. Jednak inni mogą zastąpić go mniejszą lub większą szerokością. Jak zauważono powyżej, oczekiwana szerokość dla 2.5 to trzy znaki; Ale użyto 8 znaków, dając 2.500000. Poniższy segment kodu powinien ograniczyć to do szerokości 4 znaków i trzech miejsc dziesiętnych:

String str = string.Format ("%4.3F to niewłaściwa część.", 2.5);
System.na zewnątrz.println (str);

Wyjście to:

2.500 to niewłaściwa część.

Specyfikator formatu to %4.3f, gdzie 4 to szerokość, a 3 to liczba miejsc dziesiętnych. Na wyjściu jest właściwie 5 znaków, w tym punkt dziesiętny, więc 4 zostały zignorowane. Poniższy segment kodu daje szerokość 7 znaków i 3 miejsca po przecinku:

String str = string.format ("%7.3F to niewłaściwa część.", 2.5);
System.na zewnątrz.println (str);

Wyjście to:

„” 2.500 to niewłaściwa część.

Zauważ, że dwa znaki przestrzenne poprzedzają liczbę pełną liczbę, aby nadrobić siedmioma znakami szerokości. Liczba miejsc dziesiętnych wynosi 3 . Jest tu 7 znaków, wszystkie razem, w tym punkt dziesiętny.

Parametr flagowy specyfikatora formatu

Flaga 0
Zamiast poprzedzać liczbę z przestrzeniami, liczba może być poprzedzona 0. Poniższy segment kodu to ilustruje:

String str = string.Format ("%07.3F to niewłaściwa część.", 2.5);
System.na zewnątrz.println (str);

Wyjście to:

002.500 to niewłaściwa część.

Dokładny specyfikator formatu tutaj jest,

%07.3f

które należy porównać z składnią specyfikatora formatu,

%[argument_index $] [flagi] [szerokość] [.Precision] Konwersja

Kolejność meta-znaków dokładnego specyfikatora formatu szanuje kolejność składni specyfikatora formatu. Opcjonalna flaga, 0, pojawia się przed opcjonalną szerokością, 7, która pojawia się przed opcjonalną precyzją, .3, zgodnie z składnią. „F” to konwersja (wciąż ceza meta).

Flaga +
Z flagą +, wynik liczby całkowitych jest zawsze poprzedzony - lub + . Poniższy program ilustruje to:

String str = string.Format („Rezultatem jest %+d euro.", -5);
System.na zewnątrz.println (str);

Wyjście to:

Rezultat to -5 euro.

Opcjonalne parametry szerokości i precyzji nie są dołączone do dokładnego specyfikatora formatu, %+D. Tutaj D to konwersja liczby całkowitej.

Rozważ segment kodu,

String str = string.Format („Rezultatem jest %+d euro.", 5);
System.na zewnątrz.println (str);

Wyjście jest,

Wynik to +5 euro.

Wniosek

Argumenty dotyczące metody formatu ciągu są podzielone na dwie sekcje. Pierwsza sekcja jest pierwszym argumentem, który musi być ciągiem. Jest to ciąg zainteresowania. Nazywa się to ciąg formatowym, choć nadal ma właściwe podstępy (sformatowane). Reszta argumentów jest określana jako lista argumentów. Lista argumentów ma prawdziwe podjazdy, które wymagają formatowania. Każdy z tych podłoża odpowiada specyfikatorowi formatu w ciągu formatu. Specyfikator formatu wykorzystuje do sformatowania meta-właściciela.