String类的详细介绍和Stringbuffer、Stringbuilder 类的简单介绍

String类的详细介绍和Stringbuffer、Stringbuilder 类的简单介绍

String类

一、获取

1.1：字符串中包含的字符数，也就是字符串的长度。   int length():获取长度  1.2：根据位置获取位置上某个字符。   char charAt(int index)  1.3:根据字符获取该字符在字符串中的位置。 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在字符串中出现的位置。  1.4：int lastIndexOf(String str):反向索引。

二、判断

2.1：字符串中是否包含某一个子串。       boolean contains(str);    特殊之处：indexOf(str):可以索引str第一次出现为止，如果返回-1，表示该str不在字符串中存在。 所以，也可以用于对指定判断是否包含。     if(str.indexOf("a")!=1)   而且该方法既可以判断，也可以获取出现的位置。  2.2：字符串中是否有内容。     boolean isEmpty():原理就是判断长度是否为0。  2.3：字符串是否以指定内容开头。    boolean startsWith(str);  2.4：字符串是否以指定内容结尾。    boolean endsWith(str);  2.5：判断字符内容是否相同，复写了object类中的equals方法。    boolean equals(str);  2.6:判断内容是否相同，并忽略大小写。   boolean.equalsIgnorecase();

三、转换

3.1：将字符数组转成字符串。   构造函数：String(char[])       String(char[],offset,count):将字符数组中的一部分转成字符串    静态方法：      static String copyValueOf(char[]);      static String copyValueOf(char[] data,int offset,int count);      static String valueOf(char[]);  3.2：将字符串转成字符组   char[] tocharArray();  3.3：将字节数组转成字符串。       String(byte[])      String(byte[],offset,count):将字节数组中的一部分转成字符串  3.4：将字符串转成字节数组。   byte[] getBytes()  3.5:将基本数据类型转成字符串，  static String valueOf(int)  static String valueOf(double)  // 3+"" 与 String.valueOf(3)的值是一样的  特殊：字符串和字节数组在转换过程中，是可以指定编码的。

四、替换

String replace(oldchar,newchar); 5>切割  String[] split(regex); 6>子串。获取字符串中的而一部分  String subString(begin);  String subString(begin,end); 7>转换，去除空格，比较。   7.1：将字符串转成大写或小写    String toUpperCsae() 大转小    String toLowerCsae() 小转大  7.2：将字符串两端的多个空格去除    String trim();  7.3：对两个字符串进行自然顺序的比较    int compareTo(string);

五、示例展示

 请看如下代码，下面的代码都是针对上面string七种用法而进行一一举例说明：

代码如下:

class StringMethodDemo 
{
 public staticvoid method_Zhuanhuan_Qukong_Bijiao() {
    String s ="     hello Java    ";
    System.out.println(s);//打印结果是：（hello和java前后门都有空格）hello java
    System.out.println(s.toUpperCase());//打印结果是：（HELLO和JAVA前后门都有空格）HELLO JAVA
    System.out.println(s.toLowerCase());//打印及结果是：带空格的“hello java”
    System.out.println(s.trim());//打印及结果是：不带空格的“hello java”
    String s1 = "abc";
    String s2 ="aaa";
    System.out.println(s1.compareTo(s2)); //比较数的大写，打印结果是：1，因为b对应ascii值是98，//a对应是97，所以b-a=1
 }
 public static void method_sub() {
    String s ="abcdef";
    System.out.println(s.substring(2)); //打印结果是：cdef，从指定位置开始到结尾。如果角标不存在，会出现字符串角标越界。
    System.out.println(s.substring(2,4)); //打印结果是：cd，包含头，不包含尾。
 }
 public staticvoid method_split() {
    String s ="zhangsan,lisi,wangwu";
    String[] arr = s.split(",");//以，为分割，分割成数组3个3个值
    for(int x=0; x<arr.length; x++)  {
        System.out.println(arr[x]);//分别输出zhangsan  lisi  wangwu 
    }
 }
 public static void method_replace() {
    String s ="hello java";
    //String s1 = s.replace('a','n'); //把a 替换为n
    //String s1 = s.replace('w','n');  //如果要替换的字符不存在，返回的还是原串

     String s1 = s.replace("java","world");//把java 替换为world
     System.out.println("s="+s); //打印结果是：hello java因为字符串一旦被初始化，值就不可被改变
     System.out.println("s1="+s1);//打印结果是：hello jnvn
 }
 public static void method_trans() {
    char[] arr ={'a','b','c','d','e','f'};
    String s = new  String(arr,1,3);
    System.out.println("s="+s);//打印结果是：bcd
    String s1 = "zxcvbnm";
    char[] chs =s1.toCharArray();
    for(int x=0; x<chs.length; x++) {
         System.out.println("ch="+chs[x]);//打印结果是：ch=z，x,c,v,b,n,m
    }
 }
 public static void method_is() {
     String str ="ArrayDemo.java";//下面的判断对的就返回true否则返回false
     System.out.println(str.startsWith("Array"));//判断文件名称是否是Array单词开头

     System.out.println(str.endsWith(".java"));//判断文件名称是否是.java的文件
     System.out.println(str.contains("Demo"));//判断文件中是否包含Demo
 }
 
 public static void method_get() {
     String str ="abcdeakpf";
     System.out.println(str.length());//长度
     System.out.println(str.charAt(4)); //根据索引获取字符
  //System.out.println(str.charAt(40));当访问到字符串中不存在的角标时会发生StringIndexOutOfBoundsException（字符串角标越界异常）
     //根据字符获取索引
     System.out.println(str.indexOf('a')); //输出0
     System.out.println(str.indexOf('a',3));// /输出打印的是5，因为角标3是d，
     //所以从d后面开始找a，第5个角标是a
     //System.out.println(str.indexOf('t',3))打印：-1，如果没有找到角标，返回-1
     System.out.println(str.lastIndexOf("a")); //反向索引一个字符出现的位置(从右往左查找，但是角标还是从左开始)，输出还是5

 }
 public static void main(String[] args)  {
    method_Zhuanhuan_Qukong_Bijiao();
    //method_sub();
    //method_split();
    //method_replace();  
    //method_trans(); 
     //method_is();
    //method_get();
      /*
      String s1 ="abc";
      String s2 =new String("abc");
      String s3 = "abc";
     System.out.println(s1==s2);//输出false
      System.out.println(s1==s3); //输出true
    
      */
    }
 }
           

六、Stringbuffer类和Stringbuilder类

String 字符串常量

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

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

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

buffer是缓存的意思，builder是建设的意思

StringBuffer和StringBuilder使用的方法是一样的

StringBuffer 是线程安全的 StringBuilder是线程不安全的

怎么理解Stringbuffer 是线程安全的 stringbuilder是线程不安全的

1、 多个线程操作同一个StringBuffer对象会顺序进行（内部很多方法是同步方法）

2、多个线程操作同一个StringBuilder是同时的，这时候可能出现与预期不符合的结果

3、StringBuilder由于是线程不安全的，所以性能更好。

4、大部分情况下都是单线程操作字符串，这时候选择StringBuilder。  

速度比较：StringBuilder速度较快           StringBuffer相对较慢

七、StringBuffer和StringBuilder的一些使用的方法

重要的是append（）和inset（），这两个在java都没有

append的使用

StringBuilder sb = new StringBuilder(“”);//不能像String直接用双引号定义变量，这里需要new出来 sb.Append( "123456789" );//添加一个字符串 sb.Length = 3;//设置容量为3 System.out.println ( sb.toString() );//这里输出:123 sb.Length = 30;//重新设置容量为30 System.out.println ( sb.ToString() + ",结尾");//这里在原来字符串后面补齐空格,至到Length的为30 System.out.println ( sb.Length );//这里输出的长度为30

insert的使用

public static void main(String[] args){ double d=1234.5;      //double先转换为String类型，再转换为StringBuffer类型     StringBuffer sb=new StringBuffer(d+"");     for (inti = sb.indexOf(".")-3;i > 0; i-=3) {         sb.insert(i,",");     }     System.out.println(“d=”+d);//输出d=1,234.5 }

用一个例子来看StringBuilder和String之间的速度差距：

public class StringTest {
 
    // String类和StringBuffer速度的比较
    public static void main(String[] args) {
       StringBuffer sb = new StringBuffer ("");//创建Stringbuffer对象，并实例化
       int i = 0;
       long StartTime = System.currentTimeMillis();//获取系统循环执行开始时间的毫秒数
       while (i <100000) {
           sb.append((i + "").toString());//使用append方法
           i++;
       }
       long EndTime = System.currentTimeMillis();//获取系统循环执行结束时间的毫秒数
       System.out.println("StringBuffer时间:" + (EndTime - StartTime));//计算时间差
      
       String sb1 = "";//创建String对象
       i = 0;
       StartTime = System.currentTimeMillis();//获取系统循环执行开始时间的毫秒数
       while (i <100000) {
           sb1 = sb1 + i;//和append效果一样
           i++;
       }
       EndTime = System.currentTimeMillis();//获取系统循环执行结束时间的毫秒数
       System.out.println("String时间:" + (EndTime - StartTime));//计算时间差
    }
}
           

 运行结果：

运行结果相差很大哦！

所以StringBuilder和StringBuffer用于变量经常改变的情况，运行速度很快，

但是其他情况还是比较多使用String这个类的！