Paghahambing ng mga string ayon sa nilalaman

1. Paghahambing ng mga string

Ang lahat ng ito ay mabuti at mabuti. Ngunit makikita mo na ang s1at s2mga string ay talagang pareho, ibig sabihin, naglalaman ang mga ito ng parehong teksto. Kapag naghahambing ng mga string, paano mo sasabihin sa programa na hindi tumingin sa mga address ng Stringmga bagay, ngunit sa kanilang nilalaman?

Upang matulungan kami dito, Stringang klase ng Java ay may equalspamamaraan. Ang pagtawag ay ganito ang hitsura:

string1.equals(string2)

Ang pamamaraang ito ay nagbabalik truekung ang mga string ay pareho, at falsekung sila ay hindi pareho.

Halimbawa:

String s1 = "Hello";
String s2 = "HELLO";
String s3 = s1.toUpperCase();

System.out.println(s1.equals(s2));
System.out.println(s1.equals(s3));
System.out.println(s2.equals(s3));

// Hello
// HELLO
// HELLO

false // They are different
false // They are different
true // They are the same, even though the addresses are different

Higit pang mga halimbawa:

"Hello".equals("HELLO")

String s = "Hello";
"Hello".equals(s);

String s = "Hel";
"Hello".equals(s + "lo");

String s = "H";
(s + "ello").equals(s + "ello");

2. Case-insensitive na paghahambing ng string

Sa huling halimbawa, nakita mo na ang paghahambing ay nagbubunga ng . Sa katunayan, ang mga string ay hindi pantay. Pero..."Hello".equals("HELLO")false

Maliwanag, ang mga string ay hindi pantay. Iyon ay, ang kanilang nilalaman ay may parehong mga titik at naiiba lamang sa kaso ng mga titik. Mayroon bang anumang paraan upang ihambing ang mga ito at ipagwalang-bahala ang kaso ng mga titik? Iyon ay, kaya na magbubunga ?"Hello".equals("HELLO")true

At ang sagot sa tanong na ito ay oo. Sa Java, ang Stringuri ay may isa pang espesyal na pamamaraan: equalsIgnoreCase. Ang pagtawag ay ganito ang hitsura:

string1.equalsIgnoreCase(string2)

Ang pangalan ng pamamaraan ay halos isinasalin bilang paghahambing ngunit huwag pansinin ang kaso . Ang mga titik sa pangalan ng pamamaraan ay may kasamang dalawang patayong linya: ang una ay maliit na titik L, at ang pangalawa ay malaking titik i. Huwag hayaan na malito ka niyan.

Halimbawa:

String s1 = "Hello";
String s2 = "HELLO";
String s3 = s1.toUpperCase();

System.out.println(s1.equalsIgnoreCase(s2));
System.out.println(s1.equalsIgnoreCase(s3));
System.out.println(s2.equalsIgnoreCase(s3));

// Hello
// HELLO
// HELLO

true
true
true

3. Halimbawa ng paghahambing ng string

Magbigay lamang tayo ng isang simpleng halimbawa: ipagpalagay na kailangan mong magpasok ng dalawang linya mula sa keyboard at tukuyin kung pareho ang mga ito. Ito ang magiging hitsura ng code:

Scanner console = new Scanner(System.in);
String a = console.nextLine();
String b = console.nextLine();
String result = a.equals(b) ? "Same" : "Different";
System.out.println(result);

4. Isang kawili-wiling nuance ng paghahambing ng string

Mayroong isang mahalagang nuance na kailangan mong malaman.

Kung ang Java compiler ay nakahanap ng maraming magkakaparehong mga string sa iyong code (partikular sa iyong code), lilikha lamang ito ng isang bagay para sa kanila upang makatipid ng memorya.

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

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

At kung ihahambing mo text == messagedito, makakakuha ka ng true. Kaya wag ka nang magtaka diyan.

Kung sa ilang kadahilanan kailangan mo talagang maging iba ang mga sanggunian, maaari mong isulat ito:

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

O ito:

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

Sa parehong mga kasong ito, ang textat messagemga variable ay tumuturo sa iba't ibang mga bagay na naglalaman ng parehong teksto.