Java 字符相关String, StringBuffer, StringBuilder, StringTokenizer,StringJoiner,strman-java 详解

String

该类不能被继承，以下是 Java8 String 部分源码 :

public final class String  implements java.io.Serializable, Comparable<String>, CharSequence

常见 Java String API

1> 获取

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

char charAt(int  index) : 根据位置获取该位置上某个字符，基于 0

int indexOf(int ch) : 返回的是 ch在字符串中第一次出现的的位置

int indexOf(int ch,int fromIndex) : 从 fromIndex指定位置开始，获取 ch在字符串中出现的位置

int indexOf(String str) : 返回的是 str在字符串中第一次出现的的位置

int indexOf(String str,int fromIndex) : 从 fromIndex指定位置开始，获取 str在字符串中出现的位置

2> 判断

boolean contains(str) : 字符串中是否包含某一个字符串

indexOf(str) : 可以索引 str第一次出现位置，如果返回 -1，表示该 str不在字符串中存在。即用该方法就可以判断是否包含某一个字符串，而且可以返回出现的位置

boolean isEmpty() : 字符中是否有内容

boolean startsWith(str) : 字符串是否是以指定内容开头

boolean endsWith(str) : 字符串是否是以指定内容结尾

boolean equals(str) : 判断字符串内容是否相等，对于自定义 Object类的比较需要覆写 方法

boolean equalsIgnoreCase(str) : 判断字符串内容是否相同，并忽略大小写

3> 转换 :  将字符数组转换成字符串

构造函数  String(char []) : 将字符数组转换成字符串

               String(char [], offset, count) : 将字符数组中的一部分转换成字符串

静态方法： static String copyValueOf(char [] data)

                  static String copyValueOf(char [] data,int  offset , int count) : 将字节数组转换成字符串 ，类似于  valueOf

char []  toCharArray() :  将字符串转换成字符数组

构造函数  String(byte []) : 将字节数组转换成字符串

String(byte [], offset, count) : 将字节数组中的一部分转换成字符串

byte[]  getBytes() :  将基本数据类型转换成  byte 数组

static String valueOf( 基本数据类型 ) : 将其它类型数据转换成字符串

4> 替换

String replace(oldChar, newChar) : 如果要替换的字符不存在，则返回的还是原串 ( 单引号 )

String replace(oldCharSequence, newCharSequence) : 如果要替换字符串不存在，返回原串 ( 双引号 )

5> 切割

String [] split(regex) : 参数为指定的字符串

6> 子串

String substring(begin) : 获取字符串中的一部分，从指定的位置开始

String substring(begin, end) : 获取字符串中的一部分，从指定的位置开始，到指定的位置前一位结束

其它 :

String toUpperCase() : 将字符串转换成大写

String toLowerCase() :  将字符串转换成 小写

String trim() : 将字符串两端的多个空格去除

int compareTo(String) : 对两个字符串进行自然顺序的比较

 

StringBuffer :  字符串缓冲区，是一个容器

特点 :

1> 长度是可以变化的

2> 可以直接操作多个数据类型

3> 最终会通过 toString方法变成字符串

它具备 :

1> 存储

StringBuffer append() : 将指定数据作为参数添加到已有数据结尾处

StringBuffer insert(index, 数据 ) : 将指定数据作为参数添加到指定的 index位置

2> 删除

StringBuffer delete(start, end) : 删除缓冲区中的数据，包含 start，不包含 end

StringBuffer deleteCharAt(index) : 删除指定位置的字符

4> 修改

StringBuffer replace(start, end, string) : 将指定的位置范围替换成指定的数据

void setCharAt(int index, char ch) : 将指定的位置替换成指定的数据

5> 反转

StringBuffer reverse() : 将容器里的数据反向输出

String类复写了 Object类中 equals()方法，该方法用于判断字符串是否相等

String s1 = “abc”;

String s2 = new String(“abc”);

s1和 s2之间的区别 :

s1是一个类类型变量，" abc "是一个对象

s1在内存中有一个对象( " abc ") ， s2在内存中有两个对象 ( new是一个， " abc"是一个 )

基本数据类型对象包装 :  (前面是类， 后面是类型 )

Boolean boolean    Byte byet              Char char

Short short             Integer int             Long long

Float float               Double double

基本数据类型对象包装类的最常见作用，就是用于基本数据类型和字符串类型之间做转换

基本数据类型转换成字符串 :  1> 基本数据类型 +" "

                                              2> 基本数据类型 .toString(基本数据类型值 )  

字符串转换成基本数据类型 :  1> 基本数据类型包装类 .parse基本数据类型 (" xxx ")

StringBuffer与StringBuilder

StringBuilder 和  StringBuffer 都是处理字符串的类，用法和方法几乎一致

StringBuffer 字符串变量（线程安全）

StringBuilder 字符串变量（非线程安全）

简要的说，String 类型和 StringBuffer 类型的主要性能区别其实在于 String 是不可变的对象, 因此在每次对 String 类型进行改变的时候其实都等同于生成了一个新的 String 对象，然后将指针指向新的 String 对象，所以经常改变内容的字符串最好不要用 String ，因为每次生成对象都会对系统性能产生影响，特别当内存中无引用对象多了以后， JVM 的 GC 就会开始工作，那速度是一定会相当慢的

而如果是使用 StringBuffer 类则结果就不一样了，每次结果都会对 StringBuffer 对象本身进行操作，而不是生成新的对象，再改变对象引用。所以在一般情况下，推荐使用 StringBuffer ，特别是字符串对象经常改变的情况下。而在某些特别情况下， String 对象的字符串拼接其实是被 JVM 解释成了 StringBuffer 对象的拼接，所以这些时候 String 对象的速度并不会比 StringBuffer 对象慢，而特别是以下的字符串对象生成中， String 效率是远要比 StringBuffer 快的 :

String S1 = "This is only a" + "simple" + "test";

StringBuffer sb = new StringBuilder("This is only a").append("simple").append("test");

你会很惊讶的发现，生成 String S1 对象的速度简直太快了，而这个时候 StringBuffer 居然速度上根本一点都不占优势。其实这是 JVM 的一个把戏，在 JVM 眼里，这个

String S1 = "This is only a " + "simple" + "test"; 其实就是 :  String S1 = "This is only a simple test";

所以当然不需要太多的时间了。但这里要注意的是，如果字符串是来自另外的 String 对象的话，速度就没那么快了，譬如：

String S2 = "This is only a";

String S3 = " simple";

String S4 = " test";

String S1 = S2 +S3 + S4;

这时候 JVM 会规规矩矩的按照原来的方式去做

在大部分情况下 StringBuffer > String

StringBuffer

Java.lang.StringBuffer线程安全的可变字符序列。一个类似于 String 的字符串缓冲区，但不能修改。虽然在任意时间点上它都包含某种特定的字符序列，但通过某些方法调用可以改变该序列的长度和内容。

可将字符串缓冲区安全地用于多个线程。可以在必要时对这些方法进行同步，因此任意特定实例上的所有操作就好像是以串行顺序发生的，该顺序与所涉及的每个线程进行的方法调用顺序一致。

StringBuffer 上的主要操作是 append 和 insert 方法，可重载这些方法，以接受任意类型的数据。每个方法都能有效地将给定的数据转换成字符串，然后将该字符串的字符追加或插入到字符串缓冲区中。append 方法始终将这些字符添加到缓冲区的末端；而 insert 方法则在指定的点添加字符。

例如，如果 z 引用一个当前内容是“start”的字符串缓冲区对象，则此方法调用 z.append("le") 会使字符串缓冲区包含“startle”，而 z.insert(4, "le") 将更改字符串缓冲区，使之包含“starlet”。

在大部分情况下 StringBuilder > StringBuffer

java.lang.StringBuilde

java.lang.StringBuilder一个可变的字符序列是5.0新增的。此类提供一个与 StringBuffer 兼容的 API，但不保证同步。该类被设计用作 StringBuffer 的一个简易替换，用在字符串缓冲区被单个线程使用的时候（这种情况很普遍）。如果可能，建议优先采用该类，因为在大多数实现中，它比 StringBuffer 要快。两者的方法基本相同

StringTokenizer

StringTokenizer 是字符串分隔解析类型，当分割大量的字符串时使用 Sring split()的相关方法会大量消耗内存，此时使用 StringTokenizer 比较优越

StringTokenizer(String str) : 会使用默认的分隔符是“空格”、“制表符（‘\t’）”、“换行符(‘\n’）”、“回车符（‘\r’）”

StringTokenizer(String str, String delim) : 构造一个用来解析str的StringTokenizer对象，并提供一个指定的分隔符

StringTokenizer(String str, String delim, boolean returnDelims) : 构造一个用来解析str的StringTokenizer对象，并提供一个指定的分隔符，同时，指定是否返回分隔符

常用方法 :

1> int countTokens() : 返回nextToken方法被调用的次数

2> boolean hasMoreTokens() : 返回是否还有分隔符

3> boolean hasMoreElements() : 返回是否还有分隔符

4> String nextToken() : 返回从当前位置到下一个分隔符的字符串

5> Object nextElement() : 返回从当前位置到下一个分隔符的字符串

6> String nextToken(String delim) : 与4类似，以指定的分隔符返回结果

案例

1>

String s = new String ( "The Java platform is the ideal platform for network computing" );

StringTokenizer st = new StringTokenizer(s);

System. out .println( "Token Total:" + st.countTokens());

while (st.hasMoreElements())  {

    System. out .println(st.nextToken());

}

2> 不返回分隔符

String s = new String ( "The=Java=platform=is=the=ideal=platform=for=network=computing" );

StringTokenizer st = new StringTokenizer(s, "=" );

System. out .println( "Token Total: " + st.countTokens());

while (st.hasMoreElements())  {

    System. out .println(st.nextToken());

}

3> 返回分隔符 : 如下案例若指定返回分隔符，此时会将 = 也返回

String s = new String ( "The=Java=platform=is=the=ideal=platform=for=network=computing" );

StringTokenizer st = new StringTokenizer(s, "=" , true );

System. out .println( "Token Total:" + st.countTokens());

while (st.hasMoreElements())  {

    System. out .println(st.nextToken());

}

split、StringTokenizer、subString 性能比较

StringTokenizer 截取字符串效率最高，substring次之，split最差，但是 split 支持正则表达式而 StringTokenizer 这或许是性能比较低的原因

StringJoiner

用于合并字符串，并在字符串前后或者要合并的字符串之间添加指定字符是在 Java8 中出现的API

由于 StringJoiner 使用的是 StringBuilder 进行字符串合并，因此是线程不安全

例如如下代码 :

StringJoiner sj1 = new StringJoiner ( "," );

sj1.add( "a" ).add( "b" ).add( "c" );

System. out .println(sj1.toString()); // 输出 a,b,c

StringJoiner sj2 = new StringJoiner ( "," , "<" , ">" );

sj2.add( "1" ).add( "2" ).add( "3" );

System. out .println(sj2.toString()); // 输出 <1,2,3>

字符串处理库strman-java

字符串处理工具库，用于对系统字符串处理的补充，该库参考 strman 一个 javascript 库，其中的部分API采用的是 Java8 中的方法

https://github.com/shekhargulati/strman-java  Java

https://github.com/dleitee/strman  JavaScript

以下是部分 API 的使用案例，具体可参考官方 API :

String food = Strman. append ( "f" , "o" , "o" , "b" , "a" , "r" );

System. out .println( "append : " + food); // append : foobar
System. out .println( ">>>>>>>>>>>>>>>>>>>>>>>>>>>" );

String appendArray = Strman. appendArray ( "f" , new String []{ "o" , "o" , "b" , "a" , "r" });

System. out .println( "appendArray : " + appendArray); // appendArray : foobar
System. out .println( "<<<<<<<<<<<<<<<<<<<<<<<<<<<" );

Optional< String > at = Strman. at ( "foobar" , 0 );

System. out .println( "at : " + at); // at : Optional[f]
System. out .println( ">>>>>>>>>>>>>>>>>>>>>>>>>>>" );