clase común 05_StringBuilder clase java

general de la clase 1.StringBuilder

clase StringBuffer y la clase StringBuilder es muy similar, se derivan de la clase AbstractStringBuilder clase abstracta, representa una secuencia variable de caracteres Unicode. clase y de clase StringBuilder métodos de StringBuffer casi exactamente lo mismo, pero StringBuilder no es seguro para subprocesos, y esta es la principal diferencia entre StringBuffer:

• StringBuffer thread-safe, hacer chequeo de sincronización hilo, menos eficiente.

• StringBuilder thread-safe, no lo haga de verificación de sincronización de hilo, por lo que una mayor eficiencia (recomendado).

Porque antes de la versión JDK1.5 es solamente una clase StringBuffer (thread-safe), el descubrimiento de la utilización de múltiples hilos operativo en la misma cadena de datos es muy pequeña, con el fin de mejorar la eficiencia tendrá una clase StringBuilder, clase StringBuilder después de un JDK1.5 por lo que exactamente los mismos métodos de la API StringBuffer compatibles y funciones de la clase StringBuilder y StringBuffer clases.

En la actualidad, no hemos relacionada con la sincronización de hilos, se puede saber lo que el StringBuilder conclusión más rápido que StringBuffer.

2. Optimización de la concatenación de cadenas

Al hacer constante de cadena para la operación de empalme, para poder determinar los valores del compilador, el compilador se fusionará valores.

[Ejemplo] hacer constante la concatenación de cadenas

public class Test {
	public static void main(String[] args) {
		test01();
		test02();
	}
	/**
	 * 直接量拼接，对于编译期就能确定的值，编译器会将值合并
	 * String hw = "hello" + "world";反编译class
	 * 我们将看到 : String hw = "helloworld";
     *
	 * 所以hw == helloWorld 输出true
	 */
	public static void test01() {
		String hw = "hello" + "world"; // 等于：String hw = "helloworld";
		String helloWolrd = "helloworld";
		System.out.println(hw == helloWolrd); // 输出：true
	}
	/**
	 * String hw = h + "world";虽然包含变量 h的运算，但是编译器
	 * 对fianl变量在编译期能确定其值，会发生宏替换，即：h变量替换成其值"hello"，
	 * 然后编译器会对直接量字串直接合并
	 * String hw = h + "world";在编译完后就变成了 String hw = "helloworld";
     *
	 * 所以hw == helloWorld 输出true
	 */
	public static void test02() {
		final String h = "hello"; // final修饰的是常量
		String hw = h + "world"; // 等于：String hw = "helloworld";
		String helloWolrd = "helloworld";
		System.out.println(hw == helloWolrd); // 输出：true
	}
}

Para las variables cuando se realiza la operación de concatenación de cadenas, debido a la variable de la suma se almacena en la cadena de dirección de referencias, porque no pueden saber exactamente qué otro valor específico en tiempo de compilación, no hay manera de optimizar el procesamiento, a continuación, a lograr el efecto de conexión, que utiliza un mecanismos internos StringBuilder para procesar (JDK 5 en el nuevo, no tengo JDK 1.4, estimaciones utilizadas en JDK 1.4 es StringBuffer), append todos ellos en, por último toString salida.
[Ejemplo] variables de operación cadena empalme hacen

public class Test {
	/**
	 * hw在编译期并不能确定值，因为h是变量，JVM在运行期才能确定其值
	 * 会在运行期时，进行字串拼接生成新的字串对象,通过javap -c Test查看虚拟机指令
	 * 我们发现String hw = h + "world";其实等效于：
	 * StringBuilder sb = new StringBuilder(h);
	 * sb.append("world");
	 * String hw = sb.toString();
	 *
	 * 所以hw == helloWorld 输出false
	 */
	public static void main(String[] args) {
		String h = "hello";
		String hw = h + "world";
		String helloWolrd = "helloworld";
		System.out.println(hw == helloWolrd); // 输出：false 
	}
}

3. Comparación de la eficiencia de la cadena de

Fueron utilizados cadena String, StringBuffer, StringBuilder para la operación de empalme 10.000, calculando el tiempo de ejecución para analizar la eficiencia de la aplicación.

[Ejemplo comparativo] eficiencia cadena de empalme

public class StringBuilderDemo {
	public static void main(String[] args) {
		stringBuilderMethod(); // 测试StringBuilder耗时
		stringBufferMethod(); // 测试StringBuffer耗时
		stringMethod(); // 测试String耗时 
	}
	// 测试String耗时
	public static void stringMethod() {
		String str = "";
		long now1 = System.currentTimeMillis(); // 开始时间
		for (int i = 0; i < 10000; i++) { // 进行10000次字符串拼接
			str += i; // 相当于产生了10000个StringBuffer对象
		}
		long now2 = System.currentTimeMillis(); // 结束时间
		System.out.println("String耗时：" + (now2 - now1) + "ms");
	}
	// 测试StringBuffer耗时
	public static void stringBufferMethod() {
		StringBuffer sb = new StringBuffer();
		long now1 = System.currentTimeMillis(); // 开始时间
		for (int i = 0; i < 10000; i++) { // 进行10000次字符串拼接
			sb.append(i);
		}
		long now2 = System.currentTimeMillis();	// 结束时间
		System.out.println("StringBuffer耗时：" + (now2 - now1) + "ms");
	}
	// 测试StringBuilder耗时
	public static void stringBuilderMethod() {
		StringBuilder sb = new StringBuilder();
		long now1 = System.currentTimeMillis(); // 开始时间
		for (int i = 0; i < 10000; i++) { // 进行10000次字符串拼接
			sb.append(i);
		}
		long now2 = System.currentTimeMillis(); // 结束时间
		System.out.println("StringBuilder耗时：" + (now2 - now1) + "ms");
	}
}

Los anteriores resultados de la ejecución de código:

. Casi idéntica eficiencia operativa y StringBuilder StringBuffer Esto se debe a que ambos funcionen en el objeto en sí mismo, no genera un nuevo objeto de cadena. La principal diferencia entre los dos es StringBuffer es thread-safe, pero StringBuilder no es hilo de seguridad, por lo que el ligeramente más alta eficiencia operativa StringBuilder StringBuffer.

Los objetos String son inmutables, cada vez durante la operación de cuerdas, se generará un nuevo objeto (StringBuilder), ocupan mucho espacio en la memoria, esto afectará el rendimiento del sistema, la eficiencia mínima.

Por lo tanto, en el proceso de programación de costumbre, si las necesidades de string para cambiar con frecuencia, usted debe tratar de evitar el uso de cuerdas.

4. La cadena método de objeto llamada

Después de nuestro desarrollo diario, se reunirá para llamar a un método que devuelve un objeto de las circunstancias, este diseño permite al usuario llamar al método de una cadena continua, con el fin de lograr un rápido desarrollo por el pensamiento de la gente, pero lo llamamos gramática cadena . En las herramientas de uso común que hemos aprendido en clase y métodos de la clase StringBuffer StringBuilder están utilizando un modelo de la sintaxis de la cadena para invocar un método de adición de la cadena para lograr devolver esta forma por el camino, fuente StringBuilder abierto:

desde código fuente, podemos ver que cada vez que inserto método de la clase StringBuilder se llama, vuelve la variable objeto de cadena actual, y entonces podemos seguir utilizando el objeto devuelto por la llamada al método para lograr un encadenados llamadas a métodos.

caso método de objeto cadena de llamadas [Ejemplo]

// 创建一个可变字符容器，用来存放数据
StringBuilder sb = new StringBuilder("hello-world");
// 通过链式语法操作可变字符串数据
sb.append("-WHSXT").insert(4, "AAA").delete(6, 8);
// 输出："hellAA-world-WHSXT"
System.out.println(sb);

PD: Para la última documentación libre y videos de instrucción, por favor agregue QQ grupo (627407545) reciben.