java的String类的常用API详解

清疚 2024-04-01 18:27 88阅读 0赞

### 模块一：基本语法 ###

**前言：字符串创建对象创建字符串对象，需要查看API中字符串的构造方法。提供了多种创建对象的方式。**

#### 1、字符串创建 ####

> **(1) 直接写字符串字面值** String s5 = “abcd”;  
> **(2) 利用字节数组创建字符串对象<String(byte\[\] bytes) >**  
> byte\[\] bs = \{97, 98, 99, 100\}; //ASCII编码表  
> String s1 = new String(bs);  
> System.out.println(s1);  
> 打印结果：abcd  
> **（3) 利用字节数组的一部分创建字符串对象<String(byte\[\] bytes, int offset, int length) >**  
> String s2 = new String(bs, 1, 2);  
> System.out.println(s2);  
> 打印结果：bc  
> **（4）利用字符数组创建字符串对象 <String(char\[\] value)>**  
> char\[\] chs = \{‘a’, ‘b’, ‘c’,‘d’\};  
> String s3 = new String(chs);  
> System.out.println(s3);  
> 打印结果：abcd  
> **(5)利用字符数组的一部分创建字符串对象<String(char\[\] value, int offset, int count)>**  
> String s4 = new String(chs, 2, 2)  
> System.out.println(s4);  
> 打印结果: cd

#### 2、两种字符串的区别 ####

（1）直接写的字符串字面值，在常量池中，它可以被复用

String s1 = "abc"; //s1存储的值地址0x111
    	String s2 = "abc"; //s2复用s1的地址0x111
    	System.out.println(s1 == s2); //true

（2）使用构造方法创建字符串对象，在堆内存中，每次创建对象都有新的地址值

String s1 = new String("abc"); //s1存储的地址是0x222
    String s2 = new String("abc"); //s2存储的地址是0x333
    System.out.println(s1 == s2); //false

#### 3、String类方法总结 ####

字符串有很多方法，需要根据需求找到合适的方法进行使用就可以了。 为了更加方便的记忆这些方法，建议对方法进行分类记忆。  
**判断功能**

> 判断字符串的内容是否相等，不忽略大小写  
> public boolean equals(Object str)  
> 判断字符串是否相等，忽略大小写  
> public boolean equalsIgnoreCase(String anotherString)  
> 举例：“HELLO” 和 “hello” 是否相等  
> 判断字符串是否包含某些内容  
> public boolean contains(CharSequence s)  
> 举例：“helloworld” 是否包含 “world”  
> 判断字符串以什么后缀结尾  
> public boolean endsWith(String suffix)  
> 举例：“helloworld.java” 是否以 "java"结尾 public boolean  
> 判断字符串以什么前缀开头  
> startsWith(String prefix)  
> 举例：“helloworld.java” 是否以 "hello"结开头

**获取功能**

>     获取字符串中某一个索引位置的字符
>     public char charAt(int index) 
>     获取字符串的长度 
>     public int length()

**转换功能**

> 将此字符串转换为一个新的字符数组。  
> public char\[\] toCharArray()  
> 将字符串转换为小写字母  
> public String toLowerCase()  
> 将字符串转换为大写字母  
> public String toUpperCase()  
> 把字符串转换为字节数组  
> public byte\[\] getBytes()

**截取和替换功能**  
截取字符串的一部分，从指定的索引位置开始一直到末尾

> public String substring(int beginIndex)  
> 截取字符串的一部分，从指定的开始位置一直到指定的结束位置(注意：包含头，不包含尾)  
> public String substring(int beginIndex, int endIndex)  
> 使用新的字符串替换旧的字符串  
> public String replaceAll(String regex, String replacement)

**切割功能**

>     使用指定的字符串开切割字符串，得到一个字符串数组
>      public String[] split(String regex)
>     注意：如果想要用"."进行切割，必须使用"\\."

**StringBuilder类的方法**  
**构造方法**

> public StringBuilder()  
> 构造一个不带任何字符的字符串容器，其初始容量为 16 个字符。  
> 【注意：容量不够用时，会自动扩容】
> 
> public StringBuilder(String str)  
> 构造一个字符串容器，并初始化为指定的字符串内容。

**常用方法**

>     往字符串缓冲区(容器)，添加任意类型的数据。
>     public StringBuilder append(任意类型 i)  
>     获取字符串缓冲区(容器)中，字符的个数
>      public int length()  
>       把字符串缓冲区(容器)中内容反转
>      public StringBuilder reverse()  
>      把字符串缓冲区(容器)，转换为字符串
>     public String toString()

**StringJoiner类的方法**

> (1) 创建一个StringJoiner对象，用指定的分隔符  
> 构造方法 public StringJoiner(String s)
> 
> (2) 创建一个StringJoiner对象，用指定的分隔符, 开始符号，结束符号  
> public StringJoiner(String s,String start, String end)

> 常用方法  
> 往字符串缓冲区(容器)，添加字符串数据。  
> public StringJoiner add(String i)  
> 获取字符串缓冲区(容器)中，字符的个数  
> public int length()  
> 把字符串缓冲区(容器)，转换为字符串  
> public String toString()

### 模块二：应用 ###

**1、字符串切割演示**  
String str = “www itcast cn”;  
//使用 “ ” 进行切割  
String\[\] array = str.split(" ");

for (int i = 0; i < array.length; i++) \{  
System.out.println(array\[i\]);  
\}  
**2、替换字符串中内容**  
String str = “我的手机号码是：1234345566，有事联系我”;  
//替换字符串中的"1234345566" 为 “**"  
String s = str.replaceAll(“1234345566”, "**”);  
System.out.println(s);  
**3、比较字符串相等**

> String s1 = “abc”; //s2复用s1的地址0x111  
> String s2 = new String(“abc”); //s2存储的地址是0x333  
> System.out.println(s1 == s2); //false，比较地址  
> System.out.println(s1.equals(s2)); //true，比较内容  
> 原因：String类重写了Object类equals方法，所以使用String类的equals方法时比较的是两个字符串的内容。

**4、字符串遍历**  
直接遍历字符串

String str = "abcdefg";
    //快捷键：str.length().fori
    //str.length(): 获取str字符串的长度
    for(int i=0; i<str.length(); i++){
        
        //获取i索引位置的字符
        char ch = str.charAt(i);
        System.out.println(ch);
    }

把字符串转换为字符数组，再遍历数组

String str = "abcdefg";
    //把字符串转换为字符数组
    char[] chs = str.toCharArray();
    //遍历字符数组
    for(int i=0; i< chs.length; i++){
        
        char ch = chs[i];
        System.out.println(ch);
    }

**5、字符串拼接的练习**  
（1）使用StringBuilder, 把一个数组元素拼接成一个字符串

int[] array = {
        1,2,3,4,5};
    StringBuilder sb = new StringBuilder("{"); 
    //遍历数组, 把元素拼接成一个字符串
    for(int i=0; i<array.length; i++){
        
        //判断是否为最后一个元素
        if(i == array.length-1){
        
           sb.append(array[i]); //如果是最后一个元素，不用拼接“，”
        }else{
        
    	   sb.append(array[i]).append(",");//如果不是最后一个元素，需要用拼接“，”
        }
    }
    sb.append("}");
    //把StringBuilder转换为字符串
    String result = sb.toString();
    System.out.println(result);

（2）使用StringJoiner, 把一个数组元素拼接成一个字符串

int[] array = {
        1,2,3,4,5};
    StringJoiner sj = new StringJoiner(",", "[","]");
    //遍历数组, 把元素拼接成一个字符串
    for(int i=0; i<array.length; i++){
        
        //array[i]+""  目的是把数组的元素转换为字符串
        sj.add(array[i]+"");
    }
    //把StringBuilder转换为字符串
    String result = sj.toString();
    System.out.println(result);

### 模块三：经典面试题 ###

(1) 题型1

> String s1 = “abc”; String s2 = “a” + “b” + “c”;  
> //在编译时期，把 “a”+“b”+"c"转换为 “abc”  
> System.out.println(s1 == s2);  
> 打印结果：true  
> (2) 题型2  
> String s3 = “a”;  
> String s4 = “bc”; String s5 = “abc”;  
> System.out.println((s3 + s4) == s5);  
> 打印结果：false  
> 结论：(s3+s4)是变量相加，会生成新的字符串