String 、 StringBuffer

    String的常用方法：

      1.charAt( int  index ):返回指定索引处的 char 值。

      2.indexOf( int  ch ): 返回指定字符在此字符串中第一次出现处的索引

         indexOf( int  ch , int  fromIndex) :

         indexOf(String  str):

         indexOf(String  str , int  fromIndex):

      如果从后往前查找:lastIndexOf()

      3.length():返回此字符串的长度

         数组有length属性，String有length()方法

      4.split( String regex ): 根据给定正则表达式的匹配拆分此字符串

      5.substring(int  beginIndex):截取字符串

         substring( int beginIndex , int endIndex):

      6.toLowerCase():转换成小写；toUpperCase()：转换成大写

      7.字符串声明：

       String  str1 = new String("abc"); //3个空间(堆，栈，常量池)

       String  str2 = "abc"; //1个空间，栈，常量池复用str1中的内容

       String  str3 =  "hello world";

       String  str4 = "abc";

       String  str5 = "  abc  ";

       String  str6 = "ABC";

     8.连接字符串：concat():

        System.out.println(str1.concat(str2));  //abcabc

    9.判断字符串里是否有某个字符串： contains()

        System.out.println(str3.contains("world")); //true

    10.以xx开头，以xx结束：startsWith()   endsWith()

         System.out.println(str3.startsWith("he")); //true

         System.out.println(str3.endsWith("world"));//true

    11.判断字符串是否相等： == :比较内存地址，equals比较内容

         System.out.println(str1 == str2); //false

         System.out.println(str2 == str4);  //true

         System.out.println(str1.equals(str2));//true

         忽略大小写，是否相等

         System.out.println(str2.equalsIgnoreCase(str6));//true

     12.替换:replaceAll()：最常用

                  replace():

          System.out.println(str3.replace('l', 'L'));//heLLo worLd

          System.out.println(str3.replaceAll("o", "O")); //hellO wOrld

          System.out.println(str3.replaceAll("\\s", ""));//将空格特换成空串helloworld

     13.转成一个char数组：

          System.out.println(str3.toCharArray().length);//11

 StringBuffer常用方法：

     StringBuffer  sb = new StringBuffer("hello world");

      //最前面追加

     sb.append(0 , "“");

     //最后面追加

     sb.append("”");

    System.out.println(sb); //“hello world” 

   //删除引号

    sb.delete(0 , 1);//删除的是第一个引号

   sb.delete(sb.length() - 1 , sb.length());//删除的是第二个引号

   System.out.println(sb); //hello world

   //修改内容：

   replace(int start , int end , String str)

   //字符串反转

   System.out.println(sb.reverse());

拼接字符串时，String和StringBuffer性能的比较：StringBuffer更快

    // String
long start = System.nanoTime();
String str = "1";
for (int i = 0; i < 100000; i++) {
str = "1";
}
System.out.println(str);
System.out.println("String:" + (System.nanoTime() - start));


// StringBuffer
// long start2 = System.nanoTime();
// StringBuffer sb = new StringBuffer();
// for (int i = 0; i < 100000; i++) {
// sb.append(i);
// }
// System.out.println(sb);
// System.out.println("StringBuffer:" + (System.nanoTime() - start2));

   

cz

String类：

   字符串是一个特殊的对象，字符串一旦初始化就不可以被改变

   String   s1  = "abc";//s1是一个类类型变量，"abc"是一个对象

     s1 = "kk";

  //以上并不能说明s1的值已经被修改，而是说明s1现在指向了kk这个对象 ,"abc"在内存里还在

  String  str1 = "abc";

   String  str2 = new String("abc");

   str1 == str2 //false：比较的是内存地址

   str1.equals(str2);//true：比较的是字符串内容

  有什么区别：

   str1在内存中有一个对象，str2在内存中有两个对象

  String常见功能

   判断：

       判断字符串长度是否为0：boolean  isEmpty()  

       String  str = "ArrayDemo.java";

      //判断文件名 是否是Array单词开头

       System.out.println(str.startsWith("Array"));

       //判断文件是否是.java文件

       System.out.println(str.endsWith(".java"));

       //判断文件中是否包含Demo

       System.out.println(str.contains("Demo"));

     

     字符串中是否包含某一个字串：

          boolean contains(str)

        特殊之处：indexOf(str):可以索引str第一次出现的位置，如果返回-1，表示str不存在，所以也可以用于对指定字符串的判断是否包含

              if(str.indexOf("aa") != -1)

             既可以判断，又可以获取出现的位置：indexOf()

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

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

        判断内容是否相同，并判断大小写：boolean equalsIgnoreCase()

     

     转换：

      1.将字符数组转成字符串：

                  构造函数：String(char [])

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

              char[]  arr = {'a' , 'b' , 'c' ,'d' ,'e'};

               String  s  =  new  String(arr);   // s = abcde

               String str = new  String( arr , 1  ,4);  //bcde

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

                                     static  String copyValueOf(char[],int offset ,int count)

                                      static  valueOf(char[])

      2.将字符串转成字符数组

              char[]  toCharArray():

      3.将字节数组转成 字符串 

                   String(byte[])

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

      4.将字符串转成字节数组

                byte[]  getBytes()

       5.将基本数据类型转成字符串

           static  String   valueOf(int)

           static  String  valueOf(double)

     特殊：字符串和字节数组在转换过程中，是可以指定编码的。

     

       

    替换：

          1.String  replace(oldChar , newChar);     

            String   s  = "hello  java"; 

           //String  s1 = s.replace('a' ,'n');

           // String  s2 = s.replace('q' , 'n');

            String s3 = s.replace("java", "world");

            System.out.println("s=" + s); //s=hello  java

            //System.out.println("s1=" + s1); //s1=hello  jnvn

            //System.out.println("s2=" + s2); //s2=hello  java:如果替换的字符不存在，返回的还是原串

             System.out.println("s3=" + s3); //s3=hello  world

  切割：

        String split(regex)

        String s = "zhangsan , lisi, wangwu";

        String[]  arr = s.split(",");//按逗号进行拆分

   子串：获取字符串中的一部分

       String  substring(beginIndex ,endIndex);

        String str = "abcdef";
        System.out.println(str.substring(2)); //cdef：从指定位置开始
        System.out.println(str.substring(2, 4)); //cd：包含头，不包含尾；

                 截取整个字符串:str.substring(0,str.length);

       如果角标不存在，会出现字符串角标越界异常。

  转成大小写：

        toLowerCase();

        toUpperCase();

  去除空格：trim()

  两个字符串的自然顺序比较：基于各个字符的Unicode值

      int compareTo(String):相等返回0，大于返回一个正数，小于返回一个负数

      String s1 = "a1c";

      String s2 = "aaa";

     System.out.println(s1.compareTo(s2)); //-48:第一个a相同就不用比较了，比较第二位，1的ascii值为49，a的ascii值为97，所以结果为-48

  忽略 大小写比较，不惯参与的字符串是什么，全变小写进行比较。

   StringBuffer是字符串缓冲区
StringBuffer被final修饰了，不能去继承
C:create  U:update  R:read  D:delete

线程安全的可变字符序列
  是一个容器;


缓冲区的特点：
长度是可变化的；
可以直接操作多个数据类型;
最终会通过toString()变成字符串
    什么时候使用：数据类型不确定，数据个数不确定，最终要变成字符串的时候使用。


1.存储
   append():
   StringBuffer append():将指定的数据作为参数添加到已有数据的结尾处
   StringBuffer sb = new StringBuffer();
   //StringBuffer sb1 = sb.append(34);
   //System.out.println(sb == sb1);//true
   //System.out.println(sb.toString()); //结果为34
   //System.out.println(sb.toString());  //结果为34:StringBuffer是一个容器
   sb.append("abc").append(true).append(34)  //方法链
   System.out.println(sb.toString()); //结果为：abctrue34
   
   insert(index , 数据(任意类型)):可以将数据插入到指定index位置
       如果角标不存在，出现角标越界错误
  


2.删除
    StringBuffer delete(int start ,int end):删除缓冲区中的数据，包含start,不包含end
StringBuffer  deleteCharAt(int index)：删除指定位置的字符

StringBuffer sb = new StringBuffer("abcde");
sb.delete(1,3);//结果为：ade
//清空缓冲区：
sb.delete(0,sb.length())
//删除c
sb.deleteCharAt(2);或者sb.deleteCharAt(sb.indexOf("c"));
3.获取:
    char charAt(int index)
int indexOf(String str)
int lastIndexOf(String str)
int length()
String substring(int start , int end) //注意，这里返回的是String类型
4.修改:
   StringBuffer replace(int start ,int end ,String str):用str替换从start到end位置的字符(包含start,不包含end哦)
   StringBuffer sb = new StringBuffer("abcde");
   sb.replace(1,4,"java");//即将bcd替换成java
   System.out.println(sb);//结果：ajavae   
   
   void setCharAt(int index ,char ch):将指定位置的字符设置成要替换的字符


5.反转：
    StringBuffer reverse();
6.将缓冲区中指定数据存储到指定字符数组中
  void getChars(int srcBegin , int srcEnd ,char[] dst ,int dstBegin):
  StringBuffer sb = new StringBuffer("abcdef");
  char[] chs = new char[4];
  sb.getChars(1,4,chs,1);
  for(int i = 0 ;i < chs.length ; i++){
     System.out.println("chs["+ i+"]="+chs[i]+";");
  }

 StringBuilder

     在jdk1.5版本之后出现了StringBuilder,与StringBuffer相比，StringBuffer是线程同步(是安全的)的，StringBuilder是线程不同步的。单线程StringBuffer效率低。将StringBuilder的实例用于多个线程是不安全的，如果需要这样的同步，建议使用StringBuffer，

   以后开发建议使用StringBuilder

   升级三个因素：

    1.提高效率

     2.简化书写

    3.提高安全性

基本数据类型包装类：

   byte     Byte

   short    Short

   int        Integer

   long     Long

   boolean   Boolean

   float       Float

   double   Double

   char        Character

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

    基本数据类型转成字符串：

       基本数据类型 +  ""

       基本数据类型.toString(基本数据类型值);

       如：Integer.toString(34); //将34变成"34"

    字符串转成基本数据类型：

       xxx a = Xxx.parseXxx(String);

       例子:

         静态转换：

             int a = Integer.parseInt("123");

             double d = Double.parseDouble("12.23");

              boolean b = Boolean.parseBoolean("true");

        非静态转换：

                Integer i = new Integer("123");

                 int num = i.intValue();

       文本框获取的数据几乎都是字符串：parseInt()

       //将字符串转成整数：int num = Integer.parseInt("123");//必须传入数字格式的字符串，否则出现NumberFormatException

                                         long x = Long.parseLong("123");

      

       十进制转成其他进制：       

                Integer.toBinaryString()//转二进制

                Integer.toHexString()//转十六进制

                Integer.toOctalString()//转八进制

        其他进制转成十进制 ：

                parseInt(String s ,进制基数)

                int x = Integer.parseInt("110",2); //结果6

                int y = Integer.parseInt("120" ,2);//编译出错 ，NumberFormatException，因为2进制里面没有2

                 int z = Integer.parseInt("3c" , 16);//如果此处将3c转成10进制，则编译出错，因为10进制里面没有c

     

         基本数据类型对象包装类新特性：

            Integer   x  =  new Integer("123");

            Integer   y  =  new Integer(123);

             System.out.println(x == y);// 结果：false ，比较内存地址

             System.out.println(x.equals(y));//  结果：true  ，比较值

                 jdk1.5版本以后出现的新特性：

                   Integer  x  = new  Integer(4);就等于Integer  x =  4;//自动装箱，简化书写    

                     x = x  + 2;  // x进行自动拆箱，变成了int类型和2进行加法运算，再将和进行装箱，赋值x

                    拆箱原理：x.intValue()

                    使用Integer就多了一个取值null，而int是没有null的，当integer不为null的时候才能进行运算，否则是不能进行运算的，会抛出空指针异常。

       Integer   m =  128;

       Integer  n   =  128;

       System.out.println(m == n);//false，这个相当于Integer  m  = new Integer(128);，两个对象

       Integer  a  =  127;

       Integer   b   =  127;

       System.out.println( a ==  b); //true，因为a和b指向了同一个Integer对象，因为当数值在byte范围内容时，对于新特性，如果该数值已经存在，不会再开辟空间。byte范围在-128~127，超过这个范围就会开辟新空间，不超过的话为了节省内存，就不会开辟新空间了。

   对于a和b,a的值已经是127了，当b为127的时候，b就直接指向原有的127，不再开辟新空间了。