Chuỗi nhóm trong Java là gì?

Question

Tôi đang nhầm lẫn về StringPool trong Java. Tôi đã xem qua điều này trong khi đọc chương String trong Java. Xin hãy giúp tôi hiểu, trong điều khoản của giáo dân, những gì StringPool thực sự làm.

Answer 1

này in true (mặc dù chúng ta không sử dụng phương pháp equals: cách chính xác để so sánh chuỗi)

String s = "a" + "bc"; 
    String t = "ab" + "c"; 
    System.out.println(s == t); 

Khi trình biên dịch tối ưu hóa chuỗi literals của bạn, nó thấy rằng cả hai s và t có cùng giá trị và do đó bạn chỉ cần một đối tượng chuỗi. Nó an toàn vì String là bất biến trong Java.
Kết quả là cả hai số s và t trỏ đến cùng một đối tượng và một số bộ nhớ nhỏ được lưu.

Tên 'chuỗi nhóm' xuất phát từ ý tưởng rằng tất cả chuỗi đã xác định được lưu trữ trong một số 'nhóm' và trước khi tạo trình biên dịch đối tượng String mới kiểm tra xem chuỗi đó đã được xác định chưa.

Answer 2

Tôi không nghĩ nó thực sự làm được gì nhiều, có vẻ như nó chỉ là một bộ nhớ đệm cho các chuỗi ký tự. Nếu bạn có nhiều chuỗi giá trị giống nhau, tất cả chúng sẽ trỏ đến cùng một chuỗi ký tự trong nhóm chuỗi.

String s1 = "Arul"; //case 1 
String s2 = "Arul"; //case 2 

Trong trường hợp 1, chữ S1 được tạo mới và được giữ trong hồ bơi. Nhưng trong trường hợp 2, s2 theo nghĩa đen tham chiếu s1, nó sẽ không tạo ra s1 mới.

if(s1 == s2) System.out.println("equal"); //Prints equal. 

String n1 = new String("Arul"); 
String n2 = new String("Arul"); 
if(n1 == n2) System.out.println("equal"); //No output. 

http://p2p.wrox.com/java-espanol/29312-string-pooling.html

Answer 3

Khi tải lớp JVM, hoặc nếu không thấy một chuỗi chữ, hoặc một số chuỗi sa đang intern, nó bổ sung thêm chuỗi vào một bảng tra cứu chủ yếu-ẩn mà có một bản sao của mỗi ví dụ chuỗi. Nếu một bản sao khác được thêm vào, thời gian chạy sẽ sắp xếp nó sao cho tất cả các chữ cái tham chiếu đến cùng một đối tượng chuỗi. Điều này được gọi là "interning". Nếu bạn nói điều gì đó giống như

String s = "test"; 
return (s == "test"); 

nó sẽ trả lại true, vì thử nghiệm đầu tiên và thứ hai thực sự là cùng một đối tượng. So sánh chuỗi nội bộ theo cách này có thể nhiều, nhiều hơn nhanh hơn String.equals, vì có một so sánh tham chiếu đơn lẻ thay vì một loạt các so sánh char.

Bạn có thể thêm chuỗi vào hồ bơi bằng cách gọi String.intern(), sẽ cung cấp cho bạn phiên bản chuỗi được gộp chung (có thể là cùng chuỗi mà bạn đang thực tập, nhưng bạn sẽ điên khùng dựa vào đó - - bạn thường không thể chắc chắn chính xác mã nào đã được tải và chạy lên đến bây giờ và thực hiện cùng một chuỗi). Phiên bản gộp (chuỗi được trả về từ intern) sẽ bằng bất kỳ chữ nào giống hệt nhau. Ví dụ:

String s1 = "test"; 
String s2 = new String("test"); // "new String" guarantees a different object 

System.out.println(s1 == s2); // should print "false" 

s2 = s2.intern(); 
System.out.println(s1 == s2); // should print "true" 

Answer 4

Hãy bắt đầu với một trích dẫn từ các máy đặc tả ảo:

tải của một lớp hoặc giao diện có chứa một chuỗi đen có thể tạo ra một đối tượng String mới (§2.4.8) đại diện cho chữ đó. Điều này có thể không xảy ra nếu một đối tượng String đã được tạo ra để đại diện cho một lần xuất hiện trước đó của chữ đó, hoặc nếu phương thức String.intern đã được gọi trên một đối tượng String biểu diễn cùng một chuỗi như chữ.

Điều này có thể không xảy ra - Đây là gợi ý, có điều gì đó đặc biệt về các đối tượng String. Thông thường, gọi một hàm tạo sẽ luôn tạo một phiên bản mới của lớp. Đây không phải là trường hợp với Strings, đặc biệt là khi các đối tượng String được 'tạo ra' với các chữ. Các String này được lưu trữ trong một kho lưu trữ toàn cục (pool) - hoặc ít nhất các tham chiếu được lưu giữ trong một pool, và bất cứ khi nào một thể hiện mới của một Strings đã biết là cần thiết, vm trả về một tham chiếu đến đối tượng từ nhóm. Trong mã giả, nó có thể đi như thế:

1: a := "one" 
    --> if(pool[hash("one")] == null) // true 
      pool[hash("one") --> "one"] 
     return pool[hash("one")] 

2: b := "one" 
    --> if(pool[hash("one")] == null) // false, "one" already in pool 
     pool[hash("one") --> "one"] 
     return pool[hash("one")] 

Vì vậy, trong trường hợp này, các biến a và b tài liệu tham khảo để giữ cùng đối tượng. Trong trường hợp này, chúng tôi có (a == b) && (a.equals(b)) == true.

Đây không phải là trường hợp nếu chúng tôi sử dụng các nhà xây dựng:

1: a := "one" 
2: b := new String("one") 

Một lần nữa, "one" được tạo ra trên hồ nhưng sau đó chúng ta tạo một đối tượng mới so với cùng theo nghĩa đen, và trong trường hợp này, nó dẫn đến (a == b) && (a.equals(b)) == false

Vì vậy, lý do tại sao chúng tôi có hồ bơi Chuỗi không? Các chuỗi và đặc biệt là các chuỗi ký tự String được sử dụng rộng rãi trong mã Java điển hình. Và họ là bất biến. Và không thay đổi được phép cache String để tiết kiệm bộ nhớ và tăng hiệu suất (ít nỗ lực để tạo ra, ít rác hơn để được thu thập).

Khi lập trình, chúng tôi không cần phải quan tâm nhiều về hồ String, miễn là chúng ta cần lưu ý:

• (a == b) && (a.equals(b)) có thể true hoặc false (luôn sử dụng equals để so sánh Strings)
• Không sử dụng sự phản chiếu để thay đổi sự ủng hộ char[] của một chuỗi (vì bạn không biết ai đang sử dụng chuỗi đó)