Rajah 1
Seret untuk memutar · shift-seret untuk menganjak · klik untuk membongkar
Tatal untuk bertukar halaman
Computer Science A · AP Computer Science A
nilai, rujukan dan kaedah yang menggunakannya
Pemboleh ubah ialah kotak bernama dalam memori. Pemboleh ubah primitif menyimpan nilainya; pemboleh ubah rujukan menyimpan lokasi sebuah objek.
int score = 42; int copy = score; // salinan mendapat 42 sendiri copy = 7; // score masih 42 String name = "Ada"; // satu rujukan String other = name; // rujukan yang sama
Rajah menjalankan baris-baris ini. copy = score menyalin nilai 42 ke dalam kotak kedua, jadi apabila copy menjadi 7, score tidak terjejas. name tidak menyimpan sebarang aksara: kotaknya menyimpan anak panah (merah) ke objek String yang dicipta di tempat lain dalam memori. other = name menyalin anak panah itu, bukan objeknya: dua anak panah, satu objek.
Perbezaan itu terdapat dalam seluruh Java, dan dalam bab ini: apa yang disimpan oleh pemboleh ubah, apa yang diberikan kepada kaedah dan dipulangkan olehnya, apa yang dicipta oleh new, dan mengapa sebuah String tidak pernah berubah setelah wujud.
Bab ini ialah Unit 1 AP Computer Science A, Menggunakan Objek dan Kaedah, 15–25% daripada skor aneka pilihan: pengkompilan dan ralat (1.1), jenis, ungkapan dan penugasan (1.2–1.6), pustaka, dokumentasi dan kaedah (1.7–1.11), objek dan penciptaannya (1.12–1.14) serta String (1.15). Kesemua 42 soalan aneka pilihan dalam peperiksaan disertakan dengan Java Quick Reference, yang menyenaraikan setiap kaedah pustaka yang boleh digunakan; soalan respons bebas pertamanya memanggil kaedah String.
dan tiga jenis ralat
Algoritma ialah proses langkah demi langkah untuk melengkapkan tugasan atau menyelesaikan masalah. Ia boleh ditulis dengan kata-kata, dilukis sebagai gambar rajah, atau ditulis sebagai aturcara.
Penjujukan meletakkan langkah-langkah dalam tertib, dan langkah itu dijalankan satu demi satu: kaedah Java menjalankan pernyataannya dari atas ke bawah kecuali ada sesuatu yang mengubah aliran.
Kod boleh ditulis dalam mana-mana penyunting teks, tetapi kebanyakan pengaturcara menggunakan persekitaran pembangunan bersepadu (IDE), yang mempunyai alat untuk menulis, mengkompil dan menjalankannya. Pengkompil menyemak sumber untuk mencari sesetengah ralat dan menterjemahkannya; pengkompil Java menghasilkan bytecode, yang dijalankan oleh Java Virtual Machine (JVM). Ralat yang ditemui oleh pengkompil mesti dibetulkan sebelum aturcara boleh dijalankan sama sekali.
Rajah menghantar tiga aturcara menyusuri garisan itu, masing-masing dengan satu jenis ralat.
int total = 7 + 3 // ; tertinggal System.out.println(total); Ralat sintaks melanggar peraturan bahasa. Pengkompil menemuinya (error: ';' expected) dan tiada apa yang dijalankan.
int count = 0; System.out.println(10 / count);
Ralat masa larian berlaku semasa aturcara dijalankan, dan lazimnya menamatkannya secara tidak normal. Yang ini ialah pengecualian: ralat yang tidak dikesan oleh pengkompil, yang mengganggu aliran pelaksanaan biasa (ArithmeticException: / by zero).
double avg = (7 + 8) / 2; System.out.println(avg); // prints 7.0 Ralat logik berkompil dan berjalan, tetapi berkelakuan secara salah: purata 7 and 8 sepatutnya 7.5. Hanya pengujian dengan data tertentu, dan membandingkannya dengan hasil yang dijangka, dapat menemuinya. (Sebab ia mencetak 7.0: halaman 1.3.)
int, double, boolean, dan rujukan
Jenis data ialah satu set nilai dan operasi ke atasnya. Setiap jenis sama ada primitif atau jenis rujukan.
Kursus ini menggunakan tiga jenis primitif, untuk nombor dan nilai Boolean:
| type | values | examples |
|---|---|---|
int | integers | 7, -40, 0 |
double | nombor nyata | 2.5, 7.0, -0.01 |
boolean | true atau false | true |
Java mempunyai lima jenis primitif lain (long, short, byte, float, char); jenis itu berada di luar kursus dan peperiksaan. Apa-apa yang bukan primitif, seperti String, ialah objek, dan jenisnya ialah jenis rujukan.
Pemboleh ubah ialah lokasi storan yang menyimpan nilai, yang boleh berubah semasa aturcara dijalankan. Setiap pemboleh ubah mempunyai nama dan jenis, dan pemboleh ubah berjenis primitif menyimpan nilai berjenis itu.
int n = 7; double d = 2.5; boolean ok = true; double w = 7; // stores 7.0 int m = 2.5; // tidak dapat dikompil
Int muat dalam double: double w = 7; menyimpan 7.0. Double tidak muat dalam int, jadi int m = 2.5; ialah ralat kompil: incompatible types: possible lossy conversion from double to int.
Pilih jenis berdasarkan nilai yang mungkin: bilangan murid ialah int, harga atau purata ialah double, sama ada lampu menyala ialah boolean.
print, println dan jujukan escape
System.out.print dan System.out.println memaparkan maklumat pada skrin. println kemudian menggerakkan kursor ke baris baharu; print membiarkannya di tempat asal.
Literal ialah perwakilan kod bagi nilai tetap: 7, 2.5, true. Literal rentetan ialah jujukan aksara dalam tanda petik berganda: "CSA".
Sesetengah aksara tidak boleh ditaip terus di dalam tanda petik. Jujukan escape bermula dengan garis condong terbalik dan mempunyai makna khas. Kursus ini menggunakan tiga:
| jujukan escape | means |
|---|---|
\" | tanda petik berganda |
\\ | garis condong terbalik |
\n | baris baharu |
System.out.print("AP "); System.out.println("CSA"); System.out.println("say \"hi\""); System.out.print("a\\b\nc"); Konsol kemudian menunjukkan (rajah menaipnya):
AP CSA say "hi" a\b c print pertama membiarkan kursor selepas AP , jadi CSA berada pada baris yang sama. Pada baris terakhir, \\ mencetak satu garis condong terbalik dan \n memulakan baris baharu di tengah-tengah rentetan.
pembahagian int, baki dan keutamaan
Ungkapan aritmetik menggabungkan nilai berangka, pemboleh ubah dan operator +, -, *, / dan %. Dua nilai int menghasilkan int; sekurang-kurangnya satu double menghasilkan double.
System.out.println(17 / 5); // 3 System.out.println(17 % 5); // 2 System.out.println(17.0 / 5); // 3.4
Membahagi dua int hanya mengekalkan bahagian integer hasil bahagi: 17 blok membentuk 3 kumpulan penuh sebanyak 5. Operator baki % memberikan apa yang tinggal: 2. Dengan double dalam pembahagian itu, hasilnya ialah hasil bahagi itu sendiri, 3.4. (Kursus ini menggunakan % hanya dengan a ≥ 0 dan b > 0.)
Keutamaan: *, / dan % dikenakan sebelum + dan -; operator yang keutamaannya sama bergerak dari kiri ke kanan; tanda kurung mengubah pengelompokan. Pengkompil mengelompokkan nilai dengan operatornya mengikut cara ini semasa kompil.
| expression | value |
|---|---|
2 + 3 * 4 | 14 |
(2 + 3) * 4 | 20 |
10 - 4 - 3 | 3 |
7 + 9 % 4 | 8 |
1 / 2 * 4.0 | 0.0 |
1.0 / 2 * 4 | 2.0 |
Dalam 1 / 2 * 4.0, 1 / 2 ialah pembahagian int dan sudah menjadi 0 sebelum double muncul.
Membahagi int dengan int sifar melontarkan ArithmeticException apabila baris itu dijalankan. (Pembahagian dengan sifar menggunakan double, dan nilai double khas yang terhasil, berada di luar kursus.)
bahagian kanan, disimpan di kiri
Operator penugasan = menilai ungkapan di sebelah kanannya kepada satu nilai dan menyimpannya dalam pemboleh ubah di sebelah kirinya.
Pemboleh ubah mesti diberi nilai sebelum digunakan dalam ungkapan, dan nilai itu mestilah berjenis serasi. Penugasan pertama memulakannya. Setiap penugasan seterusnya menggantikan nilai itu: nilai lama hilang.
int a = 3; // a 3 int b = 8; // a 3, b 8 int temp = a; // a 3, b 8, temp 3 a = b; // a 8, b 8, temp 3 b = temp; // a 8, b 3, temp 3
Itulah sebabnya menukar dua pemboleh ubah memerlukan yang ketiga. Tanpa temp, a = b akan memusnahkan 3 milik a sebelum b sempat mendapatkannya. Rajah menggerakkan setiap salinan dari kotak ke kotak: sumbernya mengekalkan nilainya.
Apabila aturcara dijalankan, ungkapan dinilai kepada satu nilai, dan nilai itu mempunyai jenis: a + b ialah int, a + 0.5 ialah double. Pernyataan seperti count = count + 1 bukan persamaan; ia membaca count, menambah 1, dan menyimpan hasilnya semula.
Pemboleh ubah rujukan boleh diberi objek baharu atau null. Literal null bermaksud rujukan itu tidak dikaitkan dengan sebarang objek.
Penugasan di dalam ungkapan, seperti a = b = 4;, berada di luar kursus.
Input boleh berbentuk sentuhan, audio, visual atau teks. Kelas Scanner ialah satu cara membaca teks yang ditaip pada papan kekunci; peperiksaan tidak menguji sebarang bentuk input pengguna yang khusus.
pemangkasan, pelebaran dan pembundaran
Operator penukaran jenis (int) dan (double) menukar nilai daripada satu jenis primitif kepada yang lain.
Menukar double kepada int akan memangkas: digit selepas titik perpuluhan dibuang, jadi nilai bergerak ke arah sifar, apa pun tandanya.
| expression | value |
|---|---|
(int) 3.99 | 3 |
(int) -3.99 | -3 |
7 / 2 | 3 |
(double) 7 / 2 | 3.5 |
(double) (7 / 2) | 3.0 |
7 / 2.0 | 3.5 |
1 + 2.5 | 3.5 |
Penukaran dikenakan pada nilai yang terus mengikutinya. (double) 7 / 2 menukar 7, kemudian membahagi sebagai double; (double) (7 / 2) melakukan pembahagian int dahulu dan menukar hasilnya, 3.0.
Sesetengah kod melebarkan int kepada double secara automatik: dalam 1 + 2.5, dan apabila int disimpan dalam pemboleh ubah double (halaman 1.2).
Untuk membundarkan double kepada integer terdekat, anjakkan setengah unit menjauhi sifar kemudian pangkas: (int) (x + 0.5) bagi x bukan negatif, (int) (x - 0.5) bagi x negatif.
| x | (int) x | rounded |
|---|---|---|
2.7 | 2 | 3 |
-2.7 | -2 | -3 |
3.2 | 3 | 3 |
-1.4 | -1 | -1 |
Rajah menukar setiap satu daripada ini: merah memangkas ke arah sifar; biru beranjak setengah, kemudian memangkas.
limpahan integer dan ralat pembundaran
int disimpan dalam jumlah memori yang tetap, 4 bait, jadi ia mempunyai julat: dari Integer.MIN_VALUE hingga Integer.MAX_VALUE, termasuk kedua-duanya.
| constant | value |
|---|---|
Integer.MAX_VALUE | 2147483647 |
Integer.MIN_VALUE | -2147483648 |
int n = Integer.MAX_VALUE - 2; // n ialah 2147483645 n = n + 1; // n ialah 2147483646 n = n + 1; // n ialah 2147483647 n = n + 1; // n ialah -2147483648 n = n + 1; // n ialah -2147483647
Jika ungkapan dinilai kepada int di luar julat, berlaku limpahan integer (overflow). Hasilnya ialah int di dalam julat, tetapi bukan nilai yang dijangka: satu selepas MAX_VALUE ialah MIN_VALUE. Rajah melukis int sebagai gelang (bukan mengikut skala) dengan sambungan di atas. Tiada mesej ralat; aturcara diteruskan dengan nombor yang salah.
Double mempunyai had yang berbeza. Double juga disimpan dalam jumlah memori yang tetap, jadi hasil yang lebih tepat daripada yang boleh disimpannya dibundarkan kepada nilai terdekat yang boleh diwakilinya: ralat pembundaran.
System.out.println(0.1 + 0.2); // 0.30000000000000004 Tiada satu pun daripada 0.1 dan 0.2 mempunyai bentuk perduaan yang tepat, dan ralat kecil kelihatan dalam hasil tambah. Untuk mengelakkan ralat pembundaran, gunakan nilai int jika boleh: kira wang dalam sen, bukan dolar. (Jenis perpuluhan khas yang mengelakkannya berada di luar kursus.)
+=, −=, *=, /=, %=, ++ dan −−
Operator penugasan majmuk melakukan aritmetik antara nilai pemboleh ubah dengan nilai di sebelah kanan, kemudian menugaskan hasilnya kepada pemboleh ubah itu.
score += 5 melakukan apa yang dilakukan oleh score = score + 5. Perkara yang sama berlaku bagi -=, *=, /= dan %=; /= pada int ialah pembahagian int.
Operator pasca-tokokan ++ menambah 1 kepada pemboleh ubah berangka dan menyimpannya; operator pasca-susutan -- menolak 1.
int score = 10; // score ialah 10 score += 5; // score ialah 15 score -= 3; // score ialah 12 score *= 2; // score ialah 24 score /= 5; // score ialah 4 score %= 3; // score ialah 1 score++; // score ialah 2 score--; // score ialah 1
Rajah menjalankan baris-baris itu dan menyimpan setiap nilai pada pita. Jejak di atas kertas dengan cara yang sama: satu baris, satu nilai baharu.
Bentuk awalan (++x) dan tokokan di dalam ungkapan lain (arr[x++]) berada di luar kursus.
menggunakan kelas yang bukan anda tulis
Pustaka ialah koleksi kelas. Spesifikasi antara muka pengaturcaraan aplikasi (API) memberitahu pengaturcara cara menggunakannya.
Kelas mentakrifkan jenis rujukan. Kelas pustaka dikumpulkan dalam pakej: String dan Math berada dalam java.lang, Scanner dan ArrayList dalam java.util. Kelas sedia ada boleh digunakan untuk mencipta objek tanpa melihat kodnya; dokumentasinyalah yang menjadikannya boleh digunakan.
Atribut sesebuah kelas ialah data yang berkaitan dengannya, disimpan dalam pemboleh ubah: aksara bagi String. Kelakuannya ialah apa yang boleh dilakukan oleh tikanya, atau apa yang boleh dilakukan terhadapnya, dan ditakrifkan oleh kaedah: length(), substring.
Komen menerangkan kod kepada pengaturcara asal dan orang lain. Pengkompil mengabaikannya dan komen tidak pernah dijalankan. Java mempunyai tiga jenis:
// a comment to the end of the line /* a block of comment, selama beberapa baris */ /** a Javadoc comment, used to make API documentation */
Rajah mengambil String dari rak dan membuka dokumentasinya untuk substring.
Prasyarat mesti benar sejurus sebelum kaedah dijalankan supaya ia berfungsi seperti yang dijangka. Kaedah itu tidak dijangka menyemaknya: memanggil substring dengan to melepasi hujung melanggar prasyarat, dan hasilnya ialah pengecualian, bukan jawapan yang sopan.
Pascasyarat mesti sentiasa benar selepas kaedah dijalankan. Ia menerangkan hasilnya: apa yang dipulangkan, atau nilai atribut objek selepas itu.
parameter, argumen, nilai pulangan
Kaedah ialah blok kod bernama yang hanya dijalankan apabila dipanggil. Blok ialah mana-mana kod dalam pendakap.
Pengabstrakan prosedur: anda boleh menggunakan kaedah dengan mengetahui apa yang dilakukannya, tanpa mengetahui cara ia ditulis. Pengepalanya memberitahu apa yang anda perlukan:
public static double pow(double base, double exponent)
Parameter ialah pemboleh ubah yang diisytiharkan dalam pengepala (base, exponent), digunakan di dalam kaedah. Tandatangan kaedah ialah nama kaedah dan senarai jenis parameter yang tersusun: pow(double, double). Kaedah tanpa parameter mempunyai senarai kosong: length().
Argumen ialah nilai yang dihantar semasa kaedah dipanggil. Argumen mesti sepadan dengan parameter dari segi bilangan dan tertib. Argumen dihantar secara mengikut nilai: setiap parameter bermula sebagai salinan argumennya. Dalam rajah, 2 dan 10 menjadi salinan 2.0 dan 10.0.
double r = Math.pow(2, 10); System.out.println(r); // 1024.0 Kaedah bukan void memulangkan nilai berjenis pulangannya; untuk menggunakannya, simpan dalam pemboleh ubah atau gunakan dalam ungkapan. Kaedah void tidak memulangkan apa-apa, jadi ia tidak boleh menjadi sebahagian daripada ungkapan: int x = System.out.println(5); tidak berkompil.
Kaedah dilebihmuatkan (overloaded) apabila beberapa kaedah mempunyai nama yang sama dengan tandatangan yang berbeza: Math.abs(int) dan Math.abs(double). Argumen menentukan yang mana dijalankan.
Panggilan mengganggu jujukan pernyataan: pernyataan kaedah dijalankan dahulu, dan apabila yang terakhir (atau return) selesai, kawalan kembali ke tempat sejurus selepas panggilan.
kaedah statik, dan Math.random()
Kaedah kelas milik kelas, bukan mana-mana satu objek. Pengepalanya mempunyai kata kunci static, dan ia dipanggil dengan nama kelas dan operator titik: Math.sqrt(2.0). Di dalam kelas yang mentakrifkannya, nama kelas boleh ditinggalkan.
Kelas Math berada dalam java.lang, jadi ia tersedia tanpa import, dan hanya mempunyai kaedah kelas. Java Quick Reference menyenaraikan lima:
| method | returns |
|---|---|
static int abs(int x) | nilai mutlak bagi int |
static double abs(double x) | nilai mutlak bagi double |
static double pow(double base, double exponent) | base dikuasakan exponent |
static double sqrt(double x) | punca kuasa dua tak negatif |
static double random() | double ≥ 0.0 dan < 1.0 |
Julat Math.random() merangkumi 0.0 (titik hujung inklusif) dan tidak merangkumi 1.0 (titik hujung eksklusif). Aritmetik dan penukaran jenis menggerakkannya ke julat yang anda mahu:
int roll = (int) (Math.random() * 6) + 1;
Rajah melakukannya langkah demi langkah. * 6 meregangkan [0.0, 1.0) kepada [0.0, 6.0). (int) memangkas setiap bahagian kepada 0, 1, …, 5: 6 bahagian sama, jadi 6 nilai yang sama kemungkinannya. + 1 menganjakkannya kepada 1, …, 6. Secara umum, (int) (Math.random() * count) + low memberikan satu daripada count int bermula pada low.
30 lontarannya jatuh pada 5 on 1, 5 on 2, 6 on 3, 4 on 4, 6 on 5, 4 on 6: sama kemungkinan tidak bermakna sama kerap dalam larian yang pendek.
pelan tindakan dan apa yang dihasilkannya
Kelas ialah pelaksanaan formal, atau pelan tindakan, bagi atribut dan kelakuan sesebuah objek. Objek ialah satu tika tertentu bagi kelas, dengan nilainya sendiri untuk atribut tersebut.
Rajah menggunakan kelas hipotesis, Book, dengan dua atribut (tajuk dan bilangan halaman) dan dua kelakuan (getTitle() dan getPages()). Setiap Book yang dihasilkan daripadanya mempunyai tajuk dan halamannya sendiri: "Peta", 120; "Burung", 340; "Bintang", 96.
Kelas yang berkaitan boleh berkongsi atribut dan kelakuan sepunya dengan meletakkannya dalam satu kelas, iaitu superkelas. Kelas yang memperluaskannya, iaitu subkelas, menggunakan atribut dan kelakuan itu tanpa menulisnya semula: hubungan pewarisan. (Mereka bentuk dan menulis pewarisan berada di luar kursus.)
Setiap kelas dalam Java ialah subkelas bagi kelas Object, itulah sebabnya setiap objek mempunyai kaedah seperti toString() dan equals.
Pemboleh ubah berjenis rujukan menyimpan rujukan objek, yang boleh dianggap sebagai alamat memori objek itu: anak panah dalam rajah, bukan objeknya.
Book b; // b boleh menyimpan rujukan kepada Book String s; // s boleh menyimpan rujukan kepada String
new, pembina dan null
Objek dicipta dengan kata kunci new diikuti panggilan kepada salah satu pembina kelas itu.
Pembina mempunyai nama yang sama dengan kelasnya. Tandatangannya ialah nama itu dan senarai jenis parameter yang tersusun; pengepalanya menyenaraikan jenis dan nama parameter. Dokumentasi Book hipotesis menyenaraikan:
Book(String title, int pages) Book(String title) String getTitle() int getPages()
Dua pembina dengan tandatangan yang berbeza: pembina itu dilebihmuatkan, dan argumen menentukan yang mana dipanggil. new Book("Peta") memanggil yang kedua.
Book b = new Book("Peta", 120); Book c = null; Rajah menjalankan baris pertama mengikut tertib: new menyediakan memori untuk Book; pembina dijalankan, parameternya menetapkan nilai awal atribut; kemudian rujukan kepada objek baharu disimpan dalam b. Seperti panggilan kaedah, panggilan pembina mengganggu jujukan pernyataan, dan kawalan kembali ke tempat sejurus selepas panggilan apabila pernyataan terakhirnya selesai dijalankan.
Argumen pembina mesti serasi dari segi bilangan dan tertib dengan jenis parameter, dan dihantar mengikut nilai: new Book(120, "Peta") tidak berkompil, kerana tiada pembina yang menerima int kemudian String.
Pemboleh ubah berjenis rujukan menyimpan rujukan objek atau, jika tiada objek, null: c merujuk kepada tiada apa-apa.
operator titik, dan null
Kaedah tika dipanggil pada objek kelas itu, dengan nama objek, operator titik dan kaedahnya: b.getPages().
int p = b.getPages(); // p ialah 120 int q = c.getPages(); // NullPointerException
Panggilan itu mengikut rujukan dalam b ke objeknya, menjalankan getPages() pada objek itu, dan int yang dipulangkannya (120) disimpan dalam p. Objek Book yang lain akan menjawab dengan halamannya sendiri.
c ialah null: tiada objek untuk dituju oleh anak panah. Memanggil kaedah pada rujukan null melontarkan NullPointerException apabila baris itu dijalankan. Ia berkompil: pengkompil hanya menyemak bahawa Book mempunyai getPages().
Bandingkan kaedah kelas pada halaman 1.10: Math.sqrt(x) dipanggil pada kelas; s.length() dipanggil pada satu objek String, dan menjawab bagi rentetan itu sahaja.
tak boleh ubah; penyambungan menghasilkan yang baharu
Objek String mewakili jujukan aksara. Ia dibuat daripada literal rentetan, "cat", atau dengan pembina, new String("cat"). String berada dalam java.lang, tersedia secara lalai.
Objek String adalah tak boleh ubah: setelah dicipta, aksaranya tidak pernah berubah. Kaedah yang dipanggil pada String tidak mengubahnya; ia memulangkan nilai baharu.
String s = "cat"; // s ialah "cat" s = s + "s"; // s ialah "cats" String t = s + 1 + 2; // t ialah "cats12" String v = 1 + 2 + s; // v ialah "3cats"
+ dan += menyambung String, menghasilkan objek String yang baharu. Dalam rajah, s = s + "s" membina "cats" dan menuding s kepadanya; objek "cat" masih tepat "cat".
Primitif yang disambung dengan String ditukar kepada String. + berfungsi dari kiri ke kanan, jadi tempat String mula muncul adalah penting: dalam s + 1 + 2, setiap nombor disambung sebagai teks; dalam 1 + 2 + s, 1 + 2 ditambah dahulu, sebagai int.
Mana-mana objek boleh disambung dengan String: Java memanggil kaedah toString objek itu, yang dimiliki setiap kelas daripada Object, dan yang memulangkan rentetan yang mewakili objek itu. Subkelas sering mengatasi (override) kaedah ini (kaedah public dengan tandatangan yang sama seperti superkelasnya, dengan kelakuan sendiri); menulis pengatasan sedemikian berada di luar kursus.
indeks, length, substring, indexOf
Aksara sesebuah String mempunyai indeks dari 0 hingga satu kurang daripada panjangnya. Menggunakan indeks di luar julat itu melontarkan StringIndexOutOfBoundsException.
Java Quick Reference menyenaraikan kaedah String ini (dan pembinanya; split datang bersama fail teks, dalam topik 4.6):
| method | returns |
|---|---|
int length() | bilangan aksara |
String substring(int from, int to) | aksara dari indeks from hingga indeks to - 1 |
String substring(int from) | substring(from, length()) |
int indexOf(String str) | indeks kemunculan pertama str; −1 jika tidak ditemui |
boolean equals(Object other) | halaman seterusnya |
int compareTo(String other) | halaman seterusnya |
String s = "BANANAS"; s.length(); // 7 s.substring(1, 4); // "ANA" s.substring(4); // "NAS" s.indexOf("NA"); // 2 s.indexOf("X"); // -1 s.substring(3, 4); // "A"
to ialah indeks pertama yang ditinggalkan, jadi substring(from, to) mempunyai to - from aksara. indexOf hanya menemui kemunculan pertama: "NA" juga bermula pada indeks 4.
Rentetan yang menyimpan satu aksara pada index ialah substring(index, index + 1).
equals, compareTo, dan bukan ==
equals bertanya sama ada dua String menyimpan jujukan aksara yang sama. compareTo bertanya yang mana datang dahulu.
String a = "pear"; String b = new String("pear"); System.out.println(a == b); // false System.out.println(a.equals(b)); // true System.out.println(a.compareTo("peach") > 0); // true a dan b merujuk dua objek berlainan yang menyimpan aksara yang sama. a.equals(b) membandingkan aksara, pasangan demi pasangan: true. a == b membandingkan rujukan, iaitu sama ada keduanya menuding ke objek yang sama: false. Bandingkan String dengan equals. (Membandingkan rujukan dengan == kembali dalam topik 2.6.)
a.compareTo(other) memulangkan nilai kurang daripada 0 jika a datang sebelum other, 0 jika sama, dan lebih besar daripada 0 jika a datang selepas. String disusun berdasarkan abjad: aksara pertama yang berbeza menentukannya. "pear" dan "peach" sama sehingga indeks 3, tempat 'r' datang selepas 'c', jadi hasilnya positif. Bergantunglah pada tandanya sahaja: itu sahaja yang dijanjikan oleh Quick Reference.
Kursus ini menggunakan equals hanya untuk membandingkan String dengan String lain.