CodeGym /Blog Jawa /Acak /Bandhingake String lan Equals ing Jawa
John Squirrels
tingkat
San Francisco

# Bandhingake String lan Equals ing Jawa

Hi! Dina iki kita bakal ngomong babagan topik sing penting banget lan menarik, yaiku, mbandhingake obyek karo obyek (Bandingake Strings lan Equals). Dadi ing Jawa, kapan persis obyek A padha karo obyek B ? Ayo coba nulis conto:
``````
public class Car {

String model;
int maxSpeed;

public static void main(String[] args) {

Car car1 = new Car();
car1.model = "Ferrari";
car1.maxSpeed = 300;

Car car2 = new Car();
car2.model = "Ferrari";
car2.maxSpeed = 300;

System.out.println(car1 == car2);
}
}
``````
Output konsol: palsu Enteni, mandheg. Lha kok montor loro iki ora padha? Kita menehi properti sing padha, nanging asil perbandingan kasebut salah. Jawaban iki prasaja. Operator == mbandhingake referensi obyek, dudu properti obyek. Loro obyek bisa uga duwe 500 kolom kanthi nilai sing padha, nanging mbandhingake isih bakal ngasilake palsu. Sawise kabeh, referensi mobil1 lan mobil2arahake menyang rong obyek sing beda, yaiku rong alamat sing beda. Bayangake kahanan nalika sampeyan mbandhingake wong. Mesthi wae, nang endi wae ing jagad iki ana wong sing duwe jeneng sing padha, warna mripat, umur, dhuwur, warna rambut, lsp. Sing nggawe sampeyan padha ing pirang-pirang aspek, nanging sampeyan isih dudu kembar — lan sampeyan jelas dudu wong sing padha.
Operator == nggunakake kira-kira logika sing padha nalika digunakake kanggo mbandhingake rong obyek. Nanging kepiye yen sampeyan butuh program sampeyan nggunakake logika sing beda? Contone, umpamane program sampeyan nindakake analisis DNA. Iki mbandhingake kode genetik wong loro, lan nemtokake manawa dheweke kembar.
``````
public class Man {

int geneticCode;

public static void main(String[] args) {

Man man1 = new Man();
man1.geneticCode = 1111222233;

Man man2 = new Man();
man2.geneticCode = 1111222233;

System.out.println(man1 == man2);
}
}
``````
Output konsol: palsu Kita entuk asil logis sing padha (amarga ora owah akeh), nanging saiki logika kasebut ora apik! Sawise kabeh, ing urip nyata, analisis DNA kudu menehi jaminan 100% yen kita duwe kembar sing ngadeg ing ngarep. Nanging program kita lan operator == marang kita ngelawan. Kepiye carane ngganti prilaku iki lan priksa manawa program kasebut ngasilake asil sing bener nalika DNA cocog? Jawa nduweni cara khusus kanggo iki: padha () . Kaya metode toString () , sing kita rembugan sadurunge, padha karo () kalebu kelas Obyek - kelas paling penting ing Jawa, kelas sing asale kabeh kelas liyane. Nanging padha ()ora ngganti prilaku program kita dhewe:
``````
public class Man {

String geneticCode;

public static void main(String[] args) {

Man man1 = new Man();
man1.geneticCode = "111122223333";

Man man2 = new Man();
man2.geneticCode = "111122223333";

System.out.println(man1.equals(man2));
}
}
``````
Output Console: palsu Persis asil padha, supaya apa kita kudu cara iki? :/ Iku kabeh prasaja. Masalah ing kene yaiku saiki kita nggunakake metode iki amarga dileksanakake ing kelas Obyek . Lan yen kita mlebu kode kelas Obyek lan ndeleng implementasine metode kasebut, iki sing bakal kita deleng:
``````
public boolean equals(Object obj) {
return (this == obj);
}
``````
Sing alesan ngapa prilaku program ora diganti! Operator == sing padha (sing mbandhingake referensi) digunakake ing metode sing padha () saka kelas Obyek . Nanging trik kanthi cara iki yaiku kita bisa ngatasi. Kanggo override tegese nulis cara padha () ing kelas Man kita , menehi prilaku kita kudu! Saiki, kita ora seneng yen man1.equals(man2) sejatine padha karo man1 == man2 . Mangkene apa sing bakal ditindakake ing kahanan iki:
``````
public class Man {

int dnaCode;

public boolean equals(Man man) {
return this.dnaCode ==  man.dnaCode;

}

public static void main(String[] args) {

Man man1 = new Man();
man1.dnaCode = 1111222233;

Man man2 = new Man();
man2.dnaCode = 1111222233;

System.out.println(man1.equals(man2));

}
}
``````
Output konsol: bener Saiki kita entuk asil sing beda banget! Kanthi nulis kita padha () cara lan nggunakake tinimbang standar, kita wis diprodhuksi prilaku bener: Saiki yen wong loro duwe DNA padha, laporan program "Analisis DNA wis mbuktekaken padha kembar" lan bali bener! Kanthi overriding cara padha () ing kelas, sampeyan bisa kanthi gampang nggawe apa wae logika comparison obyek sampeyan kudu. Nyatane, kita mung ndemek perbandingan obyek. Ing ngarep, isih ana pawulangan mandiri sing gedhe babagan topik iki (sampeyan saiki maca yen sampeyan kasengsem).

## Mbandhingake senar ing basa Jawa

Napa kita nimbang perbandingan senar kanthi kapisah saka kabeh liyane? Kasunyatane yaiku strings minangka subyek ing pemrograman dhewe. Kaping pisanan, yen sampeyan njupuk kabeh program Java sing wis ditulis, sampeyan bakal nemokake manawa udakara 25% obyek kasebut minangka senar. Dadi topik iki penting banget. Kapindho, proses mbandhingake senar pancen beda banget karo obyek liyane. Coba conto sing prasaja:
``````
public class Main {

public static void main(String[] args) {

String s1 = "CodeGym is the best website for learning Java!";
String s2 = new String("CodeGym is the best website for learning Java!");
System.out.println(s1 == s2);
}
}
``````
Output konsol: palsu Nanging kenapa kita entuk palsu? Sawise kabeh, strings padha persis, tembung kanggo tembung: / Sampeyan bisa uga wis guessed alesan: iku amarga operator == mbandhingaké referensi ! Cetha, s1 lan s2 duwe alamat sing beda ing memori. Yen sampeyan mikir babagan iki, ayo gawe maneh conto:
``````
public class Main {

public static void main(String[] args) {

String s1 = "CodeGym is the best website for learning Java!";
String s2 = "CodeGym is the best website for learning Java!";
System.out.println(s1 == s2);
}
}
``````
Saiki kita maneh duwe loro referensi, nanging asil ngelawan pas: Output Console: bener Helplessly bingung? Ayo ngerteni apa sing kedadeyan. Operator == pancen mbandhingake alamat memori. Iki mesthi bener lan sampeyan ora perlu mangu-mangu. Tegese yen s1 == s2 bali bener, banjur loro strings iki alamat padha. Lan pancen iki bener! Wektu kanggo ngenalake sampeyan menyang area memori khusus kanggo nyimpen senar: kolam senar
Kolam senar minangka area kanggo nyimpen kabeh nilai senar sing digawe ing program sampeyan. Apa sebabé digawé? Kaya sing wis dakkandhakake sadurunge, senar nggambarake persentase gedhe saka kabeh obyek. Sembarang program gedhe nggawe akeh strings. Kolam senar digawe kanggo ngirit memori: senar diselehake ing kana lan banjur senar digawe ngrujuk menyang area memori sing padha-ora perlu ngalokasi memori tambahan saben wektu. Saben-saben sampeyan nulis String = "........" program mriksa yen ana senar sing padha ing blumbang senar. Yen ana, string anyar ora bakal digawe. Lan referensi anyar bakal nuduhake alamat sing padha ing blumbang senar (ngendi senar sing padha). Dadi nalika kita nulis
``````
String s1 = "CodeGym is the best website for learning Java!";
String s2 = "CodeGym is the best website for learning Java!";
``````
s2 tumuju panggonan sing padha karo s1 . Pernyataan pisanan nggawe senar anyar ing blumbang senar. Pernyataan kapindho mung nuduhake area memori sing padha karo s1 . Sampeyan bisa nggawe liyane 500 strings podho rupo lan asil ora bakal ngganti. Ngenteni sedhela. Yen pancen bener, mula kenapa conto iki ora bisa digunakake sadurunge?
``````
public class Main {

public static void main(String[] args) {

String s1 = "CodeGym is the best website for learning Java!";
String s2 = new String("CodeGym is the best website for learning Java!");
System.out.println(s1 == s2);
}
}
``````
Aku intuisi sampeyan wis ngandhani alesan =) Coba guess sadurunge maca luwih lanjut. Sampeyan bisa ndeleng manawa rong senar kasebut diumumake kanthi cara sing beda. Siji karo operator anyar, lan liyane tanpa. Punika dumunung alesan. Nalika operator anyar digunakake kanggo nggawe obyek, forcefully allocates area anyar saka memori kanggo obyek. Lan senar digawe nggunakake anyar ora mungkasi munggah ing blumbang senar - dadi obyek kapisah, sanajan teks sawijining sampurna cocog senar ing blumbang senar. Yaiku, yen kita nulis kode ing ngisor iki:
``````
public class Main {

public static void main(String[] args) {

String s1 = "CodeGym is the best website for learning Java!";
String s2 = "CodeGym is the best website for learning Java!";
String s3 = new String("CodeGym is the best website for learning Java!");
}
}
``````
Ing memori, katon kaya iki:
Lan saben-saben sampeyan nggawe obyek anyar nggunakake new , area memori anyar diparengake, sanajan teks ing senar anyar padha! Kayane kita wis ngerti operator == . Nanging babagan kenalan anyar kita, cara sing padha () ?
``````
public class Main {

public static void main(String[] args) {

String s1 = "CodeGym is the best website for learning Java!";
String s2 = new String("CodeGym is the best website for learning Java!");
System.out.println(s1.equals(s2));
}
}
``````
Output console: bener Interesting. Kita yakin manawa s1 lan s2 nuduhake wilayah sing beda ing memori. Nanging cara sing padha () isih ngandhani yen padha. Kenging punapa? Elingi kita sadurunge ngandika sing padha () cara bisa ditindhes kanggo mbandhingaké obyek Nanging kita arep? Iku mung apa sing wis rampung karo kelas String . Iku overrides padha ()cara. Lan tinimbang mbandhingake referensi, mbandhingake urutan karakter ing senar. Yen teks padha, banjur ora Matter carane padha digawe utawa ing ngendi padha disimpen: apa ing blumbang senar utawa wilayah kapisah saka memori. Asil saka comparison bakal bener. Miturut cara, Jawa ngidini sampeyan nindakake perbandingan string sing ora sensitif huruf cilik. Biasane, yen salah siji saka senar duwe kabeh huruf gedhe, banjur asil perbandingan bakal palsu:
``````
public class Main {

public static void main(String[] args) {

String s1 = "CodeGym is the best website for learning Java!";
String s2 = new String("CODEGYM IS THE BEST WEBSITE FOR LEARNING JAVA!");
System.out.println(s1.equals(s2));
}
}
``````
Output konsol: palsu Kanggo mbandhingake cilik-ora sensitif, kelas String duwe metode equalsIgnoreCase () . Sampeyan bisa nggunakake yen sampeyan mung peduli babagan mbandhingake urutan karakter tartamtu tinimbang huruf cilik. Contone, iki bisa mbiyantu nalika mbandhingake rong alamat:
``````
public class Main {

public static void main(String[] args) {

}
}
``````
Ing kasus iki, kita temenan ngomong bab alamat sing padha, supaya iku ndadekake pangertèn kanggo nggunakake equalsIgnoreCase () cara.

## Metode String.intern().

Kelas String duwe siji cara sing luwih angel: intern () ; Intern () cara bisa langsung karo blumbang senar. Yen sampeyan nelpon metode intern () ing sawetara string:
• Iku mriksa apa ana senar cocog ing blumbang senar
• Yen ana, bali referensi kanggo senar ing blumbang
• Yen ora, iku nambah senar kanggo blumbang senar lan bali referensi kanggo.
Sawise nggunakake intern () cara ing referensi senar dijupuk nggunakake anyar , kita bisa nggunakake operator == kanggo mbandhingaké karo referensi senar saka blumbang senar.
``````
public class Main {

public static void main(String[] args) {

String s1 = "CodeGym is the best website for learning Java!";
String s2 = new String("CodeGym is the best website for learning Java!");
System.out.println(s1 == s2.intern());
}
}
``````
output Console: bener Nalika kita dibandhingake strings iki sadurunge tanpa intern () , asil iki palsu. Saiki metode intern () mriksa apa string "CodeGym minangka situs paling apik kanggo sinau basa Jawa!" ana ing blumbang senar. Mesthi, iku: kita digawe karo
``````
String s1 = "CodeGym is the best website for learning Java!";
``````
We mriksa apa s1 lan referensi bali dening s2.intern () titik menyang wilayah padha memori. Lan mesthi, padha nindakake :) Ing ringkesan, apal lan aplikasi aturan penting iki: Tansah nggunakake witjaksono () cara kanggo mbandhingaké strings! Nalika mbandhingake strings, kita meh tansah maksud kanggo mbandhingaké karakter tinimbang referensi, area memori, utawa liyane. Cara sing padha () nindakake apa sing sampeyan butuhake. Kanggo nguatake apa sing sampeyan sinau, disaranake sampeyan nonton video pelajaran saka Kursus Jawa

Wacan liyane:

Komentar
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION