API: cadena 、 entero

Cuerda

java.lang.String: Clase de cadena y modificación final de la clase; la
capa inferior es el valor char final privado
de la matriz de caracteres []; por lo que la cadena tiene muchas características son las características de la matriz

# 1. Una vez que se crea la cadena, no se puede cambiar;

2. Para mejorar la eficiencia de acceso de las cadenas, Java ha propuesto un grupo de constantes de cadena, que es equivalente a un área de búfer; los
objetos de tipo de referencia deben almacenarse en la memoria del montón, pero las cadenas son diferentes y se almacenan en el grupo de constantes de cadena ;
3. Durante la ejecución del programa, si el programa usa una cadena; la máquina virtual busca en el pool de constantes antes, si esta cadena existe;
si la hay, apunta directamente a la cadena modificada, si no, crea una nuevo objeto de cadena y apunta a La dirección de este grupo de constantes de cadena;
debido a que la cadena no se puede cambiar una vez creada, no empalme cadenas con frecuencia.
Debido a que la eficiencia es baja, se desperdicia espacio y la recolección de basura tendrá ciertos problemas.
java .lang.StringBuffer java.lang.StringBuilder

1: ¿Qué son StringBuffer y StringBuilder?

	一个可变的字符串缓冲区

2: ¿Principio?
Solicite un espacio en la memoria por adelantado, que pueda acomodar la secuencia de caracteres (matriz de caracteres).
Si el espacio reservado no es suficiente, se expandirá automáticamente. La
capa inferior es char [], y la capacidad de inicialización predeterminada es 16 caracteres

3: ¿Cuál es la mayor diferencia entre String, StringBuffer y StringBuilder?

	①String不可变字符序列,而StringBuilder和StringBuffer是可变字符序列
	②StringBuffer是线程安全,在多线程环境下,不会出现问题,所以效率低,一般常用于类中
	③StringBuilder是非线程安全,在多线程环境下可能出现问题,效率高,一般用于方法中

4: Cómo elegir StringBuilder y StringBuffer

	多线程环境下,是否有可能出现多个线程同时操作同一个数据的可能(增,删,改)；

String Una cadena que no se puede empalmar arbitrariamente
String s2 = "a" + "b"; De esta forma de escritura, en la etapa de compilación, + se eliminará; se convierte en ab;
"a" + "b" ay b son ambos literales
Debe especificar el espacio temporal durante la etapa de compilación, por lo que debe determinar el tipo por valor.Cuando vea que se agregan dos cadenas durante la compilación, simplemente omita el + directamente y guarde ab
s1 == s2 es la misma dirección de memoria, por lo que es igual a verdadero

	String s3 = a + b;
	a和b是变量,编译阶段是不确定变量的值的
	在运行的时候,由于是两个字符串变量相加,新建了一个对象，在堆内存用来存它的值；
	自动创建一个StringBuffer对象,然后把两个变量拼接到一起,最终转换为String类型
	而是以    return new String(value, 0, count);   所以 s3是指向堆内存的

Clase de empaquetado: encapsula los tipos básicos de operaciones, que es más conveniente para nosotros usar

	byte -- java.lang.Byte
	short -- java.lang.Short
					int  -- java.lang.Integer
	long -- java.lang.Long
	float -- java.lang.Float
	double  -- java.lang.Double
					char  -- java.lang.Character
	boolean -- java.lang.Boolean

Ahora que hay tipos básicos, ¿por qué utilizar clases de empaquetado?
Conveniencia, para la completitud teórica (orientada a objetos);

¿Quieres crear un método que pueda recibir cualquier tipo?
Objeto, porque Object es el antepasado de todas las clases.
Debido al polimorfismo, cualquier objeto puede ser recibido. El
tipo básico no es una subclase de Object, ¿cómo recibirlo?
Clase Wrapper, El tipo básico se puede convertir en el tipo de clase de empaquetado correspondiente,
y la clase de empaque también es una clase y una subclase de Object.

Nuevas funciones de Java1.5

Empaquetado automático: convierte automáticamente los tipos de datos básicos en los tipos de empaque correspondientes.
Desempaquetado automático: convierte automáticamente los tipos de empaquetado en tipos de datos básicos.
Todo se realiza en tiempo de compilación;

Conocimiento profundo del boxeo automático y el desempaquetado automático

1. Es un concepto en el tiempo de compilación y no tiene nada que ver con el tiempo de ejecución.
2. Al boxear, la operación de asignación se cambiará automáticamente a Integer.valueOf (222) en el tiempo de compilación 3.
Ocho clases de empaquetado como String, Integer, Double y String All sobrescriben los métodosString (), equals (), hashCode ()
4. Integer.valueOf (xxx): implementación del método
public static Integer valueOf (int i) { if (i> = IntegerCache.low && i <= IntegerCache. high) return IntegerCache.cache [i + (-IntegerCache.low)]; return new Integer (i); }

5.valueOf: convierte el tipo básico al tipo entero

理解：一个大箱子，放的下就直接放进来用，有就直接拿走；
			放不下东西了就放个信息，告诉去哪里拿它；

(El tamaño del cuadro)
Se inicializa un grupo de constantes enteras, el rango de valores está entre -128 ~ 127, que
es una matriz Integer [] con 256 objetos, y los valores int en los objetos son -128, -127 ... 126,127 El subíndice es 0 ~ 255
(código fuente)
En la clase estática privada IntegerCache, es una clase interna estática en Integer.
Tres variables son
static final int low = -128;
static final int high;
static final Integer cache [];
y en estático Esta matriz se inicializa en el bloque de código

	如果 值 在 -128~127之间 就直接去这个缓存数组中找对应的对象即可,不用再重新创建Integer对象
		   return IntegerCache.cache[i + (-IntegerCache.low)];  
				// IntegerCache.low 是 -128   
				// (-IntegerCache.low) : 就是 128  负负得正
				// 加上 我们要添加的数据,就能得到 对应的值所在缓存数组中的下标索引
				// 把该对象返回

	那么这样的话,如果是通过自动装箱或者是通过valueOf方法赋值的两个值都符合该范围,那么 这两个变量保存的内存地址是一致的,则使用 == 也是true
		如  Integer i1 = 123;  Integer i2 = 123;  或者 Integer i3 = Integer.valueOf(123);  他们的内存地址是相等的,找到的是同一个对象

(La caja no es lo suficientemente grande)
por el contrario, significa que new Integer (xxx)
devuelve new Integer (i); dado que es nuevo, la memoria de pila puede volver a crear un nuevo objeto, luego lo mismo a pesar de la inicialización del valor int, pero la dirección de memoria es diferente,
por lo que Usar == también es falso. En este momento, se deben usar iguales para comparar si son iguales. Por
ejemplo, Integer i4 = Integer.valueOf (128); Integer i5 = Integer.valueOf (128) ; O Entero i6 = nuevo Entero (1)