字符串

字符串

字符串是Java开发中最常用的数据类型，它是双引号括起来的一系列字符的组合。例如：“hello world”，"请输入密码"等。

在Java中，String类、StringBuffer类、StringBuilder类都能表示字符串。

这个3个类都是Java官方定义好的类，我们主要学习它们的使用。通过对它们的学习，一方面掌握了解字符串的功能，掌握字符串的常用方法，另外一方面进一步掌握我们面向对象所学的各种语法。

一、API

（1）什么是API？

API（Application Programming Interface）：应用程序编程接口。它是厂商或者第三方提供好的一系列类库，这些类库能帮助你开发出你想要的项目。

例如：我想开发一款控制无人机飞行和拍照录像的软件，无人机的生产厂商已经提前开发好了飞机起飞、降落、向前飞、向后飞、向左飞、向右飞、拍照、录像等功能（即：已经定义好了类，也实现了类中上述的方法），我们在做开发的时候，只需要在自己的程序里导入开发商提供的类库，创建对应的对象，调用对应的方法即可。这些开发商提供的类库就是API。

Java API指的是JDK中提供的各种功能的Java类库。这些类库已经提供了完整的实现，我们不需要关心它如何实现的，只需要学会如何使用这些类即可。

（2）API文档

1. 什么是API文档

API文档是专门对API进行描述的文档。其实就是帮助文档或者说明书。API文档里会详细的介绍类的功能，类如何使用，方法需要什么参数，会返回什么结果等等。

2. API文档的获取

Java API文档既有线上版本，也有离线版本，以Java 8的API文档为例。

在线版API文档：

中文版：https://www.matools.com/api/java8

英文版（官方）：https://docs.oracle.com/javase/8/docs/api/index.html

离线版API文档（中文）：

下载地址（百度网盘）：链接: https://pan.baidu.com/s/1PJTzJ5vudabLtVvXnDrYTA 提取码: sxdt

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vebMJlZo-1615184758602)(13_字符串/image-20200520111536761.png)]

3. API文档的使用（离线）

1. 双击打开下载好的离线API文档

   [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1XjRpUvQ-1615184758633)(13_字符串/image-20200520112605605.png)]

2. 选择要查看的类（以Scanner类为例）

   方法一：先选包，再选类。—需要你知道类在什么包里。（Scanner在java.util包内）

   具体步骤：

   （1）找到 java.util包。

   [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OPm4LMXL-1615184758640)(13_字符串/image-20200520114241370.png)]

   （2）找到Scanner类。

   [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-o3Z5TptF-1615184758665)(13_字符串/image-20200520114430118.png)]

   方法二：直接搜索类。

   具体步骤：

   （1）显示出来边栏

   [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3pWoNBKs-1615184758667)(13_字符串/image-20200520121035145.png)]

   （2）查找要用的类

   [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-k6D1cj83-1615184758669)(13_字符串/image-20200520121217076.png)]

3. 查看类（以Scanner类为例）

   需求：通过Scanner获取用户输入的整数。

   （1）API文档包含的信息

   a. 类的基本信息

   [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-olrJbJ04-1615184758672)(13_字符串/image-20200520115200384.png)]

   ​ b. 类的介绍

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MRqZYgJN-1615184758673)(13_字符串/image-20200520115422131.png)]

​ c. 类的构造方法

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CCAFsuA3-1615184758677)(13_字符串/image-20200520115732749.png)]

​ d. 类的实例方法

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MoOSuvZC-1615184758678)(13_字符串/image-20200520115952117.png)]

​ e. 从父类继承的方法、实现的接口中的方法

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FKlBwUxG-1615184758681)(13_字符串/image-20200520120625620.png)]

​ f. 具体的方法

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9dfl8m42-1615184758683)(13_字符串/image-20200520122354301.png)]

​ （2）查看“获取用户输入的整数”对应的API

​ 方法列表中会有方法的简单描述。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mMJLa5jC-1615184758685)(13_字符串/image-20200520122910023.png)]

​ 方法的详细介绍。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iGF3ibEC-1615184758687)(13_字符串/image-20200520123342421.png)]

4. 使用Scanner类完成我们的功能（获取用户输入的整数）

   分析：通过查阅API文档，我们发现Scanner类中的nextInt()方法可以实现我们想要的功能。进一步查看nextInt()方法的描述，我们发现这是一个实例方法，需要用对象来调用，因此我们需要先创建Scanner对象，在用对象去调用nextInt()方法。

   通过看这个类的简介，我们发现，简介中已经给出来了，这个类的使用方式。

   [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PtmuVhPF-1615184758688)(13_字符串/image-20200520132523444.png)]

   编写代码，实现我们需要的功能。—别忘了导包。

   import java.util.Scanner;
   
   public class TestAPI {
   
   	public static void main(String[] args) {
   		Scanner sc = new Scanner(System.in);
   		int num = sc.nextInt();
   		System.out.println(num);
   	}
   
   }
   

（3）API文档实战

1. 使用Random类产生[5, 19]之间的随机数

1. 找到Random类。----在 java.util包中
2. 找到产生随机数的方法。
3. 实现需要的功能。

import java.util.Random;//别忘了导包

public class TestAPI {

	public static void main(String[] args) {
		//产生[5, 19]之间的随机数
		Random random = new Random();
		int num = random.nextInt(19 - 5 + 1) + 5;
		System.out.println(num);
	}

}

2. 使用Math类计算绝对值

1. 找到Math类。----在 java.lang包中。java.lang包不需要导包。
2. 找到求绝对值的方法。
3. 实现需要的功能。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ECbCUTyB-1615184758690)(13_字符串/image-20200520134114668.png)]

public class TestAPI {

	public static void main(String[] args) {
		int a = -5;
		int b = Math.abs(a);//静态方法，无需创建对象，直接用类名调用方法。
		System.out.println("a = " + a + ",b = " + b);
		double c = 3.14;
		double d = Math.abs(c);//静态方法，无需创建对象，直接用类名调用方法。
		System.out.println("c = " + c + ",d = " + d);
	}

}

3. 借助Math类计算2个点之间的距离。

1. 定义Point类，包含x和y，2个属性，以及计算两点之间距离的方法。
2. 创建Point对象，并测试代码的正误。

Point类：

public class Point {
	private double x;	//x坐标
	private double y;	//y坐标
	
	public Point() {
		super();
	}

	public Point(double x, double y) {
		super();
		this.x = x;
		this.y = y;
	}

	@Override
	public String toString() {
		return "Point [x=" + x + ", y=" + y + "]";
	}
	
	//计算2点之间的距离
	public double distanceToPoint(Point p) {
		double dx = p.x - this.x;
		double dy = p.y - this.y;
		//Math.pow(a, b)  计算 a的b次方的值。
		//Math.sqrt(a) 计算a的平方根
		double distance = Math.sqrt(Math.pow(dx, 2) + Math.pow(dy, 2));
		return distance;
	}
	
}

测试代码：

public class TestAPI {

	public static void main(String[] args) {
		Point p1 = new Point(0, 0);
		Point p2 = new Point(3, 4);
		double distance = p1.distanceToPoint(p2);
		System.out.println(distance);
	}

}

在线文档的使用和离线文档的使用一样，只不过文档是用浏览器查看的。

二、String类

（1）String类简介

String是 Java 中最常用的字符串类，双引号括起来的数据都是String类的对象。

因为String类是 java.lang包中的类，所以使用的时候无需导包。

String是不可变字符串类，不可变指的是字符串对象一旦创建，它的内容和长度是不可以修改的。String的底层用的是字符数组（char[]），JDK9之后String底层用的是字节数组（byte[]）。

（2）String的常用方法和案例

1. 构造方法

String类提供了很多构造方法，常用的构造方法如下：

方法	说明
String()	创建一个没有任何内容的字符串对象
String(char[] chs)	根据字符数组的内容，来创建一个字符串对象
String(char[] chs, int offset, int count)	创建一个字符串对象，字符串的内容是字符数组中下标从offset开始的count个字符
String(byte[] bytes)	根据字节数组的内容，来创建一个字符串对象
String(byte[] bytes, int offset, int count)	创建一个字符串对象，字符串的内容是字节数组中下标从offset开始的count个字节
String s = “abc”;	直接赋值的方式创建字符串对象，内容是abc，并未用任何构造方法。推荐

测试代码：

public class ClassTest {

	public static void main(String[] args) {
		//构造方法 String()
		String str1 = new String();
		System.out.println("str1:" + str1);
		
		//构造方法 String(char[] chs)
		char[] chs = {'h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd'};
		String str2 = new String(chs);
		System.out.println("str2:" + str2);
		
		//构造方法 String(char[] chs, int offset, int count)
		String str3 = new String(chs, 6, 5);
		System.out.println("str3:" + str3);
		
		//构造方法 String(byte[] bytes)
		byte[] bytes = {97, 98, 99, 100, 32, 65, 66, 67, 68};
		String str4 = new String(bytes);
		System.out.println("str4:" + str4);
		
		//构造方法 String(byte[] bytes, int offset, int count)
		String str5 =  new String(bytes, 2, 5);
		System.out.println("str5:" + str5);
		
		//直接赋值
		String str6 = "hello world";
		System.out.println("str6:" + str6);
	}

}

数字和字符的对应关系。（ASCII码表）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VAFYZYEi-1615184758691)(13_字符串/timg.jpg)]

a是97，A是65。a和A差32。

2. 字符串的内存表示

public class ClassTest {

	public static void main(String[] args) {
		char[] chs = {'a', 'b', 'c'};//char[] chs = new char[]{'a', 'b', 'c'};
		String str1 = new String(chs);
		String str2 = new String(chs);
		System.out.println(str1 == str2);//false
		
		String str3 = "abc";
		String str4 = "abc";
		System.out.println(str3 == str4);//true
		
		System.out.println(str1 == str3);//false
	}

}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TbGODizp-1615184758694)(13_字符串/image-20200520163526458.png)]

1. 在堆区创建字符数组，内容是abc，数组的起始地址是1000。注：new开辟的内存在堆区。
2. 将内存地址1000赋值给chs。
3. 在堆区创建字符串对象，对象的内存地址是1400，字符串对象的值是字符数组的地址1000。注：new开辟的内存在堆区。
4. 将内存地址1400赋值给str1。
5. 在堆区创建字符串对象，对象的内存地址是1600，字符串对象的值是字符数组的地址1000。注：new开辟的内存在堆区。
6. 将内存地址1400赋值给str2。
7. 在常量区创建字符串abc，内存地址是20000。常量区里同样的字符串只会有一个。
8. 将内存地址20000赋值给str3。
9. 将内存地址20000赋值给str4。

==是关系运算符，用来比较等于号两边是否相等。

基本类型：比较的是值是否相等

引用类型：比较的是地址是否相等。

总结：==只负责比较，等号两侧放的是值就比较值，放的是地址，就比较地址。

3. 字符串内容是否相同

方法：

public boolean equals(Object obj)  //判断当前字符串对象是否和参数中的字符串内容相同
public boolean equalsIgnoreCase(String anotherString)	//判断当前字符串对象是否和参数中的字符串内容相同，比较的时候忽略大小写

测试代码：

public class ClassTest {

	public static void main(String[] args) {
		char[] chs = {'a', 'b', 'c'};
		String str1 = new String(chs);
		String str2 = new String(chs);
		System.out.println(str1 == str2);//false
		System.out.println(str1.equals(str2));//true
        System.out.println(str1.equalsIgnoreCase("AbC"));//true
	}

}

实际开发中：判断字符串是否相等，指的是内容是否相等，而不是内存地址是否相等。

判断字符串内容是否相等使用equals方法。

如果要忽略大小写比较的话，使用equalsIgnoreCase方法。例如：判断验证码是否正确。

4. 用户登录案例

1. 需求：已知用户名(zhangsan)、密码(123456)。模拟用户登录（用户从控制台输入用户名和密码），一共3次输入机会，根据输入的情况给出相应的提示。

2. 分析：

   1. 正确的用户名和密码用两个字符串表示。
   2. 创建Scanner对象，用于接收用户的输入。
   3. 提示用户输入用户名，并接收输入的用户名。
   4. 提示用户输入密码，并接收输入的密码。
   5. 判断用户名是否正确。
   6. 步骤3~5通过循环实现。

3. 代码：

   import java.util.Scanner;
   
   public class ClassTest {
   
   	public static void main(String[] args) {
   		//需求：已知用户名(zhangsan)、密码(123456)。模拟用户登录（用户从控制台输入用户名和密码），
   		//一共3次输入机会，根据输入的情况给出相应的提示。
   		
   		//1. 正确的用户名和密码
   		String username = "zhangsan";
   		String password = "123456";
   		
   		//2. 创建Scanner对象
   		Scanner sc = new Scanner(System.in);
   		
   		//3. 通过循环判断3次内是否登录成功。
   		for(int i = 0; i < 3; i++) {
   			//提示输入用户名，并保存输入的用户名
   			System.out.print("请输入用户名：");
   			String u = sc.nextLine();
   			//提示输入密码，并保存输入的密码
   			System.out.print("请输入密码：");
   			String p = sc.nextLine();
   			//判断用户名和密码的正误
   			if(u.equals(username) && p.equals(password)) {
   				System.out.println("登录成功！");
   				break;//结束循环
   			}else {
   				System.out.println("登录失败！用户名或者密码错误，您还有" + (3 - 1 - i) + "次机会。");
   			}
   		}
   		
   	}
   
   }
   

5. 获取字符串的长度

方法：

public int length()		//获取当前字符串的长度，即多少个字符。

测试代码：

public class ClassTest {

	public static void main(String[] args) {
		String str = "hello";
		System.out.println(str.length());//5
	}

}

6. 获取字符串中指定位置的字符

方法：

public char charAt(int index)	//获取指定下标的字符。下标从0开始，最大下标是length()-1

测试代码：

public class ClassTest {

	public static void main(String[] args) {
		String str = "hello蓝鸥";
		char c1 = str.charAt(3);
		char c2 = str.charAt(5);
		System.out.println(c1);
		System.out.println(c2);
	}

}

7. 遍历字符串

1. 需求：从键盘输入一个字符串，遍历每一个字符。

2. 分析：

   1. 创建Scanner对象。
   2. 提示用户输入字符串，并接收用户输入的内容。
   3. 通过循环遍历每一个字符。需要用到 length方法和charAt方法。

3. 代码：

   import java.util.Scanner;
   
   public class ClassTest {
   
   	public static void main(String[] args) {
   		//需求：从键盘输入一个字符串，遍历每一个字符。
   		Scanner sc = new Scanner(System.in);
   		System.out.print("请输入一段文字：");
   		String str = sc.nextLine();
   		for(int i = 0; i < str.length(); i++) {
   			char c = str.charAt(i);
   			System.out.println(c);
   		}
   	}
   
   }
   

8. 统计字符个数

1. 需求：键盘录入一个字符串，统计该字符串中大写字母多少个，小写字母多少个，数字多少个。（不考虑汉字和其他字符）。

2. 分析：

   1. 创建一个Scanner对象。
   2. 提示用户输入，并接收输入的字符串。
   3. 定义3个变量分别记录大写字母、小写字母、数字的个数。
   4. 遍历字符串，判断每个字符的种类，对应的计数变量自增1。
   5. 循环结束后，输出各自的个数。

3. 代码：

   import java.util.Scanner;
   
   public class ClassTest {
   
   	public static void main(String[] args) {
   		//需求：键盘录入一个字符串，统计该字符串中大写字母多少个，小写字母多少个，数字多少个。（不考虑汉字和其他字符）。
   		Scanner sc = new Scanner(System.in);
   		System.out.print("请输入一段内容：");
   		String str = sc.nextLine();
   		int upperCount = 0;//大写字母的个数
   		int lowerCount = 0;//小写字母的个数
   		int numberCount = 0;//数字的个数
   		for(int i = 0; i < str.length(); i++) {
   			char c = str.charAt(i);
   			if(c >= 'A' && c <= 'Z') {
   				upperCount++;
   			}else if(c >= 'a' && c <= 'z'){
   				lowerCount++;
   			}else if(c >='0' && c <= '9') {
   				numberCount++;
   			}
   		}
   		System.out.println("大写字母：" + upperCount + "个");
   		System.out.println("小写字母：" + lowerCount + "个");
   		System.out.println("数字：" + numberCount + "个");
   	}
   
   }
   

9. 验证码

1. 需求：随机生成一个6位的验证码，判断用户从控制台录入的验证码是否正确。

2. 分析：

   1. 验证码的生成。定义一个包含包含全部大写字母、小写字母和数字的字符串，通过for循环，循环6次，每次从字符串中随机取出一个字符，拼接成一个完整的验证码。–需要创建Random对象。
   2. 创建Scanner对象。
   3. 获取用户输入的数据。
   4. 判断输入的数据和验证码是否一致（不区分大小写）。

3. 代码：

   import java.util.Random;
   import java.util.Scanner;
   
   public class ClassTest {
   
   	public static void main(String[] args) {
   		//需求：随机生成一个6位的验证码，判断用户从控制台录入的验证码是否正确。
   		String str = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
   		//code用于保存验证码的内容
   		String code = "";
   		Random random = new Random();
   		for(int i = 0; i < 6; i++) {
   			int index = random.nextInt(str.length());
   			char c = str.charAt(index);
   			code += c;
   		}
   		System.out.println("验证码是：" + code);
   		Scanner sc = new Scanner(System.in);
   		System.out.print("请输入验证码：");
   		String yourCode = sc.nextLine();
   		if(yourCode.equalsIgnoreCase(code)) {
   			System.out.println("验证码正确。");
   		}else {
   			System.out.println("您输入的验证码有误。");
   		}
   	}
   
   }
   

10. 字符串比较

方法：

public int compareTo(String anotherString)	//比较2个字符串的大小
public int compareToIgnoreCase(String anotherString)	//比较2个字符串的大小，忽略大小写

测试代码：

public class ClassTest {

	public static void main(String[] args) {
		String str1 = "hello";
		String str2 = "lanou";
		String str3 = "hello lanou";
		String str4 = "hEllo";
		String str5 = "hEllo lanou";

		//字符串在比较的时候，会一个字符一个字符比较。比较字符的差值，如果差值是正数，说明前面的大，如果是负数说明后面的大
		//如果差值是0，比较下个字符。直到比出来结果。
		//this.charAt(k)-anotherString.charAt(k)
		System.out.println(str1.compareTo(str2));
		
		//如果一个字符串的每个字符都比较完了，另外一个字符串还有字符。compareTo方法的返回值是剩余字符串的长度。
		//如果长度是正数，说明前面的大，如果是负数说明后面的大，如果是0，说明二者相等。
		System.out.println(str1.compareTo(str3));
		
		//忽略大小写的比较，规则同上，只是忽略了大小写
		System.out.println(str1.compareToIgnoreCase(str4));
		System.out.println(str1.compareToIgnoreCase(str5));
		
	}

}

11. 字符串拼接

方法：

public String concat(String str)	//返回一个由当前字符串和参数str拼接而成的新字符串。当前字符串内容不变。
+ //"+"也可以做字符串拼接。推荐使用 +

测试代码：

public class ClassTest {

	public static void main(String[] args) {
		String str1 = "hello";
		String str2 = str1.concat("lanou");
		System.out.println("str1：" + str1);//当前字符串内容不会发生改变。
		System.out.println("str2：" + str2);
		
		//推荐使用 + 进行拼接。  不仅能拼接字符串，还能拼接其他基本数据类型的数据。
		String str3 = str1 + "lanou" + 100;
		System.out.println("str3：" + str3);
	}	

}

12. 判断是否包含某字符串

方法：

public boolean contains(CharSequence s)	//判断当前字符串中是否包含字符序列s
public boolean startsWith(String prefix)	//判断当前字符串是否以某字符串开头
public boolean startsWith(String prefix, int toffset)	//判断当前字符串（从下标toffset开始）是否以某字符串开头
public boolean endsWith(String suffix)	//判断字符串是否以某字符串结尾

测试代码：

public class ClassTest {

	public static void main(String[] args) {
		String str1 = "hello lanou";
		System.out.println(str1.contains("llo"));//true
		System.out.println(str1.startsWith("he"));//true
		System.out.println(str1.startsWith("e"));//false
		System.out.println(str1.startsWith("llo", 2));//true
		System.out.println(str1.endsWith("ou"));//true
		System.out.println(str1.endsWith("lanou"));//true
	}	

}

13. 判断文件是否是图片

1. 需求：从键盘输入1个文件名（含后缀），判断这个文件是否是图片。

2. 分析：

   1. 创建一个字符串数组，保存图片格式的后缀。
   2. 创建Scanner对象。
   3. 提示用户输入文件名（含后缀），并接收用户输入的内容。
   4. 判断文件是不是图片。判断文件的后缀是否满足字符串数组中任何一种类型。

3. 代码：

   import java.util.Scanner;
   
   public class ClassTest {
   
   	public static void main(String[] args) {
   		//需求：从键盘输入1个文件名（含后缀），判断这个文件是否是图片。
   		//图片常见的拓展名
   		String[] types = {"bmp", "jpg", "jpeg", "png", "tiff", "gif"};
   		Scanner sc = new Scanner(System.in);
   		System.out.print("请输入一个文件名（含后缀）：");
   		String fileName = sc.nextLine();
   		//是否是图片
   		boolean isImage = false;
   		for(int i = 0; i < types.length; i++) {
   			String type = types[i];
   			if(fileName.endsWith(type)) {
   				isImage = true;
   				break;
   			}
   		}
   		
   		if(isImage == false) {
   			System.out.println("这不是一个图片！");
   		}else {
   			System.out.println("这是一个图片!");
   		}
   	}	
   
   }
   

14. 字符串替换

方法：

public String replace(char oldChar,char newChar)	//字符替换
public String replace(CharSequence target,CharSequence replacement)		//字符串替换

测试代码：

public class ClassTest {

	public static void main(String[] args) {
		
		String string = "hello world";
		String newString = string.replace('l', 'X');
		System.out.println("string:" + string);
		System.out.println("newString:" + newString);
		String str = "过年了，你妈逼你结婚了吗？";
		String newStr = str.replace("妈逼","***");
		System.out.println("str:" + str);
		System.out.println("newStr:" + newStr);
	}	

}

String是不可变字符串，创建之后，它的内容以及长度就固定了，不可以修改。替换实际是上创建了新的字符串。

15. 字符串的分割与合并

方法：

public String[] split(String regex)	//字符串按regex规则分割成多个小段
public static String join(CharSequence delimiter,CharSequence... s)	//将多个字符串合并成一个，合并的时候添加指定的连接符
public static String join(CharSequence delimiter, Iterable<? extends CharSequence> elements)  //将字符串数组合并成一个，合并的时候添加指定的连接符

测试代码：

public class ClassTest {

	public static void main(String[] args) {
		//某文件中存储了 用户的信息。提取出用户的用户名、密码、性别。
		String userInfo = "username:zhangsan===password:123456===sex:男";
		String[] infos = userInfo.split("===");//字符串分割
		for(int i = 0; i < infos.length; i++) {
			String info = infos[i];
			//System.out.println(info);
			String[] msgs = info.split(":");//字符串分割
			System.out.println(msgs[1]);
		}
		
		String[] strs = {"www", "lanou3g", "com"};
		String site = String.join(".", strs);//字符串合并。字符串数组
		System.out.println(site);
		
		String ip = String.join(".", "192", "168", "0", "13");//字符串合并。不定参数
		System.out.println(ip);
	}	

}

16. 字符串子串

方法：

public String subString(int beginIndex)	//获取从beginIndex开始到字符串结尾的子串
public String subString(int beginIndex, int endIndex) //获取从beginIndex到endIndex之间的子串，不含下标为endIndex的字符

测试代码：

public class ClassTest {

	public static void main(String[] args) {
		String str = "hello lanou,www.lanou3g.com";
		String subStr1 = str.substring(12);//www.lanou3g.com
		String subStr2 = str.substring(6, 11);//lanou
		System.out.println("str:" + str);
		System.out.println("subStr1:" + subStr1);
		System.out.println("subStr2:" + subStr2);
	}	

}

String是不可变字符串，创建之后，它的内容以及长度就固定了，不可以修改。求子串实际上返回的是新创建的字符串。

17. 字符串改变大小写

方法：

public String toLowerCase()		//将字符串改成全小写
public String toUpperCase()		//将字符串改成全大写

测试代码：

public class ClassTest {

	public static void main(String[] args) {
		String str = "你好HeLlo123wOrlD";
		String lowerCaseStr = str.toLowerCase();
		String upperCaseStr = str.toUpperCase();
		System.out.println(str);
		System.out.println(lowerCaseStr);
		System.out.println(upperCaseStr);
	}	

}

String是不可变字符串，创建之后，它的内容以及长度就固定了，不可以修改。改变大小写实际上是创建了新的字符串。

18. 删除字符串左右两侧的空白

方法：

public String trim()	//删除字符串左右两侧的空白(空格、换行符、缩进符)

测试代码：

public class ClassTest {

	public static void main(String[] args) {
		String str = " \n\t  hello  world \n\t ";
		String newStr = str.trim();
		System.out.println(str);
		System.out.println("-------");
		System.out.println(newStr);
	}	

}

19. 其他类型转字符串

方法：

public static String valueOf(数据类型 变量名)	//将其他数据类型的数据转换为字符串
通过""+变量进行转换，例如：int a = 10;  String str = a + "";

测试代码：

public class ClassTest {

	public static void main(String[] args) {
		//整数（int、long）转String
		String str1 = String.valueOf(100);
		System.out.println(str1);
		//小数（float、double）转String
		String str2 = String.valueOf(3.14);
		System.out.println(str2);
		//boolean转String
		String str3 = String.valueOf(true);
		System.out.println(str3);
		//char转String
		String str4 = String.valueOf('A');
		System.out.println(str4);
		
		//对象转String
		Person p = new Person("张三", 22);
		String str5 = String.valueOf(p);
		System.out.println(str5);
	}	

}

Person类：

public class Person {
	private String name;	//姓名
	private int age;		//年龄
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public Person() {
		super();
	}
	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + "]";
	}
	
}

（3）String类总结

String是Java中的不可变字符串类。对象创建的时刻就确定了大小以及内容。在使用过程中，内容不可以修改。虽然String类提供了很多和修改相关的方法（求子串、替换、大小写等），但本质上都是新建了字符串，原来的字符串并未发生任何变化。

学会String的使用固然重要，更重要的是要学会查阅文档。

如何查文档？

1. 先看要用的方法是 静态方法还是实例方法。
2. 如果是静态方法，无需创建对象，直接用类名调用方法。
3. 如果是实例方法，先找类的构造方法，通过构造方法创建对象，有了对象之后，用对象去调用实例方法。
4. 无论是静态方法还是实例方法，要摸清参数和返回值，按要求传参数，按返回值类型去接收方法的返回值。
5. 如果想详细了解方法，可以看方法的介绍。

三、StringBuffer类

（1）StringBuffer类简介

StringBuffer是 Java中的可变字符串类，可变指的是字符串的内容可变，即对字符串进行增、删、改操作，字符串本身会受到影响。

StringBuffer除了内容可变之外，另外一个特点就是线程安全。在多线程环境下，不同的线程对同一个字符串操作，结果不会紊乱。----多线程是后面的内容

因为StringBuffer类是 java.lang包中的类，所以使用的时候无需导包。

（2）StringBuffer常用方法

1. 构造方法

StringBuffer的构造方法如下：

方法	描述
StringBuffer()	创建一个初始容量为16的StringBuffer对象，里面没有任何内容
StringBuffer(int capacity)	创建一个指定容量的StringBuffer对象，里面没有任何内容。
StringBuffer(String str)	创建一个内容为str的StringBuffer对象，初始容量大小为16+str.length()
StringBuffer(charSequence seq)	创建一个内容为seq的StringBuffer对象，初始容量大小为16 + str.length()。charSequence是个接口，任何实现类都可以作为参数。

测试代码：

public class ClassTest {

	public static void main(String[] args) {
		StringBuffer sb1 = new StringBuffer();
		System.out.println("sb1:" + sb1);
		System.out.println("sb1:" + sb1.length());//StringBuffer对象的长度也是length()方法
		System.out.println(sb1.capacity());//capacity()是获取StringBuffer对象容量的方法
		
		System.out.println("------");
		StringBuffer sb2 = new StringBuffer(20);
		System.out.println("sb2:" + sb2);
		System.out.println("sb2:" + sb2.length());
		System.out.println(sb2.capacity());
		
		System.out.println("------");
		StringBuffer sb3 = new StringBuffer("hello world");
		System.out.println("sb3:" + sb3);
		System.out.println("sb3:" + sb3.length());
		System.out.println(sb3.capacity());
	}

}

2. 获取字符串的长度

方法：

public int length()		//获取当前字符串的长度，即多少个字符。

测试代码：

public class ClassTest {

	public static void main(String[] args) {
		StringBuffer sb = new StringBuffer("hello lanou");
		int length = sb.length();
		System.out.println(length);
	}

}

3. 获取字符串中指定位置的字符

方法：

public char charAt(int index)	//获取指定位置的字符。index取值范围是0~length()-1

测试代码：

public class ClassTest {

	public static void main(String[] args) {
		StringBuffer sb = new StringBuffer("hello lanou");
		char c1 = sb.charAt(0);
		char c2 = sb.charAt(7);
		System.out.println(c1);
		System.out.println(c2);
	}

}

4. 字符串的追加

方法：

public StringBuffer append(数据类型 变量名)	//将指定的数据拼接到当前字符串的末尾，并返回当前字符串对象。

测试代码：

public class ClassTest {

	public static void main(String[] args) {
		StringBuffer sb1 = new StringBuffer("hello ");
		StringBuffer sb2 = sb1.append("world");
		System.out.println("sb1:" + sb1);
		System.out.println("sb2:" + sb2);
		System.out.println(sb1 == sb2);
		
		sb1.append(true);
		sb1.append(' ');
		sb1.append(100);
		sb1.append(3.14);
		System.out.println(sb1);
		System.out.println(sb2);
	}

}

追加是在自身的基础上追加，并未产生新的StringBuffer对象。如果容量不够，自动扩容。

5. 验证码

1. 需求：随机生成一个6位的验证码，判断用户从控制台录入的验证码是否正确。

2. 分析：

   1. 验证码的生成。定义一个包含包含全部大写字母、小写字母和数字的字符串，通过for循环，循环6次，每次从字符串中随机取出一个字符，拼接成一个完整的验证码。–需要创建Random对象。
   2. 创建Scanner对象。
   3. 获取用户输入的数据。
   4. 判断输入的数据和验证码是否一致（不区分大小写）。

3. 代码：

   import java.util.Random;
   import java.util.Scanner;
   
   public class ClassTest {
   
   	public static void main(String[] args) {
   		//需求：随机生成一个6位的验证码，判断用户从控制台录入的验证码是否正确。
   		String str = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
   		//code用于保存验证码的内容
   		StringBuffer code = new StringBuffer();
   		Random random = new Random();
   		for(int i = 0; i < 6; i++) {
   			int index = random.nextInt(str.length());
   			char c = str.charAt(index);
   			code.append(c);
   		}
   		System.out.println("验证码是：" + code);
   		Scanner sc = new Scanner(System.in);
   		System.out.print("请输入验证码：");
   		String yourCode = sc.nextLine();
   		//StringBuffer转String使用 toString()方法
   		if(yourCode.equalsIgnoreCase(code.toString())) {
   			System.out.println("验证码正确。");
   		}else {
   			System.out.println("您输入的验证码有误。");
   		}
   	}
   
   }
   

6. 字符串的插入

方法：

public StringBuffer insert(int offset, 数据类型 变量)		//在原有字符串的基础是将数据插入到指定位置，返回值是自身。

测试代码：

public class ClassTest {

	public static void main(String[] args) {
		StringBuffer sb1 = new StringBuffer("我是好人");
		StringBuffer sb2 = sb1.insert(0, "别紧张，");
		System.out.println("sb1:" + sb1);
		System.out.println("sb2:" + sb2);
		System.out.println(sb1 == sb2);
		sb2.insert(5, "不");
		sb2.insert(7, "什么");
		System.out.println("sb1:" + sb1);
		System.out.println("sb2:" + sb2);
	}

}

插入是在自身的基础上插入，并未产生新的StringBuffer对象。如果容量不够，自动扩容。

7. 字符串的删除

方法：

public StringBuffer delete(int start, int end)	//删除下标从start到end的字符（不含下标end）
public StringBuffer deleteCharAt(int index)	//删除指定下标的单个字符

测试代码：

public class ClassTest {

	public static void main(String[] args) {
		StringBuffer sb1 = new StringBuffer("hello lanou");
		StringBuffer sb2 = sb1.delete(1, 4);//不含下标为4的字符
		System.out.println("sb1:" + sb1);
		System.out.println("sb2:" + sb2);
		System.out.println(sb1 == sb2);
		sb1.deleteCharAt(2);
		System.out.println("sb1:" + sb1);
		System.out.println("sb2:" + sb2);
	}

}

删除是在自身的基础上删除，并未产生新的StringBuffer对象。

8. 字符串内容的修改

方法：

public StringBuffer replace(int start, int end, String str)		//将字符串中下标从start到end（不含end）的内容替换成参数str的内容。
public void setCharAt(int index, char ch)	//将字符串中指定位置的字符替换为ch

测试代码：

public class ClassTest {

	public static void main(String[] args) {
		StringBuffer sb1 = new StringBuffer("hello lanou");
		StringBuffer sb2 = sb1.replace(6, 11, "蓝鸥");//不含下标为4的字符
		System.out.println("sb1:" + sb1);
		System.out.println("sb2:" + sb2);
		System.out.println(sb1 == sb2);
		sb1.setCharAt(0, 'H');
		System.out.println("sb1:" + sb1);
		System.out.println("sb2:" + sb2);
	}

}

修改是在自身的基础上修改，并未产生新的StringBuffer对象。

9. 字符串的反转

方法：

public StringBuffer reverse()	//将自身内容倒序

测试代码：

public class ClassTest {

	public static void main(String[] args) {
		StringBuffer sb1 = new StringBuffer("hello lanou");
		StringBuffer sb2 = sb1.reverse();
		System.out.println("sb1:" + sb1);
		System.out.println("sb2:" + sb2);
		System.out.println(sb1 == sb2);
	}

}

翻转是自身内容的反转，并未产生新的StringBuffer对象。

10. 字符串子串

方法：

public String subString(int start)	//获取从start开始到字符串结尾的子串
public String subString(int start, int end) //获取从start到end之间的子串，不含下标为end的字符

测试代码：

public class ClassTest {

	public static void main(String[] args) {
		StringBuffer sb = new StringBuffer("hello lanou,www.lanou3g.com");
		String subStr1 = sb.substring(12);//www.lanou3g.com
		String subStr2 = sb.substring(6, 11);//lanou
		System.out.println("sb:" + sb);
		System.out.println("subStr1:" + subStr1);
		System.out.println("subStr2:" + subStr2);
	}	

}

求子串会产生新的字符串（String）

11. StringBuffer和String的互转

方法：

public StringBuffer(String str)		//String转StringBuffer----StringBuffer的构造方法
public String toString()	//StringBuffer转String

测试代码：

public class ClassTest {

	public static void main(String[] args) {
		StringBuffer sb1 = new StringBuffer("hello lanou");
		StringBuffer sb2 = new StringBuffer("hello lanou");
		System.out.println(sb1 == sb2);//false
		System.out.println(sb1.equals(sb2));//false--StringBuffer自身没有重写父类的equal方法。
		String str1 = sb1.toString();
		String str2 = sb2.toString();
		System.out.println(str1.equals(str2));//true
	}

}

有些String类具有的功能，StringBuffer没有（例如：equals，equalsIgnoreCase、compareTo等）。可以通过转换把StringBuffer转换为String对象。

（3）StringBuffer总结

**StringBuffer是Java中的可变字符串类。**相比于String类，StringBuffer提供了增、删、改相关的方法。而且是对自身内容的增、删、改。

StringBuffer在多线程环境下访问是安全的，不会出现紊乱。

开发中，多数情况下String类就能满足我们的开发需求，如果需要对字符串自身进行修改，我们使用StringBuffer类（或StringBuilder类）。

StringBuffer和String可以相互转换。

四、StringBuilder类

（1）StringBuilder类简介

StringBuilder也是 Java中的可变字符串类，对字符串进行增、删、改操作，字符串本身会受到影响。

StringBuilder在用法上和StringBuffer几乎一模一样。唯一的区别就是StringBuilder在多线程环境下是不安全的。

因为StringBuilder类是 java.lang包中的类，所以使用的时候无需导包。

（2）StringBuilder常用方法

1. 构造方法

StringBuilder的构造方法如下：

方法	描述
StringBuilder()	创建一个初始容量为16的StringBuilder对象，里面没有任何内容
StringBuilder(int capacity)	创建一个指定容量的StringBuilder对象，里面没有任何内容。
StringBuilder(String str)	创建一个内容为str的StringBuilder对象，初始容量大小为16+str.length()
StringBuilder(charSequence seq)	创建一个内容为seq的StringBuilder对象，初始容量大小为16 + str.length()。charSequence是个接口，任何实现类都可以作为参数。

测试代码：

public class ClassTest {

	public static void main(String[] args) {
		StringBuilder sb1 = new StringBuilder();
		System.out.println("sb1:" + sb1);
		System.out.println("sb1:" + sb1.length());//StringBuilder对象的长度也是length()方法
		System.out.println(sb1.capacity());//capacity()是获取StringBuilder对象容量的方法
		
		System.out.println("------");
		StringBuilder sb2 = new StringBuilder(20);
		System.out.println("sb2:" + sb2);
		System.out.println("sb2:" + sb2.length());
		System.out.println(sb2.capacity());
		
		System.out.println("------");
		StringBuilder sb3 = new StringBuilder("hello world");
		System.out.println("sb3:" + sb3);
		System.out.println("sb3:" + sb3.length());
		System.out.println(sb3.capacity());
	}

}

2. 获取字符串的长度

方法：

public int length()		//获取当前字符串的长度，即多少个字符。

测试代码：

public class ClassTest {

	public static void main(String[] args) {
		StringBuilder sb = new StringBuilder("hello lanou");
		int length = sb.length();
		System.out.println(length);
	}

}

3. 获取字符串中指定位置的字符

方法：

public char charAt(int index)	//获取指定位置的字符。index取值范围是0~length()-1

测试代码：

public class ClassTest {

	public static void main(String[] args) {
		StringBuilder sb = new StringBuilder("hello lanou");
		char c1 = sb.charAt(0);
		char c2 = sb.charAt(7);
		System.out.println(c1);
		System.out.println(c2);
	}

}

4. 字符串的追加

方法：

public StringBuilder append(数据类型 变量名)	//将指定的数据拼接到当前字符串的末尾，并返回当前字符串对象。

测试代码：

public class ClassTest {

	public static void main(String[] args) {
		StringBuilder sb1 = new StringBuilder("hello ");
		StringBuilder sb2 = sb1.append("world");
		System.out.println("sb1:" + sb1);
		System.out.println("sb2:" + sb2);
		System.out.println(sb1 == sb2);
		
		sb1.append(true);
		sb1.append(' ');
		sb1.append(100);
		sb1.append(3.14);
		System.out.println(sb1);
		System.out.println(sb2);
	}

}

追加是在自身的基础上追加，并未产生新的StringBuilder对象。如果容量不够，自动扩容。

5. 验证码

1. 需求：随机生成一个6位的验证码，判断用户从控制台录入的验证码是否正确。

2. 分析：

   1. 验证码的生成。定义一个包含包含全部大写字母、小写字母和数字的字符串，通过for循环，循环6次，每次从字符串中随机取出一个字符，拼接成一个完整的验证码。–需要创建Random对象。
   2. 创建Scanner对象。
   3. 获取用户输入的数据。
   4. 判断输入的数据和验证码是否一致（不区分大小写）。

3. 代码：

   import java.util.Random;
   import java.util.Scanner;
   
   public class ClassTest {
   
   	public static void main(String[] args) {
   		//需求：随机生成一个6位的验证码，判断用户从控制台录入的验证码是否正确。
   		String str = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
   		//code用于保存验证码的内容
   		StringBuilder code = new StringBuilder();
   		Random random = new Random();
   		for(int i = 0; i < 6; i++) {
   			int index = random.nextInt(str.length());
   			char c = str.charAt(index);
   			code.append(c);
   		}
   		System.out.println("验证码是：" + code);
   		Scanner sc = new Scanner(System.in);
   		System.out.print("请输入验证码：");
   		String yourCode = sc.nextLine();
   		//StringBuffer转String使用 toString()方法
   		if(yourCode.equalsIgnoreCase(code.toString())) {
   			System.out.println("验证码正确。");
   		}else {
   			System.out.println("您输入的验证码有误。");
   		}
   	}
   
   }
   

6. 字符串的插入

方法：

public StringBuilder insert(int offset, 数据类型 变量)		//在原有字符串的基础是将数据插入到指定位置，返回值是自身。

测试代码：

public class ClassTest {

	public static void main(String[] args) {
		StringBuilder sb1 = new StringBuilder("我是好人");
		StringBuilder sb2 = sb1.insert(0, "别紧张，");
		System.out.println("sb1:" + sb1);
		System.out.println("sb2:" + sb2);
		System.out.println(sb1 == sb2);
		sb2.insert(5, "不");
		sb2.insert(7, "什么");
		System.out.println("sb1:" + sb1);
		System.out.println("sb2:" + sb2);
	}

}

插入是在自身的基础上插入，并未产生新的StringBuilder对象。如果容量不够，自动扩容。

7. 字符串的删除

方法：

public StringBuilder delete(int start, int end)	//删除下标从start到end的字符（不含下标end）
public StringBuilder deleteCharAt(int index)	//删除指定下标的单个字符

测试代码：

public class ClassTest {

	public static void main(String[] args) {
		StringBuilder sb1 = new StringBuilder("hello lanou");
		StringBuilder sb2 = sb1.delete(1, 4);//不含下标为4的字符
		System.out.println("sb1:" + sb1);
		System.out.println("sb2:" + sb2);
		System.out.println(sb1 == sb2);
		sb1.deleteCharAt(2);
		System.out.println("sb1:" + sb1);
		System.out.println("sb2:" + sb2);
	}

}

删除是在自身的基础上删除，并未产生新的StringBuilder对象。

8. 字符串内容的修改

方法：

public StringBuilder replace(int start, int end, String str)		//将字符串中下标从start到end（不含end）的内容替换成参数str的内容。
public void setCharAt(int index, char ch)	//将字符串中指定位置的字符替换为ch

测试代码：

public class ClassTest {

	public static void main(String[] args) {
		StringBuilder sb1 = new StringBuilder("hello lanou");
		StringBuilder sb2 = sb1.replace(6, 11, "蓝鸥");//不含下标为4的字符
		System.out.println("sb1:" + sb1);
		System.out.println("sb2:" + sb2);
		System.out.println(sb1 == sb2);
		sb1.setCharAt(0, 'H');
		System.out.println("sb1:" + sb1);
		System.out.println("sb2:" + sb2);
	}

}

修改是在自身的基础上修改，并未产生新的StringBuilder对象。

9. 字符串的反转

方法：

public StringBuilder reverse()	//将自身内容倒序

测试代码：

public class ClassTest {

	public static void main(String[] args) {
		StringBuilder sb1 = new StringBuilder("hello lanou");
		StringBuilder sb2 = sb1.reverse();
		System.out.println("sb1:" + sb1);
		System.out.println("sb2:" + sb2);
		System.out.println(sb1 == sb2);
	}

}

翻转是自身内容的反转，并未产生新的StringBuilder对象。

10. 字符串子串

方法：

public String subString(int start)	//获取从start开始到字符串结尾的子串
public String subString(int start, int end) //获取从start到end之间的子串，不含下标为end的字符

测试代码：

public class ClassTest {

	public static void main(String[] args) {
		StringBuilder sb = new StringBuilder("hello lanou,www.lanou3g.com");
		String subStr1 = sb.substring(12);//www.lanou3g.com
		String subStr2 = sb.substring(6, 11);//lanou
		System.out.println("sb:" + sb);
		System.out.println("subStr1:" + subStr1);
		System.out.println("subStr2:" + subStr2);
	}	

}

求子串会产生新的字符串（String）

11. StringBuilder和String的互转

方法：

public StringBuilder(String str)		//String转StringBuilder----StringBuilder的构造方法
public String toString()	//StringBuilder转String

测试代码：

public class ClassTest {

	public static void main(String[] args) {
		StringBuilder sb1 = new StringBuilder("hello lanou");
		StringBuilder sb2 = new StringBuilder("hello lanou");
		System.out.println(sb1 == sb2);//false
		System.out.println(sb1.equals(sb2));//false--StringBuilder自身没有重写父类的equal方法。
		String str1 = sb1.toString();
		String str2 = sb2.toString();
		System.out.println(str1.equals(str2));//true
	}

}

有些String类具有的功能，StringBuilder没有（例如：equals，equalsIgnoreCase、compareTo等）。可以通过转换把StringBuilder转换为String对象。

（3）StringBuilder类总结

**StringBuilder也是Java中的可变字符串类。**它的用法和StringBuffer一模一样。

唯一的区别就是：

StringBuffer在多线程环境下访问是安全的，不会出现紊乱。

StringBuilder在多线程环境下访问是不安全的，数据可能会紊乱。

开发中，多数情况下String类就能满足我们的开发需求，如果需要对字符串自身进行修改，我们通常使用StringBuilder类。

StringBuilder和String可以相互转换。

五、字符串总结

String是不可变字符串。

StringBuilder是可变字符串。多线程下不安全，执行效率比StringBuffer高。

StringBuffer也是可变字符串。多线程下安全，但执行效率低。