A classe String fornece uma variedade de métodos para pesquisar e extrair substrings. Os métodos comumente usados são:
// 是否包含子串:
"Hello".contains("ll"); // true
Subcadeia de pesquisa
exemplo:
"Hello".indexOf("l"); // 2
"Hello".lastIndexOf("l"); // 3
"Hello".startsWith("He"); // true
"Hello".endsWith("lo"); // true
Extrair substring
exemplo:
"Hello".substring(2); // "llo"
"Hello".substring(2, 4); "ll"
Substituir substring
Para substituir uma substring em uma string, existem dois métodos. Um é baseado na substituição de caractere ou string:
String s = "hello";
s.replace('l', 'w'); // "hewwo"，所有字符'l'被替换为'w'
s.replace("ll", "~~"); // "he~~o"，所有子串"ll"被替换为"~~"
Cadeia de divisão
Para dividir uma string, use o método split (), e a expressão regular também é passada:
String s = "A,B,C,D";
String[] ss = s.split("\\,"); // {"A", "B", "C", "D"}
String concatenada
Para concatenar strings, use o método estático join (), que conecta a matriz de string com a string especificada:
String[] arr = {
"A", "B", "C"};
String s = String.join("***", arr); // "A***B***C"
String de formato
A string fornece o método formatted () e o método estático format (). Você pode passar outros parâmetros, substituir os marcadores de posição e gerar uma nova string:
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));
}
}
Existem vários marcadores de posição e vários parâmetros são passados posteriormente. O tipo de parâmetro deve ser consistente com o espaço reservado. Freqüentemente, usamos esse método para formatar informações. Os marcadores de posição comumente usados são:
% s: exibir string;
% d: exibir inteiro;
% x: exibir inteiro hexadecimal;
% f: exibir número de ponto flutuante.
Os marcadores de posição também podem ser formatados, por exemplo:% .2f significa exibir duas casas decimais. Se você não tiver certeza de qual espaço reservado usar, sempre use% s, porque% s pode exibir qualquer tipo de dados.
Conversão de tipo
Para converter qualquer tipo básico ou tipo de referência em uma string, você pode usar o método estático valueOf () . Este é um método sobrecarregado, o compilador selecionará automaticamente o método apropriado de acordo com os 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 converter uma string em outros tipos, ela precisa se basear na situação. Por exemplo, para converter uma string para o tipo int:
int n1 = Integer.parseInt("123"); // 123
int n2 = Integer.parseInt("ff", 16); // 按十六进制转换，255
Converta a string para o tipo booleano:
boolean b1 = Boolean.parseBoolean("true"); // true
boolean b2 = Boolean.parseBoolean("FALSE"); // false
Preste atenção especial ao fato de que Integer tem um método getInteger (String), que não converte uma string em um int, mas converte a variável do sistema correspondente à string em um inteiro:
Integer.getInteger("java.version"); // 版本号，11
Converter entre string e char
char[] cs = "Hello".toCharArray(); // String -> char[]
String s = new String(cs); // char[] -> String
Se a matriz char [] for modificada, String não mudará:
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 os resultados são:
Hello
Hello
Isso ocorre porque quando uma nova instância de String é criada por meio de nova String (char []), ela não fará referência direta ao array char [] passado, mas fará uma cópia. Portanto, modificar o array char [] externo não afetará o array char [] dentro da instância String, porque são dois arrays diferentes.
Pode-se ver a partir do design de imutabilidade de String que, se o objeto recebido for alterado, precisamos copiá-lo em vez de referenciá-lo diretamente.
Por exemplo, o código a seguir projeta uma classe Score para armazenar as pontuações de um grupo de alunos:
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]
Observar a saída duas vezes, porque Score faz referência direta ao array int [] passado externamente, isso fará com que o código externo modifique o array int [] e afete os campos da classe Score. Se o código externo não for confiável, isso causará riscos de segurança.
Corrija o método de construção de Score para que a modificação da matriz por código externo não afete o campo int [] da instância de Score.