常用类-String类、StringBuilder、StringBuffer的使用（三）

常用类-String类、StringBuilder、StringBuffer的使用（三）

1. String类常用的一些方法，当我们要学一个新的类的时候，可以用JDK的帮助文档来学习，String不可变字符串序列。

   

2. 建一个测试类Test1，来测试以上的那些方法

   public class Test1 {
       public static void main(String[] args) {
           String str1=new String("abcdefg");
           String str2="abcdefg";//str1、str2是字符串面向对象的两种写法，但是他们却是两个不同的对象
           String str3="abcdEFG";
           String str4="def";
   
           System.out.println(str1==str2);//在原理分析时，这是两个不同的对象
           System.out.println(str1);
           System.out.println(str2);
           //设计到字符串比较的时候，都用到equals方法，比较两个字符串的值
           System.out.println(str1.equals(str2));
           System.out.println(str2.length());//7 返回字符串长度
   
           System.out.println(str2.charAt(0));//返回字符串的第一个字符
           System.out.println(str2.charAt(6));//返回字符串的最后一个字符 //str2.length()-1
           System.out.println(str2.charAt(str2.length()-1));  //取字符串的最后一个字符
   
           System.out.println(str2.equals(str3));   //false
           System.out.println(str2.equalsIgnoreCase(str3));  //true  忽略大小写判断，所以是true
   
           //从开头到结尾查找，返回到一个字符串的索引位置。如未找到返回-1。
           System.out.println("abcdefgdefg".indexOf("def"));  //结果为：3
           System.out.println("abcdefgdefg".indexOf("DF"));  //结果为：-1
           //从末尾处开始查找，但是索引还是从头开始算
           System.out.println("abcdefgdefg".lastIndexOf("def"));  //结果为：7
   
           //字符串一个字符的替换
           String str5="abcdbcd".replace('d','D');
           System.out.println(str5);
           //字符串一堆字符的替换
           String str6="abcdbcd".replace("cd","HELLO");
           System.out.println(str6);
   
           //字符串是不是已它开头
           System.out.println("sxt,i love u".startsWith("sxt"));  //true
           //字符串是不是已它结尾
           System.out.println("sxt,i love u".endsWith("sxt"));  //flase
   
           //截字符串
           String str7="abcdefghijklmnopqrstuvwsyz".substring(6);
           System.out.println(str7); //ghijklmnopqrstuvwsyz
           String str8="abcdefghijklmnopqrstuvwsyz".substring(6,11);  //6-（11-1）
           System.out.println(str8); //ghijk  包头不包尾
   
           //把字符串改成大写和小写
           System.out.println("abcdE".toUpperCase());
           System.out.println("abcdE".toLowerCase());
   
           //去除首尾的空格
           String str9="  a b  ";
           String str10=str9.trim();
           System.out.println(str10.length());
           System.out.println(str10);
   
           //String是不可变字符序列，所有的替换、截取子字符串、去空格、转换大小写等都是生成了新字符串
           //去除所有空格
           System.out.println(str9.replace(" ",""));
           System.out.println(str9);//老字符串都是没有发生变换的
       }
   }
   
   

3. StringBuilder:可变字符串序列，线程不安全，效率高,最常用的是方法是 public StringBuilder append();

​ StringBuffer:可变字符串序列，线程安全，效率低。

4. 建立一个TestString类，来测试StringBuilder和StringBuffer.

   public class TestString {
       public static void main(String[] args) {
           String str="aabb";         //不可变字符序列
           StringBuilder sb=null;    //可变字符序列，线程不安全，效率高
           StringBuffer sb2=null;    //可变字符序列，线程安全，效率低
   
           sb=new StringBuilder("gao");
   
           sb.append(123);
           sb.append(456);
           System.out.println(sb);//gao123456 在原来的字符串里，附加字符串
           sb.append("aa").append("bb").append("cc");
   
           for (int i=0;i<10;i++){
               sb.append(i);
           }
           System.out.println(sb);//gao123456aabbcc0123456789
   
           /**   StringBuffer 下面的方法同样适用StringBuilde*/
            sb2=new StringBuffer("北京尚学堂");
            sb2.insert(0,"爱").insert(0,"我");//插入字符串
            System.out.println(sb2);
            sb2.delete(0,2);//删除字符串
           System.out.println(sb2);
           sb2.deleteCharAt(0).deleteCharAt(0);//删除某个字符串
           System.out.println(sb2.charAt(0));  //获取某个字符串
           System.out.println(sb2.reverse());  //字符串逆序
   
       }
   }
   
   

5. String和StringBuilder 在字符串频繁修改时的效率测试，记住一个时间点：1970年1月1日 0:00，在这个时间点之前数值为负，在这之后时间点的数值为正。

   //记住一个时间点：1970年1月1日 0:00，在这个时间点之前数值为负，在这之后时间点的数值为正。
   public class Test2 {
       public static void main(String[] args) {
           /** 使用String进行字符串的拼接*/
           String str8="";
           //本质上使用StringBuilder拼接，但是每次循环都会生成一个StringBuilder 对象
           long num1=Runtime.getRuntime().freeMemory();//获取系统剩余内存空间
           long time1=System.currentTimeMillis();//获取系统的当前时间
           for(int i =0;i< 5000;i++){
               str8 =str8 + i;
           }
           long num2=Runtime.getRuntime().freeMemory();
           long time2=System.currentTimeMillis();
           System.out.println("String占用内存 ："+(num1-num2));
           System.out.println("String占用时间 ："+(time2 - time1));
           /** 使用StringBuilder进行字符串的拼接*/
           StringBuilder sb1=new StringBuilder("");
           long num3=Runtime.getRuntime().freeMemory();
           long time3=System.currentTimeMillis();
           for(int i =0;i< 5000;i++){
               sb1.append(i);
           }
           long num4=Runtime.getRuntime().freeMemory();
           long time4=System.currentTimeMillis();
           System.out.println("StringBuilder占用内存 ："+(num3-num4));
           System.out.println("StringBuilder占用时间 ："+(time4 - time3));
       }
   
   }
   

   6. String和StringBuilder 在字符串频繁修改时的效率测试。结果当然是StringBuilder效率高

      String占用内存 ：14914752
      String占用时间 ：121
      StringBuilder占用内存 ：0
      StringBuilder占用时间 ：1