charAt() na pamamaraan sa Java

Mayroong maraming mga pangunahing pamamaraan na regular naming ginagamit nang hindi man lang iniisip ang tungkol dito. Well, paano kung pag-isipan mo ito at tingnan kung paano ipinatupad ang ilang tila simpleng pamamaraan? Sa tingin ko ito ay makakatulong sa amin na makakuha ng isang hakbang na mas malapit sa Java) Isipin natin ang isang sitwasyon kung saan kailangan nating kunin ang isang tiyak na karakter sa ilang string. Paano natin ito magagawa sa Java? Halimbawa, sa pamamagitan ng pagtawag sa Java String charAt. charAt()Pag-uusapan natin ang pamamaraan sa artikulong ngayon.

Syntax

char charAt(int index)ibinabalik ang halaga ng char sa tinukoy na index. Ang index ay mula 0 hanggang length()-1. Iyon ay, ang unang charhalaga ng pagkakasunud-sunod ay nasa index 0, ang susunod ay nasa , index 1atbp., tulad ng kaso sa pag-index ng array.

Halimbawa

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));
}

Ang unang linya ay tumatagal ng unang karakter, ang pangalawang linya ay tumatagal ng pangalawa, at iba pa. Dahil hindi println, ngunit ginagamit dito print, nang walang bagong linya, makukuha natin ang sumusunod na output sa console:

Java

Kung charang ibinigay na index ay kinakatawan bilang Unicode, ang resulta ng pamamaraan java charAt()ay ang character na kumakatawan sa Unicode na ito:

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

Output ng console:

a

Ano ang "sa ilalim ng talukbong"

Paano ito gumagana, itatanong mo? Ang katotohanan ay ang bawat bagay Stringay naglalaman ng isang array bytena may mga byte ng mga elemento ng isang naibigay na linya:

private final byte[] value;

At narito ang pamamaraan mismo chatAt:

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

isLatin1- isang bandila na nagpapahiwatig kung ang aming string ay naglalaman lamang ng mga Latin na character o hindi. Tinutukoy nito kung aling paraan ang susunod na tatawagin.

isLatin1 = totoo

Kung ang string ay naglalaman lamang ng mga Latin na character, ang isang static na pamamaraan charAtng klase ay tinatawag na StringLatin1:

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

Ang unang hakbang ay upang suriin kung ang papasok na index ay mas malaki kaysa sa o katumbas ng 0, at hindi ito lalampas sa panloob na byte array, at kung hindi ito ang kaso, pagkatapos ay isang pagbubukod ay itinapon new StringIndexOutOfBoundsException(index). Kung ang mga tseke ay naipasa, pagkatapos ay ang elemento na kailangan namin ay kinuha. Sa dulo makikita natin:

• &umaabot para sa binary na operasyon sa bytebitwise
• 0xffwalang ginagawa kundi &nangangailangan ng argumento
• (char)nagko-convert ng data mula sa isang ASCII table sachar

isLatin1 = mali

Kung mayroon kaming higit pa sa mga Latin na character, ang klase ay gagamitin StringUTF16at ang static na pamamaraan nito ay tatawaging:

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

Na tumatawag naman:

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

At nagtalaga siya sa isang static na pamamaraan String:

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

Dito, sa katunayan, ang isang pagsusuri ay ginawa upang makita kung ang index ay wasto: muli, kung ito ay positibo o zero, at kung hindi ito lumampas sa mga limitasyon ng array. Ngunit sa isang klase StringUTF16sa isang pamamaraan, charAtang pagtawag sa pangalawang pamamaraan ay magiging mas kawili-wili:

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));
}

Simulan nating suriin kung ano talaga ang nangyayari dito. Ang unang hakbang sa simula ng pamamaraan ay isa pang pagsusuri para sa bisa ng index. Upang maunawaan kung ano ang susunod na mangyayari, kailangan mong maunawaan: kapag ang isang hindi Latin na character ay pumasok sa array value, kinakatawan ito ng dalawang byte (dalawang array cell). Kung mayroon kaming isang string ng dalawang Cyrillic character - "av", kung gayon:

• para sa 'a' ito ay isang pares ng bytes - 48 at 4;
• para sa 'in' - 50 at 4.

Ibig sabihin, kung gagawin natin ang string na “av”, magkakaroon ito ng array value- {48, 4, 50, 4} Sa totoo lang, gumagana ang pamamaraang ito sa dalawang array cell value. Samakatuwid, ang susunod na hakbang ay isang shift index <<= 1;upang direktang makarating sa index ng unang byte ng nais na character sa array value. Ngayon sabihin nating mayroon tayong string "абвг". Pagkatapos ang array ng halaga ay magiging ganito: {48, 4, 49, 4, 50, 4, 51, 4}. Hinihiling namin ang ikatlong elemento ng string, at pagkatapos ay ang binary na representasyon ay 00000000 00000011. Kapag inilipat ng 1, makakakuha tayo ng 00000000 00000110, iyon ay index = 6. Upang i-refresh ang iyong kaalaman sa mga pagpapatakbo ng bitwise, maaari mong basahin ang artikulong ito . Nakikita rin natin ang ilang mga variable: HI_BYTE_SHIFT sa kasong ito ito ay 0. LO_BYTE_SHIFTsa kasong ito ay 8. Sa huling linya ng pamamaraang ito:

1. Ang isang elemento ay kinuha mula sa value array at bitwise na inilipat ng HI_BYTE_SHIFT, iyon ay, 0, habang tumataas ang index +1.

   Sa halimbawa ng string "абвг", ang ikaanim na byte - 51 - ay mananatiling gayon, ngunit sa parehong oras ang index ay tumataas sa 7.

2. Pagkatapos nito, ang susunod na elemento ng array ay kinuha at inilipat bitwise sa parehong paraan, ngunit sa pamamagitan ng LO_BYTE_SHIFT, iyon ay, sa pamamagitan ng 8 bits.

   At kung mayroon tayong byte 4, na mayroong binary na representasyon - 00000000 00000100, pagkatapos ay pagkatapos maglipat ng 8 bits magkakaroon tayo ng 00000100 00000000. Kung ito ay isang integer - 1024.

3. Susunod, para sa dalawang value na ito, ay sumusunod sa operasyon | (OR).

   At kung mayroon kaming mga byte na 51 at 1024, na sa binary na representasyon ay mukhang 00000000 00110011 at 00000100 00000000, pagkatapos pagkatapos ng operasyon ORay makakakuha tayo ng 00000100 00110011, na nangangahulugang ang numerong 1075 sa decimal system.

   Sa huli, ang bilang na 1075 ay na-convert sa uri ng char, at kapag nagko-convert ng int -> char, ginagamit ang talahanayan ng ASCII, at sa loob nito, sa ilalim ng numerong 1075, mayroong karakter na 'g'.

Sa totoo lang, ito ay kung paano namin makuha ang 'g' bilang resulta ng pamamaraan charAt()sa Java programming.