Java (基础) - 字符串 String 与 字符串类 StringBuffer StringBuilder

String 字符串的底层是一个字符数组,而StringBuffer和StringBuilder是封装类.

一 常用方法
下面的比较简单就不举例了

int length()	  //返回字符串长度
int hashCode() //返回哈希码
boolean isEmpty()     //是否为空 
boolean contains(String str)    //是否包含str
boolean startsWith(String prefix)   //是否以字符串prefix开头 
boolean endsWith(String suffix) //是否以字符串suffix结尾
String toUpperCase() //转换成大写
String toLowerCase() //转换成小写
char charAt(int index);     //根据索引返回索引
int indexOf(String str)     //根据子串返回索引
String substring(int beginIndex)   //根据索引返回子字符串
String substring(int beginIndex, endIndex) //根据索引返回String
String replace(char oldChar, char newChar)     //替换,用newChar替换字符串中所有的oldChar,会返回新的字符串
String trim()        //去掉空格
String concat(String str)      //将字符串str连接到字符串后面  

二 Sring类型和其他数据类型的转化
1.将其他类型转化为String类型:String.valueOf(),这个方法有多个重载的方法,可以接受多种类型参数.

（1）String.valueOf(boolean b) : 将 boolean 变量 b 转换成字符串 
（2）String.valueOf(char c) : 将 char 变量 c 转换成字符串 
（3）String.valueOf(char[] data) : 将 char 数组 data 转换成字符串 
（4）String.valueOf(char[] data, int offset, int count) : 将 char 数组 data 中 由 data[offset] 开始取 count 个元素 转换成字符串 
（5）String.valueOf(double d) : 将 double 变量 d 转换成字符串 
（6）String.valueOf(float f) : 将 float 变量 f 转换成字符串 
（7）String.valueOf(int i) : 将 int 变量 i 转换成字符串 
（8）String.valueOf(long l) : 将 long 变量 l 转换成字符串 
（9）String.valueOf(Object obj) : 将 obj 对象转换成 字符串, 等于 obj.toString() 

当然也可以使用toString()方法 和 (String)强制转换,但不推荐.
2 String 类型转化为其他类型,大部分需要使用包装类

（1）Byte.parseByte(String s) : 将 s 转换成 byte 
（2）Byte.parseByte(String s, int radix) : 以 radix 为基底 将 s 转换为 byte ，比如说 Byte.parseByte("11", 16) 会得到 17 
（3）Double.parseDouble(String s) : 将 s 转换成 double 
（4）Double.parseFloat(String s) : 将 s 转换成 float 
（5）Integer.parseInt(String s) : 将 s 转换成 int 
（6）Long.parseLong(String s)
  (7)  toCharArray() :将字符串转化为字符数组

//字符串和数组转换
class Test{
    public static void main(String[] args) {
    String str = "我爱你";
    char[] ch = str.toCharArray();
    System.out.println(ch);

    char[] ch2 = {'我', '爱', '你'};
    String str2 = new String(ch2);
    System.out.println(str2);
    }
}
		
//输出
我爱你
我爱你

三 String 中的 equals() 和 “==”

四 String 中的CompareTo()
equals() 方法实现了两个字符串的是否相等逻辑运算,那么有没有字符串的大小比较运算呢?
答案就是 CompareTo()方法,这个方法返回一个int,正数表示大于.
String 实现了Comparable 接口,所以在String类里要重写CompareTo()方法.
JDK1.8的源代码如下:
其具体的比较方案就是依次比较两个字符串的字符.
如果其中一个遍历结束(即前面的字符和另一个字符串相同),就比较字符串的长短.

public int compareTo(String anotherString) {
        int len1 = value.length;
        int len2 = anotherString.value.length;
        int lim = Math.min(len1, len2);
        char v1[] = value;
        char v2[] = anotherString.value;

        int k = 0;
        while (k < lim) {
            char c1 = v1[k];
            char c2 = v2[k];
            if (c1 != c2) {
                return c1 - c2;
            }
            k++;
        }
        return len1 - len2;
    }

五 与String 相关的两个类:StringBuffer 和 StringBuilder
由于String的底层是字符数组,String的值是不可变的，这就导致每次对String的操作都会生成新的String对象，这样不仅效率低下，而且大量浪费有限的内存空间,如下图:

那么有没有一个办法可以在String后面直接添加另一个字符串呢?
答案就是用 StringBuffer 或 StringBuilder 代替String.StringBuilder 类在 Java 5 中被提出，它和 StringBuffer 之间的最大不同在于 StringBuilder 的方法不是线程安全的（不能同步访问）。

由于 StringBuilder 相较于 StringBuffer 有速度优势，所以多数情况下建议使用 StringBuilder 类。然而在应用程序要求线程安全的情况下，则必须使用 StringBuffer 类。

三者的继承关系如下:

StringBuffer 和 StringBuilder 的方法基本一样,不过前者加了synchronized修饰符.这里以StringBuffer为例,列举了几个常见用法.

StringBuffer append()：将任意类型的参数的值转化成String类型，然后追加到原字符串序列的尾部。
StringBuffer replace(): 将字符串的某一段替换
StringBuffer insert()：将参数的值转换成String类型插入到当前字符序列的指定位置。
StringBuffer reverse（）：将当前字符序列进行反转（逆序）处理。这个方法没有参数.
StringBuffer delete (int start, int end): 将字符串中的某一段子字符串删除
StringBuffer deleteCharAt(int index): 删除字符串中的某个字符
void setCharAt（int index, char ch）：设置字符序列中指定索引处的字符。
int indexOf(): 返回子串的索引
String toString() : 基本每个类都会重写的一个方法.

class Test{                                                             
    public static void main(String[] args) {                            
                                                                        
        StringBuffer sb = new StringBuffer("s");                        
        System.out.println("sb = " + sb);                               
                                                                        
        StringBuffer sb2 = sb.append(10);                               
        System.out.println("sb2 = " + sb2);                             
                                                                        
        sb2.setCharAt(2,'I');                                           
        System.out.println("sb2 = " + sb2);                             
                                                                        
        StringBuffer sb3 = sb2.replace(0,2,"OK") ;                      
        System.out.println("sb3 = " + sb3);                             
                                                                        
        StringBuffer sb4 = sb3.reverse();                               
        System.out.println("sb4 = " + sb4);                             
                                                                        
        StringBuffer sb5 = sb4.deleteCharAt(0);                         
        System.out.println("sb5 = " + sb5);                             
    }                                                                   
}                                                                       

输出

sb = s
sb2 = s10
sb2 = s1I
sb3 = OKI
sb4 = IKO
sb5 = KO