Interprétation de la méthode de tounsignedstring
J'ai vu qu'il existe une telle méthode en entier pour convertir INT en une chaîne de type non signée, mais il y a plusieurs points qui ne sont pas très clairs. Après avoir interrogé les informations, je les comprends comme suit:
/ ** * Convertissez l'entier en un numéro non signé. * / String statique privé TounSignedString (int i, int shift) {char [] buf = new char [32]; int charpos = 32; int radix = 1 << shift; int mask = radix - 1; do {buf [-charpos] = chiffres [i & mask]; i >>> = shift; } while (i! = 0); retourner la nouvelle chaîne (BUF, Charpos, (32 - Charpos)); }Le décalage des paramètres représente ici le système binaire. S'il est binaire, le changement est 2, l'octal est de 8 et le masque correspondant est calculé comme 1 et 7. Extraire en continu les caractères correspondants dans le tableau des chiffres via le masque et i.
De cette façon, j'effectue une opération de décalage à droite logique à chaque fois, et le bit le plus élevé est complété avec zéro, de sorte qu'après un décalage logique continu, je deviendrai 0
De plus, l'adoption de Do-While est d'empêcher le tableau BUF d'obtenir sa valeur lorsque je suis lui-même 0.
Interprétation de la méthode de tostring
// Ce tableau représente la partie à dix chiffres du numéro, et ce tableau sera utilisé ci-dessous. Char statique final [] digittens = {'0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '1', '1', '1', '1', '1', '1', '1', '1', '1', '1', '2,' 2 '2' '2', '2', '2', '2', '3', '3', '3', '3', '3', '3', '3', '3', '3', '3', '4', '4', '4', '4', '4', '4', '4,' 4, '4,' 4, ',' 5 ' '5', '5', '5', '5', '5', '5', '5', '5', '5', '5', '5', '5', '5', '5', '5', '5', '5', '5', '6' '', ',', ',', '5', '5', '6' '' ',', '', ',' 6, '5', '6' '', ',' '' ',' 6, '6,' 5 ',' 6 '' '6', '6', '6', '6', '6', '6', '6', '6', '6', '6', '6', '6', '6', '7', '7', '7', '7', '7', '7', '7', ',', '7,' 7, '7', '7'. '7', '7', '7', '7', '7', '7', '7', '7', '7', '7', '7', '7', '7', '7', '7', '7', '7', '7', '7', ',' 7 ',', ',' 7 ',' 7 ',' 7 '' ',' 7 '', ',' 7, '7,' 7 ',' 7 '' '', '7' ',' ',' 7 ',' 7 ',' 7 '' '' '', ',' '' ',' 7 ',' 7 '', '7' '7', '7', '8', '8', '9', '9', '9', '9', '9', '9', '9', '9',}; // Ce tableau représente la partie à un chiffre d'un nombre, et ce tableau sera utilisé ci-dessous. If each part of the array is combined, two-digit integers can be obtained in all cases within 100. final static char [] DigitOnes = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', ',' 2 ',' 3 '3', ',' 4 '', '0', ',' 2 ',' 3 '3', ',' 4 '', '0', ',' 2 ',' 3 '3' '', ',' '' '', ',' 2 '', '3' 3 '', ',', '' ',' ',' 2 '', 3 '3' ',' 4, ',' ',' ',' 2 ',' 3 '3' ',' 4, ',' ',', ', 2', '3' 3 '', '4,', '', '1', '2' ', 3' 3 '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0' 1 ',' 2 '2' '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8,' 9, '0', '1' 1 '1', '2,', '', '9', 0 ',' 1 '1' ',' 2 '', ',', 5 ',' 0 ',' 1 '1' ',' 2 '', ',', 5 ',' 0 ',' 1 '1' '' ',', '' '', ',' 0 ',' 1 '1' '' ',' '' '' ',' 5 ',' 0 ',' 1 '1' ' '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', ''; Public Static String toString (int i) {if (i == Integer.min_value) // Ajouter 1 ici. Au début, je ne sais pas ce que cela signifie. Plus tard, si je constate qu'un nombre négatif est trouvé, je dois ajouter un signe négatif devant lui, donc la taille de la chaîne doit être ajoutée 1.// La pièce transmise en lutte ici est positive, dans le tableau ci-dessous // map int size = (i <0)? StringSize (-i) + 1: StringSize (i); char [] buf = nouveau char [size]; getchars (i, taille, buf); retourner la nouvelle chaîne (0, taille, buf); } static void getchars (int i, int index, char [] buf) {int q, r; int charpos = index; signe de char = 0; if (i <0) {signe = '-'; i = -i; } // Pour les entiers supérieurs à 65536, effectuez d'abord le traitement suivant, // dans ce processus, en unités de 100, c'est-à-dire que le reste est contrôlé en deux chiffres // Cela correspond juste au tableau ci-dessus à dix chiffres et à un chiffre, et écrit deux chiffres dans le tableau BUF à la fois. Ceci est sans aucun doute beaucoup plus rapide que de trouver chaque chiffre pendant (i> = 65536) {q = i / 100; // vraiment: r = i - (q * 100); r = i - ((q << 6) + (q << 5) + (q << 2)); i = q; buf [--charpos] = digitones [r]; buf [--charpos] = digittens [r]; } // tombe en mode rapide pour les nombres plus petits // affirmer (i <= 65536, i); // Pour les entiers inférieurs ou égaux à 65536, la partie suivante peut être directement effectuée // et cet endroit est divisé par 10, mais l'implémentation n'est pas directement divisée // à la place, un 52429/2 ^ 19 est d'environ 0,1000 ... // Numéro, // Peut-être qu'il sera inexact, puis multipliez le diviseur par 10 pour obtenir le nombre de plus de 10 chiffres // partie. Par I-le nombre avec plus de dix chiffres dans cette partie, vous obtenez le nombre de chiffres uniques pour (;;) {q = (i * 52429) >>> (16 + 3); r = i - ((q << 3) + (q << 1)); // r = i- (q * 10) ... buf [--charpos] = chiffres [r]; i = q; if (i == 0) casser; } if (signe! = 0) {buf [--charpos] = signe; }} final static int [] sizetable = {9, 99, 999, 9999, 99999, 999999, 999999, 999999, 999999, 9999999, Integer.max_Value}; // Cela doit être optimisé ici, et les bits de données entiers sont stockés via Sizetable //, de un à 10 bits: 2147483647, // Cette méthode de traitement est intelligemment statique intringSize (int x) {for (int i = 0;; i ++) if (x <= sizetable [i]) return i + 1; }Interprétation de la méthode la plus élevée
public static int hautestOnebit (int i) {// hd, figure 3-1 i | = (i >> 1); i | = (i >> 2); i | = (i >> 4); i | = (i >> 8); i | = (i >> 16); retour i - (i >>> 1); }Cette méthode est très intéressante. Je l'ai calculé moi-même avant de comprendre son essence. La fonction de cette méthode est de trouver la valeur de l'entier représenté par le plus grand bit d'un entier. Cette fonction est réalisée ici par déplacement. Donnons un exemple simple. Pour 128, le binaire est de 1000 0000. Prenons-le comme exemple:
Déplacer 1 chiffre
1000 0000
0100 0000
| -------------
Déplacer 2 chiffres
1100 0000
0011 0000
| ------------
Déplacer 4 bits
1111 0000
0000 1111
| ------------
Déplacer 8 bits
1111 1111
0000 0000
| ------------
Mobile 16 bits
1111 1111
0000 0000
| ------------
1111 1111
Le résultat final est comme vous pouvez le voir. Tous les bits suivants sont remplis de 1, et tous les bits suivants sont soustraits pour obtenir l'entier représenté par le bit le plus élevé.
Analyse de la méthode BitCount
public static int bitcount (int i) {// hd, figure 5-2 i = i - ((i >>> 1) & 0x55555555); i = (i & 0x3333333) + ((i >>> 2) & 0x33333333); i = (i + (i >>> 4)) & 0x0f0f0f0f0f0f; i = i + (i >>> 8); i = i + (i >>> 16); retour i & 0x3f; } Cette méthode était vraiment inutile pendant longtemps pour étudier, et plus tard j'ai compris une idée approximative:
Dans la première ligne, l'implémentation consiste à regrouper les bits binaires du type entier en deux et deux, puis à compter le nombre de 1 parmi les deux bits. Je ne sais pas comment cette formule vient, mais c'est en effet le cas.
La deuxième ligne met en œuvre le regroupement de quatre et quatre bits binaires de l'entier, puis calcule l'ajout de décalage dans le segment, qui est de 1001-> 10 + 01 = 11. Il équivaut à trois 1. La troisième ligne consiste à groupe huit bits binaires de l'entier, puis à ajouter des déplacements similaires à la méthode ci-dessus. Bien sûr, cela est réalisé grâce à certains changements et opérations spécifiques.
Viennent ensuite seize groupes et trente-deux groupes, et enfin fusionner les statistiques dans les statistiques représentées par les derniers chiffres.
Ce qui précède est tout le contenu de cet article. J'espère que cela sera utile à l'apprentissage de tous et j'espère que tout le monde soutiendra davantage Wulin.com.