méthode charAt() en Java

Il existe de nombreuses techniques de base que nous utilisons régulièrement sans même y penser. Et si vous y réfléchissiez et regardiez comment certaines méthodes apparemment simples sont mises en œuvre ? Je pense que cela nous aidera à nous rapprocher de Java.) Imaginons une situation dans laquelle nous devons extraire un certain caractère dans une chaîne. Comment pouvons-nous faire cela en Java ? Par exemple, en appelant le Java String charAt. charAt()Nous parlerons de la méthode dans l'article d'aujourd'hui.

Syntaxe

char charAt(int index)renvoie la valeur char à l'index spécifié. L'indice varie de 0 à length()-1. Autrement dit, la première charvaleur de la séquence est in index 0, la suivante est in , index 1etc., comme c'est le cas pour l'indexation de tableau.

Exemple

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

La première ligne prend le premier caractère, la deuxième ligne prend le deuxième, et ainsi de suite. Puisque not println, mais est utilisé ici print, sans nouvelle ligne, nous obtiendrons le résultat suivant sur la console :

Java

Si charl'index donné est représenté en Unicode, le résultat de la méthode java charAt()sera le caractère qui représente cet Unicode :

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

Sortie de la console :

a

Qu'y a-t-il "sous le capot"

Comment ça marche, demandez-vous ? Le fait est que chaque objet Stringcontient un tableau byteavec des octets des éléments d'une chaîne donnée :

private final byte[] value;

Et voici la méthode elle-même chatAt:

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

isLatin1- un flag indiquant si notre chaîne contient uniquement des caractères latins ou non. Cela détermine quelle méthode sera appelée ensuite.

isLatin1 = vrai

Si la chaîne ne contient que des caractères latins, une méthode charAtde classe statique est appelée StringLatin1:

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

La première étape consiste à vérifier que l'index entrant est supérieur ou égal à 0, et qu'il ne dépasse pas le tableau d'octets interne, et si ce n'est pas le cas, alors une exception est levée new StringIndexOutOfBoundsException(index). Si les contrôles sont réussis, alors l'élément dont nous avons besoin est récupéré. A la fin on voit :

• &s'étend pour les opérations binaires au byteniveau du bit
• 0xffne fait rien mais &nécessite un argument
• (char)convertit les données d'une table ASCII enchar

isLatin1 = faux

Si nous n'avions pas que des caractères latins, la classe sera utilisée StringUTF16et sa méthode statique sera appelée :

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

Ce qui appelle à son tour :

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

Et il délègue à une méthode statique String:

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

Ici, en effet, on vérifie si l'index est valide : encore une fois, s'il est positif ou nul, et s'il n'a pas dépassé les limites du tableau. Mais dans une classe StringUTF16dans une méthode, charAtappeler la deuxième méthode sera plus intéressant :

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

Commençons par analyser ce qui se passe réellement ici. La première étape au début de la méthode est une autre vérification de la validité de l'index. Pour comprendre ce qui se passe ensuite, vous devez comprendre : lorsqu'un caractère non latin entre dans le tableau value, il est représenté par deux octets (deux cellules du tableau). Si nous avons une chaîne de deux caractères cyrilliques - « av », alors :

• pour « a », il s'agit d'une paire d'octets - 48 et 4 ;
• pour 'in' - 50 et 4.

Autrement dit, si nous créons la chaîne « av », elle aura un tableau value- {48, 4, 50, 4} En fait, cette méthode fonctionne avec deux cellules du tableau value. Par conséquent, l'étape suivante est un décalage index <<= 1;pour accéder directement à l'index du premier octet du caractère souhaité dans le tableau value. Disons maintenant que nous avons une chaîne "абвг". Ensuite, le tableau de valeurs ressemblera à ceci : {48, 4, 49, 4, 50, 4, 51, 4}. Nous demandons le troisième élément de la chaîne, puis la représentation binaire est 00000000 00000011. Lorsqu'elle est décalée de 1, nous obtenons 00000000 00000110, soit index = 6. Pour rafraîchir vos connaissances sur les opérations au niveau du bit, vous pouvez lire cet article . On voit aussi quelques variables : HI_BYTE_SHIFT dans ce cas c'est 0. LO_BYTE_SHIFTdans ce cas c'est 8. Dans la dernière ligne de cette méthode :

1. Un élément est extrait du tableau de valeurs et décalé au niveau du bit de HI_BYTE_SHIFT, c'est-à-dire 0, tout en augmentant index +1.

   Dans l'exemple avec la chaîne "абвг", le sixième octet - 51 - le resterait, mais en même temps l'index passe à 7.

2. Après cela, l'élément suivant du tableau est pris et décalé au niveau du bit de la même manière, mais de LO_BYTE_SHIFT, c'est-à-dire de 8 bits.

   Et si nous avions l'octet 4, qui a une représentation binaire - 00000000 00000100, alors après décalage de 8 bits, nous aurons 00000100 00000000. S'il s'agit d'un entier - 1024.

3. Ensuite, pour ces deux valeurs, suit l'opération | (OR).

   Et si nous avions les octets 51 et 1024, qui en représentation binaire ressemblaient à 00000000 00110011 et 00000100 00000000, alors après l'opération, ORnous obtiendrons 00000100 00110011, ce qui signifie le nombre 1075 dans le système décimal.

   Eh bien, à la fin, le nombre 1075 est converti en type char, et lors de la conversion int -> char, la table ASCII est utilisée, et dedans, sous le nombre 1075, il y a le caractère «r».

En fait, c'est ainsi que nous obtenons « g » comme résultat de la méthode charAt()de programmation Java.