Klase ng string
Ang klase na ito ay kumakatawan sa isang sequence ng mga character. Ang lahat ng string literal na tinukoy sa mga programa, tulad ng "Ito ang String" ay mga pagkakataon ng klase ng String. Ang string ay may dalawang pangunahing tampok:- ito ay isang hindi nababagong klase
- final class na ito
final
) at ang mga instance ng klase ay hindi maaaring mabago pagkatapos ng paglikha ( immutable
). Nagbibigay ito sa String class ng ilang mahahalagang pakinabang:
-
Dahil sa immutability, ang hashcode ng isang instance ng String class ay naka-cache. Hindi ito kailangang suriin sa bawat oras dahil ang mga halaga ng field ng object ay hindi kailanman magbabago pagkatapos na ito ay nilikha. Nagbibigay ito ng mataas na pagganap kapag ginagamit ang klase na ito bilang isang susi para sa
HashMap
. -
Maaaring gamitin ang String class sa isang multi-threaded na kapaligiran nang walang karagdagang pag-synchronize.
-
Ang isa pang tampok ng klase ng String ay ang pag-overload nito sa "
+
" operator sa Java. Samakatuwid, ang pagsasama-sama (pagdaragdag) ng mga string ay medyo simple:
public static void main(String[] args) {
String command = "Follow" + " " + "the" + " " + "white" + " " + "rabbit";
System.out.println(command); // Follow the white rabbit
}
Sa ilalim ng hood, ang string concatenation ay ginagawa ng StringBuilder o StringBuffer class (sa pagpapasya ng compiler) at isang paraan append
(pag-uusapan natin ang mga klaseng ito sa ibang pagkakataon). Kung magdaragdag kami ng mga instance ng String class na may mga instance ng iba pang mga klase, ang huli ay mababawasan sa isang string representation:
public static void main(String[] args) {
Boolean b = Boolean.TRUE;
String result = "b is " + b;
System.out.println(result); //b is true
}
Ito ay isa pang kawili-wiling pag-aari ng String class: ang mga object ng anumang klase ay maaaring i-cast sa isang string na representasyon gamit ang pamamaraang toString()
tinukoy sa klase Object
at minana ng lahat ng iba pang klase. Kadalasan ang toString() na pamamaraan sa isang bagay ay tinatawag na implicitly. Halimbawa, kapag nagpakita kami ng isang bagay sa screen o nagdagdag ng String sa isang bagay ng ibang klase. Ang String class ay may isa pang tampok. Ang lahat ng string literal na tinukoy sa Java code, gaya ng "asdf", ay naka-cache sa oras ng pag-compile at idinaragdag sa tinatawag na string pool. Kung patakbuhin namin ang sumusunod na code:
String a = "Wake up, Neo";
String b = "Wake up, Neo";
System.out.println(a == b);
Makikita natin ang totoo sa console dahil ang mga variable ay a
aktwal b
na tumutukoy sa parehong halimbawa ng String class na idinagdag sa string pool sa oras ng pag-compile. Iyon ay, ang iba't ibang mga pagkakataon ng klase na may parehong halaga ay hindi nilikha, at ang memorya ay nai-save.
Bahid:
Hindi mahirap hulaan na ang String class ay kailangan pangunahin para sa pagtatrabaho sa mga string. Ngunit sa ilang mga kaso, ang mga tampok sa itaas ng klase ng String ay maaaring maging disadvantage mula sa mga pakinabang. Kapag nalikha ang mga string sa Java code, maraming operasyon ang madalas na ginagawa sa kanila:- pag-convert ng mga string sa iba't ibang mga rehistro;
- pagkuha ng substring;
- pagsasama-sama;
- atbp.
public static void main(String[] args) {
String s = " Wake up, Neo! ";
s = s.toUpperCase();
s = s.trim();
System.out.println("\"" + s + "\"");
}
Sa unang tingin, parang isinalin lang namin ang linyang “Wake up, Neo!” sa uppercase, inalis ang mga dagdag na espasyo sa string na ito at binalot ito ng mga panipi. Sa katunayan, dahil sa immutability ng String class, bilang resulta ng bawat operasyon, ang mga bagong string instance ay nilikha at ang mga luma ay itinatapon, na bumubuo ng malaking halaga ng basura. Paano maiwasan ang pag-aaksaya ng memorya?
StringBuffer klase
Upang mahawakan ang paglikha ng pansamantalang basura dahil sa mga pagbabago sa isang String object, maaari mong gamitin ang StringBuffer class. Ito aymutable
isang klase, i.e. nababago. Ang isang object ng StringBuffer class ay maaaring maglaman ng isang partikular na hanay ng mga character, ang haba at halaga nito ay maaaring mabago sa pamamagitan ng pagtawag sa ilang mga pamamaraan. Tingnan natin kung paano gumagana ang klase na ito. Upang lumikha ng isang bagong bagay, gamitin ang isa sa mga constructor nito, halimbawa:
- StringBuffer() - lilikha ng walang laman (walang character) na bagay
- StringBuffer(String str) - gagawa ng object batay sa str variable (naglalaman ng lahat ng character ng str sa parehong pagkakasunud-sunod)
StringBuffer sb = new StringBuffer();
StringBuffer sb2 = new StringBuffer("Not empty");
Ang pagsasama-sama ng string sa pamamagitan ng StringBuffer sa Java ay ginagawa gamit ang append
. Sa pangkalahatan, ang pamamaraan append
sa klase ng StringBuffer ay na-overload sa paraang matatanggap nito ang halos anumang uri ng data:
public static void main(String[] args) {
StringBuffer sb = new StringBuffer();
sb.append(new Integer(2));
sb.append("; ");
sb.append(false);
sb.append("; ");
sb.append(Arrays.asList(1,2,3));
sb.append("; ");
System.out.println(sb); // 2; false; [1, 2, 3];
}
Ibinabalik ng pamamaraan append
ang bagay kung saan ito tinawag (tulad ng maraming iba pang mga pamamaraan), na nagpapahintulot na matawag ito sa isang "kadena". Ang halimbawa sa itaas ay maaaring isulat tulad nito:
public static void main(String[] args) {
StringBuffer sb = new StringBuffer();
sb.append(new Integer(2))
.append("; ")
.append(false)
.append("; ")
.append(Arrays.asList(1,2,3))
.append("; ");
System.out.println(sb); // 2; false; [1, 2, 3];
}
Ang StringBuffer class ay may ilang mga pamamaraan para sa pagtatrabaho sa mga string. Ilista natin ang mga pangunahing:
delete(int start, int end)
— tinatanggal ang isang substring ng mga character simula sa posisyonstart
, nagtataposend
deleteCharAt(int index)
— tinatanggal ang karakter sa posisyonindex
insert(int offset, String str)
— naglalagay ng linyastr
sa posisyonoffset
. Ang pamamaraaninsert
ay na-overload din at maaaring tumagal ng iba't ibang mga argumentoreplace(int start, int end, String str)
- ay papalitan ang lahat ng mga character mula sa posisyonstart
sa posisyonend
sa pamamagitan ngstr
reverse()
— binabaligtad ang pagkakasunud-sunod ng lahat ng mga charactersubstring(int start, int end)
- magbabalik ng substring simula sa posisyonstart
hanggang sa posisyonend
substring(int start)
- magbabalik ng substring simula sa posisyon
start
public static void main(String[] args) {
String numbers = "0123456789";
StringBuffer sb = new StringBuffer(numbers);
System.out.println(sb.substring(3)); // 3456789
System.out.println(sb.substring(4, 8)); // 4567
System.out.println(sb.replace(3, 5, "ABCDE")); // 012ABCDE56789
sb = new StringBuffer(numbers);
System.out.println(sb.reverse()); // 9876543210
sb.reverse(); // Return the original order
sb = new StringBuffer(numbers);
System.out.println(sb.delete(5, 9)); // 012349
System.out.println(sb.deleteCharAt(1)); // 02349
System.out.println(sb.insert(1, "One")); // 0One2349
}
Mga kalamangan:
-
Tulad ng nabanggit na, ang StringBuffer ay isang nababagong klase, kaya ang pagtatrabaho dito ay hindi lumilikha ng parehong dami ng basura ng memorya tulad ng sa String. Samakatuwid, kung maraming pagbabago ang ginawa sa mga string, mas mainam na gamitin ang
StringBuffer
. -
Ang StringBuffer ay isang thread safe class. Ang mga pamamaraan nito ay naka-synchronize at ang mga pagkakataon ay maaaring gamitin ng maraming mga thread nang sabay-sabay.
Bahid:
Sa isang banda, ang kaligtasan ng thread ay isang bentahe ng klase, at sa kabilang banda, ito ay isang kawalan. Ang mga naka-synchronize na pamamaraan ay mas mabagal kaysa sa mga hindi naka-synchronize na pamamaraan. Dito pumapasok ang StringBuilder. Alamin natin kung anong uri ng klase ng Java ito - StringBuilder, anong mga pamamaraan ang mayroon ito at kung ano ang mga tampok nito.StringBuilder klase
Ang StringBuilder sa Java ay isang klase na kumakatawan sa isang sequence ng mga character. Ito ay halos kapareho sa StringBuffer sa lahat ng paraan maliban sa kaligtasan ng thread. Nagbibigay ang StringBuilder ng API na katulad ng StringBuffer's. Ipakita natin ito gamit ang isang pamilyar na halimbawa, na pinapalitan ang deklarasyon ng mga variable mula sa StringBufer hanggang sa StringBuilder:public static void main(String[] args) {
String numbers = "0123456789";
StringBuilder sb = new StringBuilder(numbers);
System.out.println(sb.substring(3)); //3456789
System.out.println(sb.substring(4, 8)); //4567
System.out.println(sb.replace(3, 5, "ABCDE")); //012ABCDE56789
sb = new StringBuilder(numbers);
System.out.println(sb.reverse()); //9876543210
sb.reverse(); // Return the original order
sb = new StringBuilder(numbers);
System.out.println(sb.delete(5, 9)); //012349
System.out.println(sb.deleteCharAt(1)); //02349
System.out.println(sb.insert(1, "One")); //0One2349
}
Ang pagkakaiba lamang ay ang StringBuffer ay ligtas sa thread at ang lahat ng mga pamamaraan nito ay naka-synchronize, habang ang StringBuilder ay hindi. Ito ang tanging tampok. Ang StringBuilder sa Java ay mas mabilis kaysa sa StringBuffer dahil sa hindi pag-synchronize ng mga pamamaraan. Samakatuwid, sa karamihan ng mga kaso, maliban sa isang multi-threaded na kapaligiran, mas mahusay na gumamit ng StringBuilder para sa isang Java program. Binubuod namin ang lahat sa isang comparative table ng tatlong klase:
String vs StringBuffer vs StringBuilder
String | StringBuffer | StringBuilder | |
---|---|---|---|
Pagbabago | Immutable (Hindi) |
mutable (Oo) |
mutable (Oo) |
Extensibility | final (Hindi) |
final (Hindi) |
final (Hindi) |
Kaligtasan ng thread | Oo, dahil sa kawalan ng pagbabago | Oo, dahil sa pag-synchronize | Hindi |
Kailan gagamitin | Kapag nagtatrabaho sa mga string na bihirang mabago | Kapag nagtatrabaho sa mga string na madalas na babaguhin sa isang multi-threaded na kapaligiran | Kapag nagtatrabaho sa mga string na madalas na babaguhin sa isang single-threaded na kapaligiran |
GO TO FULL VERSION