Pagsasalin: Paglikha ng mga String object sa Java - gamit ang " " o constructor?

Orihinal: Lumikha ng Java String Gamit ang “ ” o Constructor? Sa pamamagitan ng X Wang Sa Java, ang isang string ay maaaring gawin gamit ang dalawang pamamaraan:

String x = "abc";
String y = new String("abc");

Ano ang pagkakaiba sa pagitan ng paggamit ng double quotes at paggamit ng constructor?

1. Double Quotes vs. Tagabuo

Ang tanong na ito ay masasagot sa pamamagitan ng pagtingin sa dalawang simpleng halimbawa. Halimbawa 1:

String a = "abcd";
String b = "abcd";
System.out.println(a == b);  // True
System.out.println(a.equals(b)); // True

a==btotoo dahil apareho silang btumutukoy sa parehong bagay - isang string na ipinahayag bilang literal (string literal sa ibaba) sa lugar ng pamamaraan (tinutukoy namin ang mambabasa sa pinagmulan sa aming mapagkukunan: Nangungunang 8 diagram para sa pag-unawa sa Java , diagram 8). Kapag ang parehong literal na string ay nilikha nang higit sa isang beses, isang kopya lamang ng string ang naka-imbak sa memorya, isang pagkakataon lamang nito (sa aming kaso "abcd"). Ito ay tinatawag na "string interning". Ang lahat ng mga string constant na naproseso sa oras ng pag-compile ay awtomatikong naka-interne sa Java. Halimbawa 2:

String c = new String("abcd");
String d = new String("abcd");
System.out.println(c == d);  // False
System.out.println(c.equals(d)); // True

c==dfalse dahil tinutukoy cnila dang dalawang magkaibang bagay sa memorya (sa heap). Ang iba't ibang mga bagay ay palaging may iba't ibang mga sanggunian. Inilalarawan ng diagram na ito ang dalawang sitwasyong inilarawan sa itaas:

2. Interning string sa panahon ng pagpapatupad ng programa

Ang may-akda ay nagpapasalamat kay LukasEder (ang komento sa ibaba ay sa kanya): Ang string interning ay maaari ding mangyari sa panahon ng pagpapatupad ng programa, kahit na ang dalawang mga string ay nilikha gamit ang mga konstruktor:

String c = new String("abcd").intern();
String d = new String("abcd").intern();
System.out.println(c == d);  // Now true
System.out.println(c.equals(d)); // True

3. Kailan gagamit ng double quotes at kung kailan gagamit ng mga constructor

Dahil sa ang katunayan na ang literal na "abcd" ay palaging may uri ng String, ang paggamit ng isang constructor ay lilikha ng karagdagang hindi kinakailangang bagay. Kaya dapat gamitin ang double quotes kung kailangan mo lang gumawa ng string. Kung talagang kailangan mong gumawa ng bagong bagay sa heap, dapat kang gumamit ng constructor. Ang mga kaso ng paggamit ay ipinapakita dito (orihinal) . (Ibinigay ko ang isinalin na teksto sa ibaba. Ngunit lubos ko pa ring inirerekomenda na maging pamilyar ka sa code ng mga komentarista sa link na ito.)

Ang substring() na pamamaraan sa JDK 6 at JDK 7

Ang substring() na Paraan sa JDK 6 at JDK 7 Ni X Wang Ang pamamaraan substring(int beginIndex, int endIndex)sa JDK 6 at JDK 7 ay magkaiba. Ang pag-alam sa mga pagkakaibang ito ay makakatulong sa iyong gamitin ang pamamaraang ito nang mas mahusay. Para sa kapakanan ng kadalian ng pagbabasa, sa ibaba substring()ang ibig sabihin ay ang buong syntax, i.e. substring(int beginIndex, int endIndex).

1. Ano ang ginagawa ng substring()?

Ang pamamaraan substring(int beginIndex, int endIndex)ay nagbabalik ng isang string na nagsisimula sa numero ng character beginIndexat nagtatapos sa numero ng character endIndex-1.

String x = "abcdef";
x = x.substring(1,3);
System.out.println(x);

Output:

bc

2. Ano ang mangyayari kapag tinawag ang substring()?

Maaaring alam mo na, dahil sa immutability x, kapag nagtatalaga ng x ang resulta ng x.substring(1,3), xito ay tumuturo sa isang ganap na bagong hilera (tingnan ang diagram): Gayunpaman, ang diagram na ito ay hindi ganap na tama; hindi nito ipinapakita kung ano talaga ang nangyayari sa tambak. Ang aktwal na nangyayari kapag tinawag substring()ay iba sa JDK 6 at JDK 7.

3. substring() sa JDK 6

Ang uri ng string ay sinusuportahan ng uri ng array char. Sa JDK 6, naglalaman ang klase ng String3 field: char value[], int offset, int count. Ginagamit ang mga ito upang iimbak ang aktwal na hanay ng mga character, ang index ng unang character sa array, ang bilang ng mga character sa linya. Kapag ang pamamaraan ay tinatawag na substring(), lumilikha ito ng bagong row, ngunit ang halaga ng variable ay tumuturo pa rin sa parehong array sa heap. Ang pagkakaiba sa pagitan ng dalawang string ay ang kanilang bilang ng mga character at ang index na halaga ng panimulang character sa array. Ang code sa ibaba ay pinasimple at naglalaman lamang ng mga pangunahing kaalaman upang ipakita ang problema.

//JDK 6
String(int offset, int count, char value[]) {
	this.value = value;
	this.offset = offset;
	this.count = count;
}

public String substring(int beginIndex, int endIndex) {
	//check boundary
	return  new String(offset + beginIndex, endIndex - beginIndex, value);
}

4. Problema na dulot ng substring() sa JDK 6

Kung mayroon kang napakahabang string, ngunit kailangan mo lamang ng isang maliit na bahagi nito, na nakukuha mo sa tuwing gumagamit ng substring(). Magdudulot ito ng mga problema sa pagpapatupad, dahil kailangan mo lamang ng isang maliit na bahagi, ngunit kailangan mo pa ring iimbak ang buong string. Para sa JDK 6, ang solusyon ay ang code sa ibaba, na maghahatid ng string sa isang tunay na substring:

x = x.substring(x, y) + ""

Ang user na si STepeR ay bumalangkas ng isang tanong (tingnan ang kanyang komento), at tila kailangang magdagdag ng punto 4. Ang "Problemang dulot substring()sa JDK 6" ay isang mas malawak na halimbawa. Umaasa ako na ito ang magiging sagot at makakatulong sa iba na mabilis na malaman kung ano ang problema. Narito ang code:

String a = "aLongLongString";
String b = a.substring(1, 2);
String c = a.substring(2, 6);

Kaya, sa JDK 7 b, ang mga bagay сna may uri ng isang Stringnilikha sa pamamagitan ng pagtawag sa isang pamamaraan substring()sa isang bagay na may uri ng isang Stringay tumutukoy sa dalawang bagong likhang array sa heap - Lpara sa b, ongLpara sa c. Ang dalawang bagong array na ito ay iimbak sa heap KASAMA ang orihinal na array aLongLongStringna isinangguni ng a. Yung. ang orihinal na hanay ay hindi nawawala kahit saan. Ngayon bumalik tayo sa JDK 6. Sa JDK 6, ang isang heap ay naglalaman ng isang solong array aLongLongString. Matapos isagawa ang mga linya ng code

String b = a.substring(1, 2);
String c = a.substring(2, 6);

ang mga object bay tumutukoy csa parehong array sa heap, na tumutugma sa object a: b- sa mga elemento mula sa 1st index hanggang sa 2nd, c- sa mga elemento mula sa 2nd index hanggang sa ika-6 (nagsisimula ang pagnunumero sa 0, paalala). Yung. Malinaw, ang anumang karagdagang pag-access sa mga variable bo c sa JDK 6 ay talagang magreresulta sa mga nais na elemento ng orihinal na array na "binibilang" sa heap. Sa JDK 7, anumang karagdagang pag-access sa mga variable bo c ay magdudulot ng access sa mga kinakailangang mas maliliit na array na nagawa na at "live" sa heap. Yung. Malinaw na gumagamit ang JDK 7 ng mas pisikal na memorya sa mga sitwasyong tulad nito. Ngunit isipin natin ang isang posibleng opsyon: ang ilang mga substring ng variable ay itinalaga sa mga variable b, at sa hinaharap lahat ay gumagamit lamang ng mga ito - mga bagay at . Wala nang nag-a-access sa variable a; wala nang mga sanggunian dito (ito ang ibig sabihin ng may-akda ng artikulo). Bilang isang resulta, sa ilang mga punto sa oras ang kolektor ng basura ay na-trigger, at (sa pinaka-pangkalahatang anyo, siyempre) nakakakuha tayo ng 2 magkakaibang sitwasyon: JDK 6 : ang bagay ay nawasak (nakolekta ang basura) , PERO - ang orihinal na malaking hanay sa bunton ay buhay; ito ay patuloy na ginagamit at . JDK 7: ang object a ay nawasak kasama ang orihinal na array sa heap. Ito ang punto sa JDK 6 na maaaring humantong sa isang memory leak. cabcabc

5. substring() sa JDK 7

Ang pamamaraan ay napabuti sa JDK 7. Sa JDK 7 substring()ito ay talagang lumilikha ng isang bagong array sa heap.

//JDK 7
public String(char value[], int offset, int count) {
	//check boundary
	this.value = Arrays.copyOfRange(value, offset, offset + count);
}

public String substring(int beginIndex, int endIndex) {
	//check boundary
	int subLen = endIndex - beginIndex;
	return new String(value, beginIndex, subLen);
}