String

String str=" abc#def g  ";


substring(  ) 截取字符串 str . subString(开始下标，结束下标（截取的字符串不包含此下标）)


split(  )分隔字符串   str . split(" #")    


contains( )  判断该字符是否存在该字符串   str . contains("#")


replace(  )将某个字符串中的字符被另一个字符替换 （替换全部）  str.replace('a','A');


trim(  ) 将一个字符串的两边的空格去掉 中间的无法去掉 str.trim( )


toUpperCase(  )将某个字符小写转换成大写  str . toUpperCase (  )


toLowerCase(  )将某个字符大写转换成小写   str . toLowerCase(  )


indexOf(  )获取指定字符的下标  str.indexOf("#") 如果没有则返回-1


str.substring(0,str.indexOf(  ));   去掉某个字符之后的字符串  包含这个字符自己


StringBuffer   




 int indexOf(String str, int fromIndex) ：从当前StringBuffer对象的fromIndex开始查找，返回第一个满足str子串的位置。


append( )拼接字符串


String substring(int start) ：取当前StringBuffer对象中，从start开始到结尾的子串。


String substring(int start, int end) ：取当前StringBuffer对象中，从start开始到end的子串。


String toString() ：将当前StringBuffer对象转换成String对象。


void setCharAt(int index, char ch) ：设置索引号index的字符为ch。


void setLength(int newLength) ：重新设置字符串缓冲区中字符串的长度，如果newLength小于当前的字符串长度，将截去多余的字符。


int capacity() ：返回当前StringBuffer对象（字符串缓冲区）的总空间，而非字符号串的长度。


char charAt(int index) ：在当前StringBuffer对象中取索引号为index的字符。第一个字符的索引为“0”


StringBuffer delete(int start, int end) ：删除当前StringBuffer对象中以索引号start开始，到end结束的子串。


StringBuffer deleteCharAt(int index) ：删除当前StringBuffer对象中索引号为index的字符。


void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) ：从当前StringBuffer对象的索引号srcBegin开始，到srcEnd结束的子串，赋值到字符数组dst中，并且从dst的索引号dstBegin开始。


int indexOf(String str) ：返回当前StringBuffer对象中，第一个满足str子串的位置。


int indexOf(String str, int fromIndex) ：从当前StringBuffer对象的fromIndex开始查找，返回第一个满足str子串的位置。

int lastIndexOf(String str) ：返回当前StringBuffer对象中，最后一个满足str子串的位置。


int lastIndexOf(String str, int fromIndex) ：从当前StringBuffer对象的fromIndex开始查找，返回最后一个满足str子串的位置


int length() ：返回当前StringBuffer对象（字符缓冲区）中，字符串的长度。注意：此方法与capacity() 不同。


StringBuffer replace(int start, int end, String str) ：替换当前StringBuffer对象的字符串。从start开始，到end结束的位置替换成str。


StringBuffer reverse() ：将字符串翻转。




String 和 StringBuffer的区别
String str="ab";
str=str+"cd";
1个String就是1个char数组   相当于创建了3个数组 分别是 ab , cd  ,  abcd
StringBuffer sb=new StringBuffer();
sb.append("ab");
sb.append("cd");
StringBuffer始终都是一个数组  


StringBuffer的长度是可变得  String的长度是不可变得


String和StringBuffer和StringBuider运行速度的比较  String最慢  StringBuider运行速度最快  


String也可以像修改对象时改变值  实例在String例子中 
他是通过改String中的 private final char value[]   不过同时也要修改 private final int count   因为更改的值得长度可能与原来的长度不相等




字符串的方法
下面是字符串列表的方法：
方法 描述
char charAt(int index) 返回指定索引处的字符
int compareTo(Object o) 该字符串的另一个对象比较
int compareTo(String anotherString) 字典顺序比较两个字符串
int compareToIgnoreCase(String str) 按字典顺序比较两个字符串，忽略大小写差异
String concat(String str) 将指定字符串添加到该字符串的结尾处
boolean contentEquals(StringBuffer sb) 当且仅当此String表示字符与指定StringBuffer的顺序相同时返回true
static String copyValueOf(char[] data) 返回表示所指定的数组中的字符序列的字符串
static String copyValueOf(char[] data, int offset, int count) 返回表示所指定的数组中的字符序列的字符串
boolean endsWith(String suffix) 测试此字符串是否以指定的后缀结束
boolean equals(Object anObject) 比较此字符串指定的对象
boolean equalsIgnoreCase(String anotherString) 这个字符串与另一个字符串比较，不考虑大小写
byte getBytes() 将此String使用平台默认的字符集的字节序列解码，并将结果存储到一个新的字节数组
byte[] getBytes(String charsetName) 将此String使用指定字符集的字节序列解码，并将结果存储到一个新的字节数组
void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) 将这个字符串的字符复制到目标字符数组
int hashCode() 返回此字符串的哈希码
int indexOf(int ch) 返回此字符串指定字符第一次出现处的索引
int indexOf(int ch, int fromIndex) 返回此字符串指定字符，从指定索引的搜索中第一次出现处的索引
int indexOf(String str) 返回此字符串的指定子第一次出现处的索引
int indexOf(String str, int fromIndex) 返回此字符串的指定从指定索引处的子字符串第一次出现的索引
String intern() 返回字符串对象规范表示形式
int lastIndexOf(int ch) 返回此字符串指定字符最后一次出现处的索引
int lastIndexOf(int ch, int fromIndex) 返回此字符串指定字符最后一次出现处的索引，从指定索引处开始向后搜索
int lastIndexOf(String str) 返回此字符串指定子最右边出现处的索引
int lastIndexOf(String str, int fromIndex) 返回此字符串的指定子最后一次出现处的索引，指定索引处向后开始搜索
int length() 返回此字符串的长度
boolean matches(String regex) 判断此字符串是否与给定的正则表达式匹配。
boolean regionMatches(boolean ignoreCase, int toffset, String other, int ooffset, int len) 检测两个字符串区域是否是相等的
boolean regionMatches(int toffset, String other, int ooffset, int len) 检测两个字符串区域是否是相等的
String replace(char oldChar, char newChar) 返回从此字符串中使用newChar替换oldChar所有出现的字符串
String replaceAll(String regex, String replacement) 这个替换字符串使用给定的正则表达式匹配并替换每个子字符串
String replaceFirst(String regex, String replacement) 这个替换字符串使用给定的正则表达式匹配替换第一个字符串
String[] split(String regex) 围绕给定的正则表达式的匹配来拆分此字符串
String[] split(String regex, int limit) 围绕给定的正则表达式的匹配来拆分此字符串
boolean startsWith(String prefix) 测试此字符串是否以指定的前缀开始
boolean startsWith(String prefix, int toffset) 检测此字符串是否从指定索引开始以指定前缀开始
CharSequence subSequence(int beginIndex, int endIndex) 返回一个新的字符序列，它是此序列的子序列
String substring(int beginIndex) 返回一个新字符串，它是此字符串的子串
String substring(int beginIndex, int endIndex) 返回一个新字符串，它是此字符串的子串
char[] toCharArray() 这个字符串转换为一个新的字符数组
String toLowerCase() 将所有在这个字符串中的字符的使用默认语言环境的规则转为小写
String toLowerCase(Locale locale) 将所有在这个字符串中的字符使用给定Locale的规则转为小写
String toString() 这个对象(这已经是一个字符串！)本身返回。
String toUpperCase() 所有的字符在这个字符串使用默认语言环境的规则转换为大写。
String toUpperCase(Locale locale) 所有的字符在这个字符串使用给定的Locale规则转换为大写
String trim() 返回字符串的副本，开头和结尾的空白省略

static String valueOf(primitive data type x) 返回传递的数据类型参数的字符串表示

代码测试

/**测试String的replace
* 将某个字符串中的指定字符改为某个字符*/
public static void replace(){
String str="adsweqasdada";
String str2 = str.replace('a','A');
System.out.println(str2);
//结果 AdsweqAsdAdA
}
/**测试String的contains()方法
* 判断某个字符存在该字符串中*/
public static void testContains(){
String s1="abcdefgh";
String s2="def";
System.out.println(s1.contains(s2));
//结果 true
} 
/**测试String的trim()方法
* 去掉俩边的空格 中间的去不掉
* */
public static void testTrim(){
String str=" a b c d e f ";
System.out.println(str.trim());
//结果a b c d e f
}
/**第一个字母大写*/
public static void setIdString(){
 String id = "abcde";
 String mehodStr = null;
 if(id!=null){
  char oldChar = id.charAt(0);
  char newChar = (oldChar + "").toUpperCase().charAt(0);
  mehodStr = id.replace(oldChar, newChar);
 }
 System.out.println(mehodStr);
 //Abcde
}

/**全部大写*/ 
public static void daXie(){
String id="abcdef";
String str=id.toUpperCase();
System.out.println(str);
//ABCDEF
}
/**全部小写*/
public static void xiaoXie(){
String id="ABCDEF";
String str=id.toLowerCase();
System.out.println(str);
//abcdef
}
/**测试去掉指定字符后的字符串*/
public static void delete(){
String str="abcdefghijk;//";
if(str.indexOf("/")==-1){
return;
}
String str1=str.substring(0,str.indexOf("/"));
System.out.println(str1);
//abcdefghijk;
}




StringBuffer
//替换某个字符  下标从0开始    
public static void testStringBuffer(){
StringBuffer sb=new StringBuffer("abcdefg");
sb.setCharAt(2, '#');
System.out.println(sb); 
//结果    ab#defg
} 
修改字符串的长度  
public static void testStringBuffer(){
StringBuffer sb=new StringBuffer("abcdefg");
sb.setLength(5);     abcde
sb.setLength(10);   abcdefg
System.out.println(sb);
//结果  abcde 
}
获取指定下标的字符
public static void testStringBuffer(){
StringBuffer sb=new StringBuffer("abcdefg");
System.out.println(sb.charAt(2));     //
//结果    c
}
删除指定区域的字符  开始下标  结束下标 （不包含）
public static void testStringBuffer(){
StringBuffer sb=new StringBuffer("abcdefg");
StringBuffer str=sb.delete(2, 4);
System.out.println(str.toString());    
//结果    abefg
}
删除指定下标的字符
public static void testStringBuffer(){
StringBuffer sb=new StringBuffer("abcdefg");
StringBuffer str=sb.deleteCharAt(4);
System.out.println(str.toString());      
//结果    abcdfg
}
从字符中截取一段字符放入数组中 
public static void testStringBuffer(){
StringBuffer sb=new StringBuffer("abcdefg");
char [] c=new char[10];
sb.getChars(1, 4, c, 2);  （开始下标    结束下标   数组名   数组下标）
for (int i = 0; i < c.length; i++) {
System.out.println(c[i]);        
}   
//结果    bcd
}
将stringBufer 的字符顺序调换过来
public static void testStringBuffer(){
StringBuffer sb=new StringBuffer("abcdefg");
StringBuffer str=sb.reverse();
System.out.println(str.toString());
//结果     gfedcba
}

String     StringBuffer     StringBuider运行速度比较

public static void main(String[] args) {
// testStringBuffer(); //100000  5毫秒
// testStringBuilder(); //100000  4毫秒
testString(); //10000  140毫秒
}
测试StringBuffer
public static void testStringBuffer(){
StringBuffer sb=new StringBuffer();
long time1=System.currentTimeMillis();
for (int i = 0; i < 100000; i++) {
sb.append(i);
}
System.out.println(System.currentTimeMillis()-time1);
//结果    100000  5毫秒
}
测试StringBuider
public static void testStringBuilder(){
StringBuilder sb=new StringBuilder();
long time1=System.currentTimeMillis();
for (int i = 0; i < 100000; i++) {
sb.append(i);
}
System.out.println(System.currentTimeMillis()-time1);
//结果    100000  4毫秒
}
测试String
public static void testString(){
String str=new String();
long time1=System.currentTimeMillis();
for (int i = 0; i < 10000; i++) {
str=str+i;
}
System.out.println(System.currentTimeMillis()-time1);
//结果    10000  140毫秒
}


修改String的值 可以同时修改2个String
public static void testString2() throws Exception{
String str1="abcd";
String str2=str1;
//改变String的长度
Field count = String.class.getDeclaredField("count");
count.setAccessible(true);     //需要改变内部状态成mutable.
count.set(str1, 6);
//改变String的值
Field f = str1.getClass().getDeclaredField("value");
f.setAccessible(true);     //需要改变内部状态成mutable.
f.set(str1, new char[]{'b','c','e','f','g','a'});

System.out.println(str1);
System.out.println(str2);
//结果     bcefga
//结果     bcefga
}




判断String  StringBuffer   StringBuider 的运行速度
public static void testStringBuffer(){
StringBuffer sb=new StringBuffer();
long time1=System.currentTimeMillis();
for (int i = 0; i < 100000; i++) {
sb.append(i);
}
System.out.println(System.currentTimeMillis()-time1);//100000  5毫秒
}
public static void testStringBuilder(){
StringBuilder sb=new StringBuilder();
long time1=System.currentTimeMillis();
for (int i = 0; i < 100000; i++) {
sb.append(i);
}
System.out.println(System.currentTimeMillis()-time1);//100000  4毫秒
}
public static void testString(){
String str=new String();
long time1=System.currentTimeMillis();
for (int i = 0; i < 10000; i++) {
str=str+i;
}
System.out.println(System.currentTimeMillis()-time1); //10000  140毫秒
}