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

Isang lecture snippet na may mentor bilang bahagi ng kurso ng Codegym University. Mag-sign up para sa buong kurso.

"Kumusta, Amigo! Ngayon ay susuriin natin ang ilan pang karaniwang mga senaryo na may kinalaman sa pagtatrabaho sa mga string. Halimbawa, alam mo ba kung paano hatiin ang isang string sa ilang bahagi?"

"Hindi ko sasabihin sayo agad, Ellie. Pero sasabihin mo naman sakin diba?"

split()paraan

"Mayroong ilang mga paraan upang gawin ito. 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 parameter. Malalaman mo kung ano ang isang regular na expression ang paghahanap sa Java Collections .

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 na character, mga tab, mga tuldok), pagkatapos ay kailangan mong bumuo ng isang medyo kumplikadong regular na expression."

"Well, sure. At kung mahirap basahin, mahirap gumawa ng mga pagbabago.

StringTokenizerklase

Isang lecture snippet na may mentor bilang bahagi ng kurso ng Codegym University. Mag-sign up para sa buong kurso.

"May espesyal na klase ang Java 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 nang sabay-sabay, ngunit sa halip ay gumagalaw mula sa simula hanggang sa pagtatapos ng isa. hakbang sa isang pagkakataon.

Ang klase ay may isang tagabuo at dalawang 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 nagpapaalala sa akin sa klase ng Scanner, na mayroon ding nextLine()mga hashNextLine()pamamaraan.

"Iyan ay magandang obserbasyon na ginawa mo. Maaari kang lumikha ng isang StringTokenizerbagay gamit ang command na ito:

StringTokenizer name = new StringTokenizer(string, delimiters);

Kung saan ang string ay ang string na hahatiin sa mga bahagi. At ang mga delimiter ay 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 sa pangalawang string sa StringTokenizerconstructor ay itinuturing na isang separator.

String.format()pamamaraan 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 gustong 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 code para sa naturang programa ay magmumukhang 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.}");

"Sasang-ayon ka sa akin na ang code ay hindi masyadong nababasa. At kung ang mga variable na pangalan ay mas mahaba, kung gayon ang code ay magiging mas mahirap:

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

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

"Oo, mahirap basahin!"

"Huwag mag-alala. Ito ay isang pangkaraniwang sitwasyon sa mga real-world na programa, kaya gusto kong sabihin sa iyo ang tungkol sa isang paraan upang maisulat ang code na ito nang mas simple at mas maigsi.

String.format

"Ang Stringklase 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 command 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 string ng format na naglalaman ng lahat ng gustong text kasama ng mga espesyal na character na tinatawag na mga format specifier (gaya ng %dat %s) sa mga lugar kung saan kailangan mong magpasok ng data.

" format()Pinapalitan ng pamamaraan ang mga ito %sat %dang mga format specifier ng mga parameter na sumusunod sa string ng format sa listahan ng parameter. Kung gusto naming magpasok ng string, pagkatapos ay isusulat namin ang . %sKung gusto naming magpasok ng isang numero, ang format na 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

%%

"Ipinapahiwatig ng mga specifier na ito ang 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 " % 1$ d " sa halip na " %d ". Halimbawa:

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

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 programa. 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? Ang code ay binubuo ng mga utos, ngunit ang data (lalo na, malalaking string) ay dapat na naka-imbak sa memorya nang hiwalay sa code. Ang mga sanggunian lamang sa mga bagay na string ay lilitaw sa code.

"Pangalawa, ang lahat ng magkaparehong string literal ay dapat na naka-imbak sa memorya ng isang beses lamang. At ganoon lang ito gumagana. Kapag ang iyong class code ay na-load ng Java machine, lahat ng string literal ay idinaragdag sa kung wala pa sila doon. Kung sila StringPoolay naroroon na, pagkatapos ay gagamit lang kami ng string reference mula sa StringPool.

Alinsunod dito, kung magtatalaga ka ng parehong literal sa ilang String variable sa iyong code, ang mga variable na ito ay maglalaman ng parehong reference. 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."

"Sana naintindihan ko lahat ng tama.

intern()paraan.

"At ang pinakamagandang bahagi ay maaari kang magdagdag ng anumang string sa programmatically sa StringPool. Upang gawin ito, kailangan mo lang 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.

"At ano ang mangyayari kung ang dalawang magkatulad na mga string ay idinagdag sa StringPoolpaggamit ng intern()pamamaraan?"

"Ang pamamaraan ay magbabalik ng parehong mga sanggunian. Ito ay magagamit 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. Iyon ay sinabi, ang mga tao ay gustong magtanong tungkol dito sa mga panayam sa trabaho.

"Kaya, mas mabuting malaman ang tungkol dito kaysa hindi malaman. Salamat, Ellie!"