Inner workings ng String, at ang substring method

"Hi, Amigo!"

"Hi, Ellie."

"Sasabihin ko sa iyo ang tungkol sa mga substring. Ang isang substring ay isang bahagi ng isang string. At ang pinakakaraniwang operasyon na ginagawa sa mga string (pagkatapos ng pagsasama-sama ng ilang mga string) ay ang pagkuha ng isang substring."

7) Paano ako makakakuha ng bahagi ng isang String?

"Ang substring method ay nagbabalik ng bahagi ng isang String. Ang pamamaraang ito ay may dalawang bersyon."

"Ibinabalik ng unang bersyon ang substring na tinukoy sa pamamagitan ng pagsisimula at pagtatapos ng mga indeks. Ngunit ang karakter sa panghuling index ay hindi kasama! Kung ipapasa mo ang mga numero 1 at 3, ang substring ay maglalaman lamang ng pangalawa at pangatlong mga character (tandaan na ang mga indeks ay nagsisimula may 0).

"Ibinabalik ng pangalawang bersyon ang substring simula sa naipasa na index hanggang sa dulo ng String."

String substring(int beginIndex, int endIndex)

String s = "Good news, everyone!";
s = s.substring(1,6);

s == "ood n";

String substring(int beginIndex)

String s = "Good news, everyone!";
s = s.substring(1);

"Simple lang. Salamat, Ellie."

"Ipapaliwanag ko rin sa iyo ang mga panloob na gawain ng mga String object."

"Tulad ng malamang na alam mo na, ang String ay isang hindi nababagong klase. At anong mga pakinabang ang ibinibigay nito sa atin? Habang nangyayari ito, ang isa sa mga pangunahing bentahe ay ang kakayahang makakuha ng isang substring. Ngunit una sa lahat."

"Sa loob, ang String object ay naglalaman ng hanay ng mga character, na hindi ganoon kahirap hulaan. Ngunit nag-iimbak din ito ng dalawa pang variable: ang index ng unang character sa array at ang bilang ng character. Ngayon sasabihin ko sa iyo kung ano ang mga ito. ay ginagamit para sa."

"Kapag gumawa kami ng substring gamit ang substring method, isang bagong String object ang gagawin."

"Ngunit, sa halip na mag-imbak ng reference sa isang bagong array ng character, ang object ay nag-iimbak ng reference sa lumang array pati na rin ang dalawang variable na ginagamit nito upang matukoy ang bahagi ng orihinal na array ng character na nauugnay dito."

"Wala akong naintindihan sa mga iyon."

"Kapag ang isang substring ay ginawa, ang character array ay hindi kinokopya sa bagong String object. Sa halip, ang parehong mga object ay nag-iimbak ng reference sa orihinal na character array. Ngunit! Ang pangalawang object ay nag-iimbak din ng dalawang variable: ang panimulang index nito sa array at ang bilang ng mga character na kabilang sa substring."

"Tingnan mo:"

String s = "mama";

char[] value = {'m','a','m','a'};
offset = 0;
count = 4;

String s2 = s.substring(1);

char[] value = {'m','a','m','a'};
offset = 1;
count = 3;

String s3 = s.substring(1, 3);

char[] value = {'m','a','m','a'};
offset = 1;
count = 2;

"Ang lahat ng tatlong Strings ay nag-iimbak ng reference sa parehong char array, ngunit iniimbak din nila ang index ng una at huling character na nauugnay sa kanila. O mas tumpak, ang index ng unang character at ang bilang ng character."

"Iyan ang akma ngayon."

"Kaya, kung kukuha ka ng String na 10,000 character ang haba at gagawa ka ng 10,000 substrings ng anumang haba, ang mga substring na ito ay gagamit ng napakakaunting memorya, dahil ang character array ay hindi nadoble. Ang mga Strings na ito, na inaasahan mong maubos ng marami. ng espasyo, literal na tatagal lamang ng ilang byte."

"Malamig!"

"Ngunit magagawa mo ba iyon kung maaari mong baguhin ang Strings?"

"Hindi, maaaring baguhin ng isang tao ang unang String, at pagkatapos ay magbabago rin ang lahat ng mga substring nito. Ngayon, makatuwiran na kung bakit nila ginawa iyon. Iyon ay isang talagang cool na solusyon."

"Natutuwa akong nagustuhan mo ito."