【Java基础】Java字符串的处理

目录

一、Java定义字符串

1.直接定义字符串

2.用构造函数创建字符串：

二、Java连接字符串

1.使用连接运算符

2.使用 concat() 方法

3.连接其他类型数据

三、Java获取字符串长度（length()）

四、Java转换大小写（toLowerCase()和toUpperCase()）

五、Java去除空格（trim()）

六、Java提取子字符串（substring()）

七、Java分割字符串（spilt()）

八、Java字符串的比较（equals()、equalsIgnoreCase()和compareTo()）

1.equals() 方法

2.equalsIgnoreCase() 方法

3.compareTo() 方法

九、Java字符串的替换（replace()、replaceFirst()和replaceAll()）

1.replace() 方法

2.replaceFirst() 方法

3.replaceAll() 方法

十、Java查找字符串（indexOf()、lastlndexOf()和charAt()）

1.根据字符查找

2.根据索引查找

十一、Java字符串的加密解密

十二、Java StringBuffer类详解：追加、反转、删除字符串及替换字符串中的某个字符

1.创建 StringBuffer 类

2.追加字符串

3.替换字符

4.反转字符串

5.删除字符串

十三、Java正则表达式

1.元字符

2.限定符

总结

---

一、Java定义字符串

在Java中定义一个字符串最简单的方法是用双引号把它包围起来。这种用双引号括起来的一串字符实际上都是 String 对象，如字符串"Hello"在编译后即成为 String 对象。因此也可以通过创建 String 类的实例来定义字符串。

不论使用哪种形式创建字符串，字符串对象一旦被创建，其值是不能改变的，但可以使用其他变量重新赋值的方式进行更改。

1.直接定义字符串

直接定义字符串是指使用双引号表示字符串中的内容，例如"Hello Java"、"Java 编程"等。具体方法是用字符串常量直接初始化一个 String 对象，示例如下：

1.	String str="Hello Java";
或者
1.	String str;
2.	str="Hello Java";

注意：字符串变量必须经过初始化才能使用。

2.用构造函数创建字符串：

String str2=new String("Hello Java");

两种方式的比较：
第一种方式创建的字符串对象是放在了常量池中，而第二中方式创建的字符串对象是放在堆内存中

二、Java连接字符串

对于已经定义的字符串，可以对其进行各种操作。连接多个字符串是字符串操作中最简单的一种。通过字符串连接，可以将两个或多个字符串、字符、整数和浮点数等类型的数据连成一个更大的字符串。

1.使用连接运算符

“+”运算符是最简单、最快捷，也是使用最多的字符串连接方式。在使用“+”运算符连接字符串和 int 型（或 double 型）数据时，“+”将 int（或 double）型数据自动转换成 String 类型。

例 1

下面的实例使用“+”运算符连接了 3 个数组和 1 个字符串。

1.	public static void main(String[] args)
2.	{
3.	    int[] no=new int[]{501,101,204,102,334};    //定义学号数组
4.	    String[] names=new String[]{"张城","刘丽丽","李国旺","孟红霞","贺宁"};    //定义姓名数组
5.	    String[] classes=new String[]{"数学","语文","数学","英语","英语"};    //定义课程数组
6.	    System.out.println("本次考试学生信息如下：")；
7.	    //循环遍历数组，连接字符串
8.	    for(int i=0;i<no.length;i++)
9.	    {
10.	        System.out.println("学号："+no[i]+"|姓名："+names[i]+"|课程："+dasses[i]+"|班级："+"初二（三）班");
11.	    }
12.	}

上述代码首先创建了 3 个包含有 5 个元素的数组，然后循环遍历数组，遍历的次数为 5。在循环体内输出学号、姓名和课程，并使用“+”运算符连接班级最终形成一个字符串。程序运行后输出结果如下：

本次考试学生信息如下：
学号：501|姓名：张城|课程：数学|班级：初二（三）班
学号：101|姓名：刘丽丽|课程：语文丨班级：初二（三）班
学号：204|姓名：李国旺|课程：数学|班级：初二（三）班
学号：102|姓名：孟红霞|课程：英语|班级：初二（三）班
学号：334|姓名：贺宁|课程：英语|班级；初二（三）班

当定义的字符串值的长度过长时，可以分作多行来写，这样比较容易阅读。例如：

1.	String str="Welcome to"+"Beijing"+"欢迎来到"+"北京。"+"北京我的故乡。";

2.使用 concat() 方法

在Java中，String 类的 concat() 方法实现了将一个字符串连接到另一个字符串的后面。concat() 方法语法格式如下：

字符串 1.concat(字符串 2);

执行结果是字符串 2 被连接到字符串 1 后面，形成新的字符串。

例 2

如 concat() 方法的语法所示，concat() 方法一次只能连接两个字符串，如果需要连接多个字符串，需要调用多次 concat() 方法。

下面创建一个实例代码来演示如何使用 concat() 方法连接多个字符串。

1.	public static void main(String[] args)
2.	{
3.	    String info="三国演义、";
4.	    info=info.concat("西游记、");
5.	    info=info.concat("水漭传、");
6.	    info=info.concat("红楼梦");
7.	    System.out.println(info);
8.	    String cn="中国";
9.	    System.out.println(cn.concat("北京").concat("海淀区").concat("人民公园"));
10.	}

执行该段代码，输出的结果如下所示。

三国演义、西游记、水浒传、红楼梦
中国北京海淀区人民公园

3.连接其他类型数据

前面介绍的例子都是字符串与字符串进行连接，其实字符串也可同其他基本数据类型进行连接。如果将字符串同这些数据类型数据进行连接，此时会将这些数据直接转换成字符串。

例 3

编写一个 Java 程序，实现将字符串与整型、浮点型变量相连并输出结果。实现代码如下：

1.	public static void main(String[] args)
2.	{
3.	    String book="三国演义";    //字符串
4.	    int price=59;    //整型变量
5.	    float readtime=2.5f;    //浮点型变量
6.	    System.out.println("我买了一本图书，名字是："+book+"\n价格是："+price+"\n我每天阅读"+readtime+"小时");
7.	}

上述代码实现的是将字符串变量 book 与整型变量 price 和浮点型变量 readtime 相连后将结果输出。在这里定义的 price 和 readtime 都不是字符串，当它们与字符串相连时会自动调用自身的 toString() 方法将其转换成字符串形式，然后再参与连接运算。因此，程序运行后的结果如下所示：

我买了一本图书，名字是：三国演义
价格是：59
我每天阅读2.5小时

假设将本例中的输出语句修改为如下形式：

1.	System.out.println("我买了一本图书，名字是："+book+"\n 价格是："+price+"\n我每天阅读"+(price+readtime)+"小时");

因为运算符具有优先级，而圆括号的优先级最高，所以先计算 price 与 readtime 的和，再将结果转换成字符串进行连接。此时的运行结果如下所示：

我买了一本图书，名字是：三国演义
价格是：59
我每天阅读61.5小时

注意：只要“+”运算符的一个操作数是字符串，编译器就会将另一个操作数转换成字符串形式，所以应该谨慎地将其他数据类型与字符串相连，以免出现意想不到的结果。

三、Java获取字符串长度（length()）

在Java中，要获取字符串的长度，可以使用 String 类的 length() 方法，其语法形式如下：

字符串名.length();

例 1

在学生信息管理系统中对管理员密码有这样的规定，即密码长度必须大于 6 位且小于 12 位。因为密码太短容易被破解，太长的话又不容易记住。这就需要首先获取用户输入的密码字符串，然后调用 length() 方法获取长度，再做进一 步的长度判断，最终实现代码如下所示：

1.	import java.util.Scanner;
2.	public class Test05
3.	{
4.	    public static void main(String[] args)
5.	    {
6.	        String sys="学生信息管理";//字义一个字符串表示系统名称
7.	        System.out.println("欢迎进入《"+sys+"》系统");//输出系统名称
8.	        System.out.println("请设置一个管理员密码：");
9.	        Scanner input=new Scanner(System.in);
10.	        String pass=input.next();//获取用户输入的密码
11.	        int length=pass.length();//获取密码的长度
12.	        if(length>6&&length<12)
13.	        {
14.	            System.out.println("密码长度符合规定。");
15.	            System.out.println("已生效，请牢记密码："+pass);
16.	        }
17.	        else if(length>=12)
18.	            System.out.println("密码过长。");
19.	        else
20.	            System.out.println("密码过短。");
21.	    }
22.	}

上述代码将用户输入的密码保存到字符串变量 pass 中，再调用 pass.length() 方法将长度保存到 length 变量，然后使用 if 语句根据长度给出提示。

运行程序，当输入的密码过短时，运行结果如下所示：

欢迎进入《学生信息管理》系统
请设置一个管理员密码：
123456
密码过短。

当输入的密码符合规定时，运行结果如下所示：

欢迎进入《学生信息管理》系统
请设置一个管理员密码：
abc12345678
密码长度符合规定。
已生效，请牢记密码：abc12345678

四、Java转换大小写（toLowerCase()和toUpperCase()）

String 类的 toLowerCase() 方法可以将字符串中的所有字符全部转换成小写，而非字母的字符不受影响。语法格式如下：

字符串名.toLowerCase()    //将字符串中的字母全部转换为小写，非字母不受影响

toUpperCase() 则将字符串中的所有字符全部转换成大写，而非字母的字符不受影响。语法格式如下：

字符串名.toUpperCase()    //将字符串中的字母全部转换为大写，非字母不受影响

例如：

1.	String str="abcdef 我 ghijklmn";
2.	System.out.println(str.toLowerCase());    //输出：abcdef 我 ghijklmn
3.	System.out.println(str.toUpperCase());    //输出：ABCDEF 我 GHIJKLMN

例 1

下面的实例代码演示了如何对字符串应用大写和小写转换。

1.	public static void main(String[] args)
2.	{
3.	    String en="The Day You Went Away";    //定义原始字符串
4.	    System.out.println("原始字符串："+en);
5.	    System.out.println("使用 toLowerCase() 方法之后为："+en.toLowerCase());
6.	    System.out.println("使用 toUpperCase() 方法之后为："+en.toUpperCase());
7.	    
8.	    en="sun sun 是太阳，圆圆挂在 SKY 上";    //定义原始字符串
9.	    System.out.println("原始字符串："+en);
10.	    System.out.println("使用 toLowerCase() 方法之后为："+en.toLowerCase());
11.	    System.out.printIn("使用 toUpperCase() 方法之后为："+en.toUpperCase());
12.	    
13.	    en="select id,name,sex,address,birthday from students";
14.	    System.out.println("原始字符串："+en);    //定义原始字符串
15.	    System.out.println("使用 toLowerCase() 方法之后为："+en.toLowerCase());
16.	    System.out.println("使用 toUpperCase() 方法之后为："+en.toUpperCase());
17.	}

代码比较简单，运行后的输出结果如下：

原始字符串：The Day You Went Away
使用 toLowerCase() 方法之后为：the day you went away
使用 toUpperCase() 方法之后为：THE DAY YOU WENT AWAY
原始字符串：sun sun 是太阳，圆圆挂在 SKY 上
使用 toLowerCase() 方法之后为：sun sun 是太阳，圆圆挂在 sky 上
使用 toUpperCase() 方法之后为：SUN SUN 是太阳，圆圆挂在 SKY 上
原始字符串：select id,name,sex,address,birthday from students
使用 toLowerCase() 方法之后为：select id,name,sex,address,birthday from students
使用 toUpperCase() 方法之后为：SELECT ID,NAME,SEX,ADDRESS,BIRTHDAY FROM STUDENTS

五、Java去除空格（trim()）

字符串中存在的首尾空格一般情况下都没有任何意义，如字符串" Hello"，但是这些空格会影响到字符串的操作，如连接字符串或比较字符串等，所以应该去掉字符串中的首尾空格，这需要使用 String 类提供的 trim() 方法。

trim() 方法的语法形式如下：

字符串名.trim()

使用 trim() 方法的示例如下：

1.	String str=" hello ";
2.	System.out.println(str.length());    //输出 9
3.	System.out.println(str.trim().length());    //输出 5

从该示例中可以看出，字符串中的每个空格占一个位置，直接影响了计算字符串的长度。

技巧

如果不确定要操作的字符串首尾是否有空格，最好在操作之前调用该字符串的 trim() 方法去除首尾空格，然后再对其进行操作。

六、Java提取子字符串（substring()）

String 类的 substring() 方法用于对字符串进行提取，该方法主要有两种重载形式，下面分别介绍。

1. substring(int beginIndex) 形式

此方式用于提取从索引位置开始至结尾处的字符串部分。调用时，括号中是需要提取字符串的开始位置，方法的返回值是提取的字符串。例如：

1.	String str="我爱 Java 编程";
2.	String result=str.substring(3);
3.	System.out.println(result);    //输出：Java 编程

2. substring(int beginIndex，int endIndex) 形式

此方法中的 beginIndex 表示截取的起始索引，截取的字符串中包括起始索引对应的字符；endIndex 表示结束索引，截取的字符串中不包括结束索引对应的字符，如果不指定 endIndex，则表示截取到目标字符串末尾。该方法用于提取位置 beginIndex 和位置 endIndex 位置之间的字符串部分。                        

注意：substring() 方法是按字符截取，而不是按字节截取。

例 1

创建一个字符串，对它使用 substring() 方法进行截取并输出结果。示例代码如下：

1.	public static void main(String[] args)
2.	{
3.	    String day="Today is Monday";    //原始字符串
4.	    System.out.println("substring(0)结果："+day.substring(0));
5.	    System.out.println("substring(2)结果："+day.substring(2));
6.	    System.out.println("substring(10)结果："+day.substring(10));
7.	    System.out.println("substring(2,10)结果："+day.substring(2,10));
8.	    System.out.println("substring(0,5)结果："+day.substring(0,5));
9.	}

输出结果如下所示：

substring(0)结果：Today is Monday
substring(2)结果：day is Monday
substring(10)结果：onday
substring(2,10)结果：day is M
substring(0,5)结果：Today

七、Java分割字符串（spilt()）

String 类的 split() 方法可以按指定的分割符对目标字符串进行分割，分割后的内容存放在字符串数组中。该方法主要有如下两种重载形式：

1.	str.split(String sign)
2.	str.split(String sign,int limit)

其中，str 为需要分割的目标字符串；sign 为指定的分割符，可以是任意字符串；limit 表示分割后生成的字符串的限制个数，如果不指定，则表示不限制，直到将整个目标字符串完全分割为止。

例 1

使用 split() 方法对字符串进行分割的实例如下：

1.	public static void main(String[] args)
2.	{
3.	    String Colors="Red,Black,White,Yellow,Blue";
4.	    String[] arr1=Colors.split(",");    //不限制元素个数
5.	    String[] arr2=Colors.split(",",3);    //限制元素个数为3
6.	    System.out.println("所有颜色为：");
7.	    for(int i=0;i<arr1.length;i++)
8.	    {
9.	        System.out.println(arr1[i]);
10.	    }
11.	    System.out.println("前三个颜色为：");
12.	    for(int j=0;j<arr2.length;j++)
13.	    {
14.	        System.out.println(arr2[j]);
15.	    }
16.	}

输出结果如下：

所有颜色为：
Red
Black
White
Yellow Blue
前三个颜色为：
Red
Black
White,Yellow,Blue

从输出的结果可以看出，当指定分割字符串后组成的数组长度（大于或等于 1）时，数组的前几个元素为字符串分割后的前几个字符，而最后一个元素为字符串的剩余部分。

例如，在该实例中，指定了 arr2 的长度为 3，而字符串 Colors 分割后组成的数组长度为 5。因此会将 arr2 中的前两个元素赋值为 Colors 分割后的前两个字符，arr2 中的第 3 个元素为 Colors 字符串的后 3 个字符组成的字符串。

八、Java字符串的比较（equals()、equalsIgnoreCase()和compareTo()）

在Java中，比较字符串的常用方法有 3 个：equals() 方法、equalsIgnoreCase() 方法、 compareTo() 方法。下面详细介绍这 3 个方法的使用。

1.equals() 方法

equals() 方法将逐个地比较两个字符串的每个字符是否相同。对于字符的大小写，也在检查的范围之内。equals() 方法的语法格式如下：

字符串1.equals(字符串2);

例如：

public class StringMethod6 {
    public static void main(String[] args) {
        // 用两种方法创建三个内容相同的字符串
        String str1 = "java";
        String str2 = "java";
        String str3 = new String("java");
        System.out.println("使用equals()方法比较str1和str2的结果为：" + str1.equals(str2));
        System.out.println("使用==运算符比较str1和str2的结果为：" + (str1 == str2));
        System.out.println("使用equals()方法比较str1和str3的结果为：" + str1.equals(str3));
        System.out.println("使用==运算符比较str1和str3的结果为：" + (str1 == str3));
    }
}

运行结果为：

使用equals()方法比较str1和str2的结果为：true
使用==运算符比较str1和str2的结果为：true
使用equals()方法比较str1和str3的结果为：true
使用==运算符比较str1和str3的结果为：false

代码中三个字符串str1，str2和str3的内容都是java，因此使用equals()方法对它们进行比较，其结果总是为true。

注意观察执行结果，其中使用==运算符比较str1和str2的结果为true，但使用==运算符比较的str1和str3的结果为false。这是因为==运算符比较的是两个变量的地址而不是内容。

要探究其原因，就要理解上述创建字符串的代码在计算机内存中是如何执行的。下面我们通过图解的形式来描述这三个变量是如何在内存中创建的。

1. 当执行String str1 = "hello;"语句时，会在内存的栈空间中创建一个str1，在常量池中创建一个"hello"，并将str1指向hello。

 

     2.当执行String str2 = "hello";语句时，栈空间中会创建一个str2，由于其内容与str1相同，会指向常量池中的同一个对象。所以str1与str2指向的地址是相同的，这就是==运算符比较str1和str2的结果为true的原因。

      3.当执行String str3 = new String("hello");语句时，使用了new关键字创建字符串对象，由于对象的实例化操作是在内存的堆空间进行的，此时会在栈空间创建一个str3，在堆空间实例化一个内容为hello的字符串对象，并将str3地址指向堆空间中的hello，这就是==运算符比较str1和str3的结果为false的原因。

 

2.equalsIgnoreCase() 方法

equalsIgnoreCase() 方法的作用和语法与 equals() 方法完全相同，唯一不同的是 equalsIgnoreCase() 比较时不区分大小写。例如：

1.	String str1="abc";
2.	String str2="ABC";
3.	System.out.println(str1.equalsIgnoreCase(str2));    //输出 true

例 2

在会员系统中需要输入用户名和密码进行检验，下面使用 equalsIgnoreCase() 方法实现检验登录时不区分用户名和密码的大小写，具体的代码实现如下所示。

1.	public static void main(String[] args)
2.	{
3.	    String sys="学生信息管理";
4.	    System.out.println("欢迎进入《"+sys+"》系统");
5.	    System.out.println("请输入管理员名称：");
6.	    Scanner input=new Scanner(System.in);
7.	    String name=input.next();    //获取用户输入的名称
8.	    System.out.println("请输入管理员密码：");
9.	    input=new Scanner(System.in);
10.	    String pass=input.next();    //获取用户输入的密码
11.	    //比较用户名与密码，注意此处忽略大小写
12.	    if(name.equalsIgnoreCase("admin")&&pass.equalsIgnoreCase("somboy"))
13.	    {   //验证
14.	        System.out.println("登录成功。");
15.	    }
16.	    else
17.	    {
18.	        System.out.println("登录失败。");
19.	    }
20.	}

在上述代码中，由于使用 equalsIgnoreCase() 方法进行比较，所以会忽略大小写判断。因此输入 ADMIN 和 SOMBOY 也会验证通过，如下所示：

欢迎进入《学生信息管理》系统
请输入管理员名称：
ADMIN
请输入管理员密码：
SOMBOY
登录成功。

否则输出结果如下所示：

欢迎进入《学生信息管理》系统
请输入管理员名称：
admin
请输入管理员密码：
sommboy
登录失败。

3.compareTo() 方法

compareTo() 方法用于按字典顺序比较两个字符串的大小，该比较是基于字符串各个字符的 Unicode 值。compareTo() 方法的语法格式如下：

str.compareTo(String otherstr);

它会按字典顺序将 str 表示的字符序列与 otherstr 参数表示的字符序列进行比较。如果按字典顺序 str 位于 otherster 参数之前，比较结果为一个负整数；如果 str 位于 otherstr 之后，比较结果为一个正整数；如果两个字符串相等，则结果为 0。

提示：如果两个字符串调用 equals() 方法返回 true，那么调用 compareTo() 方法会返回 0。

例 3

编写一个简单的 Java 程序，演示 compareTo() 方法比较字符串的用法，以及返回值的区别。代码如下：

1.	public static void main(String[] args)
2.	{
3.	    String str="A";
4.	    String str1="a";
5.	    System.out.println("str="+str);
6.	    System.out.println("str1="+str1);
7.	    System.out.println("str.compareTo(str1)的结果是："+str.compareTo(str1));
8.	    System.out.println("str1.compareTo(str)的结果是："+str1.compareTo(str));
9.	    System.out.println("str1.compareTo('a')的结果是："+str1.compareTo("a"));
10.	}

上述代码定义了两个字符串"A"和"a"， 然后调用 compareTo() 方法进行相互比较。最后一行代码拿"a"与"a"进行比较，由于两个字符串相同比较结果为 0。运行后的输出结果如下：

其实就是前面的字符的Unicode 值减去后面的字符的Unicode 值，A的Unicode 值为65，a的Unicode 值为97，所以A.compareTo(a).就等于65-97= -32,反之a.compareTo(A).就等于97-65= 32

str=A
str1=a
str.compareTo(str1)的结果是：-32
str1.compareTo(str)的结果是：32
str1.compareTo('a')的结果是：0

九、Java字符串的替换（replace()、replaceFirst()和replaceAll()）

在Java中，String 类提供了 3 种字符串替换方法，分别是 replace()、replaceFirst() 和 replaceAll()，本文将详细介绍它们的使用方法。

1.replace() 方法

replace() 方法用于将目标字符串中的指定字符（串）替换成新的字符（串），其语法格式如下：

字符串.replace(String oldChar, String newChar)

其中，oldChar 表示被替换的字符串；newChar 表示用于替换的字符串。replace() 方法会将字符串中所有 oldChar 替换成 newChar。

例 1

创建一个字符串，对它使用 replace() 方法进行字符串替换并输出结果。代码如下：

1.	public static void main(String[] args)
2.	{
3.	    String words="hello java,hello php";
4.	    System.out.println("原始字符串是'"+words+"'");
5.	    System.out.println("replace(\"l\",\"D\")结果："+words.replace("l","D"));
6.	    System.out.println("replace(\"hello\",\"你好\")结果："+words.replace("hello","你好 "));
7.	    words="hr's dog";
8.	    System.out.println("原始字符串是'"+words+"'");
9.	    System.out.println("replace(\"r's\",\"is\")结果："+words.replace("r's","is"));
10.	}

输出结果如下所示：

原始字符串是'hello java,hello php'
replace("l","D")结果：heDDo java,heDDo php
replace("hello”,"你好")结果：你好 java,你好 php 原始字符串是"hr's dog'
replace("r's","is")结果：his dog

2.replaceFirst() 方法

replaceFirst() 方法用于将目标字符串中匹配某正则表达式的第一个子字符串替换成新的字符串，其语法形式如下：

字符串.replaceFirst(String regex, String replacement)

其中，regex 表示正则表达式；replacement 表示用于替换的字符串。例如：

1.	String words="hello java,hello php";
2.	String newStr=words.replaceFirst("hello","你好 ");
3.	System.out.println(newStr);    //输出：你好 java,hello php

3.replaceAll() 方法

replaceAll() 方法用于将目标字符串中匹配某正则表达式的所有子字符串替换成新的字符串，其语法形式如下：

字符串.replaceAll(String regex, String replacement)

其中，regex 表示正则表达式，replacement 表示用于替换的字符串。例如：

1.	String words="hello java,hello php";
2.	String newStr=words.replaceAll("hello","你好 ");
3.	System.out.println(newStr);    //输出：你好 java,你好 php

十、Java查找字符串（indexOf()、lastlndexOf()和charAt()）

字符串查找分为两种形式：一种是在字符串中获取匹配字符（串）的索引值，另一种是在字符串中获取指定索引位置的字符。

1.根据字符查找

String 类的 indexOf() 方法和 lastlndexOf() 方法用于在字符串中获取匹配字符（串）的索引值。
 

1. indexOf() 方法

indexOf() 方法用于返回字符（串）在指 定字符串中首次出现的索引位置，如果能找到，则返回索引值，否则返回 -1。该方法主要有两种重载形式：

1.	str.indexOf(value)
2.	str.indexOf(value,int fromIndex)

其中，str 表示指定字符串；value 表示待查找的字符（串）；fromIndex 表示查找时的起始索引，如果不指定 fromIndex，则默认从指定字符串中的开始位置（即 fromIndex 默认为 0）开始查找。

例如，下列代码在字符串"Hello Java”中查找字母 v 的索引位置。

1.	String s="Hello Java";
2.	int size=s.indexOf('v');    //size的结果为8

上述代码执行后 size 的结果为 8，它的查找过程如图 1 所示。

                                                图1 indexOf() 方法查找字符过程 

例 1

编写一个简单的 Java 程序，演示 indexOf() 方法查找字符串的用法，并输出结果。代码如下：

1.	public static void main(String[] args)
2.	{
3.	    String words="today,monday,sunday";
4.	    System.out.println("原始字符串是'"+words+"'");
5.	    System.out.println("indexOf(\"day\")结果："+words.indexOf("day"));
6.	    System.out.println("indexOf(\"day\",5)结果："+words.indexOf("day",5));
7.	    System.out.println("indexOf(\"o\")结果："+words.indexOf("o"));
8.	    System.out.println("indexOf(\"o\",6)结果："+words.indexOf("o",6));
9.	}

运行后的输出结果如下：

原始字符串是'today,monday,sunday'
indexOf("day")结果：2
indexOf("day",5)结果：9
indexOf("o")结果：1
indexOf("o",6)结果：7

2. lastlndexOf() 方法

lastIndexOf() 方法用于返回字符（串）在指定字符串中最后一次出现的索引位置，如果能找到则返回索引值，否则返回 -1。该方法也有两种重载形式：

1.	str.lastIndexOf(value)
2.	str.lastlndexOf(value, int fromIndex)

注意：lastIndexOf() 方法的查找策略是从右往左查找，如果不指定起始索引，则默认从字符串的末尾开始查找。

例 2

编写一个简单的 Java 程序，演示 lastIndexOf() 方法查找字符串的用法，并输出结果。代码如下：

1.	public static void main(String[] args)
2.	{
3.	    String words="today,monday,Sunday";
4.	    System.out.println("原始字符串是'"+words+"'");
5.	    System.out.println("lastIndexOf(\"day\")结果："+words.lastIndexOf("day"));
6.	    System.out.println("lastIndexOf(\"day\",5)结果："+words.lastIndexOf("day",5));
7.	    System.out.println("lastIndexOf(\"o\")结果："+words.lastIndexOf("o"));
8.	    System.out.println("lastlndexOf(\"o\",6)结果："+words.lastIndexOf("o",6));
9.	}

运行后的输出结果如下：

原始字符串是'today,monday,Sunday'
lastIndexOf("day")结果：16
lastIndexOf("day",5)结果：2
lastIndexOf("o")结果：7
lastlndexOf("o",6)结果：1

2.根据索引查找

String 类的 charAt() 方法可以在字符串内根据指定的索引查找字符，该方法的语法形式如下：

字符串名.charAt(索引值)

charAt() 方法的使用示例如下：

1.	String words="today,monday,sunday";
2.	System.out.println(words.charAt(0));    //结果：t
3.	System.out.println(words.charAt(1));    // 结果：o
4.	System.out.println(words.charAt(8));    // 结果：n

十一、Java字符串的加密解密

为了保证程序的安全，经常采用数据加密的方法。Java中提供了专门用于加密运算的类和接口。

除了使用加密类和接口外，还可以通过多种方式实现字符串的加密。其中常用的就是获取字符串的字节数组，之后对字节数组中的每个字节都进行运算，得到新的内容，这时所获得的字符串与原字符串将不相同，以此达到加密的效果；解密时再将加密字符串进行相反的运算，这样即可得到原字符串。

本实例简单介绍如何通过数据运算实现字符串的加密和解密，实现步骤如下。

(1) 创建一个静态的 encryptAndDencrypt() 方法，在该方法中传入两个参数。代码如下：

1.	public static String encryptAndDencrypt(String value, char secret)
2.	{
3.	    byte[] bt=value.getBytes();    //将需要加密的内容转换为字节数组
4.	    for(int i=0;i<bt.length;i++)
5.	    {
6.	        bt[i]=(byte)(bt[i]^(int)secret);    //通过异或运算进行加密
7.	    }
8.	    String newresult=new String(bt,0,bt.length);    //将加密后的字符串保存到 newresult 变量中
9.	    return newresult;
10.	}

上述代码首先将需要加密的内容转换为字节数组，接着遍历字节数组中的内容，在 for 语句中通过异或运算进行加密，然后将加密后的字符串保存到 newresult 变量中。最后返回 newresult 变量的值。

(2) 在 main() 方法中添加代码，接收用户在控制台输入的内容并输出，然后调用 encryptAndDencrypt() 方法对字符串分别进行加密和解密，并将加密和解密后的内容输出。代码如下：

1.	public static void main(String[] args)
2.	{
3.	    Scanner scan=new Scanner(System.in);
4.	    char secret='8';    //加密文字符
5.	    System.out.println("请输入您想加密的内容：");
6.	    String pass=scan.next();
7.	    System.out.println("原字符串内容："+pass);
8.	    String encryptResult=encryptAndDencrypt(pass,secret);
9.	    System.out.println("加密后的内容："+encryptResult);
10.	    String uncryptResult=encryptAndDencrypt(encryptResult,secret);
11.	    System.out.println("解密后的内容："+uncryptResult);
12.	}

(3) 执行上述代码进行测试，如下所示。

1.	请输入您想加密的内容：
2.	hello,java
3.	原字符串内容：hello,java
4.	加密后的内容：P]TTWRYNY
5.	解密后的内容：hello,java

十二、Java StringBuffer类详解：追加、反转、删除字符串及替换字符串中的某个字符

在Java中，除了通过 String 类创建和处理字符串之外，还可以使用 StringBuffer 类来处理字符串。StringBuffer 类可以比 String 类更高效地处理字符串。

因为 StringBuffer 类是可变字符串类，创建 StringBuffer 类的对象后可以随意修改字符串的内容。每个 StringBuffer 类的对象都能够存储指定容量的字符串，如果字符串的长度超过了 StringBuffer 类对象的容量，则该对象的容量会自动扩大。

1.创建 StringBuffer 类

StringBuffer 类提供了 3 个构造方法来创建一个字符串，如下所示：

• StringBuffer() 构造一个空的字符串缓冲区，并且初始化为 16 个字符的容量。
• StringBuffer(int length) 创建一个空的字符串缓冲区，并且初始化为指定长度 length 的容量。
• StringBuffer(String str) 创建一个字符串缓冲区，并将其内容初始化为指定的字符串内容 str，字符串缓冲区的初始容量为 16 加上字符串 str 的长度。

使用 StringBuffer 类的构造函数的示例如下：

1.	//定义一个空的字符串缓冲区，含有16个字符的容量
2.	StringBuffer str1=new StringBuffer();
3.	
4.	//定义一个含有10个字符容量的字符串缓冲区
5.	StringBuffer str2=new StringBuffer(10);
6.	
7.	//定义一个含有(16+4)的字符串缓冲区，"青春无悔"为4个字符
8.	StringBuffer str3=new StringBuffer("青春无悔");
9.	/*
10.	*输出字符串的容量大小
11.	*capacity()方法返回字符串的容量大小
12.	*/
13.	System.out.println(str1.capacity());    //输出 16
14.	System.out.println(str2.capacity());    //输出 10
15.	System.out.println(str3.capacity());    //输出 20

上述代码声明了 3 个 StringBuffer 对象 str1、str2 和 str3，并分别对其进行初始化。str1.capacity() 用于查看 str1 的容量，接着以同样的方式对 str2 和 str3 进行容量查看的操作。

2.追加字符串

StringBuffer 类的 append() 方法用于向原有 StringBuffer 对象中追加字符串。该方法的语法格式如下：

StringBuffer 对象.append(String str)

该方法的作用是追加内容到当前 StringBuffer 对象的末尾，类似于字符串的连接。调用该方法以后，StringBuffer 对象的内容也发生了改变，例如：

1.	StringBuffer buffer=new StringBuffer("hello,");    //创建一个 StringBuffer 对象
2.	String str="World!";
3.	buffer.append(str);    //向 StringBuffer 对象追加 str 字符串
4.	System.out.println(buffer.substring(0));    //输出：Hello,World!

例 1

每个新学期开始，学校都会针对本学期课程列出必修课程。编写一个 Java 程序，要求用户向控制台循环录入五门必修课程名称，并将这五个名称进行连接，最后输出连接后的字符串。代码如下：

1.	import java.util.Scanner;
2.	public class Testl9
3.	{
4.	    public static void main(String[] args)
5.	    {
6.	        StringBuffer sys=new StringBuffer("校内课程管理");
7.	        System.out.println("欢迎进入《"+sys+"》系统");
8.	        //声明课程名称字符串
9.	        StringBuffer courseName=new StringBuffer();
10.	        System.out.println("请录入本期的五门必修课名称：");
11.	        Scanner input=new Scanner(System.in);
12.	        //循环接收控制台输入的字符串
13.	        String name="";
14.	        for(int i=0;i<5;i++)
15.	        {
16.	            name=input.next();
17.	            courseName.append(name+"\t");
18.	            if(i==4)
19.	            {
20.	                System.out.println("录入完毕!");
21.	            }
22.	        }
23.	        System.out.println("本学期的必修课程有：\n"+courseName);
24.	}

在该程序中，首先声明一个空的 StringBuffer 对象，然后声明并初始化 courseName 变量，该变量用于存储用户从控制台输入的课程名称，接着使用 for 循环语句来循环接收用户输入数据。在循环体中，调用 StringBuffer 对象的 append() 方法对用户输入的字符串进行追加，当用户录完五门课程的名称后，程序将输出“录入完毕！”的提示信息。最后输出 String-Buffer 对象字符串。

运行程序，执行结果如下所示：

欢迎进入《校内课程管理》系统
请录入本期的五门必修课名称：
Java语言基础
SQL查询数据库
模拟电路
Java面向对象编程
体育
录入完毕!
本学期的必修课程有：Java语言基础  SQL查询数据库  模拟电路  Java面向对象编程  体育

3.替换字符

StringBuffer 类的 setCharAt() 方法用于在字符串的指定索引位置替换一个字符。该方法的语法格式如下：

StringBuffer 对象.setCharAt(int index, char ch);

该方法的作用是修改对象中索引值为 index 位置的字符为新的字符 ch，例如：

1.	StringBuffer sb=new StringBuffer(“hello");
2.	sb.setCharAt(1,'E');
3.	System.out.println(sb);    //输出：hEllo
4.	sb.setCharAt(0,'H');
5.	System.out.println(sb);    //输出：HEllo
6.	sb.setCharAt(2,'p');
7.	System.out.println(sb);    //输出：HEplo

4.反转字符串

StringBuffer 类中的 reverse() 方法用于将字符串序列用其反转的形式取代。该方法的语法格式如下：

StringBuffer 对象.reverse();

使用 StringBuffer 类中的 reverse() 方法对字符串进行反转的示例如下：

1.	StringBuffer sb=new StringBuffer("java");
2.	sb.reverse();
3.	System.out.println(sb);    //输出：avaj

5.删除字符串

StringBuffer 类提供了 deleteCharAt() 和 delete() 两个删除字符串的方法，下面详细介绍。

1. deleteCharAt() 方法

deleteCharAt() 方法用于移除序列中指定位置的字符，该方法的语法格式如下：

StringBuffer 对象.deleteCharAt(int index);

deleteCharAt() 方法的作用是删除指定位置的字符，然后将剩余的内容形成一个新的字符串。例如：

1.	StringBuffer sb=new StringBuffer("She");
2.	sb.deleteCharAt(2);
3.	System.out.println(sb);    //输出：Se

执行该段代码，将字符串 sb 中索引值为 2 的字符删除，剩余的内容组成一个新的字符串，因此对象 sb 的值为 Se。

2. delete() 方法

delete() 方法用于移除序列中子字符串的字符，该方法的语法格式如下：

StringBuffer 对象.delete(int start,int end);

其中，start 表示要删除字符的起始索引值（包括索引值所对应的字符），end 表示要删除字符串的结束索引值（不包括索引值所对应的字符）。该方法的作用是删除指定区域以内的所有字符，例如：

1.	StringBuffer sb=new StringBuffer("hello jack");
2.	sb.delete(2,5);
3.	System.out.println(sb);    //输出：he jack
4.	sb.delete(2,5);
5.	System.out.println(sb);    //输出：heck

执行该段代码，将字符串"hello jack"索引值为 2（包括）到索引值为 5（不包括）之间的所有字符删除，因此输出的新的字符串的值为"he jack"。

十三、Java正则表达式

正则表达式是一种可以用于模式匹配和替换的规范，一个正则表达式就是由普通的字符（如字符 a~z）以及特殊字符（元字符）组成的文字模式，它用以描述在查找文字主体时待匹配的一个或多个字符串。

正则表达式作为一个模板，将某个字符模式与所搜索的字符串进行匹配。本文简单了解一下如何使用正则表达式来操作字符串。

1.元字符

正则表达式中含有一些具有特殊意义的字符，这些特殊字符称为正则表达式的元字符。例如“\\d”表示 0~9 的任何一个数字，“\d”就是元字符。正则表达式中有多种元字符，常用的元字符如表 1 所示。

表1 正则表达式常用的元字符

元字符	正则表达式的写法	说明
.	"."	代表任意一个字符
\d	"\\d"	代表 0~9 的任何一个数字
\D	"\\D"	代表任何一个非数字字符
\s	"\\s"	代表空白字符，如"\t’’和’’\n”
\S	"\\S"	代表非空白字符
\W	"\\W"	代表不可用于标识符的字符
\p {Lower}	\\p {Lower}	代表小写字母 {a~z}
\p {Upper}	\\p {Upper}	代表大写字母 {A~Z}
\p {ASCII}	\\p {ASCII}	ASCII 字符
\p {Alpha}	\\p {Alpha}	字母字符
\p {Digit}	\\p {Digit}	十进制数字，即 [0~9]
\p {Alnum}	\\p {Alnum}	数字或字母字符
\p {Punct}	\\p {Punct}	标点符号：!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~
\p {Graph}	\\p {Graph}	可见字符：[\p{Alnum}\p{Punct}]
\p {Print}	\\p {Print}	可打印字符：[\p{Graph}\x20]
\p {Blank}	\\p {Blank}	空格或制表符：[\t]
\p {Cntrl}	\\p {Cntrl}	控制字符：[\x00-\x1F\x7F]

在正则表达式中，可以使用方括号括起来若干个字符来表示一个元字符。这个元字符可以代表方括号中的任何一个字符，例如字符串“reg="a4"” “reg="b4"”和“reg="c4"”都是与“reg="[abc]4"”匹配的字符串。

注意：在正则表达式中，"."代表任何一个字符，因此如果想在正则表达式中使用普通意义的点字符，那么必须使用转义字符。

2.限定符

正则表达式中允许使用限定修饰符来限定元字符出现的次数，例如，“B*”表示 B 字母可以在字符串中出现零次或多次。正则表达式中可以使用多种限定符，如表 2 所示。

表2 正则表达式常用的限定符

限定符	?	*	+	{n}	{n,}	{n,m}
说明	零次或一次	零次或多次	一次或多次	正好出现 n 次	至少出现 n 次	出现 n~m 次

正则表达式验证IP地址

IP 地址是网络上每台计算机的唯一标识，因此 IP 地址的错误输入将使程序无法运行。下面使用前面学习的正则表达式知识，编写一个Java程序来验证 IP 地址是否合法。

在定义正则表达式之前，首先要知道一个正确 IP 地址的格式及组成部分。IP 地址由 4 字节构成，每字节的值为 0~255，各字节通过一个句点分隔。因此，IP 地址中的每字节有至少一个，至多三个数字。

下面是为 IP 地址编写的正则表达式：

1.	\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}

以上正则表达式对 IP 做简单的匹配，不完全和 IP 的规则一致。如果想完全匹配，读者可以重新修改匹配的正则表达式。

创建 Test22 类，在该类的 main() 方法中 编写验证 IP 地址的代码。代码如下：

1.	import java.util.Scanner;
2.	import java.util.regex.Matcher;
3.	import java.util.regex.Pattern;
4.	public class Test22
5.	{
6.	    public static void main(String[] args)
7.	    {
8.	        String regex="\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}";
9.	        String answer="Y";
10.	        do
11.	        {
12.	            System.out.print("请输入 IP 地址：");
13.	            Scanner scan=new Scanner(System.in);
14.	            String phone=scan.next();    //接收用户在控制台输入的电话号码
15.	            Pattern pattern=Pattern.compile(regex);    //编译正则表达式
16.	            Matcher matcher=pattern.matcher(phone);    //创建给定输入模式的匹配器
17.	            boolean bool=matcher.matches();
18.	            if(bool)
19.	            {   //如果验证通过
20.	                System.out.println("输入的 IP 地址正确。");
21.	            }
22.	            else
23.	            {
24.	                System.out.println("输入的IP地址格式错误。");
25.	            }
26.	            System.out.print("是否继续输入？（Y/N 或者 y/n)");
27.	            answer=scan.next();
28.	        }while(answer.equalsIgnoreCase("Y"));
29.	        System.out.println("程序结束。");
30.	    }
31.	}

运行程序，然后输入不同格式的 IP 地址,输出结果如下所示：

请输入 IP 地址：11.154.15.1
输入的 IP 地址正确。
是否继续输入？（Y/N 或者 y/n)y
请输入 IP 地址：22a.7.68.9
输入的IP地址格式错误。
是否继续输入？（Y/N 或者 y/n)n
程序结束。

---

总结

各位小主，如果感觉有一点点帮助到你的话，麻烦留下赞赞一枚哦~