Paghahambing ng mga sanggunian

1. Paghahambing

Kailangang ihambing ng mga programmer ang iba't ibang mga variable sa isa't isa sa lahat ng oras. Ngunit, tulad ng nakita mo na, ang lahat ay hindi gaanong simple.

Napakadaling ikumpara ang mga integer== — gagamit ka lang at tapos ka na. Upang ihambing ang mga tunay na numero , kailangan mong ihambing ang kanilang pagkakaiba (o sa halip, ang ganap na halaga ng pagkakaiba) sa ilang napakaliit na bilang.

Ang paghahambing ng mga string ay mas mahirap. Higit sa lahat, ito ay dahil ang mga string ay mga bagay. Higit pa rito, madalas na gusto ng mga programmer na ang paghahambing ng string ay medyo naiiba depende sa sitwasyon.

2. Paano nakaayos ang mga string ng memorya

Tulad ng nakita mo na, ang mga string ay nakaimbak sa memorya nang iba kaysa sa mga integer at totoong numero:

Dalawang bloke ng memorya ang ginagamit upang mag-imbak ng mga string: ang isang bloke ay nag-iimbak ng teksto mismo (depende ang laki nito sa laki ng teksto) habang ang pangalawang bloke (4 bytes) ay nag-iimbak ng address ng unang bloke.

Bagaman ang isang bihasang programmer ay magsasabi ng isang bagay tulad ng "ang String strvariable ay nag-iimbak ng isang sanggunian sa isang Stringbagay.

3. Pagtatalaga ng mga sanggunian sa isang string

Ang mga benepisyo ng diskarteng ito ay nagiging maliwanag kapag kailangan mong magtalaga ng isang string variable sa isa pang string variable. Halimbawa:

String text = "This is a very important message";
String message = text;

At narito kung ano ang nilalaman ng memorya bilang isang resulta:

Pagkatapos ng ganitong uri ng pagpapatakbo ng pagtatalaga, ang Stringobject ay nananatili sa kung saan ito, at ang address lamang nito (isang reference sa object) ay kinopya sa messagevariable.

4. Paggawa gamit ang mga sanggunian at mga bagay

Ngunit kung magpasya kang i-convert ang isang string sa uppercase (capital letters), ginagawa ng Java machine ang lahat ng tama: magkakaroon ka ng dalawang Stringobject, at ang textand messagevariables ay mag-iimbak ng mga reference, bawat isa sa sarili nitong object.

Halimbawa:

String text = "This is a very important message";
String message = text.toUpperCase(); 

At narito kung ano ang nilalaman ng memorya bilang isang resulta:

Pakitandaan na hindi binabagotoUpperCase() ng pamamaraan ang string kung saan ito tinatawag. Sa halip, lumilikha ito ng bagong string (bagong object) at nagbabalik ng reference dito.

Paano ang tungkol sa isang mas kawili-wiling halimbawa. Sabihin nating nagpasya kang magpasa ng string sa isang Scannerbagay (upang mabasa nito ang mga halaga mula sa string).

Halimbawa:

String text = "10 20 40 80";
Scanner console = new Scanner(text);
int a = console.nextInt();
int b = console.nextInt();

Maaari kang matuto nang higit pa tungkol sa kung paano Scannergumagana ang klase dito .

Ito ay kung paano ang lahat ng ito ay maiimbak sa memorya:

Sa kasong ito, ang isang Stringbagay ay nananatili sa memorya tulad ng dati - ang mga sanggunian lamang dito ay ipinapasa at iniimbak sa mga variable.

5. Paghahambing ng mga sanggunian sa Stringmga bagay

At sa wakas, naabot na namin ang nakakatuwang bahagi: paghahambing ng string.

Mayroong dalawang operator na magagamit mo upang ihambing ang mga variable ng string: ==(pantay) at !=(hindi katumbas). Hindi mo magagamit ang mga operator na "greater than", "less than", o "greater than or equal to" — hindi ito papayagan ng compiler.

Ngunit mayroong isang kawili-wiling pananarinari dito: ano ang aktwal na naiimbak sa mga variable ng string? Tama iyon: mga address (mga sanggunian) sa mga bagay. At ang mga address na ito ang ihahambing:

String text = "Hi";
String message = text;
String s1 = text.toUpperCase();
String s2 = text.toUpperCase(); 

Narito ang magiging memorya:

Ang messageat textmga variable ay tumutukoy sa (imbak ang address ng) sa parehong bagay. Ngunit ang s1at s2mga variable ay nag-iimbak ng mga sanggunian sa mga bagay na halos magkapareho ngunit naiiba.

At kung ihahambing mo ang 4 na variable na ito sa code, makukuha mo ang sumusunod na resulta:

String text = "Hi";
String message = text;
String s1 = text.toUpperCase();
String s2 = text.toUpperCase();
System.out.println(text == message);
System.out.println(text == s1);
System.out.println(s1 == s2); 

true  // The addresses are equal
false // The addresses are different
false // The addresses are different