การวิเคราะห์ที่ครอบคลุมของซอร์สโค้ดสตริง Java และพูลคงที่สตริง

1. บทนำสู่สตริงวิธีการทั่วไปการวิเคราะห์ซอร์สโค้ด

2. การวิเคราะห์พูลคงที่สตริง

วิธีการทั่วไป

เท่ากับ

ตัดแต่ง

แทนที่

การต่อ

แยก

startswith และ endswith

เครื่องประดับ

touppercase () และ toLowercase ()

เปรียบเทียบ

บทนำสู่สตริง

คลาสสตริงได้รับการแก้ไขโดยรอบชิงชนะเลิศซึ่งหมายความว่าวัตถุสตริงเป็นโปรแกรมที่ไม่เปลี่ยนรูปและพร้อมกันชอบไม่เปลี่ยนรูป คลาสสตริงใช้อินเตอร์เฟส serializable, เทียบเคียงและ charsequence

เริ่มต้นด้วยชิ้นส่วนของรหัส:

 โมฆะสาธารณะ StringTest () {String A = "A"+"B" +1; สตริง b = "ab1"; System.out.println (a == b);}

เดาว่าผลลัพธ์คืออะไร? หากข้อสรุปของคุณเป็นจริง โอเคมีรหัสอื่นกันเถอะ:

 โมฆะสาธารณะ StringTest () {String a = สตริงใหม่ ("AB1"); สตริง b = "ab1"; System.out.println (a == b);}

ผลลัพธ์คืออะไร? คำตอบที่ถูกต้องเป็นเท็จ

มาดูกันว่ารหัสที่รวบรวมโดยคอมไพเลอร์

 // รหัสแรกโมฆะสาธารณะ StringTest () {String a = "AB1"; สตริง b = "ab1"; System.out.println (a == b);}

 // รหัสที่สองโมฆะสาธารณะ StringTest () {String A1 = สตริงใหม่ ("AB1"); สตริง b = "ab1"; System.out.println (a1 == b);}

กล่าวอีกนัยหนึ่งรหัสชิ้นแรกได้รับการปรับให้เหมาะสมในช่วงระยะเวลาการรวบรวมเนื่องจากคอมไพเลอร์พบว่าผลกระทบของ "A"+"B" +1 และ "AB1" นั้นเหมือนกัน แต่ทำไมหน่วยความจำของพวกเขาถึงเหมือนกัน? หากคุณยังคงสนใจสิ่งนี้ลองมาดูซอร์สโค้ดที่สำคัญของคลาสสตริง

รหัสต้นฉบับ

1. แอตทริบิวต์สตริง

คลาสสตริงมีอาร์เรย์ถ่านที่เปลี่ยนไม่ได้เพื่อเก็บสตริงและแฮชตัวแปร int ใช้เพื่อเก็บค่าแฮชที่คำนวณได้

 /** ค่าใช้สำหรับการจัดเก็บอักขระ */ค่าถ่านสุดท้ายส่วนตัว [];/** แคชรหัสแฮชสำหรับสตริง*/ส่วนตัว int แฮช; // ค่าเริ่มต้นเป็น 0/** ใช้ serialVersionUID จาก JDK 1.0.2 สำหรับการทำงานร่วมกัน*/ส่วนตัวคงที่สุดท้าย Long SerialVersionUID = -6849794470754667710L;

2. String Constructor

 // constructors ที่ไม่มีพารามิเตอร์มักจะไร้ประโยชน์เนื่องจากค่าเป็นสตริงสาธารณะที่ไม่เปลี่ยนรูป () {this.value = ใหม่ถ่าน [0];} // พารามิเตอร์คือสตริงประเภทสตริงสาธารณะ this.hash = Original.hash;} // พารามิเตอร์เป็นอาร์เรย์ถ่านใช้คลาสอาร์เรย์ในแพ็คเกจ java.utils เพื่อคัดลอกสตริงสาธารณะ (ค่าถ่าน []) {this.value = array.copyof (ค่าความยาว); ไบต์ [], ออฟเซ็ต int, ความยาว int, สตริง charsetName) พ่น unsupportencodingexception {if (charsetName == null) โยน nullpointerexception ใหม่ ("charsetName"); Checkbounds (ไบต์, ชดเชย, ความยาว); this.value = stringCoding.decode (charsetName, ไบต์, ออฟเซ็ต, ความยาว);} // เรียกสตริงสาธารณะ (ไบต์ไบต์ [], ออฟเซ็ต int, ความยาว int, สตริง charsetName) สตริงสาธารณะ

3. วิธีการทั่วไปของสตริง

1. เท่ากับ

 บูลีนเท่ากับ (วัตถุ anobject) บูลีนสาธารณะเท่ากับ (วัตถุ anobject) {// ถ้าการอ้างอิงเป็นวัตถุเดียวกันให้ส่งคืนจริงถ้า (นี่ == anobject) {return true; } // ถ้าข้อมูลของสตริงประเภทไม่ใช่สตริงให้ส่งคืนเท็จถ้า (anobject instring ของสตริง) {string anothertring = (string) anobject; int n = value.length; // หากความยาวของอาร์เรย์ถ่านไม่เท่ากันให้ส่งคืนเท็จถ้า (n == anothertring.value.length) {char v1 [] = value; ถ่าน v2 [] = anotherstring.value; int i = 0; // ผู้พิพากษาจากตัวละครตัวเดียวกลับไปด้านหน้าหากมีความไม่เท่าเทียมใด ๆ ให้กลับมาเป็นเท็จในขณะที่ (n--! = 0) {ถ้า (v1 [i]! = v2 [i]) ส่งคืนเท็จ; i ++; } // ตัวละครแต่ละตัวเท่ากันส่งคืนกลับจริงจริง; }} return false;}

 สตริง e1 = "ดี"; สตริง e2 = "ดีทุกวัน"; e1.equals (e2); // return false

1 ก่อนอื่นตรวจสอบว่าวัตถุเดียวกันนั้นอ้างอิง == นั่นคือพิจารณาว่าที่อยู่หน่วยความจำของการอ้างอิงทั้งสองนั้นเหมือนกันหรือไม่ ถ้าเหมือนกันมันจะกลับมาจริงโดยตรง

2 จะตรวจสอบว่าประเภทนั้นเหมือนกันหรือไม่และเป็นประเภทข้อมูลเดียวกัน

3 หากใช้ประเภทเดียวกันความยาวของอาร์เรย์อักขระที่แปลงจะเหมือนกัน

4 เปรียบเทียบว่าตัวละครแต่ละตัวจะเหมือนกันจากด้านหลังไปด้านหน้า

คำสั่งการตัดสิน =》 1. ที่อยู่หน่วยความจำ 2. ข้อมูลประเภท 3. ความยาวอาร์เรย์อักขระ 4. การเปรียบเทียบอักขระเดียว

2. เปรียบเทียบ

 int compereto (String anotherstring) public int compereto (String anothertring) {// ความยาวของสตริงของวัตถุของตัวเอง len1 int len1 = value.length; // ความยาวของสตริงของวัตถุเปรียบเทียบ len2 = anotherstring.value.length; // ค่าต่ำสุดของความยาวของสองสาย Lim int lim = math.min (len1, len2); ถ่าน v1 [] = ค่า; ถ่าน v2 [] = anotherstring.value; int k = 0; // จากอักขระแรกของค่าถึง LIM ความยาวต่ำสุดหากอักขระไม่เท่ากันให้ส่งคืนตัวเอง (อักขระที่วัตถุไม่เท่ากัน - อักขระที่เปรียบเทียบ) ในขณะที่ (k <lim) {Char C1 = V1 [K]; ถ่าน C2 = v2 [k]; if (c1! = c2) {return c1 - c2; } k ++; } // ถ้าด้านหน้ามีค่าเท่ากันคืน (ความยาว - ความยาวของวัตถุที่ถูกเปรียบเทียบ) ส่งคืน len1 - len2;}

 String co1 = "hello"; string co2 = "hello"; string co3 = "สวัสดีคุณ"; System.out.println (co1.compareto (CO2)); // 0system.out.println (co1.compareto (CO3)); // -4

วิธีนี้เขียนขึ้นอย่างชาญฉลาดและคุณสามารถตัดสินขนาดของตัวละครตั้งแต่ 0 ก่อน

หากการเปรียบเทียบระหว่างวัตถุทั้งสองสามารถเปรียบเทียบอักขระยังคงเท่ากันความยาวของวัตถุที่ถูกเปรียบเทียบจะถูกส่งคืนโดยตรง หากความยาวของสองสายเท่ากันการกลับมาคือ 0 ซึ่งตัดสินสถานการณ์ทั้งสามอย่างชาญฉลาด

3.HashCode

 int hashCode () public int hashCode () {int h = hash; // หากแฮชไม่ได้รับการคำนวณและสตริงไม่ว่างเปล่าการคำนวณ HashCode จะดำเนินการถ้า (h == 0 && value.length> 0) {char val [] = value; // กระบวนการคำนวณ // s [0]*31^(n-1) + s [1]*31^(n-2) + ... + s [n-1] สำหรับ (int i = 0; i <value.length; i ++) {h = 31*h + val [i]; } // แฮชการมอบหมายแฮช = h; } return h;}

 String a = "toyou"; char val [] = a.tochararray (); char c1 = 't'; char c2 = 'a'; int f = c1; int e = c2; System.out.println (e); // 97 asystem.out.println (f); // 116 tsystem.out.println (31*val [0]); // 3596System.out.println (31*C1); // 3596 // การคำนวณ HashCode เนื่องจากอักขระถ่านสามารถแปลงเป็นรูปแบบ int ที่สอดคล้องกันโดยอัตโนมัติ

คลาสสตริงจะแทนที่วิธีการ HashCode และวิธีการ HashCode ในวัตถุคือการโทรแบบดั้งเดิม

แฮชของคลาสสตริงคำนวณโดยใช้พหุนาม เราสามารถรับแฮชเดียวกันผ่านสตริงที่แตกต่างกันได้อย่างสมบูรณ์ ดังนั้น hashcode ของวัตถุสตริงสองวัตถุจึงเหมือนกันซึ่งไม่ได้หมายความว่าทั้งสองสตริงจะเหมือนกัน

hashcode ของวัตถุสตริงเดียวกันจะต้องเหมือนกัน แต่ hashcode เหมือนกันไม่จำเป็นต้องเป็นวัตถุเดียวกัน

4. Startswith

 บูลีน startswith (คำนำหน้าสตริง, int toffset) public boolean startswith (คำนำหน้าสตริง, int toffset) {char ta [] = ค่า; int ถึง = toffset; ถ่าน PA [] = คำนำหน้าค่า; int po = 0; int pc = prefix.value.length; // หมายเหตุ: toffset อาจอยู่ใกล้ -1 >>> 1 // ถ้าที่อยู่เริ่มต้นน้อยกว่า 0 หรือ (ที่อยู่เริ่มต้น + ความยาวของวัตถุเปรียบเทียบ) มากกว่าความยาวของวัตถุของตัวเองให้ส่งคืนเท็จถ้า ((toffset <0) || (toffset> value.length - PC)) {return false; } // เปรียบเทียบจากส่วนท้ายของวัตถุที่ถูกเปรียบเทียบในขณะที่ (--pc> = 0) {ถ้า (ta [ถึง ++]! = pa [po ++]) {return false; }} return true;} Public Boolean Startswith (คำนำหน้าสตริง) {return startswith (คำนำหน้า, 0);} บูลีนบูลีน Endswith (สตริงต่อท้าย) {return startswith (คำต่อท้าย, value.length - suffix.value.length);}

 String d = "www.58fxp.com"; System.out.println (D.Startswith ("www")); // true system.out.println (D.endswith ("com")); // จริง

การเปรียบเทียบการเริ่มต้นและการสิ้นสุดเป็นวิธีการทั่วไป ตัวอย่างเช่นเมื่อตัดสินว่าสตริงมาจากโปรโตคอล HTTP หรือเริ่มแรกตัดสินว่าไฟล์เป็นไฟล์ MP3 คุณสามารถใช้วิธีนี้เพื่อเปรียบเทียบ

5. คอนเสิร์ต

 สตริง concat (string str) public string concat (string str) {int otterlen = str.length (); // หากสตริงที่เพิ่มขึ้นว่างให้ส่งคืนวัตถุเองถ้า (otherlen == 0) {return this; } int len = value.length; ถ่าน buf [] = arrays.copyof (ค่า, len + otherlen); str.getchars (buf, len); ส่งคืนสตริงใหม่ (buf, true);}

 String cat = "มาก"; สตริง newCat = cat.concat ("ใช่"); // มากใช่

วิธีการ concat ยังเป็นหนึ่งในวิธีการที่ใช้กันทั่วไป ก่อนอื่นกำหนดว่าสตริงที่เพิ่มขึ้นจะว่างเปล่าเพื่อตัดสินใจว่าจะสร้างวัตถุใหม่หรือไม่

1 หากความยาวอักขระ spliced เป็น 0 ให้กลับไปที่วัตถุอักขระดั้งเดิมโดยตรง

2 อักขระ spliced ไม่ว่างเปล่าและส่งคืนวัตถุอักขระใหม่

กำหนดความยาวอักขระเพื่อสร้างวัตถุใหม่

6. แทนที่

 String แทนที่ (Char oldchar, Char Newchar) String Public String (Char oldchar, Char Newchar) {// เปรียบเทียบค่าเก่าและใหม่ก่อนถ้า (oldchar! = newchar) {int len = value.length; int i = -1; ถ่าน [] val = ค่า; / * หลีกเลี่ยง getfield opcode */ // ค้นหาตำแหน่งที่ค่าเก่าปรากฏขึ้นครั้งแรกในขณะที่ (++ i <len) {ถ้า (val [i] == oldchar) {break; }} // จากตำแหน่งนั้นจนกระทั่งสิ้นสุดให้แทนที่ค่าเก่าที่ปรากฏขึ้นด้วยค่าใหม่ถ้า (i <len) {char buf [] = char ใหม่ [len]; สำหรับ (int j = 0; j <i; j ++) {buf [j] = val [j]; } ในขณะที่ (i <len) {char c = val [i]; buf [i] = (c == oldchar)? Newchar: C; i ++; } ส่งคืนสตริงใหม่ (buf, true); }} ส่งคืนสิ่งนี้;}

 String R1 = "คุณทำอย่างไร"; String r2 = r1.replace ("ทำ", "คือ"); system.out.println (r2); // คุณเป็นอย่างไร

วิธีนี้ยังมีความฉลาดบางอย่างเช่นการค้นหาว่าค่าเก่าปรากฏขึ้นที่จุดเริ่มต้นซึ่งจะช่วยประหยัดเวลาการเปรียบเทียบ

วิธีการแทนที่ (String oldstr, String NewsTR) ถูกตัดสินโดยการแสดงออกปกติ

7. การตัดทอน

 String trim () Public String trim () {int len = value.length; int st = 0; ถ่าน [] val = ค่า; / * หลีกเลี่ยง getfield opcode */ // ค้นหาตำแหน่งที่ไม่มีช่องว่างด้านหน้าของสตริงในขณะที่ ((st <len) && (val [st] <= '')) {st ++; } // ค้นหาตำแหน่งที่ไม่มีช่องว่างในตอนท้ายของสตริงในขณะที่ ((st <len) && (val [len-1] <= '')) {len--; } // หากไม่มีช่องว่างด้านหน้าและหลังให้ส่งคืนสตริงตัวเอง ((st> 0) || (len <value.length))? Substring (St, Len): this;}

 สตริง t1 = "โมฆะสาธารณะ"; // หนึ่งช่องว่างด้านหน้าและหลัง system.out.println ("t1:"+t1.length ()); // 13 ที่มีความยาวอวกาศสตริง t2 = t1.trim (); System.out.println ("T2:"+t2.length ()); // 11 ลบ SPACE System.out.println (T2);

8. ตรงข้าม

 String Intern () Public Native String Intern ();

 สตริง dd = สตริงใหม่ ("bb"). intern ();

วิธีการ NTRN คือการโทรแบบดั้งเดิมและฟังก์ชั่นของมันคือการค้นหาวัตถุที่มีค่าเท่ากันผ่านวิธีการเท่ากับในสระคงที่ในพื้นที่วิธีการ

หากไม่พบให้เปิดพื้นที่ในพูลคงที่เพื่อเก็บสตริงและส่งคืนการอ้างอิงไปยังสตริงที่เกี่ยวข้อง มิฉะนั้นจะส่งคืนการอ้างอิงโดยตรงไปยังวัตถุสตริงที่มีอยู่แล้วในพูลคงที่

นอกจากนี้คุณยังสามารถบังคับวัตถุตัวละครที่สร้างขึ้นสำหรับวิธีการใหม่เพื่อดูว่ามีสระคงที่อยู่แล้วหรือไม่

ใส่รหัสที่สองในการแนะนำ

 // สตริง a = สตริงใหม่ ("ab1"); // เปลี่ยนเป็นสตริง a = สตริงใหม่ ("ab1"). intern ();

ผลลัพธ์เป็นจริงเนื่องจากที่อยู่ที่ชี้ไปที่ A มาจากพูลคงที่และค่าคงที่สตริงที่ชี้ไปที่ B จะเรียกวิธีนี้โดยค่าเริ่มต้นดังนั้น A และ B ทั้งสองชี้ไปที่พื้นที่ที่อยู่เดียวกัน

 int hash32 () ส่วนตัวชั่วคราว int hash32 = 0; int hash32 () {int h = hash32; if (0 == h) {// การแข่งขัน Data ที่ไม่เป็นอันตรายบน HASH32 ที่นี่ h = sun.misc.hashing.murmurmur3_32 (hashing_seed, ค่า, 0, value.length); // ตรวจสอบให้แน่ใจว่าผลลัพธ์ไม่ได้เป็นศูนย์เพื่อหลีกเลี่ยงการ recalcing h = (0! = h)? H: 1; hash32 = h; } return h;}

ใน JDK1.7 เมื่อคลาสสตริงถูกใช้เป็นคีย์คลาสคอลเลกชันที่เกี่ยวข้องกับแฮชจะไม่ใช้วิธี HashCode อีกต่อไปเพื่อแยกข้อมูล แต่ใช้วิธี HASH32

วิธีนี้ใช้เวลาปัจจุบันของระบบที่อยู่คลาสสตริงที่อยู่คลาสระบบ ฯลฯ เป็นปัจจัยในการคำนวณเมล็ดแฮช ผ่านเมล็ดแฮชจะได้รับค่า INT 32 บิตผ่านเมล็ดแฮช

 ความยาว int สาธารณะ () {return value.length;} public String toString () {return this;} public boolean isempty () {return value.length == 0;} charat public Charat (INT INDEX) {ถ้า (ดัชนี <0) || (ดัชนี> = value.length)) } ค่าส่งคืน [ดัชนี];}

ข้างต้นเป็นวิธีการทั่วไปที่ง่าย

สรุป

วัตถุสตริงเป็นประเภทที่ไม่เปลี่ยนรูป วิธีการสตริงที่มีสตริงประเภทส่งคืนส่งคืนแต่ละครั้งที่วัตถุสตริงใหม่ถูกส่งคืนยกเว้นเงื่อนไขเฉพาะบางประการของบางวิธีที่จะส่งคืนตัวเอง

สามวิธีในการเปรียบเทียบวัตถุสตริง:

== การเปรียบเทียบหน่วยความจำ: เปรียบเทียบค่าหน่วยความจำโดยตรงที่ชี้ไปที่การอ้างอิงทั้งสองซึ่งมีความแม่นยำกระชับและตรงไปตรงมา

เท่ากับการเปรียบเทียบค่าสตริง: เปรียบเทียบว่าค่าตัวอักษรของวัตถุที่อ้างอิงทั้งสองนั้นเท่ากันหรือไม่

การเปรียบเทียบการทำให้เป็นตัวเลขของสตริง HashCode: การทำให้เป็นตัวเลขของสตริง hashcodes ที่อ้างอิงทั้งสองนั้นเหมือนกันและหน่วยความจำไม่ได้รับประกันว่าจะเหมือนกันและค่าตัวอักษรไม่รับประกันว่าจะเหมือนกัน

แนวคิดการออกแบบของสตริงคงที่พูล

1. ความตั้งใจดั้งเดิมของการออกแบบพูลคงที่สตริง

แต่ละสตริงเป็นวัตถุสตริงและสตริงจะถูกใช้บ่อยในการพัฒนาระบบ หากสร้างและทำลายเหมือนวัตถุอื่น ๆ มันจะส่งผลกระทบอย่างมากต่อประสิทธิภาพของโปรแกรม

เพื่อปรับปรุงประสิทธิภาพและลดค่าใช้จ่ายของหน่วยความจำ JVM ปรับให้เหมาะสมเมื่ออินสแตนซ์สตริง

สระว่ายน้ำคงที่สตริงถูกเปิดสำหรับสตริงคล้ายกับพื้นที่แคช

เมื่อสร้างค่าคงที่สตริงก่อนอื่นให้พิจารณาว่าพูลคงที่สตริงคงที่หรือไม่

สตริงส่งคืนอินสแตนซ์ที่อ้างอิงไม่มีอยู่ยกตัวอย่างสตริงและวางไว้ในพูล

ตระหนักถึงพื้นฐาน

พื้นฐานสำหรับการใช้การเพิ่มประสิทธิภาพนี้คือค่าคงที่สตริงแต่ละค่าเป็นค่าคงที่ที่แก้ไขขั้นสุดท้ายดังนั้นจึงไม่จำเป็นต้องกังวลเกี่ยวกับความขัดแย้งของข้อมูลในกลุ่มคงที่

มีตารางในพูลคงที่สตริงสโตร์ทั่วโลกที่สร้างขึ้นโดยอินสแตนซ์รันไทม์ซึ่งมักจะเก็บข้อมูลอ้างอิงสำหรับวัตถุสตริงที่ไม่ซ้ำกันแต่ละรายการในสระว่ายน้ำซึ่งหมายความว่าพวกเขามักจะอ้างถึงวัตถุในพูลคงที่สตริงดังนั้นสตริงเหล่านี้ในพูลคงที่จะไม่ถูกรวบรวมโดยนักสะสมขยะ

กองสแต็กพื้นที่วิธีการ

ทำความเข้าใจกับพูลคงที่สตริงก่อนอื่นให้ดูที่พื้นที่วิธีการสแต็ก

กอง

สิ่งที่เก็บไว้คือวัตถุแต่ละวัตถุมีคลาสที่สอดคล้องกัน

JVM มีพื้นที่หนึ่งกองเดียวและมีการแชร์โดยกระทู้ทั้งหมด ไม่มีประเภทพื้นฐานและการอ้างอิงวัตถุในกอง แต่มีเพียงวัตถุเท่านั้น

วัตถุถูกรวบรวมโดยตัวเก็บขยะดังนั้นจึงไม่จำเป็นต้องกำหนดขนาดและวงจรชีวิต

กองซ้อน

แต่ละเธรดมีพื้นที่สแต็กซึ่งจัดเก็บวัตถุชนิดข้อมูลพื้นฐานและการอ้างอิงวัตถุที่กำหนดเองเท่านั้น

ข้อมูล (ประเภทดั้งเดิมและการอ้างอิงวัตถุ) ในแต่ละสแต็กเป็นส่วนตัว

สแต็กแบ่งออกเป็นสามส่วน: พื้นที่ตัวแปรประเภทพื้นฐานบริบทสภาพแวดล้อมการดำเนินการและพื้นที่คำสั่งการดำเนินงาน (การจัดเก็บคำแนะนำการดำเนินการ)

ขนาดข้อมูลและวงจรชีวิตมีความแน่นอนและเมื่อไม่มีจุดอ้างอิงไปยังข้อมูลนี้ข้อมูลจะหายไป

พื้นที่วิธีการ

โซนคง

พื้นที่วิธีการมีองค์ประกอบที่ไม่ซ้ำกันในโปรแกรมทั้งหมดเช่นคลาสและตัวแปรคงที่

สตริงคงที่พูล

สตริงคงที่พูลคงที่อยู่ในพื้นที่วิธีการ

รหัส: สแต็กวิธีการจัดเก็บสตริงสตริง

 string str1 = "abc"; string str2 = "abc"; string str3 = "abc"; string str4 = สตริงใหม่ ("abc"); string str5 = สตริงใหม่ ("abc");

คำถามสัมภาษณ์

string str4 = สตริงใหม่ ("abc") มีวัตถุที่สร้างขึ้นกี่ชิ้น?

แยก: str4 =, สตริงใหม่ (), "abc"

คุณสามารถสร้างวัตถุใหม่ด้วยวิธีการใหม่ วิธีการใหม่สร้างวัตถุอินสแตนซ์และจะไม่ไปที่พูลคงที่เพื่อค้นหาว่ามีอยู่แล้วหรือไม่ ตราบใดที่ใหม่วัตถุใหม่จะถูกสร้างอินสแตนซ์

"ABC" แต่ละสตริงเป็นวัตถุสตริง หากไม่มีในสระว่ายน้ำคงที่วัตถุใหม่จะถูกสร้างและใส่ลงในสระคงที่ มิฉะนั้นการอ้างอิงวัตถุจะถูกส่งคืน

กำหนดที่อยู่วัตถุให้กับ STR4 และสร้างการอ้างอิง

ดังนั้นหากไม่มีตัวอักษร "ABC" ในสระคงที่ให้สร้างวัตถุสองชิ้นมิฉะนั้นสร้างวัตถุหนึ่งชิ้นและสร้างการอ้างอิง

string str1 = สตริงใหม่ ("a"+"b"); จะสร้างวัตถุกี่ชิ้น? string str2 = สตริงใหม่ ("abc") + "abc"; จะสร้างวัตถุกี่ชิ้น?

การวิเคราะห์ที่ครอบคลุมด้านบนของซอร์สโค้ดสตริง Java และพูลคงที่สตริงเป็นเนื้อหาทั้งหมดที่ฉันแบ่งปันกับคุณ ฉันหวังว่าคุณจะให้ข้อมูลอ้างอิงและฉันหวังว่าคุณจะสนับสนุน wulin.com มากขึ้น