Preguntas de la entrevista de prueba móvil
El compilador String ++ en Java convertirá automáticamente String en StringBuffer.
Apéndice A de Pensamientos de programación Java, segunda edición: pasar y devolver objetos
Versión en chino, página 759
Versión en inglés, página 1054
Las partes sobrecargadas "+" y StringBuffer representan
Los objetos de la clase String están diseñados como constantes y utilizan la tecnología de clase complementaria presentada anteriormente. Si observa el archivo JDK para la clase String (que se resumirá más adelante), verá que cada método de esa clase destinado a modificar una String está en Durante el proceso de modificación, de hecho se creó un lote de nuevos objetos String. generado y devuelto. La cadena original no se ve afectada.
Const de C++ proporciona constancia de objetos soportada por el compilador, algo que Java no tiene. Para conseguir un par que no cambie
Tienes que hacerlo tú mismo, como una cuerda.
Debido a que los objetos String son constantes, puedes darle a una cadena tantos alias como quieras. Debido a que es de solo lectura, cualquier
referencia no puede modificar el objeto, por lo que no afectará a otras referencias. Por lo tanto, los objetos de solo lectura resuelven muy bien el problema del alias.
Título.
Esto parece resolver todos los problemas. Siempre que necesites modificar un objeto, crea un montón de nuevos objetos modificados, como una cuerda como esta. Sin embargo, esto es demasiado ineficiente para algunas operaciones. El operador sobrecargado "+" para cadenas es un ejemplo importante. La sobrecarga significa que "+" recibe un significado adicional para una clase específica. (Para cadenas sobrecargadas '+' y '+= ',
es el único operador sobrecargado en Java, y Java no permite a los programadores sobrecargar otros operadores).
Cuando se usa una cadena objetos, '+' se usa para conectar objetos de cadena:
string s = "ABC "+foo+" def "+integer . tostring(47);
Puedes imaginar cómo es. obras. La cadena "abc" puede tener un método append() que genera una conexión.
Se agregaron nuevos objetos de cadena "abc" y foo. Después de concatenar la nueva cadena con "def", se genera otra nueva cadena.
Y así sucesivamente.
C++ permite a los programadores sobrecargar operadores a voluntad. Debido a que este suele ser un proceso complejo, los diseñadores de Java lo consideran una función "mala".
No debe incluirse en Java
Medio. En realidad no es tan malo. Irónicamente, utilizar la sobrecarga de operadores es mucho más fácil en Java que en C++.
Claro, esto funciona, pero requiere muchos objetos de cadena intermedios para generar la nueva cadena final y,
ocasionalmente, los resultados deben reciclarse. Dudo que hayan sido los diseñadores de Java quienes hicieron esto primero (es uno de diseño de software)
La lección es que no puedes saberlo todo hasta que esté codificado y funcionando. Supongo que encontraron este enfoque intolerablemente ineficiente.
La solución es una clase complementaria mutable, similar al ejemplo anterior. La clase complementaria de String se llama StringBuffer, que el compilador crea automáticamente al evaluar algunas expresiones, especialmente cuando los objetos String usan '+' y '+=' sobrecargados.
Búfer de cadenas. El siguiente ejemplo ilustra lo que sucede:
//:Apéndice a: fuerzas inmutables.
//Demuestra StringBuffer.
Importar com.Bruce Eckel.simple test.*;
Cadena inmutable de clase pública {
Monitor de prueba estática privada = new Test(); >
Public static void main(String[] args) {
String foo = " foo
string s = " ABC "+foo+" def "+integer . tostring( 47);
system . println(s);
//Utiliza el "equivalente" de StringBuffer:
String buffer sb =
new string buffer(" ABC "); //¡Crea una cadena!
sb.append(foo);
Alguien append( "def"); Crear cadena!
sb . append(integer . tostring(47));
system out . cadena[] {
"abcfoodef47",
" abcfoodef47 "
});
}
} ///:~
En el proceso de generar la cadena S, el compilador usa sb para realizar un código aproximadamente equivalente al siguiente trabajo: Crear un
Un StringBuffer, usar append( ) para agregar directamente una nueva cadena a este objeto StringBuffer (en lugar de crear una nueva cada vez
Aunque este método es más eficiente, no es adecuado para cadenas entre comillas, como "abc"
y "def" no funcionarán, el compilador lo convertirá en un objeto String. Por lo tanto, aunque StringBuffer proporciona
para mejorar la eficiencia, la cantidad de objetos puede ser mayor. de lo que esperas.
Clases String y StringBuffer
Los métodos disponibles para String y StringBuffer se resumen a continuación, para que puedas tener una idea de cómo interactuar con ellos. p>
No se incluyen todos los métodos, solo los importantes relevantes para esta discusión se colocan en una columna separada.
Es una clase de cadena:
Parámetros del método, uso de sobrecarga.
Sobrecarga del constructor: valor predeterminado, parámetros vacíos, crea un objeto de cadena
Cadena, búfer de cadena,
Matriz de caracteres, matriz de bytes.
longitud()El número de caracteres de la cadena.
CharAt() int índice de la posición especificada en la cadena.
Personajes.
Getchars(), copia el punto inicial y final de la fuente, y copia Char o byte al exterior.
La matriz de destino en el sistema getBytes(), la matriz de matrices de destino.
Índice.
ToCharArray() genera char[], que contiene String.
Todos los personajes.
Equals(), compara cadenas y prueba la equivalencia de dos cadenas.
equals-IgnoreCase()
CompareTo() compara cadenas según el orden lexicográfico.
Con argumentos, el resultado es negativo, cero,
o un valor positivo. Las cosas son diferentes.
IndexOf(), sobrecargado: char, char y from si no está incluido en la cadena actual.
LastIndexOf() comienza con los parámetros índice, Cadena y Cadena y devuelve -1; de lo contrario, devuelve los parámetros.
E índice inicial. El índice de posición del número en la cadena.
LastIndexOf() se invierte desde el final.
Buscado.
Sobrecarga de SubString(): índice inicial, el índice inicial devuelve un nuevo objeto de cadena, el paquete
y el índice final contienen un conjunto de caracteres específico.
La cadena Concat() que se va a concatenar devuelve un nuevo objeto de cadena, añadiendo los caracteres del parámetro después de la cadena original.
Replace() busca caracteres antiguos para reemplazarlos y devuelve caracteres nuevos después de reemplazar los caracteres especificados.
Nuevo objeto de cadena. Si no ocurre nada
Reemplace y devuelva la cadena original.
Genera una y sólo una cadena.
Cita.
Como puedes ver, cuando se debe modificar el contenido de una cadena, cada método de String devolverá cuidadosamente una nueva cadena.
Objeto. También tenga en cuenta que este método devolverá una referencia a la cadena de origen si no es necesario modificar el contenido. Esto ahorra espacio de almacenamiento.
Espacio y gastos generales.
La siguiente es la clase StringBuffer:
Parámetros del método, uso de sobrecarga
Sobrecarga del constructor: parámetros vacíos, el búfer a crear crea un nuevo StringBuffer.
Longitud, el origen de la cadena. objeto.
ToString() es generado por este StringBuffer.
Cadena.
longitud()El número de carácter
en el búfer de cadena.
SetLength() representa la longitud entera de la cadena en el búfer y se utiliza para truncar o extender la cadena original.
Si se expande, complete el nuevo con nulo.
Se aumenta el espacio.
CharAt() es un número entero que representa la posición del elemento deseado. Devuelve los caracteres en el buffer.
Ubicación.
SetCharAt() representa un número entero que representa la posición del elemento deseado y el valor de la nueva posición modificada.
Valores de caracteres
GetChars() copia los puntos inicial y final del origen y el destino de la copia a la matriz circundante. No
El índice de la matriz final y la matriz de destino. Hay uno en la cuerda.
getBytes().
Sobrecarga de Append(): convierte objetos, cadenas y parámetros en cadenas y luego los agrega.
Char[], char[] y la suma de compensación llegan al final del búfer actual. Si
Degree, boolean, char, int, el búfer se ampliará si es necesario.
Tipo largo, tipo flotante, tipo doble.
Insert() se ha sobrecargado. El primer parámetro es insertar y el segundo parámetro se convierte en una inserción de cadena.
Punto de inicio: el valor de desplazamiento del objeto ingresa a la posición especificada en el búfer actual.
Cadena, char[], booleano, conjunto. El buffer se ampliará si es necesario.
Char, int, long, float, big.
Doble.
El método más utilizado es append(). Al evaluar expresiones de cadena que contienen los operadores "+" y "+=", el compilador creará.
Úsalo. El método Insert() también tiene una forma similar. Ambos métodos realizan muchas operaciones en el búfer sin crearlo.
Nuevo objeto.
Las cuerdas son especiales.
Hasta ahora, has visto que la clase String es diferente de las clases generales en Java. String tiene muchas funciones especiales.
No es solo una clase Java incorporada, se ha convertido en la base de Java. De hecho, el compilador convierte las cadenas entre comillas dobles en objetos String, y existen operadores '+' y '+=' especialmente sobrecargados.
En este apéndice,
también puedes ver otras características especiales: constancia bien construida usando la clase complementaria StringBuffer y
algo de magia adicional.
/************
Las operaciones con objetos son ineficientes
Además, los objetos java están todos en el montón.
El texto original actúa sobre el objeto repetidamente.
Esto es un comportamiento puramente idiota
**********/
// *********** *************************************************
Cadena estática pública countStr(int count)
{
char ch[]= new char[count];
for(int I = 0;i<count;i++)
ch[I]= 'A';
Cadena str = nueva cadena(ch);
Devolver cadena;
}
// **************************** ***** *************************