Java之字符串String，StringBuffer，StringBuilder

String类：

String类即字符串类型，并不是Java的基本数据类型，但可以像基本数据类型一样使用，用双引号括起来进行声明。在Java中用String类的构造方法来创建字符串变量。

声明字符串：声明一个字符串就是创建一个字符串对象。

    //可以声明单个也可以同时声明多个字符串对象，声明不赋值，这个对象就是空， 也就是 String a= null;
    String a; 
    String b,c;

创建字符串：给字符串赋值就是创建字符串的过程。

1.给字符串赋值的四种方法：

（1）.引用字符串常量

String a="hi";
String b="hello",c="world";
String d;
d="hello world";

（2）.利用构造方法直接实例化

// 1.    
String a=new String("hello ");
// 2.
String b=new String(a);

（3）.利用字符数组实例化

char[] charArr={'t','i','m','e'};
String a=new String(charArr);
String b=new String(charArr,0,2);//从数组第0个索引开始，取2个数

（4）.利用字节数组实例化

2.把任何类型转换为字符串：

valueOf()  方法

System.out.println(String.valueOf(6));  //将6转换为字符串

3.连接字符串

+

//使用 + 号拼接
String a="123"+456;
String b=a+"hello";
//使用  += 拼接
b+="您好";
System.out.println(b);

4.获取字符串的长度：

length()  方法

String a="123 456  789";
//获取a的长度（包括空格）赋值给s
int s=a.length();
System.out.println(s);

5.获取指定索引位置的字符：

char()  方法

        String str = " a new world a new start ";
        System.out.println(str.charAt(3));// 取出字符串中制定索引位置的字符

6.判断一个字符串是否包含另一个字符：

contains()  方法

        String str = " a new world a new start ";
        System.out.println(str.contains("abc"));// 判断一个字符串是否包含另一个字符串

7.获取指定位置的字符 返回索引：

indexOf() 获取指定位置的字符四种方法：

        String str="we are the world";
        System.out.println(str.indexOf("e"));
        System.out.println(str.indexOf("e",2));//索引2之后e出现的索引
        System.out.println(str.lastIndexOf("e"));
        System.out.println(str.lastIndexOf("e",8));//索引8之前出现的e

8.截取字符串：

String id="123456199410207890";
//获取第十五位索引到最后的数字
String e4=id.substring(15);
//获取第六位到十四位索引，即生日
String bir=id.substring(6,14);
System.out.println("您的生日是："+bir);

9.判断字符串是否相等：

需要特别注意的是，如果定义两个字符串再用 == 去判断它们是否相等，那么他们的结果一定是false。这是因为这两个字符串的值都会保存在内存的堆栈中，首先我们创建 name  和  dbValue 两个引用，然后用 new 方法在堆中创建了 String 的对象实体，并让两个引用指向各自的对象实体，然后两个对象实体又会分别在栈中创建字面值内容。name  和  dbValue 始终指向的是两个独立的内存区域，而 == 判断的是内存地址，所以用 == 判断字符串结果一定false，这和他们保存的什么样的字面值没有任何关系。

判断字符串相等要使用 equales方法：

 equales方法比较的是两个字符串的内容

equalsIgnoreCase 方法： 忽略大小写的比较方法

特殊情况：

如果创建的字符串不是用 new 方法创建的，而是直接用引用字符串常量。结果会有不同。

我们让 name 创建引用字符串常量 tom 的时候，Java虚拟机首先会在栈中创建 tom  然后会自动创建一个匿名的字符串对象指向 tom ，最后将匿名字符串对象的地址交给 name 引用。然后再当我们让 dbValue也引用常量 tom 的时候， Java虚拟机会先到栈的常量区中寻找是否有相同的常量，发现有相同的常量，就直接将这个常量的匿名对象交给了dbValue引用。这时 name 和 dbValue 指向的就是同一个匿名对象，这样他们 ==  返回的结果就是 true。

常量池：String 直接引用创建字符串的时候，Java会从常量池中找这个“tom”，如果找到了，他会将找到的这个直接给他，如果找不到则新建

　　如下：

10. 判断字符串的开始和结尾：

endsWith 方法和 startsWith方法

 

11.字符串替换

 

 12.去除首尾空格和去除所有空白：

trim()方法 

replaceAll("\s","")  方法

13.大小写转换

toUpperCase()  方法

toLowerCase()   方法

14.字符串分割

.split()

需要注意的是不能用  “.”  进行分割，因为支持正则表达式，所以要用时应使用转义字符，如 “.” 应使用 “\.”

15.查找字符串

indexOf()  方法

16.格式化字符串

format方法

http://tool.oschina.net/apidocs/apidoc?api=jdk-zh       格式化字符在线API文档

        Date tim=new Date();
        String str=String.format("%tF", tim);
        System.out.println(tim);
        System.out.println(str);
        //格式化为年
        System.out.println(str.format("%tY",tim));
        //格式化为月
        System.out.println(str.format("%tB",tim));
        //格式化为日
        System.out.println(str.format("%td",tim));

　　　　 System.out.println(String.format("字母a: %c",'a'));
        System.out.println(String.format("123+456= %d",123+456));
        System.out.println(String.format("保留三位小数 %.3f",3.141592652545));
        System.out.println(String.format("判断2<3 %b",2<3));
        System.out.println(String.format("科学计数法  %e",12000000.1));
        System.out.println(String.format("天才是%d%%的汗水和%d%%的灵感",1,99));//要注意在 这种方法中要输出%号需要写两个%%
        

StringBuffer类

是线程安全的可变字符序列。一个类似于String的字符串缓冲区。String创建的字符串对象是不可修改的，StringBuff类创建的是可修改的字符串序列，且实体容量会随着存放的字符串增加而自动增加。

StringBuilder类

即字符串生成器，新创建的StringBuilder对象初始容量是16个字符，可以自行指定初始长度，也可以动态地执行添加、删除和插入等字符串的编辑操作，大大提高了频繁增加字符串的效率。如果附加的字符超过可容纳的长度，则StringBuilder对象将自动增加长度以容纳被附加的字符。

三者的关系：

在执行速度方面的比较：StringBuilder >  StringBuffer  >  String

三者之间相互转换：

三者之间的不同之处：

String只能赋值1次，每一次改变内容都生成了一个新的对象，然后原有的对象引用了新的对象，所以说String本身是不可改变，每一次改变String的内容，都会在内存创建新的对象，而每一次生成新对象都会对系统性能产生影响，这会降低Java虚拟机的工作效率。如下图所示：

而StringBuilder和StringBuffer不同，每次操作都是对自身对象的操作，而不是生成新的对象，其所占空间会随着字幅内容增加而增加，做大量修改操作时，不会因生成大量匿名对象而影响系统性能。如下图所示：

StringBuffer类：

作用：String虽然提供了很多API方法，但是始终是对字符串常量进行操作，不仅无法改变常量的值，还会占用大量内存空间。StringBuffer类则是一个非常灵活的工具，节约内存空间的同时还保障了线程安全。

创建：

        //创建一个StringBuilder类对象必须用new方法，不能像String对象那样直接引用字符串常量
        StringBuffer sbf1=new StringBuffer();  //创建一个对象无初始值
        StringBuffer sbf2=new StringBuffer("abc");   //创建一个对象，初始值 “abc”
        StringBuffer sbf3=new StringBuffer(32);   //创建一个对象，初始容量为32个字符

 

常用操作：

 追加字符串：

append()  方法

        StringBuffer sbf =new StringBuffer("谁将");
        sbf.append("新樽");   //追加字符串
        StringBuffer s1=new StringBuffer("辞旧月");  
        sbf.append(s1);  //追加新的字符串中的内容
        int a=2333;
        sbf.append(a);   //追加int型变量a
        System.out.println(sbf);

修改指定索引处的字符：

setChar() 方法

        StringBuffer sbf=new StringBuffer("谁将新樽辞旧月");
        sbf.setCharAt(6,'日');   //替换索引6的字符
        System.out.println(sbf);

插入字符串：

insert()  方法

        StringBuffer sbf=new StringBuffer("谁将新樽辞旧月");
        sbf.insert(2,"我的");  //在索引2插入
        System.out.println(sbf);

字符串的反序：

reverse()  方法

        StringBuffer sbf=new StringBuffer("谁将新樽辞旧月");
        sbf.reverse();
        System.out.println(sbf);

删除子字符串：

delete()  方法

        StringBuffer sbf=new StringBuffer("谁将新樽辞旧月");
        sbf.delete(4,6);
        System.out.println(sbf);

其他常用方法：

        StringBuffer sbf=new StringBuffer("谁将新樽辞旧月");
        System.out.println(sbf.length());   //获取字符串序列长度
        System.out.println(sbf.charAt(5));   //获取索引为5的内容
        System.out.println(sbf.indexOf("DEF"));   //获取DEF所在的索引位置，没有返回 -1
        System.out.println(sbf.substring(0,2));   //获取索引0-2的内容
        System.out.println(sbf.replace(2,5,"wode"));    //将索引2-5的内容替换

StringBuilder类和StringBuffer类具有兼容的API，所以两者使用方法也相同

        StringBuilder sbd=new StringBuilder();
        sbd.append("我是StringBuilder");  //追加字符
        sbd.length();   //长度
        sbd=sbd.insert(5,"///");   //插入
        sbd=sbd.delete(sbd.length()-1,sbd.length() );   //删除最后一个字符
        sbd=sbd.reverse();   //反序

 String字符串练习整理：

public class Test2 {
    public static void main(String[] args){
        String str="像勇士这样的球队,只有防守一松懈,他们才能抓住机会,打完了三场,爵士还是没找到应对勇士的办法";
        //1, 写代码找出关键字"球队","机会"所在字符串str的索引位置, 找出字符串中第二个"勇士"的位置, 并输出在控制台上
        System.out.println(str.indexOf("球队"));
        System.out.println(str.indexOf("机会"));
        System.out.println(str.indexOf("勇士",2));
        //2, 定义int型变量m, 取值为第一题中所有索引值的和
        int m=str.indexOf("球队")+str.indexOf("机会")+str.indexOf("勇士",2);
        System.out.println(m);
        //3, 在控制台上输出m作为char型时显示的内容
        System.out.println((char)m);
        //4, 写代码实现将str字符串用","分割成数组, 并输出索引值为4的值
        String strs[]= str.split(",");
        System.out.println(strs[4]);
        //5, 写代码实现将str字符串中"爵士"用"勇士"代替, "勇士"用"爵士"代替,并将结果输出到控制台上(禁用replace方法)
        String strg[]= str.split("");
        for(int g=0;g<strg.length;g++){
            if(strg[g].equals("爵")){
                strg[g]="勇";
            }else if(strg[g].equals("勇")){
                strg[g]="爵";
            }
            System.out.print(strg[g]);
            
        }
        System.out.println();
        //6, 编写代码从str字符串中取一部分在控制台上打印这样一句话: 勇士抓住机会,找到应对办法
        int a1= str.indexOf("勇士");
        int a2= str.indexOf("抓住机会");
        int a3= str.indexOf(",");
        int a4= str.indexOf("找到应对");
        int a5= str.indexOf("办法");
        System.out.println(str.substring(a1,a1+2)+str.substring(a2,a2+4)+str.substring(a3,a3+1)+str.substring(a4,a4+4)+str.substring(a5,a5+2));
        //7, 写一段代码, 可以取出任意qq邮箱地址中的qq号码
        String qe="931375261@qq.com";
        String str1[]=qe.split("@");
        System.out.println(str1[0]);
        //8, 使用for和if打印一个空心正方形
        for(int i=0;i<10;i++){
            System.out.print('*');
        }
        System.out.println();
        for(int i=0;i<=3;i++){
            System.out.print("*        *");
            System.out.println();
        }
        for(int i=0;i<10;i++){
            System.out.print('*');
        }
        System.out.println();
        
        int M, N;
        int h, j;
        M=N=6;
        for(h=0;h<M;++h)
        {
            if(h==0||h==M-1)
            {
                for(j=0;j<N;++j)
                {
                    System.out.print("* ");
                }
            }
            else
            {
                System.out.print("* ");
                for(j=0;j<N-2;++j)
                {
                    System.out.print("  ");
                }
                System.out.print("* ");
            }
            System.out.println("");
        }
        //9, 使用for循环打印一个菱形
        int lineCount = 9;// 输出的菱形有多少行，请赋值成奇数
        int maxLineNum = (lineCount + 1) / 2;// 菱形最多一行
        for (int i = 1; i <= maxLineNum; i++) {// 循环菱形数量越来越多的几行
            for (int space = 1; space <= maxLineNum - i; space++) {// 输出空格，数量=最后一行-当前行数
                System.out.print(" ");
            }
            for (int star = 1; star <= (i * 2) - 1; star++) {// 输出星号，数量=行数*2-1
                System.out.print("*");
            }
            System.out.println();// 换行
        }
        int declineCount = lineCount - maxLineNum;// 计算剩下的几行，这几行星号的数量是递减的
        for (int i = 1; i <= declineCount; i++) {// 循环菱形数量越来越少的行数
            for (int space = 1; space <= i; space++) {// 输出空格，数量等于当前的行数
                System.out.print(" ");
            }
            for (int star = 1; star <= (declineCount - i + 1) * 2 - 1; star++) {// 输出星号，数量等于（总数-当前行数）*2-1
                System.out.print("*");
            }
            System.out.println();
        }
        //10, 使用for循环打印一个空心菱形(选做题)*/
        int max=9;
        int mid=(max+1)/2;
        for(int v=1;v<=mid;v++){
            // 输出空格，数量=最后一行-当前行数
            for(int sp=1;sp<=mid-v;sp++){
                System.out.print(" ");
            }
            // 输出星号，数量=行数*2-1
            for(int sp=1;sp<=(v*2)-1;sp++){
                if(sp==1){
                    System.out.print("*");
                }else if(sp==(v*2-1)){
                    System.out.print("*");
                }else{
                    System.out.print(" ");
                }
            }
            System.out.println();
        }
        int end=max-mid;
     // 循环菱形数量越来越少的行数
        for(int f=1;f<=end;f++){
            for(int sp=1;sp<=f;sp++){
                System.out.print(" ");
            }
            for(int st= 1;st<=(end-f+1)*2-1;st++){
                if(st==1){
                    System.out.print("*");
                }else if(st==(end-f+1)*2-1){
                    System.out.print("*");
                }else{
                    System.out.print(" ");
                }
            }
            System.out.println();
        }
    }
}