kaedah charAt() dalam Java

Terdapat banyak teknik asas yang kita gunakan secara berkala tanpa memikirkannya. Nah, bagaimana jika anda memikirkannya dan melihat bagaimana beberapa kaedah yang kelihatan mudah dilaksanakan? Saya rasa ini akan membantu kita mendekati Java) Mari bayangkan situasi di mana kita perlu mengekstrak aksara tertentu dalam beberapa rentetan. Bagaimanakah kita boleh melakukan ini di Jawa? Sebagai contoh, dengan memanggil Java String charAt. charAt()Kami akan bercakap mengenai kaedah dalam artikel hari ini.

Sintaks

char charAt(int index)mengembalikan nilai char pada indeks yang ditentukan. Indeks berjulat dari 0 hingga length()-1. Iaitu, charnilai pertama jujukan adalah dalam index 0, seterusnya adalah dalam , index 1dsb., seperti yang berlaku dengan pengindeksan tatasusunan.

Contoh

public static void main(String[] args) {
   System.out.print("JavaRush".charAt(0));
   System.out.print("JavaRush".charAt(1));
   System.out.print("JavaRush".charAt(2));
   System.out.print("JavaRush".charAt(3));
}

Baris pertama mengambil aksara pertama, baris kedua mengambil aksara kedua, dan seterusnya. Oleh kerana tidak println, tetapi digunakan di sini print, tanpa baris baharu, kami akan mendapat output berikut ke konsol:

Java

Jika charindeks yang diberikan diwakili sebagai Unicode, hasil kaedah java charAt()akan menjadi aksara yang mewakili Unicode ini:

System.out.println("J\u0061vaRush".charAt(1));

Output konsol:

a

Apakah "di bawah tudung"

Bagaimana ia berfungsi, anda bertanya? Hakikatnya ialah setiap objek Stringmengandungi tatasusunan bytedengan bait unsur-unsur baris tertentu:

private final byte[] value;

Dan inilah kaedahnya sendiri chatAt:

public char charAt(int index) {
   if (isLatin1()) {
       return StringLatin1.charAt(value, index);
   } else {
       return StringUTF16.charAt(value, index);
   }
}

isLatin1- bendera yang menunjukkan sama ada rentetan kami hanya mengandungi aksara Latin atau tidak. Ini menentukan kaedah mana yang akan dipanggil seterusnya.

isLatin1 = benar

Jika rentetan hanya mengandungi aksara Latin, kaedah charAtkelas statik dipanggil StringLatin1:

public static char charAt(byte[] value, int index) {
   if (index < 0 || index >= value.length) {
       throw new StringIndexOutOfBoundsException(index);
   }
   return (char)(value[index] & 0xff);
}

Langkah pertama ialah untuk menyemak sama ada indeks masuk lebih besar daripada atau sama dengan 0, dan ia tidak melangkaui tatasusunan bait dalaman, dan jika ini tidak berlaku, maka pengecualian akan dilemparkan new StringIndexOutOfBoundsException(index). Jika cek diluluskan, maka elemen yang kita perlukan diambil. Pada akhirnya kita melihat:

• &dilanjutkan untuk operasi binari kepada bytebitwise
• 0xfftidak melakukan apa-apa tetapi &memerlukan hujah
• (char)menukar data daripada jadual ASCII kepadachar

isLatin1 = palsu

Jika kita mempunyai lebih daripada aksara Latin, kelas akan digunakan StringUTF16dan kaedah statiknya akan dipanggil:

public static char charAt(byte[] value, int index) {
   checkIndex(index, value);
   return getChar(value, index);
}

Yang seterusnya memanggil:

public static void checkIndex(int off, byte[] val) {
   String.checkIndex(off, length(val));
}

Dan dia mewakilkan kepada kaedah statik String:

static void checkIndex(int index, int length) {
   if (index < 0 || index >= length) {
       throw new StringIndexOutOfBoundsException("index " + index +
                                                 ", length " + length);
   }
}

Di sini, sebenarnya, semakan dibuat untuk melihat sama ada indeks itu sah: sekali lagi, sama ada ia positif atau sifar, dan sama ada ia tidak melampaui had tatasusunan. Tetapi dalam kelas StringUTF16dalam kaedah, charAtmemanggil kaedah kedua akan menjadi lebih menarik:

static char getChar(byte[] val, int index) {
   assert index >= 0 && index < length(val) : "Trusted caller missed bounds check";
   index <<= 1;
   return (char)(((val[index++] & 0xff) << HI_BYTE_SHIFT) |
                 ((val[index]   & 0xff) << LO_BYTE_SHIFT));
}

Mari kita mula menganalisis apa yang sebenarnya berlaku di sini. Langkah pertama pada permulaan kaedah ialah pemeriksaan lain untuk kesahihan indeks. Untuk memahami perkara yang berlaku seterusnya, anda perlu memahami: apabila aksara bukan Latin memasuki tatasusunan value, ia diwakili oleh dua bait (dua sel tatasusunan). Jika kita mempunyai rentetan dua aksara Cyrillic - "av", maka:

• untuk 'a' ini ialah sepasang bait - 48 dan 4;
• untuk 'dalam' - 50 dan 4.

Iaitu, jika kita mencipta rentetan "av", ia akan mempunyai tatasusunan value- {48, 4, 50, 4} Sebenarnya, kaedah ini berfungsi dengan dua sel tatasusunan value. Oleh itu, langkah seterusnya ialah anjakan index <<= 1;untuk terus ke indeks bait pertama aksara yang dikehendaki dalam tatasusunan value. Sekarang katakan kita mempunyai rentetan "абвг". Kemudian tatasusunan nilai akan kelihatan seperti ini: {48, 4, 49, 4, 50, 4, 51, 4}. Kami meminta elemen ketiga rentetan, dan kemudian perwakilan binari ialah 00000000 00000011. Apabila dialihkan sebanyak 1, kami mendapat 00000000 00000110, iaitu index = 6. Untuk menyegarkan pengetahuan anda tentang operasi bitwise, anda boleh membaca artikel ini . Kami juga melihat beberapa pembolehubah: HI_BYTE_SHIFT dalam kes ini ia adalah 0. LO_BYTE_SHIFTdalam kes ini ia adalah 8. Dalam baris terakhir kaedah ini:

1. Satu elemen diambil daripada tatasusunan nilai dan dianjakkan sedikit demi sedikit dengan HI_BYTE_SHIFT, iaitu 0, sambil meningkat index +1.

   Dalam contoh dengan rentetan "абвг", bait keenam - 51 - akan kekal begitu, tetapi pada masa yang sama indeks meningkat kepada 7.

2. Selepas ini, elemen tatasusunan seterusnya diambil dan dialihkan secara bitwise dengan cara yang sama, tetapi dengan LO_BYTE_SHIFT, iaitu sebanyak 8 bit.

   Dan jika kita mempunyai bait 4, yang mempunyai perwakilan binari - 00000000 00000100, maka selepas beralih sebanyak 8 bit kita akan mempunyai 00000100 00000000. Jika ia adalah integer - 1024.

3. Seterusnya, untuk kedua-dua nilai ini, ikuti operasi | (OR).

   Dan jika kita mempunyai bait 51 dan 1024, yang dalam perwakilan binari kelihatan seperti 00000000 00110011 dan 00000100 00000000, maka selepas operasi ORkita akan mendapat 00000100 00110011, yang bermaksud nombor 1075 dalam sistem perpuluhan.

   Nah, pada akhirnya, nombor 1075 ditukar kepada jenis char, dan apabila menukar int -> char, jadual ASCII digunakan, dan di dalamnya, di bawah nombor 1075, terdapat aksara 'g'.

Sebenarnya, ini adalah bagaimana kita mendapat 'g' sebagai hasil daripada kaedah charAt()dalam pengaturcaraan Java.