java String、StringBuffer、StringBuilder

 1.简介

String是不可变类,且是线程安全的;

StringBuffer是可变类,且是线程安全的;

StringBuilder是可变类,且不是线程安全的。

注:“可变/不可变”指对该类对象进行修改操作时,是否会产生新的对象。对String对象进行修改时会产生新的对象,

对StringBuffer和StringBuilder对象修改时不会产生新的对象。

String类的定义如下,使用了final关键字:

1 /** The value is used for character storage. */
2 private final char value[];
3
4 /** The offset is the first index of the storage that is used. */
5 private final int offset;
6
7 /** The count is the number of characters in the String. */
8 private final int count;

2.String类常用方法

char charAt(int index):返回指定索引处的 char 值;

int indexOf(int ch):返回指定字符的索引(第一次出现);

int indexOf(int ch, int fromIndex):返回指定字符的索引(第一次出现),并指定索引开始查询;

int indexOf(String str):返回给定字符串第一次出现的索引;

int indexOf(String str, int fromIndex):返回给定字符串第一次出现的索引,指定开始检索索引;

int lastIndexOf(int ch):返回指定字符最后一次出现的索引;

int lastIndexOf(int ch, int fromIndex):返回指定字符最后一次出现的索引,从指定索引开始反向查询;

int lastIndexOf(String str):返回给定字符串最后一次出现的索引;

int lastIndexOf(String str, int fromIndex):返回给定字符串最后一次出现的索引,指定开始检索索引;

String replace(char oldChar, char newChar):替换指定的字符(所有),返回新字符串;

String substring(int beginIndex):返回指定开始索引的子字符串(默认到结尾);

String substring(int beginIndex, int endIndex):返回指定开始索引和结束索引的子字符串;

byte[] getBytes():使用默认字符集将字符串编码为 byte 序列,并返回一个新byte数组;

char[] toCharArray():将字符串转换为一个新的字符数组;

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

String concat(String str):将给定字符串拼接到该字符串末尾;

boolean contains(CharSquence s):判断字符串是否包含给定字符序列;

String toLowerCase():使用默认规则将字符串中的字符小写;

String toUpperCase():使用默认规则将字符串中的字符大写;

String valueOf(Object obj) :将Object类型数据转为String类型数据;

String trim():去除字符串中的所有空格;

int length():返回字符串长度;

示例代码:

 1 import java.util.Arrays;
 2
 3 public class StringFunc {
 4     public static void main(String[] args){
 5
 6         String str1 = "1223";
 7
 8         //返回指定索引的char值
 9         char s1 = str1.charAt(1);
10         System.out.println(s1);     // 2
11
12         //返回指定字符的索引
13         int index0 = str1.indexOf(‘4‘);
14         int index1 = str1.indexOf(‘2‘);
15         int index2 = str1.indexOf(‘2‘,2);
16         System.out.println(index0+" "+index1+" "+index2);   // -1 1 2
17         int index3 = str1.indexOf("22");
18         int index4 = str1.indexOf("22",2);
19         System.out.println(index3+" "+index4);         // 1 -1
20
21         // 判断字符串是否包含指定字符串,需要连续("13"不行)
22         boolean flag = str1.contains("12");
23         System.out.println(flag);
24
25         // 替换字符串中指定的字符(会替换多个)
26         String str2 = str1.replace(‘2‘,‘4‘);
27         System.out.println(str2);         // "1443"
28
29         //返回一个子串,指定开始/结束位置(不包含结束位置)
30         String str3 = str1.substring(1);
31         String str4 = str1.substring(1,3);
32         System.out.println(str3);          // "223"
33         System.out.println(str4);         // "22"
34
35         // 字符串拼接
36         String str5 = str3.concat(str4);
37         System.out.println(str5);        // 22322
38
39         // 将字符串转换为byte数组
40         byte[] b1 = str1.getBytes();
41         for(byte b:b1){
42             System.out.print(b+" ");   // 49 50 50 51
43         }
44
45         // 字符串转char数组
46         char[] charStr1 = str1.toCharArray();
47         System.out.println(charStr1);       // [‘1‘, ‘2‘, ‘2‘, ‘3‘]
48
49         // 拆分字符串
50         String str6 = "1,2,3,4";
51         String[] arr6 = str6.split(",");
52         System.out.println(Arrays.toString(arr6));   // [‘1‘, ‘2‘, ‘3‘, ‘4‘]
53
54     }
55 }

3.StringBuffer类常用方法

StringBuffer append(Object obj):将object参数的字符串表达式添加到序列;

StringBuffer insert(int offset, Object obj):向序列插入指定偏移量的object参数的字符串表示式;

StringBuffer delete(int start, int end):从序列中删除给定开始/结束索引的字符序列;

StringBuffer replace(int start, int end, String str):使用给定字符串替换给定开始/结束索引的字符序列;

StringBuffer reverse():返回反转的序列;

CharSequence subSequence(int start, int end):从序列中返回给定开始/结束索引的子序列;

void setCharAt(int index, char ch):序列指定索引处的字符设置为char值;

void setLength(int newLength):设置字符序列的长度;

int indexOf(String str):返回指定子字符串第一次出现的字符串中的索引;

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

char charAt(int index):返回给定索引在该序列中的char值;

int capacity():返回当前容量;

示例代码:

 1 public class StringBufferFunc {
 2
 3     public static void main(String[] args){
 4
 5         StringBuffer sb = new StringBuffer("1223");
 6
 7         // append
 8         sb.append("45");
 9         System.out.println(sb);    // 122345
10
11         // insert
12         sb.insert(1,1);
13         System.out.println(sb);    // 1122345
14
15         // delete/deleteCharAt
16         sb.delete(3,5);
17         System.out.println(sb);    // 11245
18         sb.deleteCharAt(2);
19         System.out.println(sb);    // 1145
20
21         // replace
22         sb.replace(1,3,"6");
23         System.out.println(sb);     // 165
24
25         // reverse
26         sb.reverse();
27         System.out.println(sb);  // 561
28
29         // setCharAt
30         sb.setCharAt(0,‘2‘);
31         System.out.println(sb);       // 261
32
33         // setLength
34         sb.setLength(2);
35         System.out.println(sb);    // 26
36
37         // subSequence
38         CharSequence cs = sb.subSequence(0,1);
39         System.out.println(cs);     // 2
40
41         // toString
42         String str = sb.toString();
43         System.out.println(str);   // 26
44     }
45 }

4.StringBuilder类常用方法

StringBuilder类的方法与StringBuffer类似,这里不再赘述。

5.其他说明

(1)基本原则:String用于操作少量的数据;StringBuilder用于单线程操作大量数据;StringBuffer用于多线程操作大量数据。

(2)不要使用String类的"+"来进行频繁的拼接,它会导致性能变差;应使用StringBuffer或StringBuilder类进行这些操作。

(3)为了获得更好的性能,在构造 StringBuffer 或 StringBuilder 时应尽可能指定它们的容量。

!!!!!!!

原文地址:https://www.cnblogs.com/jfl-xx/p/10649616.html

时间: 2024-10-07 13:38:58

java String、StringBuffer、StringBuilder的相关文章

Java:String、StringBuffer和StringBuilder的区别

Java:String.StringBuffer和StringBuilder的区别 1 String String:字符串常量,字符串长度不可变.Java中String是immutable(不可变)的. String类的包含如下定义: [java] view plain copy /** The value is used for character storage. */ private final char value[]; /** The offset is the first index

Java中的String、StringBuffer和StringBuilder

任何语言都离不了字符串的处理.Java中处理字符串的三个类String.StringBuffer和StringBuilder.这三个到底有什么区别呢? 他们三个都是实现了CharSequence接口.但实现过程不一样. 其实他们的使用方法都很简单,这里看下StringBuilder的用法. public class TestStringBuffer{ public static void main(String args[]){ StringBuffer str=new StringBuffer

全面解释java中StringBuilder、StringBuffer、String类之间的关系

http://www.jb51.net/article/33398.htm String的值是不可变的,这就导致每次对String的操作都会生成新的String对象,不仅效率低下,而且大量浪费有限的内存空间,StringBuffer是可变类,和线程安全的字符串操作类,任何对它指向的字符串的操作都不会产生新的对象,StringBuffer和StringBuilder类功能基本相似 1. String 类  String的值是不可变的,这就导致每次对String的操作都会生成新的String对象,不

【Java面向对象基础(二)】细说String、StringBuffer和StringBuilder

[喵"的Android之路][基础篇(二)][Java面向对象基础]细说String.StringBuffer和StringBuilder 1.String String是Java中的一个final类,主要用于字符串的处理. 1.1 不可变性 String内的字符串是不可变的,每一次修改都会重新生成一个新的String对象实例. 例: 1 // 在堆中会创建一个"Hello"字符串实例,把地址赋给对象a 2 String a = new String("Hello&

JAVA中 String 、StringBuffer和StringBuilder 的区别

String 内容定义成 final char[],只能在属性和构造函数中赋值,其它地方不能改变 :String 覆盖实现了 equals . StringBuffer 内容定义成了 char[] ,但没实现 equals. String 和 StringBuffer 的区别是: 1.String 通过构造新的String 实现可变字符串,而 StringBuffer 通过改变内部的内容属性来实现可变字符串. 2.new String("ABC").equals("ABC&q

java中StringBuilder、StringBuffer、String类之间的关系

今天在CSDN的高校俱乐部里看到了"Java基础水平測试(英文)".感觉自己学了java这么久,想看下自己的java水平究竟是个什么样.測试结果就不说了,反正是慘不忍睹. 看了一下结果分析,关于StringBuilder.StringBuffer.String类的三道题所有答错.所以就查阅了一些资料记录一下. String的值是不可变的,这就导致每次对String的操作都会生成新的String对象.不仅效率低下,并且大量浪费有限的内存空间,StringBuffer是可变类.和线程安全的

java中的String、StringBuffer、StringBuilder的区别

String.StringBuffer.StringBuilder都是java中的常用字符串类 ,下面来看看三者之间的异同. 一.可变与不可变: String:字符串常量,不可变.StringBuffer.StringBuilder为可变字符序列,是可变的. 二.是否多线程安全: String中的对象是不可变的,相当于常量,显然线程安全. StringBuffer:支持多线程安全. StringBuilder:不支持多线程安全. 三.执行效率: String.StringBuffer.Strin

深刻理解Java中的String、StringBuffer和StringBuilder的差别

声明:本博客为原创博客,未经同意.不得转载!小伙伴们假设是在别的地方看到的话,建议还是来csdn上看吧(链接为http://blog.csdn.net/bettarwang/article/details/26412497),看代码和提问.讨论都更方便. 首先简单地来梳理一下Java中String.StringBuffer和StringBuilder各自的含义. 1.String类 首先.它是线程安全的,即能够用于多线程编程中. 其次,String类的对象是不可变的,即在定义时就确定了,类似St

四:Java之字符串操作String、StringBuffer和StringBuilder

string是我们经经常使用到的一个类型,事实上有时候认为敲代码就是在重复的操作字符串,这是C的特点,在java中.jdk非常好的封装了关于字符串的操作.三个类String .StringBuffer . StringBuilder .这三个类基本上满足了我们在不同情景下使用字符串的需求. 一.String JDK的解释是 "Strings are constant; their valuescannot be changed after they are created"也就是说St

java中String、StringBuffer、StringBuilder的区别

java中String.StringBuffer.StringBuilder是编程中经常使用的字符串类,他们之间的区别也是经常在面试中会问到的问题.现在总结一下,看看他们的不同与相同. 1.可变与不可变 String类中使用字符数组保存字符串,如下就是,因为有“final”修饰符,所以可以知道string对象是不可变的. private final char value[]; StringBuilder与StringBuffer都继承自AbstractStringBuilder类,在Abstra