Java中String,StringBuffer,StringBuilder

class StringDemo{
  public static void main(String[] args){
   /*
    String s=new String();
    String s="";
    //以上两句话均创建空串
   */ 
   String s1="abc";//s1是一个类类型(引用)变量,"abc"是一个对象
                  //字符串最大特点:一旦被初始化就不可以被改变.(指的是该字符串对象)
    //s1="haha";//改变的是s1引用变量的指向
   String s2=new String("abc");
   //s1和s2有什么区别?
   //s1在内存中有一个对象
   //s2在内存中有两个对象(new和"abc")
      /*
     new String("abc"):
     通过new产生一个字符串（假设为”abc”）时，
     会先去常量池中查找是否已经有了”abc”对象，
     如果没有则在常量池中创建一个此字符串对象，
     然后堆中再创建一个常量池中此"abc”对象的拷贝对象。
     */ 
   
   System.out.println(s1==s2);//s1,s2指向不同对象,对象内存地址不同 
   System.out.println(s1.equals(s2));//String类中复写了Object类中的equals方法
                              //该方法用于判断两个字符串是否相同(比较的是内容)  
  }
}

/*
字符串存放在常量池(其中有数组存放字符)
abc存放在数组中
efg同理
abf会找到a b f拼成一个新的字符串.
*/

/*
常量存储在常量池,常量池也在方法区中

*/

class StringDemo{
 public static void main(String[] args){ 
     String s1="abc";
     String s2=new String("abc");
     String s3="abc";
     System.out.println(s1==s2);//false 用new String()创建的字符串不是常量，
                               //不能在编译期就确定,所以new String() 创建的字符串不放入常量池中,
                               //它们有自己的地址空间。
     System.out.println(s1==s3);//true 因为"abc"对象已存在,存放在常量池
                                //且不能改变,节约内存->s1,s3指向同一个对象
                                //"abc"字符串常量在编译时期已经确定
    }
}

关于常量池:http://baike.baidu.com/view/8680346.htm

String类中常用的方法归纳:

/*
String类适用于描述字符串事物.
那么它就提供了多个方法对字符串进行操作

常见的操作有?(API文档)
"abcd"
1.获取.
  1.1 字符串中包含的字符数->字符串长度
      int length():获取长度
  1.2 根据位置获取位置上的某个字符
      char charAt(int index)
  1.3 根据字符获取该字符的位置
      int indexOf(int ch):返回的是ch在字符串中第一次出现的位置
      //传入的为ASCII码
      int indexOf(int ch,int fromIndex):从指定fromIndex位置开始,获取ch在字符串中的位置
      int indexOf(String str, int fromIndex): 从指定fromIndex位置开始,返回指定子字符串(str)在此字符串中第一次出现的位置.
      int lastIndexOf(int ch):反向索引一个字符出现的位置    
2.判断.
  2.1 字符串中是否包含某一个子串
      boolean contains(CharSequence);
      特殊之处:
              indexOf(str):可以索引str第一次出现的位置.如果没有找到返回-1.
              所以,也可以用于对指定判断是否包含
              该方法既可以判断,又可以获取出现的位置
              if(str.indexof("aa")!=-1)
  2.2 字符串中是否有内容(空串)
      boolean isEmpty():原理就是判断长度是否为0
  2.3 字符串是否以指定内容开头
      boolean startsWith(str);
  2.4 字符串是否以指定内容结尾
      boolean endsWith(str);
  2.5 判断字符串内容是否相同(不忽略大小写).复写了Object类中的equals方法
      boolean equals(Object anObject);
   2.6 判断内容是否相同,并忽略大小写
      boolean  equalsIgnoreCase(String str);
3.转换
  3.1 将字符数组转成字符串
      构造函数: String(char[])
                String(char[],int offset,int count):count 参数指定子数组的长度,将字符数组中的一部分转成字符串
      静态函数:
               static String copyValueOf(char[]);
               static String copyValueOf(char[] data,int offset,int count)
               static String valueOf(char[])
  ※3.2 将字符串转成字符数组
      char[] toCharArray();//直接调用 "abcde".toCharArray();
  3.3 将字节数组转成字符串
       String(byte[] bytes)
  3.4 将字符串转成字节数组
       byte[] getBytes();
  3.5 将基本数据类型转成字符串
       static String valueOf(int);
     
//3+"";等价于String.valueOf(3);->很麻烦
   特殊:字符串和字节数组在转换过程中,是可以指定编码表的
     
*/
class StringMethodDemo{
   //获取子串
   public static void method_sub(){
    String s="abcdef";
    sop(s.substring(2));//cdef
    sop(s.substring(2,4));//cd  //2->4实际上是2->3
    //如果利用substring获取整个字符串s.substring(2,s.length());
   }

    //切割示例
    public static void method_split(){
      String s="zhangsan.lisi.wangwu";
      String[] arr=s.split("\\.");//.比较特殊
      for(int i=0;i<3;++i)
        sop(arr[i]);
      /*
        zhangsan 
        lisi 
        wangwu
      */
    }
    //替换示例
    public static void method_replace(){
     String s="hello java";
     String s1=s.replace('a','n');//字符串一经初始化不可改变,"hello,java"依然存在
     sop("s="+s);// s=hello java    //如果替换的字符不存在,返回的为原串
     sop("s1="+s1);//s1=hello jnvn
     sop("hello java".replace("java","world"));//hello world  
    }     
    //转换示例
    public static void method_trans(){
     char[] arr={'a','b','c','d','e','f'};
     //char[] arr="abcdef";会报不兼容的类型 char[]与String
     String s=new String(arr);
     String s2=new String(arr,1,4);
     sop("s="+s);//abcdef
     sop("s2="+s2);//bcde
     }    
    //判断示例
    public static void methodIf() {
     String str="ArrayDemo.java";
     //判断文件名称是否是Array单词开头
     sop(str.startsWith("Array"));//true
     //判断文件名称是否是.java文件
     sop(str.endsWith(".java"));//true
     //判断文件是否包含Demo
     sop(str.contains(".java"));//true   
    }
    //索引示例
    public static void main(String[] args) {
     String str="abcdefakpf";
     sop(str.length());//10
     sop(str.charAt(4));//当访问到字符串不存在的角标时会  //e
                       //发生StringIndexOutOfBoundsException.
     sop(str.indexOf("akps",3));//如果没有找到返回-1(字符和字符串均是)
                                //返回字符串首个字符位置  
     sop(str.lastIndexOf('a'));//当字符串足够长,知道该字符/字符串在靠后位置
                               //从后往前索引,效率较高 //6
     methodIf();
     method_trans();
     method_replace();
     method_split();
     method_sub();
    }                         
  public static void sop(Object obj){//1.5版本后新特性(装箱)基本数据类型提升 
   System.out.println(obj);
   //最终是obj所指向的对象调用 该对象所属类的toString()方法  
  }
}
/*
4.替换
 String replace(char oldchar,char newchar);
它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。
 String replace(CharSequence target, CharSequence replacement)  
5.切割
  String[] split(String regex);//已指定字符串切割
6.子串,获取字符串的一部分
  String substring(begin);//从指定位置至结尾
  String substring(begin,end);//包含头不包含尾
*/

/*
7转换,去除空格,比较
 7.1 将字符串转成大写或小写.
    String toUpperCase();
    String toLowerCase();
 7.2 将字符串两端(开头和结尾)的多个空格去除.
    String trime();
 7.3 对两个字符串进行自然顺序的比较
   int compareTo(string);
*/
class StringMethodDemo2{
    public static void method_7() {
     String s="     Hello Java    ";
     sop(s.toLowerCase());
     sop(s.toUpperCase());
     sop(s.trim());
     String s1="a1d";
     String s2="aac";
      sop(s1.compareTo(s2));//'1'-'a'->49-97=-48
                            //该比较不忽略大小写
    }
    
    public static void main(String[] args){
     method_7(); 
    }
    public static void sop(Object obj){
      System.out.println(obj);
    }
  }

StringBuffer类与StringBuilder类:

package stringbuffer;
/*
StringBuffer是字符串缓冲区
是一个容器
1.而且长度是可变化的,数组一经分配固定的.
2.可以直接操作多个数据类型,而数组只能操作一种
3.最终通过toString变成字符串.

StringBuffer 上的主要操作是 append 和 insert 方法，可重载这些方法，以接受任意类型的数据。每个方法都能有效地将给定的数据转换成字符串，然后将该字符串的字符追加或插入到字符串缓冲区中。append 方法始终将这些字符添加到缓冲区的末端；而 insert 方法则在指定的点添加字符。

例如，如果 z 引用一个当前内容为 "start" 的字符串缓冲区对象，则此方法调用 z.append("le") 会使字符串缓冲区包含 "startle"，而 z.insert(4, "le") 将更改字符串缓冲区，使之包含 "starlet"。

1.存储.
  StringBuffer append():将指定数据(int,boolean,String,Object...)作为参数添加到
已有数据结尾处.
  StringBuffer insert(index,数据):可以将数据插入到指定index位置.
2.删除
  StringBuffer delete(start,end):删除缓冲区中的数据,包含start,不包含end
  StringBuffer deleteCharAt(int Index)
3.获取(类似字符串操作)
 char charAt(int)
 int indexOf(String)
 int lastIndexOf(String)
 String substring(int start,int end);

4.修改
 StringBuffer replace(start,end,String)//包含头不包含尾
 void setCharAt(int index,char ch)
 //注意以上返回类型
 5.反转
   StringBuffer reverse();

6.void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) 
  将缓冲区中数据复制到指定字符数组中
  String中也有
*/
class StringBufferDemo{
  public static void method_getChars(){
    StringBuffer sb=new StringBuffer("abcdef");
    char[] ch=new char[6];
    sb.getChars(1,4,ch,2);
    for(int i=0;i<ch.length;++i)
      System.out.println("ch["+i+"]="+ch[i]);
    /*
     ch[0]= 
     ch[1]=
     ch[2]=b
     ch[3]=c
     ch[4]=d
     ch[5]=
    */
  }
  
  //修改
  public static void method_update() {
    StringBuffer sb=new StringBuffer("abcde");
    sb.replace(1,4,"java");//包含头不包含尾->ajavae
    sb.setCharAt(2,'h');//ajhvae
    sop(sb.toString());
  }
  
  //删除示例
  public static void method_del() {
   StringBuffer sb=new StringBuffer("abcde");
   sb.delete(1,3);//包含头不包含尾 //ade
   //清空缓冲区
   //sb.delete(0,sb.length());//删除所有
   sb.delete(2,2);//依然是原串 //ade
   sb.deleteCharAt(2);//删除单个字符 //ad
   sop(sb.toString());
  }
  //添加示例
  public static void method_add(){
     StringBuffer sb=new StringBuffer();
       sb.append("abc").append(true).append(12);//方法调用链 //abctrue12
      sb.insert(1,"qq"); //一直在操作同一个对象sb //aqqbctrue12
      sop(sb.toString()); 
  }
  public static void main(String[] args) {
        method_getChars();
        method_update(); 
        method_del();
        method_add();
    } 
   public static void sop(String str){
       System.out.println(str);
   }
}
/*
toString()复写了Object中的:

public String toString()

返回此序列(StringBuffer中的序列)中数据的字符串表示形式。
分配一个新的 String 对象，并将它初始化，
以包含当前由此对象表示的字符串序列。
然后返回此 String。对此序列的后续更改不影响该 String 的内容.
*/

/*
StringBuffer与StringBulider
JDK1.5 版本以后出现了StringBuilder
StringBuffer是线程同步
StringBuilder是线程不同步      
单线程情况下->判断锁->StringBuffer效率低于StringBuilder
将 StringBuilder 的实例用于多个线程是不安全的。
如果需要这样的同步，则建议使用 StringBuffer。 
JDK升级三个因素:
1.提高效率
2.提高安全性
3.简化书写
*/

String方法经典练习:

 

package stringtest;
//1.模拟一个trime方法,去除字符串两端的空格
class Trime{
    public static String newTrime(String str) {
      int start=0,end=str.length()-1;
      //从头至尾扫描,直至出现非空格为止
      while(start<=end&&str.charAt(start)==' ')//第一个条件防止全是空格
        ++start;                               //start<=end条件必须放在前面,因为当start>end时                                              //JVM无法取值判断->StringIndexOutOfBoundsException
      //从尾至头扫描
      while(start<=end&&str.charAt(end)==' ')//当str全为空格,start为end+1,该循环不再执行
        --end; 
     return str.substring(start,end+1);  
}
    public static void main(String[] args) {
       String s=" ab c ";
       System.out.println(s+"\n"+newTrime(s));
    }
}
//2.讲一个字符串进行反转.将字符串中指定部分进行反转
//  例如:"abcdefg"
//         "abfedcg" cdef->fedc

class StrReverse{
  //功能细分(注意这个思想)
   public static void swap(char[] ch,int x,int y) {
     char temp;
     temp=ch[x];
     ch[x]=ch[y];
     ch[y]=temp;
   }
  //反转
   public static void reverse(char[] ch,int start,int end) {
       for( ;start<end-1;++start,--end)//start=end无需交换 例如:cdefg->都指向e
         swap(ch,start,end-1);          //end-1一般包含头不包含尾         
    }
 
   public static String StrReverse(String str,int start,int end){
       //将字符数组->变成字符串
         char[] ch=str.toCharArray();        
       //反转
        reverse(ch,start,end);         
         //将字符串->字符数组
         //return String.copyValueOf(ch);
         return String.valueOf(ch);
         //return new String(ch); 
   }
   //全部翻转
   public static String StrReverse(String str){
     return StrReverse(str,0,str.length());   
   }

   public static void main(String[] args){
       String s="abcdefg";
       System.out.println(s+"\n"+StrReverse(s)+"\n"+StrReverse(s,0,2)); 
   } 
}

//3.获取一个字符串在另一个字符串中出现的次数.
/*
算法思想:
用indexOf从指定位置开始索引看字符串是否存在
*/
class StrStr{
  public static int getCount(String strA,String strB) {
    int count=0,strBLength=strB.length(),strALength=strA.length();
    int pos=0; 
     //利用indexOf找寻子串位置     
       while((pos=strA.indexOf(strB,pos))!=-1){  
            ++count;
            pos+=strBLength;//从下个位置索取
          }     
    return count; 
  }
  public static void main(String[] args){
    String s1="abcdefgdehfcdefghdef",s2="def";
    System.out.println(getCount(s1,s2));
  }
}
//※4.获取两个字符串中最大相同子串. 
/*
算法思想:
假设有A,B两个串,
对于B串:
①A.contains(B)==true 返回 否则转②
②B.length()-1,尾指针-1,首指针-尾指针之间的字符串,是否被A包含,包含返回
  不包含,首指针++,尾指针++->判断尾指针<=B.length()-1->大于则B.length()-1长度
  的子串索引完毕
③B.length()-2,重复②直至B.length()>0
(画示意图)
*/
class MaxSubstring{
  public static String maxSubstr(String strA,String strB){
   //产生一个问题,如果strB为长串那么循环次数将非常大
   //因此在遍历前确定谁长谁短->减少循环次数
    String str,maxStr=strA,minStr=strB;
    if(strB.length()>strA.length()){
      maxStr=strB;
      minStr=StrA;
    }
    int length=minStr.length(); 
    for(int i=length;i>0;--i)//控制子串长度
      for(int start=0,end=i;end!=length+1;++start,++end){//对相同长度子串进行查找 {
         str=minStr.substring(start,end);
         if(maxStr.contains(str))//或者使用if(strA.indexOf(str)!=-1)
             return str;
       }
    return "";
  }
  public static void main(String[] args){
   System.out.println(maxSubstr("abcdefgh","defgh"));   
  }
}

关于第四个练习:画个示意图

基本数据类型对象包装类:

/*
基本数据类型对象包装类
例如:整数有多种表现形式(十进制,十六进制..)
     整数变成对象,功能封装,操作方便.
     也就是说把对整数操作的一些方法封装成类
基本      类
byte      Byte
short     Short
int       Integer
boolean   Boolean
float     Float
double    Double
char      Character

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

1.基本数据类型->转成字符串
   基本数据类型+""
    

   基本数据类型.toString(基本数据类型)
   如:Integer.toString(34);//将整数34->"34"
 
2.字符串->基本数据类型
   基本数据类型 a=类.parseXxx(String);
    double a=Double.parseDouble("3.14");
    Boolean b=Boolean.parseBoolean("true");
    或
    Integer i=new Integer("123");//通过构造函数
    int number=i.intValue();//123
3.十进制转成其他进制
   Integer.toBinaryString(int)//返回String
   Integer.toHexString(int)
   Integer.toOctalString(int)
   

   Integer.toString(数据,指定基数)
4.其它进制转为十进制
   Integer.parseInt("1011",2);
*/
class IntegerDemo{  
   public static void sop(String str) {
     System.out.println(str);
   }
     
  public static void main(String[] args){
    sop("int max "+Integer.MAX_VALUE);
    //讲一个字符串转成整数(double,long等同理)
    int num=Integer.parseInt("123");
    sop("num="+(num+4));//num=127
    //转换
    sop(Integer.toBinaryString(10));//1010
    sop("1010十进制: "+Integer.parseInt("1010",2));//10
    sop(Integer.toString(20,2));//10100
  }
}

 

 

JDK1.5版本新特性:

 

 

/*
JDK 1.5出现的新特性
*/
class IntegerDemo2{
    public static void method() {
      Integer i1=new Integer(12);//也可以传入十六进制/八进制
      Integer i2=new Integer("12");
      System.out.println(i1==i2);//false,两个对象内存地址不同
      System.out.println(i1.equals(i2));//true 12==12
    }

    public static void main(String[] args){
      method();
     Integer i=new Integer(4);
     Integer x=4;//4等价于Integer.valueOf(4)隐式转换
                 //自动装箱
     //x=null;   //x可以取null,那么下面x=x+2运行失败,nullPointerException
     x=x+2;//x+2:x 进行自行拆箱.变成int 和2进行加法运算
           //再将和装箱赋给x
           //实际上x=Integer.valueOf(x.intValue()+2);
    
    Integer y1=127;
    Integer y2=127;
    System.out.println("x==y: "+(y1==y2));
    /*
    注意:结果为true.
    因为a和b指向了同一个Integer对象
    因为数值在byte范围内容,对于新特性,如果该数值已存在,则不会在
    开辟新空间
    */
    }    
}

 

最后解析下:

 

/*
  public static void sop(Object obj){//1.5版本后新特性(装箱)基本数据类型提升
   System.out.println(obj);
   //最终是obj所指向的对象调用 该对象所属类的toString()方法
  }
解析:如果传入int型的值相当于->obj=new Integer(int ) 多态
System.out.println(obj)内部是怎么执行的?
①查看java.io.PrintStream中的println方法
  void println(Object x):
  打印 Object，然后终止该行。
  此方法首先调用 String.valueOf(x) 获取打印对象的字符串值
②查看java.lang下的String类valueOf方法:
  public static String valueOf(Object obj)
  如果参数为 null，则字符串等于 "null"；否则，
  返回 obj.toString() 的值
  也就是:
  如果obj=new Integer(int )->也就是调用Integer类中的toString方法
③Integer类中的toString:
   将该参数转换为有符号的十进制表示形式，并以字符串的形式返回它
最终转换成字符串
*/