En primer lugar, quiero entender clase string, mirar el código fuente:
1 Clase public final Cadena
2 implementos java.io.Serializable, Comparable <String> , CharSequence {
3 / ** El valor se utiliza para el almacenamiento de caracteres. * /
4 Char final privado valor [];
5
6 / ** caché el código hash de la cadena * /
7 int privada de hash; // por defecto a 0
8 ... 9}
Como puede verse de lo anterior
- clase String se modifica medios finales de palabras clave de la clase String no se puede heredar, y sus miembros son el método por defecto para el método final, una vez creada, no se puede modificar la cadena.
- implementa la clase string Serializable, CharSequence, la interfaz Comparable.
- instancia String es alcanzar un valor almacenado por la matriz de cadenas de caracteres.
Dos, método de String
Esta es la clase String soportes métodos para más detalles, consulte la API de Java cadena documentación:
En tercer lugar, la piscina constante de cadena
En la asignación de memoria de Java, un total de tres tipos de agrupación de constantes, que son del grupo de constantes de clase, piscina runtime constante, una piscina constante de cadena.
cadenas de asignación y distribución de otros objetos, es una alta necesidad de consumir tiempo y el espacio, y una cadena que se utiliza mucho. JVM para mejorar el rendimiento y reducir la sobrecarga de memoria, el número de optimización cuando la instancia de la cadena: la piscina constante de cadena. Siempre que se crea una constante de cadena, JVM primero comprobará la piscina constante de cadena, si la piscina constante de cadena ya existe, entonces la referencia a ejemplos de retornos directos de la piscina constante. Si la piscina constante de cadena no existe, ejemplos de la cadena y lo coloca en la piscina constante. Desde la inmutabilidad cordaje piscina constante necesidad no existe dos cuerdas idénticas.
1 pública clase Cadena1 { 2 estática String a = " AB " ; 3 estática Cadena b = " AB " ; 4 estática secuencia de c = nuevo String ( " AB " ); 5 estática Cadena d = " A " + " B " ; 6 estática Cadena e = " A " ; 7 estática Cadena f = " B "; 8 estática Cadena g = e + f; 9 estática Cadena h = " A " + f; 10 pública estática void main (String [] args) { 11 del sistema. fuera .println (a == b); // verdadera 12 del sistema. fuera .println (a == c); // falsa 13 del sistema. fuera .println (a == d); // verdadera 14 del sistema. fuera .println (a == g); // falsa 15 Sistema. fuera .println (a.equals (G)); // verdadera 16 del sistema. fuera .println (a.equals (h)); // verdadera 17 del sistema. fuera .println (a == h); // falsa 18 } 19 }
Memoria muestra en la figura Análisis.:
En cuarto lugar, el operador de concatenación de cadenas "+"
El "java", "lenguaje" y estas tres palabras cantidad de superficie "Especificación" "+" operador para obtener una constante "javalanguagespecification", y esta constante directamente en el grupo de cadena, esto es realmente una optimización, los tres en uno literal, evitando la creación de un exceso objeto de cadena. La cadena entre comillas "+" operación se realiza durante el tiempo de ejecución de Java que str + + str2 str3 se calcularán durante la ejecución del programa, que será re-creado después de un mosaico objeto de cadena en la memoria del montón . La conclusión es: constante de cadena "+" costura se realiza en tiempo de compilación, la costura de cadena almacenada en el grupo de cadena; y la cadena de referencias al "+" concatenación realmente esté funcionando , y el recién creado cadenas almacenadas en el montón.
Para cadena de adición directa, muy eficiente, ya que el compilador determinará su valor, que tiene forma de "I" "amor" + + "Java", se añade la cadena, durante la compilación es optimización se ha convertido en "Ilovejava". Para la adición indirecta (es decir, que comprende una cadena de referencia), la forma s1 + s2 + s3; bajo eficiente que la adición directa, ya que el compilador no optimizar la variable de referencia.
Cinco ,, Sobre String.intern ()
método interno: una piscina inicialmente cadena vacía, que se mantiene por la clase String solo. Cuando una llamada al método interno, si la piscina ya contiene una cadena como este objeto String (determinado por el método equals (ecto)), devuelve el grupo de cadena. De lo contrario, se añade este objeto String a la piscina, y devuelve el objeto de cadena.
De ello se sigue las siguientes reglas: Para cualquier par de cadenas S y T, si y sólo si s.equals (t) es verdadera, s.intern () == t.intern () es cierto.
El String.intern ();
a continuación, agregar describe que: presente en la piscina constante archivo .class, JVM se carga durante el funcionamiento, y se puede ampliar. El método de cuerda pasante () es un método para expandir el conjunto de constantes; instancia String str cuando un método interno de llamadas (), java encontrar si existe el mismo conjunto de constantes constante de cadena Unicode, de ser así, se devuelve su referencia, si no hay se incrementa en la piscina constante es igual a una cadena str unicode y devuelve su referencia.
Ejemplo 1:
1 / * * 2 *关于String.intern () 3 * / 4 público void test11 () { 5 Cadena s0 = " kvill " ; 6 Cadena s1 = nuevo String ( " kvill " ); 7 Cadena s2 = nuevo String ( " kvill " ); 8 Sistema. fuera .println ( " =========== test11 ============ " ); 9 Sistema. fuera .println (s0 == s1);// false 10 del Sistema. OUT .println ( " ********** " ); . 11 s1.intern (); // a pesar de la aplicación s1.intern (), pero no asigna su valor de retorno S1 12 es S2 = s2.intern (); // la referencia constante pool "kvill" asignado a S2 13 es el Sistema. OUT .println (S0 == S1); // flase 14 . Sistema OUT .println (S0 == s1.intern ()); // true // Descripción s1.intern () devuelve la piscina constante "kvill" de referencia 15 Sistema. OUT .println (S0 == S2); // true 16 }
Los resultados: falsas, falsas, cierto, cierto.
Ejemplo 2:
1 público clase Cadena1 { 2 3 público estáticas void principales (String [] args) { 4 / * * 5 * String a = "AB"; 6 * Cadena b = "AB"; 7 * Cadena c = new String ( "AB"); 8 * Cadena d = "A" + "B"; 9 * Cadena e = "A"; 10 * Cadena f = "B"; 11 * Cadena g = e + f; 12 * Cadena h = "A" + f; 13 * System.out.println (a == b); * System.out.println (a == c); // false 15 * System.out.println (a == d); // true 16 * System.out.println (a == g); // false 17 * System.out.println (a.equals (g)); // true 18 * System.out.println (a.equals (h)); // true 19 * System.out.println (a == h); // false 20 * / 21 Cadena s1 = " AB " ; 22 Cadena s2 = nuevo String ( " AB " ); 23 Cadena s3 = "Un " ; 24 Cadena s4 = " B " ; 25 Cadena s5 = " A " + " B " ; 26 Cadena s6 = s3 + s4; 27 del sistema. Cabo .println (s1 == s2); // falso 28 del sistema. fuera .println (s1 == s5); // verdadero 29 del sistema. cabo .println (s1 == s6); // falso 30 del sistema.OUT .println (s1 == s6.intern ()); // true 31 del sistema. OUT .println (s2 == s2.intern ()); // falsa entiendo: izquierda s2 = new String ( "AB" ); 32 // el s2.intern derecha () y la cadena s2 = "AB" se entiende una, 33 // lados tan desigual 34 } 35 }
análisis de la memoria:
Dios grande Referencia: https://blog.csdn.net/ifwinds/article/details/80849184
https://www.cnblogs.com/xiaoxi/p/6036701.html
¿Qué es más detallada y quieren entender más profundamente, puede hacer clic en el enlace! !