Interpretação do método TounSignedString
Vi que existe esse método em número inteiro para converter int em uma string de tipo não assinada, mas existem vários pontos que não são muito claros. Depois de consultar as informações, entendo as seguintes:
/*** Converta o número inteiro em um número não assinado. */ Private Static String TounsignedString (int i, int shift) {char [] buf = new Char [32]; int charpos = 32; int radix = 1 << Shift; int máscara = radix - 1; do {buf [-charpos] = dígitos [i & máscara]; i >>> = shift; } while (i! = 0); retornar nova string (BUF, Charpos, (32 - Charpos)); }A mudança de parâmetro aqui representa o sistema binário. Se for binário, o turno é 2, o octal é 8 e a máscara correspondente é calculada como 1 e 7. Extrair continuamente os caracteres correspondentes na matriz de dígitos através da máscara e i.
Dessa forma, eu realizo uma operação lógica de deslocamento direito sempre, e a parte mais alta é suplementada com zero, de modo que, após o deslocamento lógico contínuo, eu ficarei 0
Além disso, a adoção de Do-While é impedir que a matriz BUF obtenha seu valor quando eu próprio é 0.
Interpretação do método da tostragem
// Esta matriz representa a parte de dez dígitos do número, e essa matriz será usada abaixo. final static char [] 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', '2', '2', '2', '3', '3', '3', '3', '3', '3', '3', '3', '3', '3', '4', '4,' 4, 4, '4,', '' '' '' 4, '4,' 4, '4, 4,' 4, '4,' 4, '' '', '4,' 4, '4, do 4 do, do 4 do,' 4, 'do 4 do,' 4, '4,' 4 do, '4,' 4, '4,' 4, '4 do,' 4, '4,' 4, '4,' 4 do 4S, do 4 do, '4,' 4, '4,' 4, '4 do,' 4, '4,' 4 do, '4 do 4 do,' 3 ',' 4, '4,' 4, '4,' 4, '4,' 4, '4,' 4 do 4S, '4 do 4S, 4, 4, '5', '5', '5', '5', '5', '5', '5', '5', '5', '5', '5', '5', '5', '5', '5,' 5, '5,' 5, '5,' 5, '5,' '5,' 5, '5,' 5, 5, '5,' 5, '5,' 5, '' 5, '5, o 5, o 5, o 5, o 5, o 5, o 5, o 5, o 5, o 5, o 5, o 5, o 5, o 5, o 5, o 5, o 5, o 5, o 5, o 5, o 5, o 5, o 5, o 5 5, o 5, o 5 5, o 5, o 5' 5, o 5 '5', o 5 '5', o 5 '5', o 5 '5', o 5 '5', o 5 '5', o 5 '5', o 5 '5', o 5 '5', o 5 '5', o 5 '5', o 5 '5', o 5 '5', o 5 '5, o '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', '8', '8', '9', '9', '9', '9', '9', '9', '9', '9',}; // Esta matriz representa a parte de um dígito de um número, e essa matriz será usada abaixo. Cada parte da matriz é combinada, os números inteiros de dois dígitos podem ser obtidos em todos os casos dentro de 100. '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', '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', '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', } ; public static string toString (int i) {if (i == Integer.min_value) // Adicione 1 aqui. No começo, não sei o que isso significa. Posteriormente, se eu achar que um número negativo é encontrado, preciso adicionar um sinal negativo na frente dele; portanto, o tamanho da string deve ser adicionado 1.// a peça passada em stringsize aqui é positiva, na matriz abaixo // mapa int size = (i <0)? pressionamento (-i) + 1: stringsize (i); char [] buf = novo char [size]; getchars (i, tamanho, buf); retornar nova string (0, tamanho, buf); } Void estático getchars (int i, int index, char [] buf) {int q, r; int charpos = index; sinal de char = 0; if (i <0) {sin = '-'; i = -i; } // Para números inteiros acima de 65536, primeiro execute o seguinte processamento, // nesse processo, em unidades de 100, ou seja, o restante é controlado em dois dígitos // isso apenas mapeia a matriz de dez dígitos e de dígitos acima e grava dois dígitos na matriz de buf a uma vez. Isso é sem dúvida muito mais rápido do que encontrar cada dígito enquanto (i> = 65536) {q = i / 100; // realmente: r = i - (q * 100); r = i - ((q << 6) + (q << 5) + (q << 2)); i = q; BUF [--Charpos] = Digitones [R]; BUF [--Charpos] = Digittens [r]; } // cair no modo rápido para números menores // assert (i <= 65536, i); // Para números inteiros menores ou iguais a 65536, a parte a seguir pode ser executada diretamente // e este local é dividido por 10, mas a implementação não é dividida diretamente //, em vez disso, encontre um número de 52429/2^19, é cerca de 0,1000 ... // é equivalente a dividir I por 10, mas o que eu não sei é por que é por que é direta // // Talvez seja impreciso e multiplique o divisor por 10 para obter o número de mais de 10 dígitos // parte. Por I-O número com mais de dez dígitos nesta parte, você obtém o número de dígitos únicos para (;;) {q = (i * 52429) >>> (16+3); r = i - ((q << 3) + (q << 1)); // r = i- (q*10) ... buf [--charpos] = dígitos [r]; i = q; if (i == 0) quebra; } if (signo! = 0) {buf [--charpos] = sinal; }} final estático int [] sizetable = {9, 99, 999, 9999, 99999, 999999, 999999, 999999, 9999999, 9999999, integer.max_value}; // Isso deve ser otimizado aqui, e os bits de dados inteiros são armazenados por meio de sizetable //, de um a 10 bits: 2147483647, // esse método de processamento é inteligentemente estático int stringsize (int x) {para (int i = 0; i ++) se (x <= mantable [i]) {para (int i = 0; }Interpretação do método HighStonebit
public static int HighStoneBit (int i) {// hd, Figura 3-1 i | = (i >> 1); i | = (i >> 2); i | = (i >> 4); i | = (i >> 8); i | = (i >> 16); retornar i - (i >>> 1); }Este método é muito interessante. Eu mesmo calculei antes de entender sua essência. A função desse método é encontrar o valor do número inteiro representado pelo maior bit de um número inteiro. Esta função é realizada aqui através do deslocamento. Vamos dar um exemplo simples. Para 128, o binário é de 1000 0000. Vamos considerá -lo como exemplo:
Mova 1 dígito
1000 0000
0100 0000
| ---------------
Mova 2 dígitos
1100 0000
0011 0000
| --------------
Mova 4 bits
1111 0000
0000 1111
| --------------
Mova 8 bits
1111 1111
0000 0000
| --------------
Mobile 16 bits
1111 1111
0000 0000
| --------------
1111 1111
O resultado final é como você pode ver. Todos os bits a seguir são preenchidos com 1 e todos os seguintes bits são subtraídos para obter o número inteiro representado pelo bit mais alto.
Análise do método BitCount
public static int bitCount (int i) {// hd, Figura 5-2 i = i - ((i >>> 1) e 0x555555555); i = (i & 0x33333333) + ((i >>> 2) & 0x33333333); i = (i + (i >>> 4)) e 0x0f0f0f0f0f0f; i = i + (i >>> 8); i = i + (i >>> 16); retornar i & 0x3f; } Esse método foi realmente inútil por um longo tempo para estudar, e mais tarde eu descobri uma ideia difícil:
Na primeira linha, a implementação é agrupar os bits binários do tipo inteiro em dois e dois e depois contar o número de 1 entre os dois bits. Não sei como vem essa fórmula, mas é realmente o caso.
A segunda linha implementa o agrupamento de quatro e quatro bits binários do número inteiro e calcula a adição de mudança no segmento, que é 1001-> 10 + 01 = 11. É equivalente a três 1s. A terceira linha é agrupar oito bits binários do número inteiro e, em seguida, adicionar deslocamentos semelhantes ao método acima. Obviamente, isso é alcançado através de algumas mudanças e operações específicas.
Em seguida, são dezesseis grupos e trinta e dois grupos e, finalmente, mescla as estatísticas nas estatísticas representadas pelos últimos dígitos.
O exposto acima é todo o conteúdo deste artigo. Espero que seja útil para o aprendizado de todos e espero que todos apoiem mais o wulin.com.