String类最详解（String、StringBuffer、StringBuilder、正则表达式）表格+代码让你一文读懂！！！

文章目录

String类

String类的方法是特别的多,当我们讲到方法时会用功能块来给大家进行讲解

概述

字符串是由多个字符组成的一串数据（字符序列）的字符串常量，值改变后会重新创建一个新的对象。

我们知道,String属于引用数据类型, Java中的所有 “…” 这个样子的字面值都是String类的示例, String类在java.lang包下, 它提供了很多的方法, 像字符串的比较, 查找 , 截取, 拼接, 大小写转换等等方法，需要注意的是，String类中的成员方法都默认为final方法，这与String类的结构有关。

String类的结构：

public final class String extends Object implements Serializable，Comparable<String>,CharSequence{
    
    }

从String类的结构我们可以得到：String类被final关键字修饰，这代表String类不能被继承，字符串一旦创建便不能再修改，一旦修改就会创建一个新的对象；String类实现了Serializable，Comparable, CharSequence三个接口。

创建字符串

字符串有两种创建形式：

(1) String s = “adc” ;

(2) String s = new String(“abc”);

这两种创建字符串的方法本质上还是有所不同的, 下面我们来详细的讲讲。

第一种创建方式

String s = “adc” ;这种创建字符串的方式，会先在栈中创建一个对String类的对象引用变量s，然后去查找"abc"是否被保存在字符串常量池中, 如果没有则在堆中创建一个String对象object，当第二次创建时，常量池已经存在，直接让引用变量指向已有字符串的对象即可。举个例子：

public class MakeStringDemo {
    
    
    public static void main(String[] args) {
    
    
        String s = "abc";
        String s1 = "abc";
        System.out.println(s == s1);//true
    }
}

我们知道，引用类型的""比较时一般是比较两个引用类型的地址，而这里的String类型正是引用类型，ss1的返回值却是为true，这证明s和s1都指向了同一个对象。

在这里插入图片描述

上面的图片中有个错误，常量池应该位于堆中，其它的指向都没问题。

第二种创建方式

String s = new String(“abc”);这种创建方式就是通过String类的构造方法进行创建，一概在堆中创建新的对象，不管其字符串值是否相等，是否有必要创建新的对象。

代码示例

public class MakeStringDemo1 {
    public static void main(String[] args) {
        String s1 = new String("abc");
        String s2 = new String("abc");
        System.out.println(s1 == s2);//false
    }
}

构造方法

	1. public String()  初始化新创建一个字符串对象, 使其表示一个空的字符序列

 		2. public String(String str)     初始化新创建一个字符串对象, 并传入内容, 使其表示一个有内容的字符序列
           		3. public String(byte[] bytes)  将byte数组的内容按照给定的编码集或默认编码集转换成字符串,会抛出一个异常,害怕你输入的编码集有问题。
                     		4. public String(char[] value)   将字符数组转换为字符串

代码示例

import java.io.UnsupportedEncodingException;

public class StrutDemo {
    
    
    public static void main(String[] args) throws UnsupportedEncodingException {
    
    
        String s = new String();
        String s1 = new String("asd");

        byte [] b = {
    
    97,98,99};//给定一个byte数组
        //public String(byte[] bytes)  将byte数组的内容按照给定的编码集或默认编码集转换成字符串
//        String s2 = new String(b);
        String s2 = new String(b,"utf-8");
        System.out.println(s2);//abc
        
        char [] c = {
    
    '中','国'};
        String s3 = new String(c);
        System.out.println(s3);
    }
}

判断功能

返回值类型	代码	功能
boolean	equals(Object obj)	判断值是否一致
boolean	equalsIgnoreCase(String str)	判断值是否一致,忽略大小写
boolean	contains(String str)	判断一个字符串中是否包含另一个字符串
boolean	isEmpty()	判断字符串是否为空
boolean	startsWith(String prefix)	判断字符串是否由某个字符串起始
boolean	endsWith(String suffix)	判断字符串是否由某个字符串结尾

代码示例

//判断功能
public class JudgeDemo {
    
    
    public static void main(String[] args) {
    
    
        String s1 = new String("abc");
        String s2 = new String("abc");
        String s3 = new String("asd");
        String s4 = new String("ABC");
        String s5 = new String("abcdef");
        String s6 = new String();

        //判断值是否一致
        System.out.println(s1.equals(s2));//true
        System.out.println(s1.equals(s3));//false
        //判断值是否一致,忽略大小写
        System.out.println(s1.equalsIgnoreCase(s4));//true
        //判断一个字符串中是否包含另一个字符串
        System.out.println(s5.contains(s1));//true
        System.out.println(s5.contains(s3));//false
        //判断字符串是否为空
        System.out.println(s1.isEmpty());//false
        System.out.println(s6.isEmpty());//true
        //判断字符串是否由某个字符串起始
        System.out.println(s5.startsWith("abc"));//true
        //判断字符串是否由某个字符串结尾
        System.out.println(s5.endsWith("abc"));//false
        System.out.println(s5.endsWith("f"));//true
    }
}

获取功能

返回值类型	代码	功能
int	length()	获取字符串长度
char	charAt(int index)	返回指定位置的字符
int	indexOf(String str)	获取元素首次出现的位置
int	indexOf(String str,int fromIndex)	跳过这个索引,找下一次元素出现的位置
int	lastindexOf(String str)	从后往前找,获取元素首次出现的位置
String	substring(int start)	从第二个开始截取一个新的字符串
String	substring(int start,int end)	截取指定区间的字符串,包含开始不包含结束

代码示例

public class GetDemo {
    
    
    public static void main(String[] args) {
    
    
        String str = "01234567589";

        //获取字符串长度
        System.out.println(str.length());
        //返回指定位置字符
        System.out.println(str.charAt(3));
        //获得字符首次出现的位置
        System.out.println(str.indexOf("5"));
        //跳过这个索引
        System.out.println(str.indexOf("5",str.indexOf("5")));
        //从后往前找
        System.out.println(str.lastIndexOf("5"));
        //截取字符串---从指定位置到结束
        System.out.println(str.substring(4));
        //截取字符串---指定区间
        System.out.println(str.substring(4,8));
    }
}

转换功能

返回值类型	代码	功能
byte[]	getBytes()	把字符串按照编码集转换为byte数组
char[]	tocharArray()	把字符串转为字符数组
static String	valueOf(char[] chs)	把字符数组转为字符串
String	toLowerCase()	把字符串转为全小写
String	toUpperCase()	把字符串转为全大写
String	concat(String str)	把两个字符串拼接成一个字符串
String[]	split(分隔符)	把字符串通过给定的分割符分成字符串数组

代码示例

import java.util.Arrays;

public class Zhuanhuan {
    
    
    public static void main(String[] args) {
    
    
        String str = "你好!";
        //转换为字符数组,按照编码集转换
        byte [] bytes = str.getBytes();
        System.out.println(Arrays.toString(bytes));//[-28, -67, -96, -27, -91, -67, 33]
        //转为字符数组
        char [] chars = str.toCharArray();
        System.out.println(Arrays.toString(chars));//[你, 好, !]
        //字符数组转为字符串
        System.out.println(new String().valueOf(chars));//你好!
        //转小写
        String str1 = "asdaASFJKLAlakqSKDAL";
        System.out.println(str1.toLowerCase());//asdaasfjklalakqskdal
        //转大写
        System.out.println(str1.toUpperCase());//ASDAASFJKLALAKQSKDAL
        //连接两个字符串
        System.out.println(str.concat(str1));//你好!asdaASFJKLAlakqSKDAL
        //分割字符数组
        String [] arr = str1.split("s");
        System.out.println(Arrays.toString(arr));//[a, daASFJKLAlakqSKDAL]
    }
}

**注意:**split(String regex)中的regex实质是正则表达式的符号,不同符号的意义都不相同, 遇见regex一定要小心。

替换功能

返回值类型	代码	功能
String	replace（char old，char new）	用new的新字符替换就字符
String	trim（）	去除字符串两端的空格

代码示例

public class ReplaceDemo {
    
    
    public static void main(String[] args) {
    
    
        String str = " AsDs ";
        System.out.println(str.replace('s','S'));// ASDS
        System.out.println(str.trim());//AsDs
    }
}

正则表达式

正则表达式又称规则表达式, (英语: Regular Expression)，在代码中简写为regex、regexp或着RE。

模式匹配语法：用特定的符号表示某种规则，去匹配某个字符串，如果字符串与贵则相匹配，返回true，否则返回false。

表达式	含义
\ \d	匹配数字 == 1~9
\ \D	匹配非数字
\ \s	匹配空白字符 [\t \n \X \f \r]
\ \S	匹配非空白字符
\ \w	匹配单词字符 [a-z A-Z _ 0-9]
\ \W	匹配非单词字符
.	在正则中表示任意字符, 需 \ \ 转义

数量控制符号

符号(示例 \ \ d*)	意义
?	一次或一次也没有
*	0次或多次
+	一次或多次
{n}	恰好n次
{n,}	至少n次
{n,m}	至少n次

代码示例

public class StringDemo5 {
    
    
    public static void main(String[] args) {
    
    
        /*
        * 正则表达式 又称 规则表达式
        * 模式匹配语法:
        * 1.用特定的符号表示某种规则,去 匹配某个字符串
        * 2.字符串与规则的匹配返回boolean值
        */

        String str = "8";
//        \\d 匹配数字  ==  0-9
        System.out.println(str.matches("\\d"));
        String str0 = "";
        String str1 = "234567";
//        数量控制1   \\d?    一次或一次也没有
        System.out.println(str.matches("\\d?"));
        System.out.println(str0.matches("\\d?"));
//        数量控制2   \\d*   零次或多次
        System.out.println(str0.matches("\\d*"));
        System.out.println(str1.matches("\\d*"));
//        数量控制3    \\d+  一次或多次
        System.out.println(str.matches("\\d+"));
        System.out.println(str1.matches("\\d+"));
//        数量控制4     \\d{n} 恰好n次
        System.out.println(str.matches("\\d{1}"));
        System.out.println(str1.matches("\\d{5}"));
//        数量控制5     \\d{n,}  至少n次
        System.out.println(str.matches("\\d{1,}"));
        System.out.println(str1.matches("\\d{6,}"));
//        数量控制6     \\d{n,m}  至少n次至多m次
        System.out.println(str.matches("\\d{1,6}"));

//        \\D 匹配非数字
        String str2 = "asdc+-=--e";
        System.out.println(str1.matches("\\D+"));//false
        System.out.println(str2.matches("\\D+"));//true

//        \\s匹配空白字符  [\t \n \xOB \f \r ]
        String str3 = "  ";
        System.out.println(str.matches("\\s*"));//false
        System.out.println(str3.matches("\\s*"));//true

//        \\S匹配非空白字符串
        System.out.println(str3.matches("\\S*"));//false
        System.out.println(str2.matches("\\S*"));//true

//        \\w匹配单词字符  [a-z A-Z _ 0-9]
        String str4 = "asdAWDqadwq12_";
        System.out.println(str4.matches("\\w*"));
        System.out.println(str4.matches("[A-z0-9_]*"));
//        \\W匹配非单词字符
        System.out.println(str3.matches("\\W+"));//true
        System.out.println(str4.matches("\\W+"));//false

//        邮箱[email protected]
        String str5 = "[email protected]";

        boolean yx = str5.matches("[a-z]{4,}\\d{3,10}@[hao]{3}[123]{3}\\.(com|com.pp)");
        System.out.println(yx);


    }
}

StringBuffer类

概述

使用String类对字符串进行拼接操作，每次拼接，都会构建一个新的String对象，即耗时，又浪费空间。而StringBuffer就可以解决这个问题。

StringBuffer的特点有：线程安全和可便字符序列。

StringBuffer的方法功能

构造方法

public StringBuffer( ) 构造一个不带字符的字符缓冲区，初始容量为16个字符

public StringBuffer(String str) 构造一个字符串缓冲区，并将其内容初始化为指定的字符串内容

添加功能

public StringBuffer append（String str）末尾添加

public StringBUffer insert（int offset，String str）指定位置添加

删除功能

public StringBuffer deleteCharAt（int index）删除指定为元素

public StringBuffer delete（int start，int end）删除指定区间元素

替换功能

public StringBuffer replace（int start，int end，String str）替换指定区间元素

反转功能

public StringBuffer reverse（）反转字符串

截取功能

截取功能返回值类型为String类型，本身没有发生改变

public String substring(int start)

public String subString(int start,int end)

代码示例

public class StringBufferDemo {
    
    
    public static void main(String[] args) {
    
    
        StringBuffer str = new StringBuffer("abcdefg");

        //添加
        str.append("gh");
        str.append("zgy",0,2);//截取字符串添加
        str.insert(0,"w");
        System.out.println(str);//wabcdefgghzg
        //删除
        str.deleteCharAt(str.length()-1);//删除指定位置字符
        str.delete(0,2);//删除指定区间字符  包含开始,不包含结束
        System.out.println(str);//bcdefgghz
        //替换
        str.replace(0,3,"123");
        System.out.println(str);//123efgghz
        //反转
        str.reverse();
        System.out.println(str);//zhggfe321
        //截取
        System.out.println(str.substring(5));//e321
        System.out.println(str.substring(2,5));//ggf
    }
}

StringBuilder类

StringBuilder类的功能和StringBuffer功能完全一致,区别在于,StringBuffer是线程安全的。

代码示例

public class StringBuliderDemo {
    
    
    public static void main(String[] args) {
    
    
        StringBuilder str = new StringBuilder("abcdefg");

        //添加
        str.append("gh");
        str.append("zgy",0,2);//截取字符串添加
        str.insert(0,"w");
        System.out.println(str);//wabcdefgghzg
        //删除
        str.deleteCharAt(str.length()-1);//删除指定位置字符
        str.delete(0,2);//删除指定区间字符  包含开始,不包含结束
        System.out.println(str);//bcdefgghz
        //替换
        str.replace(0,3,"123");
        System.out.println(str);//123efgghz
        //反转
        str.reverse();
        System.out.println(str);//zhggfe321
        //截取
        System.out.println(str.substring(5));//e321
        System.out.println(str.substring(2,5));//ggf
    }
}

String、StringBuffer、StringBuilder的区别

String是不可变的字符序列，适用于少量的字符串操作的情况；

StringBuffer是可变的字符序列，线程安全，适用于多线程下在字符缓冲区进行大量的操作；

StringBuilder是可变的字符序列，线程不安全，适用于单线程下在字符串缓冲区进行大量操作的情况。