java基础 JAVAString StringBuffer StringBuilder

package com.zemeng;

import java.util.Arrays;

import java.util.Date;

public class ArrayDemo {

public staticvoid main( String[] argv ){

/* 数组是长度不可改变，但是数组中的元素值可以改变；

 * 

 * String 字符串:

 * 

 *   String是java中一个不可变的类，所以它一旦被实例化就无法被修改。不可变类的实例一旦创建,内容无法再修改.

 * 不可变类有很多优势:

 * (1) 字符串常量池:

 * 字符串池是方法区中的一部分特殊存储。当一个字符串被创建的时候，首先会去这个字符串池中查找，如果找到，

 * 直接返回对该字符串的引用;  

 *      (也就是说，如果两个字符串的内容完全一样，那么他们的内存地址一定相等，且其实只有一份)

 * 

 * (2) 缓存Hashcode:

 * java中经常会用到字符串的哈希码。在HashMap中，字符串的不可变，保证了其hashcode永远相同;

 * 这样每次使用一个字符串的hashcode的时候，不用重新计算一次，更加高效；

 * 

 * (3) Set

 * 在Set中，默认方式就是通过字符串的hashcode来判断数据是否重复，而相同的string就必有相同的

 * hashcode,从而保证了Set中元素的唯一性；

 * 

 * (4) 线程的安全性;

 * 多线程操作之所以不安全，完全是因为多个子线程在同一时间内操作某个公共变量，且该变量在操作之后变量的值

 * 会发生改变；因为String一旦创建之后，就无法再修改其值，所以，String是线程安全的；

 * 

 * 

 * 

 * 

 * 

 * 

 * String类:

 * 

 * String类描述的文本字符串序列.

 * 创建String类对象的两种方式:

 * 1. String s = "1234";

 * 2. String s = new String();

 * 

 * 因为String类是对象类型，所以默认在new String()之后，初始化为""; 

 * */

String s = new String();

System.out.println( "hehe:"+s );

 

   /* 字符串常量池：

    *

    * */

String str1 = "jack";

String str2 = "jack";

String str3 = new String("jack");

String str4 = new String("jack");

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

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

System.out.println( str3 == str4 ); //false

/* 

*  由上面的字符串对象的内存地址比较 --> 得出字符串创建过程

     String str = "jack"这个语句会先检查字符串常量池是否存放这个"jack"这个字符串对象：

    如果常量池中存在, 则直接返回常量池中该字符串的内存地址值;

    如果不存在,那么会先在字符串常量池中创建这个字符串对象，然后返回地址值；

String str = new String("jack"); 这语句会创建两个对象，首先会先检查字符串常量池中是否存在jack这个字符串对象，

如果不存在就会创建，如果存在就返回内存地址值；

创建出来之后，new String这个语句就会在堆内存中开辟一个字符串对象。

注意: 

只有字符串常量才会被创建在 字符串常量池中； new 出来的String对象，还是存储在堆中的；

* 

* */

/* 2.2 获取方法

* 

*  字符串不具有属性，所以获取值时，都需要调用

*  (1) int  length();   获取字符串的长度

*  (2) char charAt( int index );  获取特定位置的字符( 注意下标越界 )

*  (3) int  indexOf( String str); 获取特定字符的位置

*  (4) int  lastIndexOf(intch);  获取最后一个字符的位置 

*  

*  */

String string  =new String("13rfshddhkfgfhfshdfdssffgf");

System.out.println( "字符串长度:"+string.length() );

for( inti=0; i<string.length();i++ ){

/* 获取字符串中指定位置的字符 */

System.out.print(string.charAt(i) );

}

System.out.println("");

/* 关于查找字符: indexOf,lastIndexOf 都只查找第一个遇到的该字符就停止，如果没有找到，返回-1 */

System.out.println("获取特定字符的位置:"+string.indexOf('d'));

System.out.println("在字符串中查找字符:(从后向前)"+string.lastIndexOf('d'));

/* 2.3 判断方法

* 

* boolean isEmpty()  字符串长度是否为0；( 如果string==null,并不是为空;string.equals("")才是空 )

* boolean startsWith( subString );   判断是否以子串开头

* boolean endsWith( subString );     判断是否以子串结尾

* boolean contains( CharSequences ); 是否包含子串 ；

* boolean equals( Object abObject ); 判断两个字符串是否相等；

* boolean equalsIgnoreCase( String anotherString ); 忽略字符的大小写，判断两个字符串是否相等

* 

* */

String temp = "";

System.out.println( "判断子串是否是空:"+temp.isEmpty() );

System.out.println( "判断是否以某子串开头:"+string.startsWith("13r") );

System.out.println("判断是否以某子串结尾:"+string.endsWith("ffgf"));

System.out.println("判断是否包含某子串:"+string.contains("ffggdsdf"));  

/* 因为String变量是引用类型的变量，所以 == 是判断两个字符串对象的地址， 如果要判断内容相等，要用equals(string) */

System.out.println( "判断两个字符串是否相等"+string.equals("afgfdddddef") );

System.out.println( "判断两个字符串是否相等(忽略大小写)"+string.equalsIgnoreCase(new String("abc")) );

/* 

* 2.4 转换方法

*

* String( char[] value ) 将字符数组转换为字符串

* String( char[] value, int offset,int count )  将字符数组的某个范围转换为字符串

* char[] toCharArray()     字符串转换为字符数组

* 

* String( byte[] value )   byte数组 转 字符串

* String( byte )  

* byte[] getBytes()        字符串转byte数组

*  

* static String valueOf( char[] data );    字符数组转字符串

* static String valueOf( char[] data, int offset, int count ); 字符数组转字符串

* 

* 

* 

* */

/* 字符数组 转 字符串 */

String str = new String( new char[]{'h','e','l','l','o'} );

System.out.println( str );

/* 字符串 转 字符数组 */

char[] chs =str.toCharArray();

System.out.println( Arrays.toString(chs) );

/* 字符串 转 byte[] */

byte[] bytes =str.getBytes();

System.out.println( Arrays.toString(bytes) );

/* byte[] 转 字符串 */

System.out.println( new String(bytes) );

System.out.println( new String( bytes, 2, 3 ) );

/* 2.5 其他方法

*  

* 注意: 

*     下面的方法涉及到字符串内容的替代，但是java中的字符串是常量，内容不会被替换；

*    能实现替换，截取等功能，是通过生成新的字符串并且返回来实现的；String对象中内容不改变；

*      

* String   subString( int beginIndex );   截取字符串

* String   subString( int beginIndex,int endIndex ); 截取字符串

* 

* String   replace( char oldChar, char newChar )   替换

* String[] split( String regex );  切割 

* String   trim();  去除字符串首尾空格

* 

* String toUpperCase()  字符串所有字母转大写

* String toLowerCase()  字符串所有字母转小写

* 

**/

System.out.println( "截取子串到末尾:"+string.substring( 1 ) );

System.out.println( "截取子串:"+string.substring(3, 5) ); /* startIndex, endIndex 包头不包尾 */

System.out.println( "转换字母到大写:"+string.toUpperCase() );

System.out.println( "转换字母到小写:"+string.toLowerCase() );

 

System.out.println("字符串替换(先匹配字串，然后替换):"+string.replace("13r","    12345") );

System.out.println( "字符串切割:"+Arrays.toString(string.split("ddhk")) );

System.out.println( "去除首尾空格:"+string.trim() );

  }

}

//trim实现

String s = "  ddff  fff  fff  fff  ffff    ";

int start = 0;

int end   = s.length()-1;

for( int i=0; i<s.length(); i++ ){

if( s.charAt(i)  != ' ' ){

break;

}

start++;

}

for( int i=s.length()-1; i>0;  i-- ){

if( s.charAt(i) != ' ' ){

break;

}

end--;

}

System.out.println(start+"  "+end+"  \n"+  s.substring(start, end) );

//截取文件名字:

String s1 = "D:\\20120512\\day12\\Demo1.java";

String[] arr = s1.split("\\\\");

System.out.println( arr[arr.length-1] );

//将字符串对象中存储的字符反序:

char[] chs = s1.toCharArray();

int start1 = 0;

int end1   = chs.length-1;

while( start1 < end1 ){

char temp = chs[start1];

chs[start1] = chs[end1];

chs[end1] = temp;

 

start1++;

end1--;

}

System.out.println( new String(chs) );

//记录子串出现的次数

int count1 = 0;

int index = -1;

while( (index=s1.indexOf("12")) != -1 ){

s1 = s1.substring( index + "12".length() ); //去掉已经被查询过的子串；

count1++;

}

System.out.println( "count:"+count1 );

/* StringBuffer

 * 

 * StringBuffer: 由于String是不可变的，所以导致String对象泛滥，在频繁改变字符串对象的应用中，需要使用可变的字符串缓冲区类。

 * 

 * 特点:

 * (1) 默认缓冲区的容量是16

 *  (2) StringBuffer:  线程安全的所有的缓冲区 操作方法都是同步的； 效率底下；

 * 

 * 

 * 常用操作方法;

 * 

 * 1. 添加方法  append();

 * StringBuffer( "jack" );  //可以使用int, string, charSequence作为参数来初始化StringBuffer;

 * append();     在缓冲区的尾部添加新的文本对象;（支持基础数据，任意对象的追加，都会被转化为charSequence后追加）

 * insert();     在指定的下标位置添加新的文本对象；( 支持基础数据，任意对象的追加 )

 * 

 * */

StringBuffer sb = new StringBuffer("jack");

sb.append(true);

sb.append('a');

sb.append(97).append(34.0).append( new char[]{'o','o'} );

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

sb = new StringBuffer( "jack" );

sb.insert( 2, "java" );  //插入位置， 插入内容

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

  /*

   *2. 查看 

   * toString()  返回这个容器的字符串

   * indexOf( String str );  返回第一次出现的制定字符串在该字符序列中的索引；

   * lastIndexOf( String str );

   *    subString( int  start );  从开始的位置开始截取字符串；

   * */

/*

* 3.修改

*  replace( int start, int end, String str )   //替换子串

* 

*   setCharAt( int index, char ch )  //替换字符

* */

/*

* 4.删除

*  delete( int start, int end )  //删除子串   delete(0, sb.length()) 清空缓冲区

* 

*  deleteCharAt( int index )  //删除序列中的指定字符

* */

/*

* 5.反序

* reverse(); 把字符串反序输出

* */

//StringBuilder  ( 增 删  改  查 )

/*  |-- CharSequence ( 接口 )

 *     

 *       |--- String    

 *  

 *  |--- AbstractStringBuilder

 * 

 * |--- StringBuffer

 * 

 * |--- StringBuilder

 * 

 * 

 * 结构图上显示:   stringBuffer,StringBuilder属于同级关系， 且并不是继承自String类；

 * 

 * CharSequence接口的方法:

 * 1. int length();      字符序列的长度；

 * 2. char charAt( int index );  获取字符串指定位置的字符

 *  3. CharSequence subSequence( int start, int end );  截取字串

 *  4. String toString();  转换成字符串  

 *  

 *  

 *  

 *  

 * 基础概念:

 *  String: 此类代表字符串常量，它们的值在创建之后就无法再修改；只能通过生成新的字串来完成替换，截取等功能;

 * 

 *   StringBuffer: 是一个线程安全的可变字符序列，与String一样，在内存中保存的都是一个有序的字符串序列； 但是StringBuffer中字符内容可以变；

 *   

 *   StringBuilder: 与StringBuffer类相同，都是可变字符串系列, 不过StringBuilder是线程不安全的;

 *   

 *   

 *

 * 分析:

 * (1)   简单的说: String类型和 StringBuffer，StringBuilder类型的主要性能区别在于String是不可变的对象；

 * String类型每次进行改变的时候，其实都等同于生成了一个新的String对象，然后将指针指向新的String对象。所以频繁

 *      改变内容的字符串最好不要使用String, 每次出现字符串常量中不存在的字符串时，都会创建一份，且一直无法销毁;

 *  当然: 编译器也会将同一个表达式中的连续+链接的字符串常量优化成为一个字符串; 

 *   

 *   

 *  (2)   对StringBuilder类型进行修改时，就是对其对象本身进行改变，而不会产生新的对象，一般推荐使用StringBuilder;

 * 

 *  

 *  (3)  StringBuffer在程序中可将字符串缓冲区安全地用于多线程，而且在必要时可以对这些方法进行同步。在多线程情形，且该变量

 *      被多个子线程共享，且该Stringbuffer内容可能被修改的情况喜爱， 可以考虑使用StringBuffer对象来保存字符序列;

 *      

 *      

 *      

 *      

 *   

 *      

 * equal( charSequence ) 与 ==    

 * 

 * (1) String, StringBuffer, StringBuilder都是对象类型，所以==只能比较对象的地址;

 * 

 *  (2) equals( charSequence ) 默认也是比较地址；但是在String,StringBuffer,StringBuilder中被重写，比较的是字符序列；

 *  

 *

 * */

/* charSequence源码

 * 

 * package java.lang

 * public interface CharSequence {

 * 

 * 返回字符序列的长度:

 * int length();  

 * 

 * 返回指定索引的char值:

 * char charAt( int index );

 * 

 * 返回该序列的子序列

 * (startIndex, endIndex)  包头不包尾

 * CharSequence subSequence( int start, int end );

 * 

 * 返回一个包含该序列中字符的字符串，该字符串与序列的顺序相同

 * public String toString();

 * }

 *  

 *  

 *  

 *  

 *  

 *  StringBuilder源码

 *  

 *  package java.lang

 *  

 *  public final class StringBuilder extends AbstractStringBuilder

 *  implements  java.io.Serializable, CharSequence

 *  {

 *  

 *  static final long serialVersionUUID = 4383685877147921099L;

 *  

 * //四种初始化构造器

 *  

 *  不带任何参数的构造器:

 *  public StringBuilder() { super(16) }

 *  

 *  

 *  指定初始容量的构造器:  参数不能为负数，否则会抛出异常NegativeArraySizeException

 *  public StringBuilder( int capacity ){

 *  super(capacity);

 *  }

 *  

 *  

 *  参数为String对象的 构造器, 其初始容量为指定字符串的长度 + 16字节 ( 参数不能为null,否则抛出异常NULLPointerException )

 *  public StringBuilder( String str ){

 *  super( str.length() + 16 );

 *  append(str);

 *  }

 *  

 *  参数为charSequence的 构造器, 初始容量为 字符序列长度 + 16字节

 *  public StringBuilder( CharSequence seq ){

 *  

 *  this(seq.length() + 16);

 *  append(seq);

 *  }

 *  

 *  

 *  

 *  

 *  

 *  //各种类型数据的追加

 *  

 *  

 *  Object类型参数append， 会调用Object中的valueOf()获取对应的String值;

 *  public StringBuilder append( Object obj ){

 *  

 *  return append( String.valueOf(obj) );

 *  }

 *  

 *  

 *  String类型参数append, ( 如果参数为null, 那么追加"null"字符串 )

 *  public StringBuilder append( String str ){

 *  

 *  super.append( str );

 *  return this;

 *  }

 *  

 *  

 *  StringBuilder类型参数append  (如果参数为null,那么追加"null"字符串)

 *      public StringBuilder append( CharSequence s ){

 *      

 *      if( s == null ){

 *      s = "null";

 *      }

 *      

 *      if( s instanceof String ){

 *      return this.append( (String)s );

 *      }

 *      

 *      if( s instanceof StringBuffer ){

 *      return this.append( (StringBuffer)s );

 *      }

 *      

 *      if( s instanceof StringBuilder ){

 *      return this.append( (StringBuilder)s );

 *      }

 *      

 *      return this.append( s, 0, s.length );

 *      }

 *  

 *  

 *  public StringBuilder append( CharSequence s, int start, int end ){

 *  

 *  super.append( s, start, end );

 *  return this;

 *  }

 *  

 *  

 *  字符序列参数append:

 *  public StringBuilder append( char[] str ){

 *  

 *  super.append( str );

 *  return this;

 *  }

 *  

 *  字符序列参数，且指定起始位置 和长度

 *  public StringBuilder append( char[] str, int offset, int len ){

 *  

 *  super.append( str, offset, len );

 *  return this;

 *  }

 *  

 *  

 *  基础类型数据的添加 ---> 先封装成对应的对象数据类型，然后调用valueOf()方法获取到字符串

 *  public StringBuilder append( boolean b ) {

 *  super.append(b);

 *  return this; 

 *  }

 *  

 *  

 *  

 *  

 *  

 *  //删除子串序列  ( startIndex, endIndex ) 包头不包尾  ( 删除子串 )

 *  public StringBuilder delete( int start, int end ){

 *  super.delete( start, end );

 *  return this;

 *  }

 *  

 *  

//删除序列中指定位置上的字符 （ 删除字符 ）

public StringBuilder deleteCharAt( int index ){

super.deleteCharAt( index );

return this;

}

 *  

 *  

 *  

 *  //使用给定的子串，替换序列中的子串； ( startIndex, endIndex )包头不包尾

 *  public StringBuilder replace( int start, int end , String str  ){

 *  

 *  super.replace( start, end, str );

 *  return this;

 *  }

 *  

 *  

 *  

 *  

 *  

 *  

 *  

 *  

 *  //插入

 * //1. 插入字符数组

 * public StringBuilder insert( int index, char[] str, int offset, int len ){

 * 

 * super.insert( index, str, offset, len );

 * } 

 * 

 * public StringBuilder insert( int offset, char[] str ){

 * 

 * super.insert( offset, str );

 * }

 * 

 *  

 *  //2. 插入对象

 *  public StringBuilder insert( int offset, Object obj ){

 *  return  insert( offset, String.valueOf(obj) );

 *  }

 *  

 *  //3. 字符串插入

 *  public StringBuilder insert( int offset, String str ){

 *  

 *  super.insert( offset, str );

 *  return this;

 *  }

 *  

 *  

 *   //4. 插入字符序列,  将整个序列插入

 *   public StringBuilder insert( int dstOffset, CharSequence s ){

 *   

 *   if( s==null ){

 *   s = "null";

 *   }

 *   

 *   if( s instanceof String ){

 *   return this.insert( dstOffset, (String)s );

 *   }

 *   

 *   return this.insert( dstOffset, s, 0, s.length ); 

 *   }

 *   

 *   

 *   //5. 将字符序列 的子序列插入此序列中

 *   public StringBuilder insert( int dstOffset, CharSequence s, int start, int end ){

 *   

 *   super.insert( dstOffset, s, start, end );

 *   return this;

 *   }

 *   

 *   

 *   //6. 插入基础数据， 转为封装类,然后通过valueOf(...),转化成字符串，然后insert

 *   public StringBuilder insert( int dstOffset, boolean b ){

 *   super.insert( dstOffset, b );

 *   return this;

 *   }

 *   ......

 *   

 *   

 *   

 *   

 *   

 *   

 *   查询某个子串在序列中的位置  indexOf, lastIndexOf

 *   public int indexOf( String str ){

 *   return indexOf(str, 0);

 *   }

 *   

 *   public int indexOf( String str, int fromIndex ){

 *   return String.indexOf( value, 0, count, str.toCharArray(), 0, str.length(), fromIndex );

 *   }

 *   

 *   public int lastIndexOf( String str ){

 *   

 *   return  lastIndexOf( str, count );

 *   }

 *   

 *   public int lastIndexOf( String str, int fromIndex ){

 *   

 *   return String.lastIndexOf( value, 0, count, str.toCharArray(), 0, str.length(), fromIndex );

 *   }

 *   

 *   

 *   

 *   

 * //reverse

 * public StringBuilder reverse(){

 * super.reverse();

 * return this;

 * }

 *   

 *   

 *  //返回字符串

 *  public String toString(){

 *  return new String( value, 0, count );

 *  } 

 *   

 *   

 *   

 *  }

 *  

 *  

 *  

 *  

 *  

 *  

 *  */