Cadena: constante de cadena
StringBuffer: variable de cadena (segura para subprocesos)
StringBuilder: variable de cadena (no segura para subprocesos)
La diferencia entre String y StringBuffer: la
principal diferencia es que el contenido de StringBuffer es variable. En otras palabras, si cree que el contenido de la cadena es variable, es mejor utilizar StringBuffer. Esto puede reducir el consumo de memoria.
StringBuffer name = new StringBuffer("Name");
StringBuffer password = new StringBuffer("Password");
name.append(password);
El código es muy simple, es decir, se crean dos nuevas clases StringBuffer. Luego agregue el contenido del objeto de contraseña al nombre. Seguimos la función append ().
public synchronized StringBuffer append(StringBuffer sb) {
toStringCache = null;
super.append(sb);
return this;
}
En primer lugar, la seguridad de los subprocesos se logra mediante la palabra clave sincronizada. Esto asegura que solo un hilo llame a append () en el nombre.
Eche un vistazo a la variable toStringCache, que es la caché que se usa para almacenar el método toString (). Si se modifica StringBuffer, se vuelve nulo. Veamos el método toString ():
public synchronized String toString() {
if (toStringCache == null) {
toStringCache = Arrays.copyOfRange(value, 0, count);
}
return new String(toStringCache, true);
}
Si toStringCache es nulo, se construirá primero. Luego devuelve la cadena.
Sigamos con super.append (sb); este método
public AbstractStringBuilder append(StringBuffer sb) {
if (sb == null)
return appendNull();
int len = sb.length();
ensureCapacityInternal(count + len);
sb.getChars(0, len, value, count);
count += len;
return this;
}
Se puede ver que si sb está vacío, se devuelve un valor nulo.
Si sb no está vacío, obtenga la longitud de sb y luego llame a la función secureCapacityInternal (int).
Vamos a seguir
private void ensureCapacityInternal(int minimumCapacity) {
if (minimumCapacity - value.length > 0)
expandCapacity(minimumCapacity);
}
Puede verse que esta función juzga primero si la longitud del valor [matriz de caracteres] puede cumplir con la longitud aumentada. Si no se satisface, se llama al método expandCapacity (int) y seguimos.
void expandCapacity(int minimumCapacity) {
int newCapacity = value.length * 2 + 2;
if (newCapacity - minimumCapacity < 0)
newCapacity = minimumCapacity;
if (newCapacity < 0) {
if (minimumCapacity < 0) // overflow
hrow new OutOfMemoryError();
newCapacity = Integer.MAX_VALUE;
}
value = Arrays.copyOf(value, newCapacity);
}
En primer lugar, la clase StringBuffer es equivalente a Capacity, el tamaño predeterminado es 16. Por supuesto, puede personalizar el tamaño de la Capacidad cuando la crea. Luego, si no se cumplen los requisitos, ampliamos. En términos generales, la longitud expandida es la longitud actual * 2 + 2, lo que significa que no hay ningún accidente.Cuando la longitud es 17, el tamaño de capacidad de la clase StringBuffer es 34. Etcétera. Sin embargo, si la longitud expandida es 40, significa que 34 no puede cumplir con los requisitos. Entonces, extienda la longitud en 40 y luego llame al método Arrays.copyOf () para asignar el valor después de agregar al valor.
Aquí solo se menciona el método de la función append (), y el proceso de implementación de otras funciones es similar.
Debido a que StringBuffer utiliza tecnología segura para subprocesos, se ejecuta un poco más lento. Y String es una constante de carácter. Será más rápido cuando se cotice. Sin embargo, si se sabe que el contenido de la cadena cambiará, no se considera utilizar String, porque las constantes String consumirán más memoria.
Y StringBuilder es similar a StringBuffer. El contenido es variable y el método de implementación es básicamente similar. La única diferencia es que StringBuilder no implementa tecnología segura para subprocesos. Pero también significa que se procesará más rápido que StringBuffer.