La clase String proporciona una variedad de métodos para buscar y extraer subcadenas. Los métodos más utilizados son:
// 是否包含子串:
"Hello".contains("ll"); // true
Subcadena de búsqueda
ejemplo:
"Hello".indexOf("l"); // 2
"Hello".lastIndexOf("l"); // 3
"Hello".startsWith("He"); // true
"Hello".endsWith("lo"); // true
Extraer subcadena
ejemplo:
"Hello".substring(2); // "llo"
"Hello".substring(2, 4); "ll"
Reemplazar subcadena
Para reemplazar una subcadena en una cadena, existen dos métodos. Uno se basa en el reemplazo de caracteres o cadenas:
String s = "hello";
s.replace('l', 'w'); // "hewwo"，所有字符'l'被替换为'w'
s.replace("ll", "~~"); // "he~~o"，所有子串"ll"被替换为"~~"
Cuerda partida
Para dividir una cadena, use el método split () y la expresión regular también se pasa en:
String s = "A,B,C,D";
String[] ss = s.split("\\,"); // {"A", "B", "C", "D"}
Cadena concatenada
Para concatenar cadenas, use el método estático join (), que conecta la matriz de cadenas con la cadena especificada:
String[] arr = {
"A", "B", "C"};
String s = String.join("***", arr); // "A***B***C"
Cadena de formato
La cadena proporciona el método formatted () y el método estático format (). Puede pasar otros parámetros, reemplazar los marcadores de posición y luego generar una nueva cadena:
public class Main {
public static void main(String[] args) {
String s = "Hi %s, your score is %d!";
System.out.println(s.formatted("Alice", 80));
System.out.println(String.format("Hi %s, your score is %.2f!", "Bob", 59.5));
}
}
Hay varios marcadores de posición y varios parámetros se pasan posteriormente. El tipo de parámetro debe ser coherente con el marcador de posición. A menudo usamos este método para formatear la información. Los marcadores de posición de uso común son:
% s: muestra la cadena;
% d: muestra el entero;
% x: muestra el entero hexadecimal;
% f: muestra el número de punto flotante.
Los marcadores de posición también pueden formatearse, por ejemplo:% .2f significa mostrar dos lugares decimales. Si no está seguro de qué marcador de posición utilizar, utilice siempre% s, porque% s puede mostrar cualquier tipo de datos.
Conversión de tipo
Para convertir cualquier tipo básico o tipo de referencia en una cadena, puede usar el método estático valueOf () . Este es un método sobrecargado, el compilador seleccionará automáticamente el método apropiado de acuerdo con los parámetros:
String.valueOf(123); // "123"
String.valueOf(45.67); // "45.67"
String.valueOf(true); // "true"
String.valueOf(new Object()); // 类似java.lang.Object@636be97c
Para convertir una cadena a otros tipos, debe basarse en la situación. Por ejemplo, para convertir una cadena a tipo int:
int n1 = Integer.parseInt("123"); // 123
int n2 = Integer.parseInt("ff", 16); // 按十六进制转换，255
Convierta la cadena a tipo booleano:
boolean b1 = Boolean.parseBoolean("true"); // true
boolean b2 = Boolean.parseBoolean("FALSE"); // false
Preste especial atención al hecho de que Integer tiene un método getInteger (String), que no convierte una cadena en un int, pero convierte la variable del sistema correspondiente a la cadena en un Integer:
Integer.getInteger("java.version"); // 版本号，11
Convertir entre String y char
char[] cs = "Hello".toCharArray(); // String -> char[]
String s = new String(cs); // char[] -> String
Si se modifica la matriz char [], String no cambiará:
public class Main {
public static void main(String[] args) {
char[] cs = "Hello".toCharArray();
String s = new String(cs);
System.out.println(s);
cs[0] = 'X';
System.out.println(s);
}
}
Ambos resultados son:
Hola
Hola
Esto se debe a que cuando se crea una nueva instancia de String a través de new String (char []), no hará referencia directa a la matriz char [] pasada, sino que hará una copia. Por lo tanto, modificar la matriz char [] externa no afectará la char [] dentro de la instancia de String, porque son dos matrices diferentes.
Se puede ver en el diseño de inmutabilidad de String que si es probable que el objeto entrante cambie, debemos copiarlo en lugar de hacer referencia a él directamente.
Por ejemplo, el siguiente código diseña una clase de puntuación para almacenar las puntuaciones de un grupo de estudiantes:
public class Main {
public static void main(String[] args) {
int[] scores = new int[] {
88, 77, 51, 66 };
Score s = new Score(scores);
s.printScores();
scores[2] = 99;
s.printScores();
}
}
class Score {
private int[] scores;
public Score(int[] scores) {
this.scores = scores;
}
public void printScores() {
System.out.println(Arrays.toString(scores));
}
}
[88, 77, 51, 66]
[88, 77, 99, 66]
Al observar la salida dos veces, debido a que Score hace referencia directamente a la matriz int [] pasada externamente, esto hará que el código externo modifique la matriz int [] y afecte los campos de la clase Score. Si el código externo no es confiable, esto ocasionará riesgos de seguridad.
Corrija el método de construcción de Score para que la modificación de la matriz mediante código externo no afecte el campo int [] de la instancia de Score.