字符串的操作方法总结_字符串常用操作

关于 String 类的基本操作，可以分为以下几类：

在整理这些内容之前，需要提醒的是关于字符串的操作方法我们是不需要像其他操作一样手动导包的，其 String 和 StringBuffer 等类封装在 java.lang 包中，我们之间调用字符串方法即可！

一、String 基本操作方法

1）获取字符串长度 length()

格式：int length = str.length();

2）获取字符串中的第 i 个字符 charAt(i)

// i 为字符串的索引号，可得到字符串任意位置处的字符，保存到字符变量中

格式：char ch = str.char(i);

3）获取指定位置的字符 getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)

//先要创建一个容量足够大的 char 型数组，数组名为 array

格式：char array[] = new char[80];

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

这样我们就可以将字符串中想要的范围内的字符都复制到字符数组中，将字符数组打印输出即可。

与 getChars() 类似的方法有一个 getBytes()，两者使用上基本相同，只是 getBytes() 方法创建的是 byte 类型的数组，而 byte 编码是默认字符集编码，它是用编码表示的字符。

直接上代码简单演示一下三种方法的用法：

//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); //**括号中不可带其他字符串
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

运行结果如下

二、String 字符串的比较

明确的数值之间可以很方便地进行比较，那么字符串该如何进行比较呢？字符串的比较是将两个字符串从左到右逐个字符逐个字符进行比较，比较的依据是当前字符的 Unicode 编码值，知道比较出两个不同字符的大小。

字符串比较也分为两大类：一类是字符串大小的比较，这样的比较有三种结果，大于、等于已经小于；还有一类比较方法就是比较两个字符串是否相等，这样产生的比较结果无非就两种，ture 和 false。

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);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

运行结果如下：

三、String 与其他数据类型的转换

有时候我们需要在字符串与其他数据类型之间做一个转换，例如将字符串数据变为整形数据，或者反过来将整形数据变为字符串类型数据，"20"是字符串，20就是整形数。我们都知道整形和浮点型之间可以利用强制类型转换和自动类型转换两种机制实现两者之间的转换，那么"20"和20这两种属于不同类型的数据就需要用到String类提供的数据类型转换方法了。

由于数据类型较多，因而转换使用的方法也比较多，在此我就用一个表格罗列一下：

简单测试的小demo如下：

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); //将字符型转换为字符串类型
　　}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

四、String 字符串查找

我们有时候需要在一段很长的字符串中查找我们需要的其中一部分字符串或者某个字符，String类恰恰提供了相应的查找方法，这些方法返回的都是目标查找对象在字符串中的索引值，所以都是整形值。具体分类情况如下：

字符串查找无非分为两类：查找字符串和查找单个字符，而查找又可分为查找对象在字符串中第一次出现的位置和最后一次出现的位置，再扩展一步，我们可以缩小查找范围，在指定范围之内查找其第一次或最后一次出现的位置。

//字符与字符串查找
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);
　　}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

结果如下：

五、String 截取与拆分

这类方法是截取出一个长字符串中的一个子字符串或将字符串按照正则表达式的要求全部拆分保存到一个字符串数组中。具体方法如下所示：

//字符串截取与拆分
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");
　　　　}
　　}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

代码执行结果如下：

六、String 替换或修改

有时候我们需要对原字符串中的某些子字符串进行替换或修改，此时也需要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 a = "1-1-1-1";
       String result = a.replace("-","");　　　　

　　　　String str6 = str1.replaceFirst("(?i)VBASIC","C++");
　　　　String str7 = str2.replaceFirst("(?-i)VBASIC","C++");
　　　　
　　　　System.out.println("替换后的str1："+str6);
　　　　System.out.println("替换后的str2:"+str7);
　　}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

代码执行结果如下：

//字符串替换
public class StringFindandReplace {
　　public static void main(String args[]){
　　
　　　　String a = "1-1-1-1";
　　　　
　　　　/***1、replace() 方法将目标字符串中的指定字符（串）替换成新的字符（串）***/
　　　　
　　　　String result1 = a.replace("-","");
　　　　
　　　　System.out.println("result1："+result1);
　　　　
　　　　
　　　　/***2、replaceFirst() 方法将目标字符串中匹配某正则表达式的第一个子字符串替换成新的字符串***/
　　　　
　　　　String result2 = a.replaceFirst("1","0");
　　　　
　　　　System.out.println("result2："+result2);
　　　　
　　　　
　　　　/***3、replaceAll() 方法将目标字符串中匹配某正则表达式的所有子字符串替换成新的字符串***/
　　　　
　　　　String result3 = a.replaceAll("1","0");
　　　　
　　　　System.out.println("result3："+result3);
　　}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

代码执行结果如下：

	result1：1111
	result2：0-1-1-1
	result3：0-0-0-0
1
2
3

七、String 拼接成字符串

有时候我们需要使用指定分隔符拼接一个字符串。
从 JDK 1.8 开始，Java 字符串才包含 join() 方法。在 join() 方法中，为每个元素添加了分隔符。如果为 null 元素，则添加 “null”。

//拼接成字符串
public class StringFindandReplace {
　　public static void main(String args[]){
　　
　　　　// 字符串数组
        String []arr={"ab","ce","df"};
        System.out.println(String.join(",",arr));


        // 集合
        List<String> list=new ArrayList<>();
        list.add("s1");
        list.add("s5");
        list.add("s3");
        System.out.println(String.join("-",list));

        // 显示时间
        String date = String.join("/","01","25","2020");
        System.out.print(date);
        String time = String.join(":", "12","10","10");
        System.out.println(" "+time);
　　}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

结果：

	ab,ce,df
	s1-s5-s3
	01/25/2020 12:10:10
1
2
3

---

好事定律：每件事最后都会是好事，如果不是好事，说明还没到最后。