Java基础（8）-------API（上）String和StringBuilder以及StringBuffer

最新推荐文章于 2023-03-04 20:45:56 发布

?abc!

最新推荐文章于 2023-03-04 20:45:56 发布

阅读量139

点赞数 1

分类专栏： Java基础

本文链接：https://blog.csdn.net/yyuggjggg/article/details/119802281

版权

Java基础专栏收录该内容

88 篇文章 1 订阅

订阅专栏

什么是API

API (Application Programming Interface) ：应用程序编程接口
java中的API

指的就是 JDK 中提供的各种功能的 Java类，这些类将底层的实现封装了起来，我们不需要关心这些类是如何实现的，只需要学习这些类如何使用即可，我们可以通过帮助文档来学习这些API如何使用。

String类

特点

字符串不可变，它们的值在创建后不能被更改
虽然 String 的值是不可变的，但是它们可以被共享
字符串效果上相当于字符数组( char[] )，但是底层原理是字节数组( byte[] )

构造方法

常用的构造方法

方法名	说明
public String()	创建一个空白字符串对象，不含有任何内容
public String(char[] chs)	根据字符数组的内容，来创建字符串对象
public String(byte[] bys)	根据字节数组的内容，来创建字符串对象
String s = “abc”;	直接赋值的方式创建字符串对象，内容就是abc

@Test
	public void test1(){
		//public String()：创建一个空白字符串对象，不含有任何内容
		String s1 = new String();
		System.out.println("s1:" + s1);//s1:
		
		//public String(char[] chs)：根据字符数组的内容，来创建字符串对象
		char[] chs = {'a', 'b', 'c'};
		String s2 = new String(chs);
		System.out.println("s2:" + s2);//s2:abc
		
		//public String(byte[] bys)：根据字节数组的内容，来创建字符串对象
		byte[] bys = {97, 98, 99};
		String s3 = new String(bys);
		System.out.println("s3:" + s3);//s3:abc
		
		//String s = “abc”;	直接赋值的方式创建字符串对象，内容就是abc
		String s4 = "abc";
		System.out.println("s4:" + s4);//s4:abc
	}

常用方法

方法名	说明
public boolean equals(Object anObject)	比较字符串的内容，严格区分大小写(用户名和密码)
public char charAt(int index)	返回指定索引处的 char 值
public int length()	返回此字符串的长度

创建字符串对象两种方式的区别

通过构造方法创建

通过 new 创建的字符串对象，每一次 new 都会申请一个内存空间，虽然内容相同，但是地址值不同
直接赋值方式创建

以“”方式给出的字符串，只要字符序列相同(顺序和大小写)，无论在程序代码中出现几次，JVM 都只会建立一个 String 对象，并在字符串池中维护

==与equals字符串比较区别

==号的作用
- 比较基本数据类型：比较的是具体的值
比较引用数据类型：比较的是对象地址值
equals方法的作用

默认地址比较
如果没有覆盖重写equals方法，那么Object类中默认进行 == 运算符的对象地址比较，只要不是同一个对象，结果必然为false。
对象内容比较
如果希望进行对象的内容比较，即所有或指定的部分成员变量相同就判定两个对象相同，则可以覆盖重写equals方法。
- 方法介绍
```
public boolean equals(String s)     比较两个字符串内容是否相同、区分大小写
```

其他常用方法

subString方法

字符串截取方法。返回截取的字符串，

subString(first,last)：截取字符串，获取想要的内容，索引从0开始，包括前面不包括后面

@Test
	public void test8(){
		String str = "HelloJavaWorld"; 
		System.out.println(str.substring(5, 9));//java[5,9)
		System.out.println(str.substring(9, 14));//World[9,14)
		System.out.println(str.substring(9));//World[9...)
	}

split方法

将一个字符串安装指定规则拆分成字符串数组，区别中英文

@Test
	public void test2(){
		String str = "北京,上海,杭州,深圳";
		String[] arr = str.split(",");
		for(String s:arr){
			System.out.println(s);
		}
	}
/*
北京
上海
杭州
深圳
*/

indexOf

在一个大字符串中查询某个小字符串，如果查询到，则返回该小字符串的位置（索引），如果查询不到则返回-1

@Test
	public void test3(){
		String str = "helloJavaWorld";
		int a1 =str.indexOf("world");
		int a2 =str.indexOf("po");
		int a3 =str.indexOf("World");
		System.out.println("a1:"+a1);//-1
		System.out.println("a2:"+a2);//-1
		System.out.println("a3:"+a3);//9
	}

replace

字符串替换

@Test
	public void test4(){
		String str = "yaghasdhghj@qq.com";
		String str2 = str.replace("qq", "163");
		System.out.println(str2);//yaghasdhghj@163.com
	}

trim

删除字符串左右两边的空格

@Test
	public void test5(){
		String s = " hjs iajhk  ";
		System.out.println(s);// hjs iajhk  
		System.out.println(s.trim());//hjs iajhk
	}

案例

综合运用

@Test
	public void test9(){
		/*
		 
一。字符串 String str = "...  我爱北京烤鸭店，焖炉挂炉尝个遍";
1.创建新的String类子字符串，内容为str去掉"..." 输出新字符串
2.对str字符串以","为节点分开 创建字符串数组 遍历字符串数组并在控制台输出
3.找出字符串中"爱"字第一次出现的位置
4.对str进行操作，把"..."替换成"歌词:" 并输出新的字符串
5.把str中所有的"烤鸭店"都替换成"北冰洋" 并输出新的字符串语句
6.对str进行操作，去掉空格 并输出新的字符串语句 
		 */
		
		String str = "...  我爱北京烤鸭店,焖炉挂炉尝个遍";
		String str1 = str.substring(3);
		System.out.println(str1);
		
		String[] arr = str.split(",");
		for(String s : arr){
			System.out.println(s);
		}
		System.out.println(str.indexOf("爱"));
		
		String str2 = str.replace("...", "歌词：");
		System.out.println(str2);
		
		String str3 = str.replace("烤鸭店", "北冰洋");
		System.out.println(str3);
		
		String str4 = str.replace(" ", "");
		System.out.println(str4);
	}

1.定义一个方法，实现字符串反转。键盘录入一个字符串，调用该方法后，在控制台输出结果

例如，键盘录入 abc，输出结果 cba

代码实现

/*
    思路：
        1:键盘录入一个字符串，用 Scanner 实现
        2:定义一个方法，实现字符串反转。返回值类型 String，参数 String s
        3:在方法中把字符串倒着遍历，然后把每一个得到的字符拼接成一个字符串并返回
        4:调用方法，用一个变量接收结果
        5:输出结果
 */
public class StringTest05 {
    public static void main(String[] args) {
        //键盘录入一个字符串，用 Scanner 实现
        Scanner sc = new Scanner(System.in);

        System.out.println("请输入一个字符串：");
        String line = sc.nextLine();

        //调用方法，用一个变量接收结果
        String s = reverse(line);

        //输出结果
        System.out.println("s:" + s);
    }

    //定义一个方法，实现字符串反转
    /*
        两个明确：
            返回值类型：String
            参数：String s
     */
    public static String reverse(String s) {
        //在方法中把字符串倒着遍历，然后把每一个得到的字符拼接成一个字符串并返回
        String ss = "";

        for(int i=s.length()-1; i>=0; i--) {
            ss += s.charAt(i);
        }

        return ss;
    }
}

2.键盘录入一个字符串，统计该字符串中大写字母字符，小写字母字符，数字字符出现的次数(不考虑其他字符)

/*
  思路：
        1:键盘录入一个字符串，用 Scanner 实现
        2:要统计三种类型的字符个数，需定义三个统计变量，初始值都为0
        3:遍历字符串，得到每一个字符
        4:判断该字符属于哪种类型，然后对应类型的统计变量+1
            假如ch是一个字符，我要判断它属于大写字母，小写字母，还是数字，直接判断该字符是否在对应的范围即可
            大写字母：ch>='A' && ch<='Z'
            小写字母： ch>='a' && ch<='z'
            数字： ch>='0' && ch<='9'
        5:输出三种类型的字符个数
 */
public class StringTest03 {
    public static void main(String[] args) {
        //键盘录入一个字符串，用 Scanner 实现
        Scanner sc = new Scanner(System.in);

        System.out.println("请输入一个字符串：");
        String line = sc.nextLine();

        //要统计三种类型的字符个数，需定义三个统计变量，初始值都为0
        int bigCount = 0;
        int smallCount = 0;
        int numberCount = 0;

        //遍历字符串，得到每一个字符
        for(int i=0; i<line.length(); i++) {
            char ch = line.charAt(i);

            //判断该字符属于哪种类型，然后对应类型的统计变量+1
            if(ch>='A' && ch<='Z') {
                bigCount++;
            } else if(ch>='a' && ch<='z') {
                smallCount++;
            } else if(ch>='0' && ch<='9') {
                numberCount++;
            }
        }

        //输出三种类型的字符个数
        System.out.println("大写字母：" + bigCount + "个");
        System.out.println("小写字母：" + smallCount + "个");
        System.out.println("数字：" + numberCount + "个");
    }
}

StringBuilder类

StringBuilder 是一个可变的字符串类，我们可以把它看成是一个容器，这里的可变指的是 StringBuilder 对象中的内容是可变的

StringBuilder类和String类，已经StringBuffer类的区别

都是final类,不允许被继承

运行速度快慢为：StringBuilder > StringBuffer > String

String：适用于少量的字符串操作的情况
- StringBuilder：适用于单线程下在字符缓冲区进行大量操作的情况
- StringBuffer：适用多线程下在字符缓冲区进行大量操作的情况
String类：内容是不可变的
StringBuilder类：内容是可变的
StringBuilder是多线程不安全的，可以不需要额外的同步用于多线程中；非同步,运行于多线程中就需要使用着单独同步处理，但是速度就比StringBuffer快多了;
StringBuffer是多线程安全的。
StringBuffer与StringBuilder两者共同之处:可以通过append、insert进行字符串的操作。

构造方法

方法名	说明
public StringBuilder()	创建一个空白可变字符串对象，不含有任何内容
public StringBuilder(String str)	根据字符串的内容，来创建可变字符串对象

@Test
	public void test6(){
		//public StringBuilder()：创建一个空白可变字符串对象，不含有任何内容
        StringBuilder sb = new StringBuilder();
        System.out.println("sb:" + sb);
        System.out.println("sb.length():" + sb.length());

        //public StringBuilder(String str)：根据字符串的内容，来创建可变字符串对象
        StringBuilder sb2 = new StringBuilder("hello");
        System.out.println("sb2:" + sb2);
        System.out.println("sb2.length():" + sb2.length());
	}
/*
sb:
sb.length():0
sb2:hello
sb2.length():5
*/

常用方法

添加和反转方法

方法名	说明
public StringBuilder append (任意类型)	添加数据，并返回对象本身
public StringBuilder reverse()	返回相反的字符序列
public int length()	返回长度，实际存储值
public String toString()	通过toString()就可以实现把StringBuilder转换为String
insert( , )	向指定位置插入字符/字符串
delete( , )	删除指定位置的字符/字符串
replace( , ， )	替换指定的字符串
subString()	截取字符串

@Test
	public void test11(){
		StringBuffer str = new StringBuffer("HelloWorld");
		str.insert(5, "java");
		System.out.println(str);//HellojavaWorld
		str.delete(5, 9);
		System.out.println(str);//HelloWorld
		str.replace(5, 10, "java");
		System.out.println(str);//Hellojava
		String s = str.substring(5,9);
		System.out.println(s);//java

	}

@Test
	public void test7(){
		//创建对象
        StringBuilder sb = new StringBuilder();

        //public StringBuilder append(任意类型)：添加数据，并返回对象本身
//        StringBuilder sb2 = sb.append("hello");
//
//        System.out.println("sb:" + sb);
//        System.out.println("sb2:" + sb2);
//        System.out.println(sb == sb2);

//        sb.append("hello");
//        sb.append("world");
//        sb.append("java");
//        sb.append(100);

        //链式编程
        sb.append("hello").append("world").append("java").append(100);

        System.out.println("sb:" + sb);

        //public StringBuilder reverse()：返回相反的字符序列
        sb.reverse();
        System.out.println("sb:" + sb);
	}
/*
sb:helloworldjava100
sb:001avajdlrowolleh

*/

StringBuilder和String相互转换

StringBuilder转换为String

public String toString()：通过 toString() 就可以实现把 StringBuilder 转换为 String
String转换为StringBuilder

public StringBuilder(String s)：通过构造方法就可以实现把 String 转换为 StringBuilder