Panimula sa String, StringBuffer at StringBuilder sa Java

Mayroong tatlong mga klase sa Java para sa pagtatrabaho sa data ng teksto: String , StringBuffer at StringBuilder . Nakatagpo ng bawat developer ang una sa simula ng pag-aaral ng wika. Paano ang natitira pang dalawa? Ano ang kanilang mga pagkakaiba, at kailan mas mahusay na gumamit ng isa o ibang klase? Sa pangkalahatan, ang pagkakaiba sa pagitan nila ay maliit, ngunit mas mahusay na maunawaan ang lahat sa pagsasanay :)

• String class sa Java
• StringBuffer class sa Java
• StringBuilder na klase sa Java

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

Sa pangkalahatan, ang String class ay hindi maaaring magkaroon ng mga anak ( final) at ang mga instance ng klase ay hindi maaaring mabago pagkatapos ng paglikha ( immutable). Nagbibigay ito sa String class ng ilang mahahalagang pakinabang:

1. 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.

2. Maaaring gamitin ang String class sa isang multi-threaded na kapaligiran nang walang karagdagang pag-synchronize.

3. 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 Objectat 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 aaktwal bna 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.

Tingnan natin ang code na ito:

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 ay mutableisang 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)

Pagsasanay:

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 appendsa 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 appendang 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 posisyon start, nagtataposend
• deleteCharAt(int index)— tinatanggal ang karakter sa posisyonindex
• insert(int offset, String str)— naglalagay ng linya strsa posisyon offset. Ang pamamaraan insertay na-overload din at maaaring tumagal ng iba't ibang mga argumento
• replace(int start, int end, String str)- ay papalitan ang lahat ng mga character mula sa posisyon startsa posisyon endsa pamamagitan ngstr
• reverse()— binabaligtad ang pagkakasunud-sunod ng lahat ng mga character
substring(int start)- magbabalik ng substring simula sa posisyon start
• substring(int start, int end)- magbabalik ng substring simula sa posisyon starthanggang sa posisyonend

Ang isang kumpletong listahan ng mga pamamaraan at constructor ay nasa opisyal na dokumentasyon . Paano gumagana ang mga pamamaraan sa itaas? Tingnan natin sa pagsasanay:

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:

1. 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.

2. 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

Maaari mong pag-aralan ang paksang ito nang mas detalyado sa ikalawang antas ng Java Multithreading quest sa kursong JavaRush:

• String internals, substring method
• StringBuilder, StringBuffer
• Mga Gawain para sa StringBuilder, StringBuffer