Mga klase sa kaginhawaan para sa pagtatrabaho sa mga string sa Java

1. StringTokenizerklase

At ngayon ang ilang mas karaniwang mga sitwasyon na kinasasangkutan ng pagtatrabaho sa mga string. Paano mo hatiin ang isang string sa ilang bahagi? Mayroong ilang mga paraan upang gawin ito.

split()paraan

Ang unang paraan upang hatiin ang isang string sa maraming bahagi ay ang paggamit ng split()pamamaraan. Ang isang regular na expression na tumutukoy sa isang espesyal na delimiting string ay dapat ipasa bilang isang argumento. Malalaman mo kung ano ang isang regular na expression sa Java Multithreading quest.

Halimbawa:

String str = "Good news everyone!";
String[] strings = str.split("ne");
System.out.println(Arrays.toString(strings));

["Good ", "ws everyo", "!"]

Simple, ngunit kung minsan ang diskarte na ito ay labis. Kung mayroong maraming mga delimiter (halimbawa, mga puwang, mga bagong linya ng character, mga tab, mga tuldok), pagkatapos ay kailangan mong bumuo ng isang medyo kumplikadong regular na expression. Mahirap basahin kaya mahirap baguhin.

StringTokenizerklase

Ang Java ay may espesyal na klase na ang buong trabaho ay hatiin ang isang string sa mga substring.

Ang klase na ito ay hindi gumagamit ng mga regular na expression: sa halip, pumasa ka lang sa isang string na binubuo ng mga delimiter. Ang bentahe ng diskarteng ito ay hindi nito pinuputol ang buong string sa mga piraso nang sabay-sabay, ngunit sa halip ay gumagalaw mula simula hanggang wakas nang paisa-isa.

Ang klase ay may isang constructor at dalawang mahalagang pamamaraan. Ipinapasa namin sa constructor ang isang string na hinati namin sa mga bahagi, at isang string na binubuo ng isang set ng mga character na nagde-delimiting.

String nextToken()

boolean hasMoreTokens()

Ang klase na ito ay kahit papaano ay nakapagpapaalaala sa klase ng Scanner, na mayroon din nextLine()at hasNextLine()mga pamamaraan.

Maaari kang lumikha ng isang StringTokenizerbagay gamit ang command na ito:

StringTokenizer name = new StringTokenizer(string, delimiters);

Nasaan stringang string na hahatiin sa mga bahagi. At delimitersay isang string, at ang bawat karakter dito ay itinuturing bilang isang delimiter. Halimbawa:

String str = "Good news everyone!";

StringTokenizer tokenizer = new StringTokenizer(str,"ne");
while (tokenizer.hasMoreTokens())
{
   String token = tokenizer.nextToken();
   System.out.println(token);
}

Good 
ws 
v
ryo
!

Tandaan na ang bawat character sa string na ipinasa bilang pangalawang string sa StringTokenizerconstructor ay itinuturing na isang separator.

2. String.format()paraan at StringFormatterklase

Ang isa pang kawili-wiling paraan ng String class ay format().

Sabihin nating mayroon kang iba't ibang mga variable na nag-iimbak ng data. Paano mo ipapakita ang mga ito sa screen sa isang linya? Halimbawa, mayroon kaming ilang data (kaliwang column) at ninanais na output (kanang column):

String name = "Amigo";
int age = 12;
String friend = "Diego";
int weight = 200;

User = {name: Amigo, age: 12 years, friend: Diego, weight: 200 kg.}

Ang iyong code ay maaaring magmukhang ganito:

String name = "Amigo";
int age = 12;
String friend = "Diego";
int weight = 200;

System.out.println("User = {name: " + name + ", age:" + age + " years, friend: " + friend+", weight: " + weight + " kg.}");

Ang ganitong code ay hindi masyadong nababasa. At kung ang mga variable na pangalan ay mas mahaba, ang code ay magiging mas mahirap:

class User {
    ......
    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public List<String> getFriends() {
        return friends;
    }

    public ExtraInformation getExtraInformation() {
        return extraInformation;
    }
}

User user = new User();

System.out.println("User = {name: " + user.getName() + ", age:" + user.getAge() + " years, friend: " + user.getFriends().get(0) + ", weight: " + user.getExtraInformation().getWeight() + " kg.}");

Hindi masyadong nababasa, di ba?

Ngunit ito ay isang pangkaraniwang sitwasyon sa mga real-world na programa, kaya gusto kong sabihin sa iyo ang tungkol sa isang paraan upang isulat ang code na ito nang mas simple at mas maigsi.

String.format

Ang String class ay may static format()na pamamaraan: hinahayaan ka nitong tukuyin ang isang pattern para sa pag-assemble ng string na may data. Ang pangkalahatang hitsura ng utos ay ang mga sumusunod:

String name = String.format(pattern, parameters);

Halimbawa:

String.format("Age=%d, Name=%s", age, name);

Age=12, Name=Amigo

String.format("Width=%d, Height=%d", width, height);

Width=20, Height=10

String.format("Fullname=%s", name);

Fullname=Diego

Ang format()unang parameter ng pamamaraan ay isang format na string na naglalaman ng lahat ng gustong text kasama ng mga espesyal na character na tinatawag na format specifiers (gaya ng %dat %s) sa mga lugar kung saan kailangan mong magpasok ng data.

format()Pinapalitan ng pamamaraan ang mga ito %sat %dang mga tagatukoy ng format ng mga parameter na sumusunod sa string ng format sa listahan ng parameter. Kung gusto naming magpasok ng isang string, pagkatapos ay isulat namin %s. Kung gusto naming magpasok ng isang numero, ang format specifier ay %d. Halimbawa:

String s = String.format("a=%d, b=%d, c=%d", 1, 4, 3);

Narito ang isang maikling listahan ng mga tagatukoy ng format na maaaring gamitin sa loob ng string ng format:

%s

%d

%f

%b

%c

%t

%%

Ang mga specifier na ito ay nagpapahiwatig ng uri ng data, ngunit mayroon ding mga specifier na nagpapahiwatig ng pagkakasunud-sunod ng data. Upang makakuha ng argumento ayon sa numero nito (nagsisimula ang pagnunumero sa isa), kailangan mong isulat ang " " sa halip na " ". Halimbawa:%1$d%d

String s = String.format("a=%3$d, b=%2$d, c=%d", 11, 12, 13);

%3$day makakakuha ng ika-3 argumento, %2$dmakakakuha ng pangalawang argumento, at %dmakakakuha ng pinakaunang argumento. Ang %sat %dformat specifiers ay tumutukoy sa mga argumento anuman ang mga specifier tulad ng %3$do%2$s

3. String Pool

Ang bawat string na tinukoy sa code bilang literal na string ay naka-imbak sa isang lugar ng memorya na tinatawag na StringPoolhabang tumatakbo ang program. StringPoolay isang espesyal na array para sa pag-iimbak ng mga string. Ang layunin nito ay i-optimize ang imbakan ng string:

Una, ang mga string na tinukoy sa code ay dapat na naka-imbak sa isang lugar, tama? Binubuo ang code ng mga command, ngunit ang data (lalo na, malalaking string) ay dapat na naka-imbak sa memorya nang hiwalay sa code. Ang mga sanggunian lamang sa mga string na bagay ay lilitaw sa code.

Pangalawa, ang lahat ng magkaparehong string literal ay dapat na naka-imbak sa memorya ng isang beses lamang. At iyon lang kung paano ito gumagana. Kapag ang iyong class code ay na-load ng Java machine, ang lahat ng string literal ay idinaragdag sa StringPoolkung wala pa sila doon. Kung nandoon na sila, gumamit lang kami ng string reference mula sa StringPool.

Alinsunod dito, kung magtatalaga ka ng parehong literal sa ilang Stringmga variable sa iyong code, ang mga variable na ito ay maglalaman ng parehong sanggunian. Isang literal ang idaragdag sa StringPoolisang beses lamang. Sa lahat ng iba pang mga kaso, ang code ay makakakuha ng reference sa string na na-load na sa StringPool.

Narito ang halos kung paano ito gumagana:

String a = "Hello";
String b = "Hello";
String c = "Bye";

String[] pool = {"Hello", "Bye"};
a = pool[0];
b = pool[0];
c = pool[1];

Iyon ang dahilan kung bakit ang aat bmga variable ay mag-iimbak ng parehong mga sanggunian.

intern()paraan

At ang pinakamagandang bahagi ay na maaari mong programmatically magdagdag ng anumang string sa StringPool. Upang gawin ito, kailangan mo lamang tawagan ang pamamaraan Stringng variable intern().

intern()Idaragdag ng pamamaraan ang string sa StringPoolkung wala pa ito, at magbabalik ng reference sa string sa StringPool.

Kung ang dalawang magkatulad na mga string ay idinagdag sa StringPoolpaggamit ng intern()pamamaraan, ang pamamaraan ay nagbabalik ng parehong sanggunian. Magagamit ito upang ihambing ang mga string sa pamamagitan ng sanggunian. Halimbawa:

String a = new String("Hello");
String b = new String("Hello");
System.out.println(a == b);

false

String a = new String("Hello");
String b = new String("Hello");

String t1 = a.intern();
String t2 = b.intern();
System.out.println(a == b);
System.out.println(t1 == t2);

false
true

Malamang na hindi mo madalas gamitin ang paraang ito, ngunit gustong magtanong ng mga tao tungkol dito sa mga panayam . Kaya mas mabuting malaman ang tungkol dito kaysa hindi alam.