Importancia de la clase String
Ya hemos involucrado cadenas en lenguaje C antes, pero para representar cadenas en lenguaje C, solo podemos usar matrices de caracteres o punteros de caracteres. Podemos usar las funciones de serie de cadenas proporcionadas por la biblioteca estándar para completar la mayoría de las operaciones, pero esto La separación de datos y los métodos de manipulación de datos no se ajustan al pensamiento orientado a objetos y las cadenas se utilizan ampliamente, por lo que el lenguaje Java proporciona específicamente la clase String.
Y en la prueba escrita actual de desarrollo y reclutamiento escolar, la clase String es aún más importante, así que veamos la clase String hoy.
método común
construcción de cuerdas
Hay muchos métodos de construcción proporcionados en la clase String, y los tres siguientes se usan comúnmente:
public static void main(String[] args) {
//使用常量字符串构造
String s1 = "hello world";
System.out.println(s1);
//直接newString对象
String s2 = new String("hello world");
System.out.println(s2);
//使用字符数组进行构造
char[] array = {'h', 'e', 'l', 'l', 'o', 'w', 'o', 'r', 'l', 'd'};
String s3 = new String(array);
System.out.println(s3);
}Aviso:
1. String es un tipo de referencia y la cadena en sí no se almacena internamente. En el código fuente de implementación de la clase String, las variables de instancia de la clase String son las siguientes:
Podemos ver que String tiene dos miembros principales: valor [], hash.
hash: en Java,
Stringel valor de la clasehashsehashCode()calcula mediante el método yhashCode()el método se calcula en función del contenido de la cadena. Cuando llamashashCode()al método, en realidad calculas un valor de código hash basado en el contenido de caracteres de la cadena . El hash general por defecto es 0valor[]: En Java,
Stringen la clasevalue[]hay una matriz de caracteres, que almacena el contenido de caracteres de la cadena. CadaStringobjeto tiene unvalue[]arreglo para almacenar los caracteres de la cadena, este arreglo esprivate final char[]de tipo .
public static void main(String[] args) {
//s1和s2引用的是不同的对象 s1和s3引用的是不同对象
String s1 = new String("hello");
String s2 = new String("world");
String s3 = s1;
String s4 = "";//表明指向的对象是空的
String s5 = null;//表明不指向任何对象
System.out.println(s1.length());//获取字符串的长度-输出5
//isEmpyt():检查字符串是否是空，如果是空返回true,不是空返回false
System.out.println(s1.isEmpty());//false
System.out.println(s4.isEmpty());//true
System.out.println(s5.isEmpty());//空指针异常
}2. En Java, "" también es un objeto de tipo String .
Comparación de objetos String
La comparación de cadenas también es una de las operaciones comunes, como la clasificación de cadenas. Java proporciona 4 formas:
1. == compara si las referencias son el mismo objeto .
Nota: Para tipos integrados (tipos básicos como int, etc.), == compara el valor en la variable; para tipos de referencia, == compara la dirección en la referencia.
public static void main(String[] args) {
int a = 10;
int b = 20;
int c = 10;
//对于基本类型变量，==比较的是两个变量中存储的值是否相同
System.out.println(a == b);//false
System.out.println(a == c);//true
//对于引用类型变量，==比较的是两个引用变量引用的是否为同一个对象
String s1 = new String("hello");
String s2 = new String("hello");
String s3 = new String("world");
String s4 = s1;
System.out.println(s1 == s2);//false
System.out.println(s2 == s3);//false
System.out.println(s1 == s4);//true
}2. Método booleano igual (Objeto y Objeto): comparar según el orden lexicográfico
Orden lexicográfico: orden del tamaño de los caracteres
La clase String reescribe el método igual en la clase principal Objeto. El valor predeterminado es == comparación. Después de que String reescribe el método igual, compara de acuerdo con las siguientes reglas: por ejemplo, s1.equals(s2)
public boolean equals(Object anObject) {
// 1. 先检测this 和 anObject 是否为同一个对象比较，如果是返回true
if (this == anObject) {
return true;
}
// 2. 检测anObject是否为String类型的对象，如果是继续比较，否则返回false
if (anObject instanceof String) {
// 将anObject向下转型为String类型对象
String anotherString = (String)anObject;
int n = value.length;
// 3. this和anObject两个字符串的长度是否相同，是继续比较，否则返回false
if (n == anotherString.value.length) {
char v1[] = value;
char v2[] = anotherString.value;
int i = 0;
// 4. 按照字典序，从前往后逐个字符进行比较
while (n-- != 0) {
if (v1[i] != v2[i])
return false;
i++;
}
return true;
}
}
return false;
}Dé un ejemplo de uso:
public static void main(String[] args) {
String s1 = new String("hello");
String s2 = new String("hello");
String s3 = new String("Hello");
//s1,s2,s3引用的是三个不同的对象，因此==比较全部为false
System.out.println(s1 == s2);//false
System.out.println(s1 == s3);//false
//equals比较：String对象中的逐个字符
//虽然s1和s2引用的是不同的对象，但是两个对象中放置的内容相同
//s1和s3引用的是不同的对象，而且两个对象中的内容也不同
System.out.println(s1.equals(s2));//true
System.out.println(s1.equals(s3));//false
}3. Método int compareTo (String s): comparar lexicográficamente
A diferencia de iguales, iguales devuelve un tipo booleano, mientras que compareTo devuelve un tipo int. Método de comparación específico:
1. Primero compare los tamaños en el orden del diccionario. Si hay caracteres diferentes, devuelva directamente la diferencia de tamaño entre los dos caracteres.
2. Si los primeros k caracteres son iguales (k es la longitud mínima de dos caracteres), el valor de retorno es la diferencia entre las dos cadenas.
public static void main(String[] args) {
String s1 = new String("abc");
String s2 = new String("ac");
String s3 = new String("abc");
String s4 = new String("abcdef");
System.out.println(s1.compareTo(s2));//不同输出字符差值-1
System.out.println(s1.compareTo(s3));//相同输出0
System.out.println(s1.compareTo(s4));//前k个字符完全相同，返回长度差值-3
}4.int método compareTolgnoreCase(String str): igual que el método compareTo, pero se ignora la comparación de casos
búsqueda de cadenas
La búsqueda de cadenas también es una operación muy común en cadenas, y la clase String proporciona métodos de búsqueda comunes:
| método | Función |
| char charAt(índice int) | Devuelve el carácter en la posición del índice, si el índice es negativo o está fuera de límites, tira Excepción IndexOutOfBoundsException |
| int índice de (int ch) | Devuelve la posición de la primera aparición de ch, o -1 si no hay |
| int indexOf(int ch, int fromIndex) | Encuentre la primera aparición de ch desde la posición fromIndex |
| int Índice de (cadena cadena) | Devuelve la posición de la primera aparición de str, o -1 si no hay |
| int IndexOf(String str, int fromIndex) | Encuentre la primera aparición de str desde la posición fromIndex y devuelva -1 |
| int último índice de (int ch) | Busque de atrás hacia adelante, devuelva la posición donde apareció ch por primera vez y devuelva -1 si no |
| int último índice de (cadena cadena) | Busque de atrás hacia adelante, devuelva la primera aparición de str, no devuelva -1 |
| int último índice de (int ch, int desde índice) | Encuentre la primera aparición de ch de atrás hacia adelante desde la posición fromIndex y devuelva -1 si no regresa |
| int lastIndexOf(String str，int fromIndex) | Comenzando desde la posición fromIndex, busque la primera aparición de str de atrás hacia adelante y devuelva -1 |
Tomemos una cadena como ejemplo:
public static void main(String[] args) {
String s = "aaabbbcccaaabbbccc";
System.out.println(s.charAt(3));//'b
System.out.println(s.indexOf('d'));//-1
System.out.println(s.indexOf('c'));//6
System.out.println(s.indexOf('c', 10));//15
System.out.println(s.indexOf("bbb"));//3
System.out.println(s.indexOf("bbb", 10));//12
System.out.println(s.lastIndexOf('c'));//17
System.out.println(s.lastIndexOf('c', 10));//8
System.out.println(s.lastIndexOf("bbb"));//12
System.out.println(s.lastIndexOf("bbb", 10));//3
}convertir
1. Conversión de valores numéricos y cadenas.
public static void main(String[] args) {
//数值转字符串
String s1 = String.valueOf(1234);
String s2 = String.valueOf(12.34);
String s3 = String.valueOf(true);
String s4 = String.valueOf(new Student("zhangsan", 18));
//打印
System.out.println(s1);
System.out.println(s2);
System.out.println(s3);
System.out.println(s4);//打印的是对象名@哈希码
System.out.println("======================");
//字符串转数字
//注意：Integer,Double等是Java的包装类型，这个后面会讲
int data1 = Integer.parseInt("1234");
double data2 = Double.parseDouble("12.34");
System.out.println(data1);
System.out.println(data2);
}2. Conversión de casos
public static void main(String[] args) {
String s1 = "hello";
String s2 = "HELLO";
//注意：不是在原来的基础上转变，转变之后是一个新的对象
//小写转大写
System.out.println(s1.toUpperCase());//HELLO
System.out.println(s2.toLowerCase());//hello
}3. Cadena a matriz
public static void main(String[] args) {
String s = "hello";
//字符串转数组
char[] ch = s.toCharArray();
for(int i=0; i<ch.length; i++) {
System.out.print(ch[i]);
}
System.out.println();
//数组转字符串
String s2 = new String(ch);
System.out.println(s2);
}4. Formateo
public static void main(String[] args) {
String s = String.format("%d-%d-%d", 2019, 9, 14);
System.out.println(s);
}reemplazo de cuerdas
Utilice una nueva cadena para reemplazar los datos de la cadena existente, los métodos disponibles son los siguientes:
| método | Función |
| Reemplazo de cadenaTodo(Expresión regular de cadena, Reemplazo de cadena) | Reemplazar todo el contenido especificado |
| Reemplazo de cadenaPrimero (expresión regular de cadena, reemplazo de cadena) | Reemplazar el primer contenido |
| Reemplazo de cadena (destino de cadena, reemplazo de cadena) | Reemplace todas las cadenas de destino con la cadena especificada |
| Reemplazo de cadena (char oldChar, char newChar) | Reemplaza todos los personajes antiguos por otros nuevos. |
Nota: Dado que las cadenas son objetos inmutables, el reemplazo no cambia la cadena actual, sino que produce una nueva cadena.