Những chữ đã in#
Hãy nghĩ đến một thẻ tên làm bằng máy in nhãn. Khi các chữ đã được in, bạn không thể xóa đi một chữ rồi sửa. Nếu muốn tên khác, bạn in một nhãn mới, và nhãn cũ vẫn y như trước.
Một String trong Java chính là nhãn đó. Khi một String đã tồn tại, các ký tự của nó không bao giờ thay đổi. Từ chỉ điều này là bất biến (immutable), nghĩa là “không thể thay đổi”. Mọi phương thức String có vẻ làm thay đổi văn bản thật ra in cho bạn một nhãn mới và đưa nó lại. Nếu bạn không nhận lấy, thì chẳng có gì xảy ra.
String là một lớp, không phải kiểu nguyên thủy, đó là lý do tên nó bắt đầu bằng chữ hoa và nó có các phương thức. Một biến String giữ một tham chiếu (reference): một mũi tên trỏ đến đối tượng String, chứ không phải chính văn bản. Một sự thật đó giải thích cái bẫy == ở phần sau.
Vị trí bắt đầu từ không#
Mỗi ký tự có một vị trí, gọi là chỉ số (index) của nó, và chỉ số đầu tiên là 0.
| chỉ số | 0 | 1 | 2 | 3 | 4 | 5 |
|---|---|---|---|---|---|---|
| char | S | a | t | u | r | n |
public class Index {
public static void main(String[] args) {
String planet = "Saturn";
System.out.println(planet.length());
System.out.println(planet.charAt(0));
System.out.println(planet.charAt(2));
System.out.println(planet.charAt(planet.length() - 1));
}
}
6
S
t
n
“Saturn” có độ dài 6, nên các chỉ số của nó chạy từ 0 đến 5. Ký tự cuối cùng luôn ở length() - 1. Yêu cầu charAt(6) vượt quá phần cuối, và chương trình dừng với một StringIndexOutOfBoundsException khi đang chạy. Trình biên dịch không thể bắt được, vì nó không biết String sẽ dài bao nhiêu.
charAt trả về một char, một ký tự đơn trong dấu nháy đơn như 'S', không phải một String một chữ cái.
substring dừng sớm một ký tự#
substring cắt ra một đoạn và trả về nó dưới dạng một String mới. Nó có hai dạng:
| Lời gọi | Cho bạn |
|---|---|
s.substring(begin) | từ begin đến hết |
s.substring(begin, end) | từ begin đến, nhưng không bao gồm, end |
public class Slice {
public static void main(String[] args) {
String file = "report_final.pdf";
System.out.println(file.substring(7));
System.out.println(file.substring(0, 6));
System.out.println(file.substring(7, 12));
System.out.println("[" + file.substring(3, 3) + "]");
}
}
final.pdf
report
final
[]
Chỉ số kết thúc không bao giờ được tính. Cách kiểm tra nhanh là độ dài của đoạn bằng end - begin: substring(7, 12) dài 5 ký tự. Khi begin và end bằng nhau, đoạn có độ dài 0, là String rỗng (empty String), "". Điều đó hoàn toàn hợp lệ.
Tìm văn bản: indexOf và lastIndexOf#
indexOf tìm một ký tự hoặc một đoạn văn bản và cho bạn biết chỉ số nơi kết quả khớp đầu tiên bắt đầu. lastIndexOf làm tương tự từ đầu bên kia. Nếu không có kết quả khớp, cả hai đều trả về -1, không bao giờ là một vị trí thật.
public class Find {
public static void main(String[] args) {
String path = "home/docs/notes/docs.txt";
System.out.println(path.indexOf("docs"));
System.out.println(path.lastIndexOf("docs"));
System.out.println(path.indexOf('/'));
System.out.println(path.indexOf('/', 5));
System.out.println(path.indexOf("music"));
int dot = path.lastIndexOf('.');
System.out.println(path.substring(dot + 1));
}
}
5
16
4
9
-1
txt
“docs” xuất hiện hai lần: lần đầu ở chỉ số 5, lần cuối ở chỉ số 16. indexOf('/', 5) bắt đầu tìm từ chỉ số 5, nên nó bỏ qua dấu gạch chéo đầu tiên và tìm thấy dấu kế tiếp ở 9. Và hai dòng cuối cho thấy cặp đôi thường gặp: tìm một vị trí bằng indexOf, rồi cắt bằng substring. Ở đây nó lấy ra phần mở rộng của tệp.
Các phương thức trả lại một String mới#
Đây là lỗi trông như Java phớt lờ bạn:
public class Stuck {
public static void main(String[] args) {
String city = "savannah";
city.toUpperCase();
city.replace('a', 'o');
System.out.println(city);
city = city.toUpperCase();
System.out.println(city);
String tidy = " Columbus ".trim();
System.out.println("[" + tidy + "] " + tidy.length());
}
}
savannah
SAVANNAH
[Columbus] 8
println đầu tiên vẫn hiện savannah. toUpperCase() và replace() mỗi cái tạo ra một String hoàn toàn mới và trả lại, và đoạn mã này đã bỏ rơi cả hai. city vẫn trỏ đến bản gốc.
Cách sửa là hứng lấy String mới: city = city.toUpperCase();. Biến giờ trỏ đến nhãn mới. trim() hoạt động tương tự, trả về một bản sao đã bỏ dấu cách ở hai đầu.
| Phương thức | Trả về |
|---|---|
toUpperCase(), toLowerCase() | một String mới với kiểu chữ đã đổi |
trim() | một String mới không có dấu cách ở đầu và cuối |
replace(old, new) | một String mới với mọi kết quả khớp được thay thế |
concat(other) | một String mới với other được nối vào cuối, giống + |
Nối văn bản bằng +#
+ có hai nghĩa khác nhau. Giữa hai số, nó cộng. Hễ có một String tham gia, nó nối. Java làm việc từ trái sang phải, nên vị trí String xuất hiện thay đổi tất cả:
public class Join {
public static void main(String[] args) {
System.out.println("Total: " + 3 + 4);
System.out.println("Total: " + (3 + 4));
System.out.println(3 + 4 + " total");
System.out.println('a' + 'b' + "!");
System.out.println("" + 'a' + 'b' + "!");
}
}
Total: 34
Total: 7
7 total
195!
ab!
"Total: " + 3 + 4nối 3, rồi nối 4:Total: 34.- Dấu ngoặc làm phép cộng xảy ra trước:
Total: 7. 3 + 4 + " total"cộng trước khi có String nào xuất hiện:7 total.'a' + 'b'là hai char, và char về bản chất là số (97 và 98), nên chúng được cộng:195!. Bắt đầu bằng""khiến nó là văn bản từ bước đầu tiên.
equals so với ==#
Đây là quy tắc, rồi đến lý do. Để so sánh văn bản của hai String, hãy dùng equals. Đừng bao giờ dùng ==.
public class Same {
public static void main(String[] args) {
String a = "Java";
String b = "Javascript".substring(0, 4);
System.out.println(a + " and " + b);
System.out.println(a == b);
System.out.println(a.equals(b));
System.out.println("java".equals(a));
System.out.println("java".equalsIgnoreCase(a));
}
}
Java and Java
false
true
false
true
Cả hai biến đều in ra Java, nhưng a == b là false. Đó là vì == so sánh các tham chiếu: nó hỏi “hai mũi tên này có trỏ đến cùng một đối tượng không?”. substring tạo ra một đối tượng hoàn toàn mới lúc chạy, nên có hai đối tượng riêng biệt tình cờ chứa cùng các chữ cái. equals so sánh từng ký tự một, là điều bạn muốn nói.
Giống như hai bản của cùng một cuốn sách. Cùng chữ, nhưng khác sách. equals hỏi về chữ; == hỏi liệu đó có phải cùng một cuốn sách vật lý hay không.
Điều này gây rắc rối nhất với dữ liệu nhập. Văn bản người dùng gõ vào một Scanner luôn là một đối tượng mới, nên if (answer == "yes") là false ngay cả khi họ đã gõ yes. equals cũng phân biệt chữ hoa chữ thường; equalsIgnoreCase là phiên bản không phân biệt. Viết literal trước, "yes".equals(answer), có thêm một lợi ích: nó không thể bị lỗi ngay cả khi answer là null.
compareTo: cái nào đứng trước#
equals trả lời “giống hay không?”. compareTo trả lời “cái nào đứng trước?”, và nó trả về một số chứ không phải boolean. Hãy đọc a.compareTo(b) như “a trừ b”:
| Kết quả | Ý nghĩa |
|---|---|
| âm | a đứng trước b |
| không | chúng bằng nhau |
| dương | a đứng sau b |
public class Order {
public static void main(String[] args) {
System.out.println("apple".compareTo("banana"));
System.out.println("banana".compareTo("apple"));
System.out.println("pear".compareTo("pear"));
System.out.println("car".compareTo("cart"));
System.out.println("Zebra".compareTo("apple"));
String first = "Omar", second = "Aisha";
if (first.compareTo(second) < 0) {
System.out.println(first + " comes first");
} else {
System.out.println(second + " comes first");
}
}
}
-1
1
0
-1
-7
Aisha comes first
Các con số chính xác là hiệu giữa các ký tự, nhưng chỉ dấu mới quan trọng, nên hãy luôn kiểm tra bằng < 0, == 0 hoặc > 0. Hai chi tiết thường được ra thi:
- Khi một String là phần đầu của String kia, như
carvàcart, String ngắn hơn đứng trước. - Mọi chữ hoa đứng trước mọi chữ thường, do các con số đằng sau ký tự:
'Z'là 90 và'a'là 97. Vì vậy"Zebra"được sắp trước"apple". Hãy dùngcompareToIgnoreCasenếu đó không phải điều bạn muốn.
Java sẽ không cho bạn viết first < second với String. compareTo là cách duy nhất để sắp xếp chúng.
StringBuilder: String bạn có thể chỉnh sửa#
Nếu một String là một nhãn đã in, thì một StringBuilder là một tấm bảng trắng. Bạn có thể thêm vào, chèn vào, xóa bớt và đảo ngược nó, và nó vẫn là cùng tấm bảng đó. Nó khả biến (mutable), trái nghĩa với bất biến.
public class Builder {
public static void main(String[] args) {
StringBuilder sb = new StringBuilder("tea");
sb.append("pot");
System.out.println(sb);
sb.insert(0, "big ");
System.out.println(sb);
sb.reverse();
System.out.println(sb);
sb.reverse().setCharAt(0, 'B');
System.out.println(sb + " (" + sb.length() + " chars)");
String done = sb.toString();
System.out.println(done.toUpperCase());
}
}
teapot
big teapot
topaet gib
Big teapot (10 chars)
BIG TEAPOT
Không lệnh gọi nào trong số đó cần sb = ... ở phía trước, vì mỗi lệnh thay đổi chính sb. Mỗi phương thức cũng trả về chính builder đó, điều cho phép nối chuỗi các lệnh gọi, như trong sb.reverse().setCharAt(0, 'B').
Một StringBuilder không phải là một String. Khi bạn cần một String, cho equals hoặc một phương thức String hoặc một biến kiểu String, hãy gọi toString(). Bỏ qua nó và trình biên dịch sẽ báo:
public class Mixup {
public static void main(String[] args) {
String s = new StringBuilder("ab");
}
}
Mixup.java:3: error: incompatible types: StringBuilder cannot be converted to String
String s = new StringBuilder("ab");
^
1 error
String | StringBuilder | StringBuffer | |
|---|---|---|---|
| có thể thay đổi | không | có | có |
| an toàn cho nhiều luồng cùng lúc | có | không | có (được đồng bộ hóa) |
| tốc độ khi thay đổi | chậm: mỗi lần một đối tượng mới | nhanh nhất | chậm hơn một chút |
StringBuffer có cùng các phương thức với StringBuilder. Nó thêm khóa để nhiều luồng có thể dùng chung một cái một cách an toàn, và phải trả một cái giá nhỏ cho điều đó. Trong các chương trình đơn luồng thông thường, tức mọi chương trình trong khóa học này, hãy dùng StringBuilder.
Xây dựng văn bản trong vòng lặp#
Nơi StringBuilder thực sự phát huy giá trị là một vòng lặp xây dựng dần văn bản:
public class Loop {
public static void main(String[] args) {
StringBuilder row = new StringBuilder();
for (int i = 1; i <= 5; i++) {
row.append(i);
if (i < 5) {
row.append(", ");
}
}
System.out.println(row);
}
}
1, 2, 3, 4, 5
Với String thường, mỗi += sẽ sao chép toàn bộ văn bản cho đến lúc đó vào một đối tượng hoàn toàn mới, và một nghìn lần lặp sẽ tạo ra một nghìn String bỏ đi. StringBuilder cứ thêm vào một đối tượng. Hãy xây dựng bằng một StringBuilder, rồi gọi toString() một lần ở cuối nếu bạn cần một String.
Mọi phương thức String đều trả lại cho bạn một String mới, và nếu bạn không hứng lấy nó, thì chẳng có gì xảy ra. Hãy so sánh văn bản bằng equals, sắp xếp bằng compareTo, nhớ rằng chỉ số kết thúc của substring không bao giờ được tính, và dùng StringBuilder khi văn bản cần thay đổi.
Những chỗ dễ sai#
- Gọi
s.toUpperCase();trên một dòng riêng. Kết quả bị vứt đi. Hãy viếts = s.toUpperCase();. - So sánh String bằng
==. Nó so sánh đối tượng, không phải văn bản. Hãy dùngequals. - Mong
substring(a, b)bao gồm chỉ sốb. Nó dừng sớm một ký tự. - Dùng
charAt(s.length()). Chỉ số cuối làlength() - 1. - Đọc kết quả của
compareTonhư true hay false. Nó là một int. Hãy kiểm tra dấu của nó. - Quên rằng chữ hoa được sắp trước.
"Zebra"đứng trước"apple". - Coi một StringBuilder như một String. Hãy gọi
toString(). - So sánh hai StringBuilder bằng
equals. StringBuilder không so sánh nội dung theo cách đó; hãy so sánh kết quảtoString()của chúng. "Total: " + a + bnối các chữ số. Hãy đặt tổng trong ngoặc.
Tự kiểm tra trong ứng dụng Kestrel Exams miễn phí
Luyện tập theo chủ đề: dùng được khi không có mạng, không quảng cáo, không cần tài khoản.
Luyện tập String →Câu hỏi thường gặp#
Vì sao == không dùng được để so sánh String trong Java?
Vì == so sánh các tham chiếu: nó kiểm tra xem hai biến có trỏ đến cùng một đối tượng hay không. Hai đối tượng String riêng biệt có thể chứa văn bản giống hệt nhau, ví dụ một cái đọc từ Scanner và một cái viết trong mã, và == coi chúng là khác nhau. equals so sánh chính các ký tự, là điều bạn hầu như luôn muốn.
substring có tính chỉ số kết thúc không?
Không. s.substring(begin, end) tính ký tự tại begin và dừng ngay trước end, nên kết quả có end - begin ký tự. s.substring(begin) với một đối số chạy từ begin đến hết String.
Vì sao toUpperCase không thay đổi String của tôi?
String là bất biến: không phương thức nào có thể thay đổi một String. toUpperCase tạo và trả về một String mới. Nếu bạn gọi nó mà không lưu kết quả, như trong city.toUpperCase();, String mới bị vứt đi. Hãy viết city = city.toUpperCase(); để giữ nó.
compareTo trả về gì trong Java?
Một int. Nó âm nếu String gọi đứng trước đối số, bằng không nếu chúng bằng nhau, và dương nếu nó đứng sau. Hãy kiểm tra dấu, không phải giá trị chính xác. Chữ hoa được sắp trước mọi chữ thường, và khi một String là phần đầu của String kia, String ngắn hơn đứng trước.
Khác biệt giữa String và StringBuilder là gì?
Một String không bao giờ có thể thay đổi; mọi phương thức đều trả về một String mới. Một StringBuilder có thể được thay đổi tại chỗ bằng append, insert, reverse và các phương thức tương tự, giúp nó nhanh hơn nhiều khi xây dựng văn bản trong vòng lặp. Gọi toString() để lấy một String từ nó.
Khác biệt giữa StringBuilder và StringBuffer là gì?
Chúng có cùng các phương thức. StringBuffer được đồng bộ hóa (synchronized), nghĩa là an toàn để nhiều luồng (thread) cùng dùng, và vì vậy nó chậm hơn một chút. StringBuilder không được đồng bộ hóa và là lựa chọn thông thường trong mã đơn luồng.
indexOf trả về gì nếu không tìm thấy văn bản?
-1. Mọi chỉ số thật đều từ 0 trở lên, nên -1 chỉ có thể có nghĩa là 'không tìm thấy'. lastIndexOf cũng trả về -1 khi không có kết quả khớp.
Có chỗ nào chưa rõ? Có chủ đề nào bạn muốn chúng tôi viết? Hãy cho chúng tôi biết. Chúng tôi đọc mọi tin nhắn, và một lời đề nghị là cách nhanh nhất để có bài hướng dẫn mới: một số bài ở đây ra đời vì có người hỏi.