binario:
revisión:
- Expresión regular:
- Describe el formato del contenido de la cadena, que generalmente se usa para determinar si el contenido de la cadena cumple con los requisitos.
- Sintaxis de expresiones regulares-------------Comprender
- Métodos relacionados con expresiones regulares en String:
- matches (): use la expresión regular dada para verificar si el contenido de la cadena actual cumple con los requisitos, devuelva verdadero si cumple con los requisitos y devuelva falso si no cumple con los requisitos
- split (): divida la cadena actual de acuerdo con la parte que satisface la expresión regular y divídala en una matriz de cadenas
- replaceAll(): reemplaza la parte de la cadena actual que satisface la expresión regular con la cadena especificada y devuelve la cadena reemplazada
- Objeto:
- El originador, todas las clases heredan directa o indirectamente Objeto, todo es un objeto
- Hay dos métodos frecuentemente anulados: toString() y equals()
- El toString() en Object devuelve el nombre completo @ dirección de la clase, que no tiene un significado de referencia, por lo que a menudo reescribimos toString() para devolver los datos que necesitamos.
- El equals() en Object todavía compara la dirección del objeto y no tiene un significado de referencia, por lo que a menudo se anula para reescribir equals() para comparar las propiedades del objeto.
- Clase de contenedor:
- 8 clases contenedoras, para resolver el problema de que los tipos de datos básicos no pueden participar en el desarrollo orientado a objetos
- Lanzamiento de JDK1.5: función de desempaquetado automático, que permite la asignación directa entre tipos básicos y clases de empaque, la capa inferior complementará automáticamente el código para completar el trabajo de conversión
notas:
que es binario
-
Regla de conteo de dos a uno
-
¿Cómo convertir binario a decimal?
- Acumula el peso de cada 1 posición de un número binario
-
¡Todas las variables/constantes en Java almacenan números binarios!
-
demostración de código:
public class Demo01 { public static void main(String[] args) { /* 1.java在编译期间将10进制数编译为2进制数，按2进制来运算 .java(50) 编译后 .class(110010) 2.Integer.toBinaryString()可以将底层的2进制数显示出来 3.int类型是32位2进制数，显示2进制数时自动省略高位0 4.System.out.println()将2进制转换为10进制输出 */ int n = 50; //110010 System.out.println(Integer.toBinaryString(n)); //2进制 n++; //110011 System.out.println(n); //10进制 System.out.println(Integer.toBinaryString(n)); //2进制 } }
que es hexadecimal
- Reglas de conteo para cada 16 en 1
- Porque la escritura binaria es demasiado engorrosa y problemática.
Por lo tanto, el hexadecimal se usa a menudo para abreviar números binarios.00000000 00000000 00000000 00110010 - Cómo abreviar: comience el binario desde el dígito más bajo y abrevie cada 4 dígitos a 1 hexadecimal
- demostración de código:
public class Demo02 { public static void main(String[] args) { /* 16进制:缩写2进制 1)0x是16进制字面量前缀，0x开头则编译器按照16进制编译 2)Java 7提供了2进制字面量前缀 0b----不用，一般都用16进制 */ int n = 0x4f057afe; //0x表示16进制 int m = 0b1001111000001010111101011111110; //0b表示二进制 System.out.println(Integer.toBinaryString(n)); //按2进制输出 System.out.println(Integer.toBinaryString(m)); //按2进制输出 //结论：用16进制来表示2进制更方便 /* 8进制： 1)逢8进1的计数规则 2)前缀0表示为8进制 3)数字:0,1,2,3,4,5,6,7，没有7以上的数字 */ //----小面试题(8进制平时不用) //权 64 8 1 int x = 067; //0开头表示8进制 System.out.println(x); //十进制的55(6个8加上7个1) } }
complemento
-
Un método de codificación para procesar números con signo (números positivos y negativos) en una computadora. El tipo mínimo de complemento en java es int, 32 dígitos
-
Tome el binario de 4 dígitos como ejemplo para explicar las reglas de codificación del complemento:
- Al calcular, si supera los 4 dígitos, automáticamente se desbordará y descartará, manteniendo los 4 dígitos sin cambios.
- Use un número binario de 4 dígitos dividido por la mitad como un número negativo
- El bit más alto se llama bit de signo, el bit más alto es 1 es negativo, el bit más alto es 0 es positivo
int n = -3; System.out.println(Integer.toBinaryString(n)); /* 规律数: 1)0111为4位补码的最大值，规律是1个0和3个1，可以推导出: 32位补码的最大值，是1个0和31个1-----(011111111...) 2)1000为4位补码的最小值，规律是1个1和3个0，可以推导出: 32位补码的最小值，是1个1和31个0-----(100000000...) 3)1111为4位补码的-1，规律是4个1，可以推导出: 32位补码的-1是，是32个1------------(11111111...) */ int max = 2147483647; //int的最大值 int min = -2147483648; //int的最小值 System.out.println(Integer.toBinaryString(max)); //011111... System.out.println(Integer.toBinaryString(min)); //100000... System.out.println(Integer.toBinaryString(-1)); //11111...
-
Entendiendo los valores negativos en profundidad:
- Recuerde -1 está codificado como 32 1s
- Reste el peso correspondiente a la posición 0 con -1
11111111111111111111111111111111 = -1 11111111111111111111111111111101 = -1-2 = -3 11111111111111111111111111111001 = -1-2-4 = -7 11111111111111111111111110010111 = -1-8-32-64 = -105
-
Simetría complementaria:
-
Fórmula: -n=~n+1 Conclusión: El complemento de un número = la inversión de este número + 1
-
por ejemplo:
int n = -3; int m = ~n+1; System.out.println(m); //3 -3的补码就是-3取反+1 -
Preguntas de entrevista:
System.out.println(~100+1); 上述代码的运算结果是(C) 注:求100的补码 A. -98 B.-99 C.-100 D.-101 System.out.println(~-100+1); 上述代码的运算结果是(C) 注:求-100的补码 A.98 B.99 C.100 D.101
-
operación de bits
~ 取反
& 与运算
| 或运算
>>> 右移位运算
<< 左移位运算
& y operador
-
Regla básica: 0 es 0
0 & 0 = 0 0 & 1 = 0 1 & 0 = 0 1 & 1 = 1 -
Al operar, alinee los dos números y realice la operación AND en los bits correspondientes
权 8421 6 1 4 f 7 b b b n = 01100001 01001111 01111011 10111011 m = 00000000 00000000 00000000 11111111 0xff k = n&m 00000000 00000000 00000000 10111011Lo que hace el código anterior:
- Divide los últimos 8 bits de n y guárdalos en k
- El número m se denomina máscara y los 8 1 se denominan máscara de 8 bits.
- La operación anterior se llama: operación de máscara
Código:
int n = 0x614f7bbb; int m = 0xff; //掩码 int k = n & m; //将n的最后8位数拆分出来，存储到k中 System.out.println(Integer.toBinaryString(n)); System.out.println(Integer.toBinaryString(m)); System.out.println(Integer.toBinaryString(k));
| O operación
- Regla básica: 1 es 1
0 | 0 = 0 0 | 1 = 1 1 | 0 = 1 1 | 1 = 1 - Al operar, alinee los dos dígitos y realice una operación OR en los dígitos correspondientes.
El significado del caso anterior: fusión de dislocación权 8421 n = 00000000 00000000 00000000 10111001 0xb9 m = 00000000 00000000 10111101 00000000 0xbd00 k = n|m 00000000 00000000 10111101 10111001
Código:int n = 0xb9; int m = 0xbd00; int k = n | m; //将n与m错位合并 System.out.println(Integer.toBinaryString(n)); System.out.println(Integer.toBinaryString(m)); System.out.println(Integer.toBinaryString(k));
>>> operación de desplazamiento a la derecha
- Reglas básicas: mueva todo el número binario a la derecha, los bits bajos se descartan automáticamente cuando se desborda y los bits altos se llenan con 0
权 8421 6 7 9 f 1 d 9 8 n = 01100111 10011111 00011101 10011000 m = n>>>1 001100111 10011111 00011101 1001100 k = n>>>2 0001100111 10011111 00011101 100110 g = n>>>8 00000000 01100111 10011111 00011101 - Código:
int n = 0x679f1d98; int m = n>>>1; int k = n>>>2; int g = n>>>8; System.out.println(Integer.toBinaryString(n)); System.out.println(Integer.toBinaryString(m)); System.out.println(Integer.toBinaryString(k)); System.out.println(Integer.toBinaryString(g));
<< operación de desplazamiento a la izquierda
- Reglas básicas: Desplace todo el número binario a la izquierda, descarte el desbordamiento de orden superior y agregue 0 al de orden inferior.
权 8421 5 e 4 e 0 d e e n = 01011110 01001110 00001101 11101110 m = n<<1 1011110 01001110 00001101 111011100 k = n<<2 011110 01001110 00001101 1110111000 - código
int n = 0x5e4e0dee; int m = n<<1; int k = n<<2; System.out.println(Integer.toBinaryString(n)); System.out.println(Integer.toBinaryString(m)); System.out.println(Integer.toBinaryString(k));
Significado matemático de la operación de cambio
权 64 32 16 8 4 2 1
0 1 0 1 = 5 向左移动
0 1 0 1 = 10
0 1 0 1 = 20
0 1 0 1 = 40
Código de desplazamiento a la izquierda: verificación de autocodificación
int n = 5;
System.out.println(n<<1); //10
System.out.println(n<<2); //20
System.out.println(n<<3); //40
Código de desplazamiento a la derecha: Verificación de autocodificación
int n = 100;
System.out.println(n>>>1); //?
System.out.println(n>>>2); //?
System.out.println(n>>>3); //?
Notas de esencia:
Contenido de fondo puro, requiere tanta absorción como sea posible, tanto como puedas absorber, y si no puedes absorberlo, ríndete.
-
Qué es binario: cada regla de conteo 2 en 1, las variables/constantes en la computadora se operan de acuerdo con el binario
- Binario:
- Reglas: Cada 2 entra en 1
- Números: 0 1
- bases: 2
- Derecha: 128 64 32 16 8 4 2 1
- Cómo convertir binario a decimal:
- Sume los pesos de cada 1 posición de un número binario ------------ número positivo
- Binario:
-
Qué es hexadecimal: reglas de conteo para cada 16 en 1
- hexadecimal:
- Reglas: 1 de cada 16
- Números: 0 1 2 3 4 5 6 7 8 9 abcdef
- base: 16
- Derecha: 4096 256 16 1
- Propósito: debido a que la escritura binaria es demasiado engorrosa, el hexadecimal se usa a menudo para abreviar números binarios
- Cómo abreviar: comience desde el dígito más bajo y abrevie cada 4 dígitos a 1 hexadecimal
- hexadecimal:
-
Complemento:
- Un método de codificación para procesar números con signo (números positivos y negativos) en una computadora. El tipo mínimo de complemento en java es int, 32 dígitos
- Tome el binario de 4 dígitos como ejemplo para explicar las reglas de codificación del complemento:
- Al calcular, si supera los 4 dígitos, automáticamente se desbordará y descartará, manteniendo los 4 dígitos sin cambios.
- Use un número binario de 4 dígitos dividido por la mitad como un número negativo
- El bit más alto se llama bit de signo, el bit más alto es 1 es negativo, el bit más alto es 0 es positivo
- Entendiendo los valores negativos en profundidad:
- Recuerde -1 está codificado como 32 1s
- Valor negativo: restar el peso correspondiente a la posición 0 de -1
- Simetría complementaria:
- Conclusión: el complemento de un número = el inverso de este número + 1 (inverso +1) fórmula: -n=~n+1
complemento a 6 = 6 inverso + 1
complemento a -3 = -3 inverso + 1 - Preguntas de entrevista:
- Conclusión: el complemento de un número = el inverso de este número + 1 (inverso +1) fórmula: -n=~n+1
System.out.println(~100+1); 前面代码的运算结果是(C)：注:求100的补码 A.-98 B:-99 C:-100 D:-101 System.out.println(~-100+1); 前面代码的运算结果是(C): 注:求-100的补码 A.98 B:99 C:100 D:101 -
Operación de bits:
- ~: Negativo (0 a 1, 1 a 0)
- &: operación Y (0 es 0)
- |: operación OR (1 es 1)
-
: operación de cambio a la derecha
- <<: operación de desplazamiento a la izquierda
Reponer:
- Debe tener:
- que es binario
- Qué es el hexadecimal, la razón de la existencia del hexadecimal
- Conversión entre binario y hexadecimal
权: 64 32 16 8 4 2 1
1 1 0 0 1 0 0 = 100 右移位
1 1 0 0 1 0 = 50
1 1 0 0 1 = 25
1 1 0 0 = 12
权: 64 32 16 8 4 2 1
n 0 1 0 1 = 5
m 0 1 0 1 = 10
k 0 1 0 1 = 20
int n = 5;
int m = n<<2;
System.out.println(m); //20