章五、API 常用类（2）—— String类、StringBuffer类、StringBuilder类

最新推荐文章于 2024-10-01 18:51:18 发布

三木几

最新推荐文章于 2024-10-01 18:51:18 发布

阅读量550

点赞数 28

文章标签： java 开发语言

本文链接：https://blog.csdn.net/king_faner/article/details/136274816

版权

本文详细介绍了Java中的String,StringBuffer和StringBuilder类，包括它们的创建方式、特性（如字符串不变性）、构造方法、常用操作方法（如添加、删除、替换和截取）以及在不同场景下的应用，特别强调了String类的不可变性和StringBuilder与StringBuffer的线程安全性差异。

摘要由CSDN通过智能技术生成

一、 String类

● 概述

• 概述：

字符串是由多个字符组成的一串数据(字符序列)的字符串常量，java中所有字符串都是String类的实例。

• 两种创建方式：

● 第一种:

String s = "abc";

先在栈中创建一个对String类的对象引用变量 s ，然后去字符串常量池中查找有没有"abc"，如果没有则在常量池中添加”abc”，s 引用变量指向常量池中的”abc”，如果常量池中有，则直接指向改地址即可，不用重新创建.

● 第二种:

String s = new String("abc");

一概在堆中创建新对象，值存储在堆内存的对象中。

package day2.stringdemo;
/*
String类
Java中所有的字符串都是此类的实例
 */
public class String1 {
    public static void main(String[] args) {

        String s = "abc";
        /*
        "abc" -> 字符串对象
        其底层是一个char数组 ：
            private final char value[];
        */

        //两种创建方式
        /*
        String str1 = new String("abc");
        String str2 = "abc";
        */
        String s1 = "abc";
        String s2 = "abc";
        System.out.println("s1 == s2 ?"+(s1==s2)); //true

        String str1 = new String("abc");
        String str2 = new String("abc");
        System.out.println("str1 == str2 ?"+(str1==str2)); //false
        
    }
}

● 字符串的特性

字符串的不变性：字符串的值一经创建，不能修改

public class String2 {
    //字符串不变：他的值在创建后不能修改
    public static void main(String[] args) {
        String s = "abc";
        s += "def";  //此时会新建一个字符串对象"abcdef"，然后把这个新的字符串对象的地址赋给s
        s += "g";  //同理，新建一个字符串对象"abcdefg"，然后把这个新的字符串对象的地址赋给s
        System.out.println(s);
    }

}

如代码所示，看似字符串在不断延长，实际上是不断创建了包含两段字符串的新字符串对象，让后把这个新字符串对象的地址赋给原字符

● 构造方法

public String ( ) //无参的构建类型

public String(String str) //有参的构件类型

public String(byte[ ] bytes) //传入字符串的 byte[ ] 数组

public String(char[ ] value) //将字符串数组转化为字符串

import java.io.UnsupportedEncodingException;
import java.util.Arrays;

public class StringConstructor {
    /*
构造方法:
    public String()

    public String(String str)

    public String(byte[] bytes)

    public String(char[] value)

     */
    public static void main(String[] args) throws UnsupportedEncodingException {
        //无参的构造方法：构造一个空字符串
        String s1 = new String();
        System.out.println("s1 = "+s1);

        //有参的构造方法：
        String s2 = new String("abc");
        System.out.println("s2 = "+s2);

        //传入一个 byte[] 数组的
        String s3 = "你好";
        byte[] bytes = s3.getBytes("utf-8"); //返回值为 byte[] 数组
        System.out.println(Arrays.toString(bytes));
        //将 “你好”拆分为 比特码，一个中文拆分为3个byte类型的数
        String s4 = new String(bytes,"utf-8"); //如果不写charsetName就默认为unicode
        System.out.println(s4);

        String s5 = "World";
        System.out.println(s5);
        //通过数组的方式来对字符串进行操作
        //s5.value；
        char[] chars =  s5.toCharArray(); //返回值是char[] 数组
        System.out.println(Arrays.toString(chars));
        //对字符串数组排个序
        Arrays.sort(chars);
        System.out.println(Arrays.toString(chars));
        //再把排了序的字符串数组转化为字符串
        String s6 = new String(chars);
        System.out.println(s6);





    }
}

● 判断功能

boolean equals(Object obj)  //比较字符串内容是否完全一样（区分大小写）
boolean equalsIgnoreCase(String str)  //判断字符串内容在忽略大小写的情况下是否一样
boolean contains(String str)  //判断字符串中是否包含输入的字符串
boolean isEmpty()  //判断字符串是否为空字符串
boolean startsWith(String prefix)  //判断字符串是否以指定的字符串开头
boolean endsWith(String suffix)  //判断字符串是否以指定的字符串结尾

/*
判断功能:
//比较字符串内容是否完全一样（区分大小写）
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("ABC");
        String s4 = new String("");

        //判断内容是否相同
        System.out.println(s1.equals(s2)); //true
        //判断字符串内容在忽略大小写的情况下是否相同
        System.out.println(s1.equalsIgnoreCase(s3)); //true
        //判断字符串中是否包含输入的字符串
        System.out.println(s1.contains("ab")); //true
        System.out.println(s1.contains("ac")); //false
        System.out.println(s1.contains(s2)); //true
        //判断字符串是否为空字符串
        System.out.println(s1.isEmpty()); //false
        System.out.println(s4.isEmpty()); //true
        //判断字符串是否以指定的字符串开头
        System.out.println(s1.startsWith("a")); //true
        System.out.println(s1.startsWith("b")); //false
        System.out.println(s1.startsWith("ab")); //true
        //判断字符串是否以指定的字符串结尾
        System.out.println(s1.endsWith("c")); //true
        System.out.println(s1.endsWith("a")); //false
        System.out.println(s1.endsWith("bc")); //true




    }

}

● 获取功能

int length()        //获取字符串的长度

char charAt(int index)        //返回字符串在输入的索引位置的字符

int indexOf(String str)        //查找传入的字符串在本字符串中的首字母的位置（不存在返回-1）

int indexOf(String str,int fromIndex)        //从传入的fromIndex开始查找传入的字符串（不存在返回-1）

int lastIndexOf(String str,int fromIndex)        //从后往前开始查找，其他同上

String substring(int start)        //从输入的索引开始截取出一个独立的字符

String substring(int start,int end)        //截取从索引开始（包含）到索引截止（不包含）的字符串

/*
获取功能
//获取字符串的长度
int length()

//返回字符串在输入的索引位置的字符
char charAt(int index)

//查找传入的字符串在本字符串中的首字母的位置（不存在返回-1）
int indexOf(String str)

//从传入的fromIndex开始查找传入的字符串（不存在返回-1）
int indexOf(String str,int fromIndex)

//从后往前开始查找，其他同上
int lastIndexOf(String str,int fromIndex)

//从输入的索引开始截取出一个独立的字符
String substring(int start)

//截取从索引开始（包含）到索引截止（不包含）的字符串
String substring(int start,int end)

 */
public class FetchDemo {
    public static void main(String[] args) {

        String s1 = "abcd efg";
        //          "01234567"


        //获取字符串的长度
        System.out.println(s1+"的长度为："+s1.length());
        //返回输入的索引位置的字符串
        System.out.println(s1.charAt(3)); // d
        for(int i=0;i<s1.length();i++){ //字符串遍历
            System.out.print(s1.charAt(i));
        }
        System.out.println();
        //查找传入的字符串在本字符串中的位置
        System.out.println(s1.indexOf("d")); //3
        System.out.println(s1.indexOf("h")); //-1
        //从传入的fromIndex开始查找传入的字符串（不存在返回-1）
        System.out.println(s1.indexOf("c",0)); //2
        System.out.println(s1.indexOf("c",2)); //从当前开始
        System.out.println(s1.indexOf("c",3)); //-1
        //从后往前开始查找，其他同理
        System.out.println(s1.lastIndexOf("c"));
        //从输入的索引开始截取出一个独立的字符
        String s2 = s1.substring(3); //从第三位开始截取复制原字符串不变
        System.out.println(s2);
        //截取从索引开始（包含）到索引截止（不包含）的字符串
        String s3 = s1.substring(3,6);//其中不包含第6位
        System.out.println(s3);



    }
}

● 转换功能

byte[] getBytes()        //将字符串转为 byte[]数组

char[] toCharArray()        //将字符串转为字符数组

static String valueOf(char[] chs)        //将整数转换为字符串操作

String toLowerCase()        //将字符串里的内容全部转为小写

String toUpperCase()        //将字符串里的内容全部转为大写

String concat(String str)        //将输入的字符串连接到引用的字符串之后

Stirng[] split(分割符);        //将字符串从输入的分隔符处分开，并返回一个数组

import java.util.Arrays;

/*
转换功能
//将字符串转为 byte[]数组
byte[] getBytes()

//将字符串转为字符数组
char[] toCharArray()

//将整数转换为字符串操作
static String valueOf(char[] chs)

//将字符串里的内容全部转为小写
String toLowerCase()

//将字符串里的内容全部转为大写
String toUpperCase()

//将输入的字符串连接到原字符串之后，并返回一个新的字符串
String concat(String str)

//将字符串从输入的分隔符处分开，并返回一个数组
Stirng[] split(分割符);

 */
public class ConversionDemo {
    public static void main(String[] args) {

        //将整数转换为字符串操作
        String s = String.valueOf(1234);
        System.out.println(s.charAt(2)); // 3
        int a = Integer.parseInt(s);  //再将字符串转回整数
        System.out.println(a);
        //将字符串里的内容全部转为小写
        String s2 = "AaBbCc";
        System.out.println("全转为小写:"+s2.toLowerCase());
        //将字符串里的内容全转为大写
        System.out.println("全转为大写:"+s2.toUpperCase());
        //将输入的字符串连接到引用的字符串之后
        String s3 = s2.concat("xxx"); //相当于 s3 = s2+"xxx"
        System.out.println(s3);
        //将字符串从输入的分隔符处分开，并返回一个数组
        String s4 = "ab;cd;efg";
        String[] strings =  s4.split(";");
        System.out.println(Arrays.toString(strings));

    }
}

● 替换功能

String replace(char old,char new)        //将字符串中所有的原字符(old)用新字符(new)替换

String replace(String old,String new)        //将字符串中所有的原字符串(old)用新字符串(new)替换

replaceAll(String regex, String replacement)        //可以传入一个正则表达式（例如"\\d"（整数）、"[a-z]"（小写字母））替换为新字符串

replaceFirst(String regex, String replacement)        //将字符串中的第一个原字符串替换为新字符串

/*
替换功能
//将字符串中所有的原字符(old)用新字符(new)替换
String replace(char old,char new)

//将字符串中所有的原字符串(old)用新字符串(new)替换
String replace(String old,String new)

//可以传入一个正则表达式（例如"\\d"（整数）、"[a-z]"（小写字母））替换为新字符串
replaceAll(String regex, String replacement)

//
replaceFirst(String regex, String replacement)

 */
public class ReplacementDemo {
    public static void main(String[] args) {
        String s = "abcdefg";

        //将字符串中所有的原字符(old)用新字符(new)替换
        System.out.println(s.replace('a','A'));
        //将字符串中所有的原字符串(old)用新字符串(new)替换
        System.out.println(s.replace("d","D"));

        //可以传入一个正则表达式
        String s1 = "a1bc2def3";
        System.out.println(s1.replaceAll("\\d"," ")); //将所有的整数全部替换为空格
        //将字符串中的第一个原字符串替换为新字符串
        String s2 = "aabbcc";
        System.out.println(s2.replaceFirst("a","A"));

    }
}

● 去除字符串前后两空格

String trim( ) //去除字符串前后两空格

/*
去除字符串前后两空格
String trim( )
 */
public class RemoveWhitespaceDemo {
    public static void main(String[] args) {
        String s = " abcdefg ";
        System.out.println(s+":"+s.length());
        System.out.println(s.trim()+":"+s.trim().length());
    }
}

二、 StringBuffer类

● 概述

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

线程安全的可变字符序列

● StringBuffer和String的区别

StringBuffer只用创建一个数组对象，并为数组空间赋内容长度+16 的 char数组

而 String 则需要先创建一个String类型的对象，再把String类型的转换为字符数组

● 构造方法

public StringBuffer()

public StringBuffer(String str)

● 添加功能

public StringBuffer append(String str) //在原字符串末尾直接添加

public StringBuffer insert(int offset,String str) //在指定索引处添加

public class StringBuffer2 {
    public static void main(String[] args) {
        StringBuffer stringBuffer = new StringBuffer();

        //在原字符串上直接增加
        stringBuffer.append("abcd");
        stringBuffer.append("efg");
        stringBuffer.append("higklmn");
        System.out.println(stringBuffer);
        //在指定的位置上插入字符串
        stringBuffer.insert(1,"AA");
        System.out.println(stringBuffer);

    }
}

● 删除功能

public StringBuffer deleteCharAt(int index) //删除指定索引处字符

public StringBuffer delete(int start,int end) //删除指定索引段处字符

package day2.stringbufferdemo;

public class StringBuffer2 {
    public static void main(String[] args) {
        StringBuffer stringBuffer = new StringBuffer();

        stringBuffer.append("abcd");

        //删除指定索引处的字符
        stringBuffer.deleteCharAt(1);
        System.out.println(stringBuffer);
        //删除指定索引段的字符
        stringBuffer.delete(0,3);
        System.out.println(stringBuffer);


    }
}

● 替换功能

public StringBuffer replace(int start,int end,String str) //替换字符串

public class StringBuffer2 {
    public static void main(String[] args) {
        StringBuffer stringBuffer = new StringBuffer();


        stringBuffer.append("abcd");

        //替换字符
        stringBuffer.replace(0,3,"A");
        System.out.println(stringBuffer);


    }
}

● 反转功能

public StringBuffer reverse() //反转字符串

public class StringBuffer2 {
    public static void main(String[] args) {
        StringBuffer stringBuffer = new StringBuffer();


        stringBuffer.append("abcd");

        //翻转字符串
        stringBuffer.reverse();
        System.out.println(stringBuffer);


    }
}

● 截取功能

public String substring(int start) //从start开始截取

public String substring(int start,int end) //从start截取到end

public class StringBuffer2 {
    public static void main(String[] args) {
        StringBuffer stringBuffer = new StringBuffer();


        stringBuffer.append("abcd");

        //截取字符串
        System.out.println(stringBuffer.substring(0,3));
        
    }
}

三、 String类、StringBuffer类、StringBuilder区别

● String：是字符常量,适用于少量的字符串操作的情况

● StringBuilder：适用于单线程下在字符缓冲区进行大量操作的情况

● StringBuffer：适用多线程下在字符缓冲区进行大量操作的情况

public class StringBuilder1 {
    public static void main(String[] args) {
        StringBuilder s1 = new StringBuilder();
        StringBuilder s2 = new StringBuilder("a");
        StringBuilder s3 = new StringBuilder(6);

        s1.append("a");
        /*
        StringBuffer: public synchronized StringBuffer append(String str)
        StringBuilder: public StringBuilder append(String str)

        synchronized:锁，在多线程（多任务）时会更加安全

         */




    }
}