String类的讲解

最新推荐文章于 2024-09-25 11:06:23 发布

坤坤爱打篮球

最新推荐文章于 2024-09-25 11:06:23 发布

阅读量250

点赞数

文章标签： java jvm servlet

本文链接：https://blog.csdn.net/shj3290984802/article/details/130683596

版权

文章介绍了Java中的String类和StringBuffer类在处理字符串时的区别和特点。String是不可变的，一旦创建其内容不能更改，而StringBuffer是可变的，适合于字符串的修改操作，特别是在多线程环境下。文中还详细讲述了String的构造方法、equals()方法的行为，以及StringBuffer的添加、删除、替换、反转和截取等操作。此外，文章提到了字符串拼接的效率问题，以及如何在两者之间进行转换。

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

一，了解String类

字符串是由多个字符组成的一串数据(字符序列)，字符串可以看成是字符数组。

在实际开发中，字符串的操作是最常见的操作，没有之一。而Java没有内置的字符串类型，所以，就在Java类库中提供了一个类String 供我们来使用。String 类代表字符串。

在应用程序中经常会用到字符串，所谓字符串就是指一连串的字符，它是由许多单个字符连接而成的，如多个英文字母所组成的一个英文单词。字符串中可以包含任意字符，这些字符必须包含在一对双引号“”之内，例如“abc”。在Java中定义了String和StringBuffer两个类来封装字符串，并提供了一系列操作字符串的方法，它们都位于java.lang包中，因此不需要导包就可以直接使用。

二，String类的特点

字符串是常量,它的值在创建之后不能更改
Java 程序中的所有字符串字面值（如 "abc" ）都作为此类的实例实现。
字符串如果是变量相加，先开空间，在拼接。
字符串如果是常量相加，是先加，然后在常量池找，如果有就直接返回，否则，就创建。

/*
* 字符串的特点：一旦被赋值，就不能改变。
*/  
public class StringDemo {
    public static void main(String[] args) {
        String s="hello";
        s+="world";
        System.out.println("s:"+s);
    }
}

那么创建String对象时的方法不同会有什么区别呢？就如：String s1 = new String(“hello”);和String s2 = “hello”;前者创建了2个或1个对象，后者创建了1个或0个对象。

String s1 = new String("hello");
        String s2 = "hello";
        boolean ret = s1 == s2; // false   
        s1.equals(s2); // true
        String s3 = "hello";    String s4 = "world";   String s5 = "helloworld";
        S5== s3 + s4 ; //fale      
        s5 == "hello" + "world"; //true

字符串如果是变量相加，先开空间，再拼接。

字符串如果是常量相加，是先加，然后到字符串常量池中找，如果有就直接返回，否则就创建。

1> 构造方法

2>判断功能

3>获取功能

4>转换功能

5>其他功能

三，StringBuffer与String的区别

由于字符串是常量，因此一旦创建，其内容和长度是不可改变的。如果需要对一个字符串进行修改，则只能创建新的字符串。为了便于对字符串进行修改，在JDK中提供了一个StringBuffer类（也称字符串缓冲区）。StringBuffer类和String类最大的区别在于它的内容和长度都是可以改变的。StringBuffer类似一个字符容器，当在其中添加或删除字符时，并不会产生新的StringBuffer对象。

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

StringBuffer是线程安全的可变字符序列。

前者长度和内容可变，后者不可变。如果使用前者做字符串的拼接，不会浪费太多的资源。

String类表示的字符串是常量，一旦创建后，内容和长度都是无法改变的。而StringBuffer表示字符容器，其内容和长度可以随时修改。在操作字符串时，如果该字符串仅用于表示数据类型，则使用String类即可，但是如果需要对字符串中的字符进行增删操作，则使用StringBuffer类。

值得注意的是：String类覆盖了Object类的equals()方法，而StringBuffer类没有覆盖Object类的equals()方法，具体示例如下：

还有就是String类对象是可以用“+”进行连接的，而StringBuffer类对象不可以用“+”连接，编译器会报错。

1>常用方法

2>添加功能

/*
 * StringBuffer的添加功能：
 * public StringBuffer append(String str):可以把任意类型数据添加到字符串缓冲区里面,并返回字符串缓冲区本身
 *  
 * public StringBuffer insert(int offset,String str):在指定位置把任意类型的数据插入到字符串缓冲区里面,并返回字符串缓冲区本身
 */  
public class StringBufferDemo {  
    public static void main(String[] args) {  
        // 创建字符串缓冲区对象  
        StringBuffer sb = new StringBuffer();  
        // public StringBuffer append(String str)  
        // StringBuffer sb2 = sb.append("hello");  
        // System.out.println("sb:" + sb);  
        // System.out.println("sb2:" + sb2);  
        // System.out.println(sb == sb2); // true  
        // 一步一步的添加数据  
        // sb.append("hello");  
        // sb.append(true);  
        // sb.append(12);  
        // sb.append(34.56);  
        // 链式编程  
        sb.append("hello").append(true).append(12).append(34.56);  
        System.out.println("sb:" + sb);  
        // public StringBuffer insert(int offset,String  
        // str):在指定位置把任意类型的数据插入到字符串缓冲区里面,并返回字符串缓冲区本身  
        sb.insert(5, "world");  
        System.out.println("sb:" + sb);  
    }  
}

运行结果:

3>删除功能

/*
 * StringBuffer的删除功能
 * public StringBuffer deleteCharAt(int index):删除指定位置的字符，并返回本身
 * public StringBuffer delete(int start,int end):删除从指定位置开始指定位置结束的内容，并返回本身
 */  
public class StringBufferDemo {  
    public static void main(String[] args) {  
        // 创建对象  
        StringBuffer sb = new StringBuffer();  
        // 添加功能  
        sb.append("hello").append("world").append("java");  
        System.out.println("sb:" + sb);  
        // public StringBuffer deleteCharAt(int index):删除指定位置的字符，并返回本身  
        // 需求：我要删除e这个字符，肿么办?  
        // sb.deleteCharAt(1);  
        // 需求:我要删除第一个l这个字符，肿么办?  
        // sb.deleteCharAt(1);  
        // public StringBuffer delete(int start,int  
        // end):删除从指定位置开始指定位置结束的内容，并返回本身  
        // 需求：我要删除world这个字符串，肿么办?  
        // sb.delete(5, 10);  
        // 需求:我要删除所有的数据  
        sb.delete(0, sb.length());  
        System.out.println("sb:" + sb);  
    }  
}

运行结果：

4>替换功能

/*
 * StringBuffer的替换功能：
 * public StringBuffer replace(int start,int end,String str):从start开始到end用str替换
 */  
public class StringBufferDemo {  
    public static void main(String[] args) {  
        // 创建字符串缓冲区对象  
        StringBuffer sb = new StringBuffer();  
        // 添加数据  
        sb.append("hello");  
        sb.append("world");  
        sb.append("java");  
        System.out.println("sb:" + sb);  
        // public StringBuffer replace(int start,int end,String  
        // str):从start开始到end用str替换  
        // 需求：我要把world这个数据替换为"节日快乐"  
        sb.replace(5, 10, "节日快乐");  
        System.out.println("sb:" + sb);  
    }  
}

运行结果：

5>反转功能


/*
 * StringBuffer的反转功能：
 * public StringBuffer reverse()
 */  
public class StringBufferDemo {  
    public static void main(String[] args) {  
        // 创建字符串缓冲区对象  
        StringBuffer sb = new StringBuffer();  
        // 添加数据  
        sb.append("篮球爱我");  
        System.out.println("sb:" + sb);  
        // public StringBuffer reverse()  
        sb.reverse();  
        System.out.println("sb:" + sb);  
    }  
}

那么结果就很明显了：就是篮球爱我和我爱篮球。

6>截取功能

/*
 * StringBuffer的截取功能:注意返回值类型不再是StringBuffer本身了
 * public String substring(int start)
 * public String substring(int start,int end)
 */  
public class StringBufferDemo {  
    public static void main(String[] args) {  
        // 创建字符串缓冲区对象  
        StringBuffer sb = new StringBuffer();  
        // 添加元素  
        sb.append("hello").append("world").append("java");  
        System.out.println("sb:" + sb);  
        // 截取功能  
        // public String substring(int start)  
        String s = sb.substring(5);  
        System.out.println("s:" + s);  
        System.out.println("sb:" + sb);  
        // public String substring(int start,int end)  
        String ss = sb.substring(5, 10);  
        System.out.println("ss:" + ss);  
        System.out.println("sb:" + sb);  
    }  
}

运行结果：

7>String和StringBuffer的相互转换

/*
 * 为什么我们要讲解类之间的转换：
 * A -- B的转换
 * 我们把A转换为B，其实是为了使用B的功能。
 * B -- A的转换
 * 我们可能要的结果是A类型，所以还得转回来。
 *  
 * String和StringBuffer的相互转换?
 */  
public class StringBufferTest {  
    public static void main(String[] args) {  
        // String -- StringBuffer  
        String s = "hello";  
        // 注意：不能把字符串的值直接赋值给StringBuffer  
        // StringBuffer sb = "hello";  
        // StringBuffer sb = s;  
        // 方式1:通过构造方法  
        StringBuffer sb = new StringBuffer(s);  
        // 方式2：通过append()方法  
        StringBuffer sb2 = new StringBuffer();  
        sb2.append(s);  
        System.out.println("sb:" + sb);  
        System.out.println("sb2:" + sb2);  
        System.out.println("---------------");  
        // StringBuffer -- String  
        StringBuffer buffer = new StringBuffer("java");  
        // String(StringBuffer buffer)  
        // 方式1:通过构造方法  
        String str = new String(buffer);  
        // 方式2：通过toString()方法  
        String str2 = buffer.toString();  
        System.out.println("str:" + str);  
        System.out.println("str2:" + str2);  
    }  
}

常见的两种方法就是方式1和2。

OK啦今天的分享就到这里，再见啦！！！