概述了所有string的方法，相当实用（转）

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拼成一个新的字符串.
*/


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


*/

1_StringDemo1

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);
}
}

Trime

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.简化书写
*/

StringBuffer

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
}
}

IntegerDemo





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:
将该参数转换为有符号的十进制表示形式，并以字符串的形式返回它
最终转换成字符串
*/