Resumo do método de operação de string

As operações básicas da classe String podem ser divididas nas seguintes categorias:

Antes de classificar esse conteúdo, precisamos lembrar que não precisamos importar manualmente o pacote como outras operações para o método de operação da string. As classes como String e StringBuffer são encapsuladas no pacote java.lang e chamamos o método string É isso!

1. Método de operação básica de string

1) Obter o comprimento da stringcomprimento()

Observação: int length = str.length();

2) Obtenha o i-ésimo caractere na stringcharAt(i)

// i é o número de índice da string, você pode obter o caractere em qualquer posição na string e salvá-lo na variável de caractere

Formato: char ch = str.char(i);

3) Obtenha o personagem na posição especificadagetChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)

//Primeiro crie um array de caracteres com capacidade grande o suficiente, o nome do array é array

Formato: char array[] = new char[80];

str.getChars(indexBegin, indexEnd, array, arrayBegin);

indexBegin	O índice inicial da string a ser copiada
indexEnd	O índice final da string a ser copiada, indexEnd - 1
variedade	O nome da matriz da matriz de caracteres definida anteriormente
arrayBegin	O número do índice da posição onde o array array começa a ser armazenado

Dessa forma, podemos copiar todos os caracteres no intervalo desejado na string para a matriz de caracteres e imprimir a matriz de caracteres.

Existe um método getBytes() semelhante a getChars(), que são basicamente os mesmos em uso, exceto que o método getBytes() cria uma matriz de tipo de byte e a codificação de byte é a codificação padrão do conjunto de caracteres, que é o caractere representado pela codificação.

Vá diretamente para o código para demonstrar brevemente o uso dos três métodos:

//String类基本操作方法
public class StringBasicOpeMethod {
    
    
    public static void main(String args[]){
    
    
    
        String str = "如何才能变得像棋哥一样优秀？算了吧，憋吹牛逼！"; //定义一个字符串
        
        System.out.println(str);  //输出字符串
        
        /***1、length()方法***/
        
        int length = str.length();//得到字符串长度
        
        System.out.println("字符串的长度为："+length);
        
        /***2、charAt()方法***/
        
        char ch = str.charAt(7);  //得到索引为7的字符
        
        System.out.println("字符串中的第8个字符为："+ch);
        
        /***3、getChars()方法***/
        
        char chardst[] = new char[80]; //定义容量为80的字符数组，用于存储从字符串中提取出的一串字符
        
        str.getChars(0,14,chardst,0);
        
        //System.out.println("字符数组中存放的内容为："+chardst);//错误，输出的是编码
        
        System.out.println(chardst); //**括号中不可带其他字符串
    }
}

O resultado da operação é o seguinte

Em segundo lugar, a comparação de strings String

Valores numéricos claros podem ser comparados facilmente, então como as strings devem ser comparadas? A comparação de strings é comparar duas strings caractere por caractere da esquerda para a direita. A comparação é baseada no valor de codificação Unicode do caractere atual, e o tamanho de dois caracteres diferentes pode ser comparado.

A comparação de strings também é dividida em duas categorias: uma é a comparação do tamanho da string, essa comparação tem três resultados, maior que, igual a e menor que; outro tipo de comparação é comparar se duas strings são iguais e a comparação resultante Existem apenas dois tipos de resultados, verdadeiros e falsos.

public class StringCompareMethod {
    
    
    public static void main(String args[]){
    
    
        String str1 = "elapant";
        String str2 = "ELEPANT";  //定义两个字符串
        String str3 = "Apple";
        String str4 = "apple";
        
        /***1、compareTo方法***/
        //不忽略字符串字符大小写
        if(str1.compareTo(str2)>0){
    
    
            System.out.println(str1+">"+str2);
        }else if(str1.compareTo(str2) == 0){
    
    
            System.out.println(str1+"="+str2);
        }else{
    
    
            System.out.println(str1+"="+str2);
        }
        
        
        /***2、compareToIgnoreCase()方法***/
        //忽略字符串字符大小写
        if(str1.compareToIgnoreCase(str2)>0){
    
    
            System.out.println(str1+">"+str2);
        }else if(str1.compareToIgnoreCase(str2) == 0){
    
    
            System.out.println(str1+"="+str2);
        }else{
    
    
            System.out.println(str1+"<"+str2);
        }
        
        
        /** 3、equals()方法
        * 	相等情况下必须保证二者长度相等
        */
        //不忽略字符串字符大小写
        if(str3.equals(str4)){
    
    
            System.out.println(str3+"="+str4);
        }else{
    
    
            System.out.println(str3+"!="+str4);
        }


        /***4、equalsIgnoreCase()方法***/
        //忽略字符串字符大小写
        if(str3.equalsIgnoreCase(str4)){
    
    
            System.out.println(str3+"="+str4);
        }else{
    
    
            System.out.println(str3+"!="+str4);
        }
    }
}

O resultado da operação é o seguinte:

3. Conversão entre String e outros tipos de dados

Às vezes, precisamos fazer uma conversão entre strings e outros tipos de dados, como converter dados de string em dados inteiros ou, inversamente, converter dados inteiros em dados do tipo string, "20" é uma string e 20 é um número inteiro. Todos nós sabemos que tipos inteiros e de ponto flutuante podem ser convertidos entre os dois por meio de conversão obrigatória de tipo e conversão automática de tipo. Então, "20" e 20, dois tipos de dados que pertencem a tipos diferentes, precisam usar a classe String O método de conversão de tipo de dados fornecido.

Devido ao grande número de tipos de dados, existem muitos métodos para conversão, aqui vou listá-los em uma tabela:

tipo de dados	cadeia para outro	Outros métodos de conversão para strings 1	Outros métodos de conversão para strings 2
byte	Byte.parseByte(str)	String.valueOf([byte] bt)	Byte.toString([byte] bt)
int	Integer.parseInt(str)	String.valueOf([int] i)	Int.toString([int] i)
longo	Long.parseLong(str)	String.valueOf([longo] l)	Long.toString([long] l)
flutuador	Float.parseFloat(str)	String.valueOf([float] f))	Float.toString(str)
dobro	double.parseDouble(str)	String.valueOf([duplo] d)	Double.toString([double] b)
Caracteres	str.charAt()	String.valueOf([char] c)	Character.toString([char] c)
boleano	Boolean.getBoolean(str)	String.valueOf([booleano] b)	Boolean.toString([boolean] b)

Uma pequena demonstração para um teste simples é a seguinte:

public class StringConvert {
    
    
　　public static void main(String args[]){
    
    
　　
　　　　/***将字符串类型转换为其他数据类型***/
　　　　boolean bool = Boolean.getBoolean("false"); //字符串类型转换为布尔类型
　　　　int integer = Integer.parseInt("20"); //字符串类型转换为整形
　　　　long LongInt = Long.parseLong("1024"); //字符串类型转换为长整形
　　　　float f = Float.parseFloat("1.521"); //字符串类型转换为单精度浮点型
　　　　double d = Double.parseDouble("1.52123");//字符串类型转换为双精度浮点型
　　　　byte bt = Byte.parseByte("200"); //字符串类型转换为byte型
　　　　char ch = "棋哥".charAt(0);
　　　　
　　　　/***将其他数据类型转换为字符串类型方法1***/
　　　　String strb1 = String.valueOf(bool); //将布尔类型转换为字符串类型
　　　　String stri1 = String.valueOf(integer); //将整形转换为字符串类型
　　　　String strl1 = String.valueOf(LongInt); //将长整型转换为字符串类型
　　　　String strf1 = String.valueOf(f); //将单精度浮点型转换为字符串类型
　　　　String strd1 = String.valueOf(d); //将double类型转换为字符串类型
　　　　String strbt1 = String.valueOf(bt); //将byte转换为字符串类型
　　　　String strch1 = String.valueOf(ch); //将字符型转换为字符串类型
　　}
}

Quatro, pesquisa de cadeia de caracteres

Às vezes, precisamos encontrar uma parte da string ou um determinado caractere que precisamos em uma string muito longa. A classe String fornece apenas os métodos de pesquisa correspondentes. Esses métodos retornam o índice do objeto de pesquisa de destino na string. são todos valores inteiros. A classificação específica é a seguinte:

A pesquisa de string nada mais é do que duas categorias: pesquise uma string e pesquise um único caractere, e a pesquisa pode ser dividida na posição da primeira ocorrência e da última ocorrência do objeto na string e, em seguida, expanda uma etapa, nós pode restringir o intervalo de pesquisa, encontra sua primeira ou última ocorrência dentro do intervalo especificado.

//字符与字符串查找
public class StringSearchChar {
    
    
　　public static void main(String args[]){
    
    
　　
　　　　String str = "How qi bocome handsome like qi ge"; //定义一个长字符串
　　　　System.out.println("该字符串为："+str);
　　　　
　　　　
　　　　/***1、indexOf()方法查找字符首个出现位置格式1,2***/
　　　　
　　　　int index1 = str.indexOf(" "); //找到第一个空格所在的索引
　　　　int index2 = str.indexOf(" ",4); //找到索引4以后的第一个空格所在索引
　　　　
　　　　System.out.println("第一个空格所在索引为："+index1);
　　　　System.out.println("索引4以后的第一个空格所在索引为："+index2);
　　　　System.out.println("*****************");
　　　　
　　　　
　　　　/***2、lastIndexOf()方法查找字符最后出现位置格式1,2***/
　　　　
　　　　int index3 = str.lastIndexOf(" "); //找到最后一个空格所在的索引
　　　　int index4 = str.lastIndexOf(" ",10);//找到索引10以后的第一个空格所在索引
　　　　
　　　　System.out.println("最后一个空格所在索引为："+index3);
　　　　System.out.println("索引10以前最后一个空格所在索引为："+index4);
　　　　System.out.println("*****************");
　　　　
　　　　
　　　　/***3、indexOf()方法查找子字符串第一次出现位置格式1,2***/
　　　　
　　　　int index5 = str.indexOf("qi"); //找到"qi"子字符串第一次出现位置的索引
　　　　int index6 = str.indexOf("qi",5);//找到索引5以后子字符串"qi"第一个出现位置所在索引
　　　　
　　　　System.out.println("子字符串qi第一次出现位置的索引号为："+index5);
　　　　System.out.println("索引5以后子字符串qi第一次出现位置的索引号为："+index6);
　　　　System.out.println("*****************");
　　　　
　　　　
　　　　/***4、lastIndexOf()方法查找子字符串最后一次出现位置格式1,2***/
　　　　
　　　　int index7 = str.lastIndexOf("qi");
　　　　int index8 = str.lastIndexOf("qi",5);
　　　　
　　　　System.out.println("子字符串qi最后一次出现位置的索引号为："+index7);
　　　　System.out.println("索引号5以后子字符串qi最后一次出现位置的索引号为："+index8);
　　}
}

O resultado é o seguinte:

Cinco, interceptação e divisão de cordas

Esse tipo de método serve para interceptar uma substring em uma string longa ou dividir a string em uma matriz de strings de acordo com os requisitos da expressão regular. O método específico é o seguinte:

//字符串截取与拆分
public class StringCutAndSplit {
    
    
　　public static void main(String args[]){
    
    
　　
　　　　String str = "How to cut and split strings"; //定义字符串
　　　　System.out.println("字符串为："+str);
　　　　
　　　　int length = str.length(); //获取字符串长度，保存到变量中
　　　　System.out.println("字符串长度为："+length);
　　　　
　　　　
　　　　/***1、substring()方法截取出第一个单词和最后一个单词***/
　　　　
　　　　//首先配合indexOf()和lastIndexOf()方法找到第一个单词和最后一个单词前后空格的索引号
　　　　//第一个单词的左范围索引为0，最后一个单词的右范围索引为length-1
　　　　
　　　　int firstIndex = str.indexOf(' '); //找到第一个空格所在位置
　　　　
　　　　int lastIndex = str.lastIndexOf(' '); //找到最后一个空格所在位置
　　　　
　　　　System.out.println("第一个空格的索引号为："+firstIndex);
　　　　System.out.println("最后一个空格的索引号为："+lastIndex);
　　　　
　　　　
　　　　//利用substring()方法根据第一个和最后一个单词的索引范围截取出第一个和最后一个单词
　　　　
　　　　String firstWord = str.substring(0,firstIndex); //截取出第一个单词
　　　　
　　　　String lastWord = str.substring(lastIndex+1,length);//截取出最后一个单词
　　　　
　　　　System.out.println("第一个单词为："+firstWord);
　　　　System.out.println("最后一个单词为："+lastWord);
　　　　
　　　　
　　　　/***2、split()方法拆分出所有单词***/
　　　　
　　　　String stringArray[] = str.split(" "); //根据空格要求拆分出所有单词保存到字符串数组中
　　　　
　　　　System.out.println("拆分之后的各个词汇为：");
　　　　
　　　　for(int i = 0;i<stringArray.length;i++){
    
    
　　　　　　System.out.print(stringArray[i]+"\t");
　　　　}
　　}
}

Os resultados da execução do código são os seguintes:

6. Substituição ou modificação de string

Finalmente chegou à última categoria de métodos, feliz! ! Às vezes, precisamos substituir ou modificar algumas substrings na string original.Nesse momento, também precisamos de alguns métodos simples, rápidos e fáceis de usar fornecidos pela classe String.

//字符串替换与修改
public class StringFindandReplace {
    
    
　　public static void main(String args[]){
    
    
　　
　　　　String str1 = "vbasic";
　　　　String str2 = "Vbasic";
　　　　
　　　　System.out.println("str1 = "+str1);
　　　　System.out.println("str2 = "+str2);
　　　　
　　　　/***1、concat()方法将两字符串合并***/
　　　　
　　　　String str3 = str1.concat(str2);
　　　　
　　　　System.out.println("str1和str2合并后的字符串为："+str3);
　　　　
　　　　
　　　　/***2、toLowerCase()方法将str1字符全部转换为小写***/
　　　　
　　　　String str4 = str1.toLowerCase();
　　　　
　　　　System.out.println("str1的字符全部转换为小写："+str4);
　　　　
　　　　
　　　　/***3、toUpperCase()方法将str2字符全部转换为大写***/
　　　　
　　　　String str5 = str2.toUpperCase();
　　　　
　　　　System.out.println("str2的字符全部转换为大写："+str5);
　　　　
　　　　
　　　　/***4、实现字符串的替换，原字符串内容不变***/
　　　　
　　　　String str6 = str1.replaceFirst("(?i)VBASIC","C++");
　　　　String str7 = str2.replaceFirst("(?-i)VBASIC","C++");
　　　　
　　　　System.out.println("替换后的str1："+str6);
　　　　System.out.println("替换后的str2:"+str7);
　　}
}

Os resultados da execução do código são os seguintes:

---

A lei das coisas boas: Tudo será bom no final, se não for bom, significa que ainda não é o fim.