【Java 12】常用类上 - 字符串相关的类：String、StringBuffer、StringBuilder

最新推荐文章于 2023-09-06 02:12:54 发布
最新推荐文章于 2023-09-06 02:12:54 发布
阅读量180 收藏
点赞数
分类专栏： Java Learning Java 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a903003911/article/details/108103463
版权
Java 同时被 3 个专栏收录
32 篇文章 0 订阅
订阅专栏
笔记
25 篇文章 0 订阅
订阅专栏
Java Learning
20 篇文章 0 订阅
订阅专栏

常用类上 - 字符串相关的类：String、StringBuffer、StringBuilder

1 字符串相关的类

1.1 String类及常用方法

1.1.1 String的特性

image-20200819081420186

  1. String声明为final的，不可被继承

  2. String实现了Serializable接口：表示字符串是支持序列化的

    ​ 实现了Comparable接口：表示String可以比较大小

  3. String内部定义了final char[] value用于存储字符串数据

  4. String：代表不可变的字符序列。简称：不可变性

    体现：不同内容的字符串，就会重新造

    1. 当对字符串重新赋值时，需要重新指定内存区域赋值，不能使用原有的value进行赋值

      String s1 = "abc";
s1 = "Hi";

    2. 当对现有的字符串进行连接操作时，也需要重新指定内存区域赋值，不能使用原有的value进行赋值

      String s2 = "abc";
s2 += "def";

    3. 当调用String的replace()方式修改内部指定的字符或字符串时，也需要重新指定内存区域赋值，不能使用原有的value进行赋值

      Srting s3 = "abc";
String s4 = s3.replace('a','m');

  5. 通过字面量的方式（不同于new）给一个字符串赋值，此时的字符串值声明在方法区的字符串常量池中

  6. 字符串常量池中是不会存储相同内容

1.1.2 String对象的创建

image-20200819084016586

image-20200819093948354

1.1.2.1 内存解析

image-20200819095213587

image-20200819095224800

1.1.2.2 练习1 字面量定义值与new定义比较

image-20200819094135841

String str = new String（“123”）；创建了两个对象

String s1 =“123”;

这种方式是字面量定义，"123"是放在方法区的字符串常量池（1.8后常量池还是在方法区里面）

String s2 = new String(“123”);

new 出来的String对象是放在堆当中的，但是"123"这个value值它还是存在方法区中，也就是在方法区也创建一个”123“.所以有问题说String s2 = new String(“123”)创建了几个对象，答案是两个

1.1.2.3 练习2 对象字符串属性

image-20200819094254362

image-20200819094304890

1.1.2.4 练习3 各种拼接

image-20200819095427130

1.1.2.5 使用陷阱（上面部分小结）

image-20200819100538413

1.1.2.6 面试题-关于String和值传递

值传递-其中方法形参相当于在栈中有了一个新的指向同一个地址

image-20200819100724750

good

best

public class StringTransmit {
    String str = new String("good");
    char [] ch = {'t','e','s','t'};
    public void change(String str1,char ch[]){
        System.out.println(this.str == str1);//true
        str1 = "test ok";
        System.out.println(this.str == str1);//false
 
        //String heapString = new String("test ok");
        //System.out.println(str1==heapString);//false
        ch[0] = 'b';
        System.out.println(this.ch==ch);//true
    }
 
    public static void main(String[] args) {
        StringTransmit ex = new StringTransmit();
        ex.change(ex.str,ex.ch);
        System.out.println(ex.str);//good
        System.out.println(ex.ch);//best
    }
 
}

​ 其实从第一个打印语句System.out.println(this.str == str1);//true的结果是true，经过赋值操作之后的第二个打印语句System.out.println(this.str == str1);//false的结果是false，已经是给出了一个线索了，说明什么呢？在经过赋值操作之后，str 成员变量和str1 形参它们的地址值是不一样的，那么str1的修改不是去操作str 指向的地址的对象就可以理解了，因为如果是修改了str 指向的地址值的对象，那么它两的地址值应该是一致的，从结果看，并不是 。

​ 下面说说详细的过程，调用ex.change(ex.str,ex.ch)方法，str 成员变量把存放对象堆中的地址给str1 ，那么当前str 和 str 1指向的对象是一致的。执行str1 = “test ok”，此时str1想去修改共同指向的对象的值，然后发现这个对象是不可变的。**（String不可变性值的是堆中的String对象或方法区字符串常量池中的对象是不能被改变的）**那么怎么办呢，我需要有个地方存放”test ok“这个值，如果是普通的对象，直接在堆中申请一块内存，把new 出来的新对象放在内存当中，然后把”test ok“放进去，最后把str1和新开辟的对象关联上。但是String比较特殊，采用str1 = “test ok"字面量定义的方式，test ok是放在方法区的常量池当中的，然后把方法区中的对象和str1关联起来。但无论是放在堆中和方法区中，因为String对象的不可变性，都是需要新的一块内存区域来存放"test ok”，也就是说原先对象的内容不会被改变。

image-20200819124317326

1.1.3 常用方法

int length()：返回字符串的长度： return value.length

 ⭐️char charAt(int index)： 返回某索引处的字符return value[index]

boolean isEmpty()：判断是否是空字符串：return value.length == 0

String toLowerCase()：使用默认语言环境，将 String 中的所有字符转换为小写

String toUpperCase()：使用默认语言环境，将 String 中的所有字符转换为大写

String trim()：返回字符串的副本，忽略前导空白和尾部空白

 ⭐️boolean equals(Object obj)：比较字符串的内容是否相同

boolean equalsIgnoreCase(String anotherString)：与equals方法类似，忽略大 小写

String concat(String str)：将指定字符串连接到此字符串的结尾。 等价于用“+”

 ⭐️int compareTo(String anotherString)：比较两个字符串的大小

String substring(int beginIndex)：返回一个新的字符串，它是此字符串的从 beginIndex开始截取到最后的一个子字符串。

String substring(int beginIndex, int endIndex) ：返回一个新字符串，它是此字 符串从beginIndex开始截取到endIndex(不包含)的一个子字符串。左闭右开

是否以指定前/后缀开始/结束

boolean endsWith(String suffix)：测试此字符串是否以指定的后缀结束

boolean startsWith(String prefix)：测试此字符串是否以指定的前缀开始

boolean startsWith(String prefix, int toffset)：测试此字符串从指定索引开始的 子字符串是否以指定前缀开始

是否包含（返回索引）

boolean contains(CharSequence s)：当且仅当此字符串包含指定的 char 值序列 时，返回 true

int indexOf(String str)：返回指定子字符串在此字符串中第一次出现处的索引

int indexOf(String str, int fromIndex)：返回指定子字符串在此字符串中第一次出 现处的索引，从指定的索引开始

int lastIndexOf(String str)：返回指定子字符串在此字符串中最右边出现处的索引

int lastIndexOf(String str, int fromIndex)：返回指定子字符串在此字符串中最后 一次出现处的索引，从指定的索引开始反向搜索

注：indexOf和lastIndexOf方法如果未找到都是返回-1

替换

String replace(char oldChar, char newChar)：返回一个新的字符串，它是 通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。

String replace(CharSequence target, CharSequence replacement)：使 用指定的字面值替换序列替换此字符串所有匹配字面值目标序列的子字符串。

String replaceAll(String regex, String replacement) ： 使 用 给 定 的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串。

String replaceFirst(String regex, String replacement) ： 使 用 给 定 的 replacement 替换此字符串匹配给定的正则表达式的第一个子字符串。

image-20200819135517034

匹配

boolean matches(String regex)：告知此字符串是否匹配给定的正则表达式。

image-20200819135525526

切片

String[] split(String regex)：根据给定正则表达式的匹配拆分此字符串。

String[] split(String regex, int limit)：根据匹配给定的正则表达式来拆分此 字符串，最多不超过limit个，如果超过了，剩下的全部都放到最后一个元素中。

image-20200819135537793

1.1.4 String与其他数据类型的转换

image-20200819140010213

String str1 = "123";
int num = Integer.parseInt(str1);//123

String str2 = String.valueOf(num);//"123"
String str3 = num + "";

image-20200819140910527

String str1 = "123";
char[] charArray = str1.toCharArray();//{'1','2','3'}

char[] arr = new char[]{'a','b','c'};
String str2 = new String(arr);//"abc"

image-20200819140918881

String str1 = "abc123中国";
byte[] bytes = str1.getBytes();//使用默认的字符集，进行编码
byte[] gbks = str1.getBytes("gbk");//使用gbk字符集，进行编码

String str2 = new String(bytes);//用默认的字符集，进行解码
String str3 = new String(gbks);//出现乱码，编码集和解码集不一样
String str2 = new String(gbks,"gbk");//没有出现乱码

编码：字符串 --> 字节（看得懂 --> 看不懂的二进制数据）

解码：编码的逆过程：字节 --> 字符串（看不懂的二进制数据 --> 看得懂）

1.1.5 常见算法题目

  1. 模拟一个trim方法，去除字符串两端的空格。

    public class exer05 {
    public static void main(String[] args) {
        String str1 = "   Hello World   ";
        System.out.println(myTrim(str1));
    }

    public static String myTrim(String str){
        int start = 0;
        int end = str.length() - 1;
        while(start < end && str.charAt(start) == ' ' ){
            start++;
        }
        while (end > start && str.charAt(end) == ' '){
            end--;
        }
        if(start == end){
            return "";
        }
        return str.substring(start,end+1);
    }
}

  2. 将一个字符串进行反转。将字符串中指定部分进行反转。

    比如“abcdefg”反 转为”abfedcg”

    public class exer06 {
    public static void main(String[] args) {
        String str1 = "HelloWorld";
        System.out.println(reverseString1(str1, 2, 5));
        System.out.println(reverseString2(str1, 2, 5));
        System.out.println(reverseString3(str1, 2, 5));
    }

    private static String reverseString1(String str, int start, int end) {
        char[] c = str.toCharArray();
        for (int i = start, j = end; i < j ; i++,j--) {
            char temp = c[i];
            c[i] = c[j];
            c[j] = temp;
        }
        return new String(c);
    }

    private static String reverseString2(String str, int start, int end) {
        String str1 = str.substring(0,start);
        for (int i = end; i >= start; i--) {
            char c = str.charAt(i);
            str1 += c;
        }
        str1 += str.substring(end + 1);
        return str1;
    }
    
    private static String reverseString3(String str1, int start, int end) {
        StringBuilder builder = new StringBuilder(str1.length());
        builder.append(str1.substring(0,start));
        for (int i = end; i >= start; i--) {
            builder.append(str1.charAt(i));
        }
        builder.append(str1.substring(end + 1));
        return builder.toString();
    }
}

  3. 获取一个字符串在另一个字符串中出现的次数。

    比如：获取“ ab”在 “abkkcadkabkebfkabkskab” 中出现的次数

    public class exer07 {
    public static void main(String[] args) {
        String str1 = "abkkcadkabkebfkabkskab";
        System.out.println(getTime1(str1, "ab"));
        System.out.println(getTime2(str1, "ab"));
    }

    private static int getTime1(String str1, String str2) {
        int count = 0,start = 0;
        while((start = str1.indexOf(str2)) != -1){
            count++;
            str1 = str1.substring(start + str2.length());
        }
        return count;
    }
    
    private static int getTime2(String str1, String str2) {
        int count = 0,start = 0;
        while((start = str1.indexOf(str2,start)) != -1){
            count++;
            start += str2.length();
        }
        return count;
    }
}

  4. 获取两个字符串中最大相同子串。

    比如： str1 = "abcwerthelloyuiodef“;str2 = “cvhellobnm” 提示：将短的那个串进行长度依次递减的子串与较长的串比较。

    public class exer08 {
    public static void main(String[] args) {
        String str1 = "abcwerthelloyuiodef";
        String str2 = "cvhellohellobnm";
        System.out.println(getMaxString(str1,str2));
        System.out.println(getMaxSubString(str1,str2));
    }

    private static String getMaxString(String str1, String str2) {
        String maxStr = (str1.length() >= str2.length())? str1 : str2;
        String minStr = (str1.length() < str2.length())? str1 : str2;
        String str = null;
        int length = minStr.length();

        for (int i = 0; i < length; i++) {
            for (int x = 0,y = length - i; y < length; x++,y++) {
                str = minStr.substring(x,y);
                if(maxStr.contains(str)){
                    return str;
                }
            }
        }

        return null;
    }

    public static List<String> getMaxSubString(String str1,String str2){
        String maxStr = (str1.length() > str2.length())? str1 : str2;
        String minStr = (str1.length() < str2.length())? str1 : str2;
        int len = minStr.length();
        List<String> list = new ArrayList<>();
        for(int i = 0;i < len;i++){
            for(int x = 0,y = len - i;y <= len;x++,y++){
                String str = minStr.substring(x, y);
                if(maxStr.contains(str)){
                    list.add(str);
                }
            }
            if(list.size() != 0){
                return list;
            }
        }
        return null;
    }

}

  5. 对字符串中字符进行自然顺序排序。

    提示：

    1）字符串变成字符数组。

    2）对数组排序，选择，冒泡，Arrays.sort();

    3）将排序后的数组变成字符串。

    public class exer09 {
    public static void main(String[] args) {
        String str1 = "abkkcadkabkebfkabkskab";
        System.out.println(sort(str1));
    }

    public static String sort(String str){
        char[] c = str.toCharArray();
        Arrays.sort(c);
        return new String(c);
    }

}

1.2 StringBuffer

image-20200819144512527

image-20200819144520480

1.2.1 创建底层
String str1 = new String();//char[] value = new char[0];
String str2 = new String("abc");//char[] value = new char[]{'a','b','c'};

StringBuffer sb1 = new StringBuffer();//char[] value = new char[16];底层创建了一个长度为16的数组
sb1.append('a');//value[0] = 'a';
sb1.append('b');//value[1] = 'b';

image-20200819151447196

image-20200819152115316

StringBuffer sb2 = new StringBuffer("abc");//char[] value = new char["abc".length() + 16];

image-20200819152038882

1.2.2 一些问题

  1. 问题1：

    System.out.println(sb2.length());//3

  2. 问题2：

    扩容问题：如果要添加的数据底层数组盛不下了，那就需要扩容底层的数组

    默认情况下，扩容为原来容量的2倍+2，同时将原有数组中的元素复制到新的数组中

    image-20200819153005495

    image-20200819153031434

    image-20200819153126703

    image-20200819153250691

    value.length << 1 相当于乘2

1.2.3 常用方法

image-20200819154118541

image-20200819154125882

StringBuffer append(xxx)：提供了很多的append()方法，用于进行字符串拼接

StringBuffer s1 = new StringBuffer("abc");//abc
s1.append(1);//abc1
s1.append('1');//abc11

StringBuffer delete(int start,int end)：删除指定位置的内容。左闭右开

s1.delete(2,4);//ab1

StringBuffer replace(int start, int end, String str)：把[start,end)位置替换为str 。左闭右开

s1.replace(2,4,"hello");//abhello1

StringBuffer insert(int offset, xxx)：在指定位置插入xxx

image-20200819155329748

s1.insert(2,false);//abfalsec11

StringBuffer reverse() ：把当前字符序列逆转

s1.reverse();//11cba

public int indexOf(String str)

public String substring(int start,int end)

 **public int length() **

public char charAt(int n )

public void setCharAt(int n ,char ch)

  • 总结：
    • 增：append(xxx)
    • 删：delete(int start,int end)
    • 改：setCharAt(int n ,char ch) / replace(int start, int end, String str)
    • 查：charAt(int n )
    • 插：insert(int offset, xxx)
    • 长度：length()
    • 遍历：for() + chaAt() / toSring()

1.3 StringBuilder

与StringBuffer差不多，只是StringBuilder是线程不安全的，效率高点

image-20200819160412484

1.4 String与StringBuffer、StringBuilder之间的转换

1.4.1 String —> StringBuffer、StringBuilder

调用StringBuffer、StringBuilder的构造器

1.4.2 StringBuffer、StringBuilder —> String
  1. 调用String的构造器；
  2. StringBuffer、StringBuilder的toString()

1.5 三者异同

  • String：不可变的字符序列；底层使用char[]存储；
  • StringBuffer：可变的字符序列；底层使用char[]存储；线程安全的，效率低；
  • StringBuilder：可变的字符序列；底层使用char[]存储；线程不安全的，效率高；JDK5.0新增的；

1.6 三者效率

//初始设置
long startTime = 0L;
long endTime = 0L;
String text = "";
StringBuffer buffer = new StringBuffer("");
StringBuilder builder = new StringBuilder("");

//开始对比
startTime = System.currentTimeMillis();
for (int i = 0; i < 20000; i++) {
	buffer.append(String.valueOf(i));
}
endTime = System.currentTimeMillis();
System.out.println("StringBuffer的执行时间：" + (endTime - startTime));//7

startTime = System.currentTimeMillis();
for (int i = 0; i < 20000; i++) {
	builder.append(String.valueOf(i));
}
endTime = System.currentTimeMillis();
System.out.println("StringBuilder的执行时间：" + (endTime - startTime));//4

startTime = System.currentTimeMillis();
for (int i = 0; i < 20000; i++) {
	text = text + i;
}
endTime = System.currentTimeMillis();
System.out.println("String的执行时间：" + (endTime - startTime));//1026

1.7 两道面试题

image-20200819162033413

//4

//“null”

//抛异常了NullPointerException

image-20200820200014272

image-20200820200040755

image-20200820200112386

image-20200820200159906

image-20200819162040609

白雪青冢 黄河黑山
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
字符串匹配（java）
小白的程序猿
11-20 1308
字符串匹配 字符串匹配可以用到蛮力法。 对于字符串s和t，若t是s的子串，返回t在s中的位置（t的首字符在s中的下标），否则返回-1. 采用的是穷举法，从s的第一个字符开始查找，看t是否会出现。 下面直接看程序 package HuiWenStrings; //有两个字符串s，t（其中t是s字符串的子字符串），求t字符串在s字符串中出现的位置。 //并输出 public class HuiWe...
字符串匹配（Java）
lsjweiyi的博客
05-17 1149
阿里笔试的一道题，当时没时间没做出来，现在补一下。 或许他的考点在正则表达式，不过这样有点太简单了（考场上那么久没用过正则表达式，还真写不出来，毕竟闭卷），所以我就自己写了个匹配算法，具体题目是： 第一行输入一个需要进行匹配的字符串，第二行输入匹配模板。成功匹配就返回1，否则返回0。 其中规定两种特殊符号：‘？’表示任意一个字符，‘*’表示一个或多个任意字符，其余字符均为普通字符。正则表达式简
java字符串匹配
小码农的成长
04-28 546
String s="D:\\MyEclipse\\Common"; int result=s.indexOf("D:\\MyEclipse"); if(result>=0){ System.out.println("匹配"); }else{ System.out.println("不匹配"); }
java 字符串匹配
Jooger 的全栈之路
10-20 425
在日常开发中，我们需要对数据进行截取，可以通过下面的方法实现，例如：需要截取下面的“CSDN”字符串String str = "This is a CSDN blog!"; String s = null;String regex = "This is a (.*?) blog!"; //利用正则表达式 Pattern pattern = Pattern.compile(regex);Ma
辨析Java中的String与StringBuffer及StringBuilder字符串类
09-02
在Java编程语言中，处理字符串是常见的任务，有三种主要的字符串类：String、StringBuffer和StringBuilder。理解它们之间的区别和应用场景对于编写高效的代码至关重要。 1. **String类**：String是Java中的字符串...
java源码stringbuffer-java-strings-api-guide:Java字符串处理指南
06-05
java源码字符串缓冲区 这是 Java String 、 StringBuilder和StringBuffer方法/API 的完整指南。 本指南的源代码示例在我们的本地开发环境中进行了良好的测试，您可以将这些示例用作无错误。 您可以在 上了解更多信息...
Java高级编程--常用类之字符串相关类String、StringBuffer、StringBuilder
༺ཌ༈君纤༈ད༻
06-12 255
Java提供了丰富的API给使用者方便其快捷高效的进行开发工作，本篇博客将介绍常用类中字符串相关类的具体使用方法，包括String、StringBuffer、StringBuilder
字符串常量：String、StringBuffer和StringBuilder的区别？
m0_61601521的博客
01-18 606
字符串常量：String、StringBuffer和StringBuilder的区别？
Java实现字符串匹配（基于正则）
09-03
主要介绍了Java中使用正则表达式实现字符串匹配，字符串查找，匹配，替换，正则无不能做，特别是灵活的运用子串匹配，感兴趣的小伙伴们可以参考一下
Java实现字符串匹配
最新发布
DevNinja的博客
09-06 632
在Java中，我们可以使用正则表达式来匹配和处理字符串。正则表达式是一种强大的模式匹配工具，可以用来查找、替换、验证和提取字符串中的特定模式。下面我将为你提供一个示例代码，演示如何使用正则表达式进行字符串匹配。接下来，我们可以编写一个方法来执行字符串匹配。该方法将接收两个参数：待匹配的字符串和匹配的模式。可以根据需要，根据实际的匹配需求修改模式字符串。Java的正则表达式支持多种匹配模式和匹配规则，可以满足各种不同的字符串匹配需求。如果匹配成功，我们将输出"字符串匹配成功！在上面的示例中，我们将。
字符串匹配（java实现）
ANGEL CITY
05-22 1247
字符串操作通常称为模式匹配，是各种串处理系统中最重要的操作之一。本文主要介绍两种常用的实现算法： 暴力匹配 KMP算法 1.暴力匹配 时间复杂度为O(n*m)：n为主串长度，m为模式串长度； 算法的基本思想：从主串的起始位置（或指定位置）开始与模式串的第一个字符比较，若相等，则继续逐个比较后续字符；否则从主串的下一个字符再重新和模式串的字符比较。以此类推，直...
【Java编程】Java中的字符串匹配
青峰碧陋室
04-29 5319
在Java中，字符串的匹配可以使用下面两种方法：         1、使用正则表达式判断字符串匹配         2、使用Pattern类和Matcher类判断字符串匹配 正则表达式的字符串匹配：         正则表达式：定义一组字符串的一系列字符和符号，它由常量字符和特殊符号构成。         下面是正则表达式的一些预定义字符类，实际上是一些转
java实现字符串的匹配
zhang434的专栏
11-25 1945
假设我们有一个一定个数的字母组成字串，我给每个字母分配一个素数，从2开始，往后类推。这样A将会是2，B将会是3，C将会是5，等等。现在我遍历第一个字串，把每个字母代表的素数相乘。你最终会得到一个很大的整数，对吧？     然后——轮询第二个字符串，用每个字母除它。如果除的结果有余数，这说明有不匹配的字母。如果整个过程中没有余数，你应该知道它是第一个字串恰好的子集了。 思路总结如下： 1.定义
java中字符串匹配_【Java编程】Java中的字符串匹配
weixin_35427369的博客
02-12 1006
package tengwei.com;import java.util.regex.Pattern;import javax.swing.JOptionPane;public class UseMatchesMethod {public static void main(String args[]){String input = JOptionPane.showInputDialog("请输入有...
Java字符串匹配算法
weixin_51532232的博客
11-07 7934
定义 串(string)是由零个或多个字符组成的有限序列又名叫字符串。 一般地，由n个字符串构成的串记作: S=“a0a1…an-1”(n≥0),其中a_i（1≤i≤n） n是个有限的数值 串一般记为S是串的名称,用引号括起来的字符序列是串的值 可以是字母,数字或其他字符,i就是该字符在串中的位置,串中的字符数目n称为串的长度 子串 在对字符串S做处理时,经常需要取出其中某一连续的片段,称为S的子串(substring) 具体地，由串S中起始于位置i的连续k个字符组成的子串记作substr(S,
Java 字符串匹配算法
修也
09-02 179
package com.ec.xy.app.algorithm; import com.xiuye.sharp.X; import com.xiuye.util.cls.XType; import com.xiuye.util.log.XLog; public class KMP { private static int[] getNext(String p) { int [] next = XType.newInstance(int[]::new,p.length()); n.
java 字符串匹配_查找匹配字符串（Java方法总结）
热门推荐
weixin_39977547的博客
02-12 1万+
总结三种方法，之后想把各种算法也总结一下，毕竟笔试中总会遇到。。。。。。一：IndexOf用法：int indexOf(String str) ：返回第一次出现的指定子字符串在此字符串中的索引。int indexOf(String str, int startIndex)：从指定的索引处开始，返回第一次出现的指定子字符串在此字符串中的索引。int lastIndexOf(String str) ：...
Java字符串与包装类详解：String、StringBuilder与StringBuffer
本文将深入探讨Java中的字符串处理，包括String类的基本概念、操作，以及StringBuilder和StringBuffer类的使用。 一、String类基本概念 String类是Java中的一个核心类，它代表不可变的字符序列。由于String是final...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值