黑马程序员java基础之字符串

------- android培训、java培训、期待与您交流！ ---------

String 类是最终类，没有类

字符串最大特点：一旦被初始化，不会再改变

class StringDemo {public static void main(String[] args) {String s="abc";//s是一个类类型变量，“abc”是一个对象String s1=new String("abc");System.out.println(s.equals(s1));<span style="white-space:pre"></span>System.out.println(s1==s);}}

执行结果是：

true

false

因为s指向的是“abc”对象，而s1指向了一个新的字符串对像，所以s==s1是false，这个比较的是字符串内存地址值

而字符串复写了Object的equals方法，比较两个字符串的内容是否相同

对于上面，s代表1个对象，s1有两个对象（new就新建一个对象，而“abc”又是一个字符串对象）

class StringDemo {public static void main(String[] args) {String s="abc";//s是一个类类型变量，“abc”是一个对象String s1=new String("abc");String s2="abc";System.out.println(s.equals(s1));System.out.println(s1==s);Systetm.out.println(s==s2);}}

执行结果是：

true

false

true

说明s2不会在开辟一片空间存储“abc”，因为其已经存在了，所以s2也指向了"abc"，所以s==s3

字符串的常见操作

1.获取：

获取字符串中字符的个数，即字符串的长度 ：int length();

根据位置获取位置上的某个字符：char  charAt(int index);

根据字符获取字符在字符串中的位置：int   indexOf(int  ch);()里面是字符对应的ASC码，所以是Int类型的，返回的是第一次出现字符的位置

int  indexOf(int ch,int fromIndex)获取从指定位置fromIndex开始出现的字符位置

int indexOf(String str)获取字符串中首次出现str的位置

int indexOf(String str,int fromIndex)获取str在字符串从指定索引处fromIndex处开始出现的位置

class StringDemo {public static void main(String[] args) {String s="abc";//s是一个类类型变量，“abc”是一个对象String s1=new String("abc");String s2="abc";method_get();System.out.println(s.equals(s1));System.out.println(s1==s);System.out.println(s==s2);}public static void method_get(){String str="abcdegha";//长度sop(str.length());//此处可以将int型的基本数据类型作为Object对象传入，是因为JDK1.5版本之后出现的新特性：基本数据类型的提升，装箱//根据索引获取字符sop(str.charAt(3));//根据字符获取索引，如果没有，返回-1sop(str.indexOf('a',3));//反向索引一个字符出现位置,从后面开始找，但是角标不会变sop(str.lastIndexOf('a'));}public static void sop(Object obj){System.out.println(obj);}}

2判断：

字符串中是否包含某个子串:boolean contains(str)

因为indexOf(str)，如果str不存在于字符串中，那么就返回-1，所以此方法也可以用于判断是否包含某字符串：if(str.indexOf("abc")  !=-1),此方法不止可以判断，还可以获取角标

字符串中是否有内容:boolean isEmpty()注意，此方法在jdk1.6之后出现原理就是判断长度是否为0

字符串是否以指定内容开头:boolean startWith(str);

字符串是否以指定内容结尾 :boolean endsWith(str);

判断字符串的内容是否相同：boolean equals(str);

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

class StringDemo {public static void main(String[] args) {String s="abc";//s是一个类类型变量，“abc”是一个对象String s1=new String("abc");String s2="abc";method_get();method_if();}public static void method_if(){String str="StringDemo.java";//判断字符串是否以“String”开头sop(str.startsWith("String"));//判断字符串是否以“.java”结束sop(str.endsWith(".java"));//判断字符串中是否包含“Demo”sop(str.contains("Demo"));}public static void method_get(){String str="abcdegha";//长度sop(str.length());//此处可以将int型的基本数据类型作为Object对象传入，是因为JDK1.5版本之后出现的新特性：基本数据类型的提升，装箱//根据索引获取字符sop(str.charAt(3));//根据字符获取索引，如果没有，返回-1sop(str.indexOf('a',3));//反向索引一个字符出现位置,从后面开始找，但是角标不会变sop(str.lastIndexOf('a'));}public static void sop(Object obj){System.out.println(obj);}}

3.转换

将字符数组转为字符串：

构造函数：String(char[ ])

String(char [ ],int offset,int count):将字符数组中的一部分转换为字符串，offset表示偏移量，count表示要转换的字符个数

static  String :valueCopyOf(char[])

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

static StringvalueOf(char[])

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

将字符串转为字符数组：

char[]: toCharArray(),括号中的对象就是字符串，相当于省略了this

将字节数组转为字符串：

String(byte[])

String(byte[],int offset,int count)

将字符串转为字节数组：

byte[]  getBytes()

将基本数据类型转为字符串：

static String:valueOf(int)3+" ",String.valueOf(3)，这两种都是将数字3转换为字符串

static String  valueOf(double)

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

注意：字符串和字节数组在转换过程中可以指定编码表

class StringDemo {public static void main(String[] args) {String s="abc";//s是一个类类型变量，“abc”是一个对象String s1=new String("abc");String s2="abc";method_get();method_if();method_change();}public static void method_change(){String str="abcde";char[] ch={'h','e','l','l','o','y','o','u'};//通过构造函数转换字符数组为字符串String s=new String(ch);String s1=new String(ch,5,3);//转换字符数组中的指定的一些字符char[] c=str.toCharArray();for(int x=0;x<c.length;x++){System.out.println(c[x]);}sop(s);sop(s1);}public static void method_if(){String str="StringDemo.java";//判断字符串是否以“String”开头sop(str.startsWith("String"));//判断字符串是否以“.java”结束sop(str.endsWith(".java"));//判断字符串中是否包含“Demo”sop(str.contains("Demo"));}public static void method_get(){String str="abcdegha";//长度sop(str.length());//此处可以将int型的基本数据类型作为Object对象传入，是因为JDK1.5版本之后出现的新特性：基本数据类型的提升，装箱//根据索引获取字符sop(str.charAt(3));//根据字符获取索引，如果没有，返回-1sop(str.indexOf('a',3));//反向索引一个字符出现位置,从后面开始找，但是角标不会变sop(str.lastIndexOf('a'));}public static void sop(Object obj){System.out.println(obj);}}

4.替换

Stringnreplace(oldchar,newchar)将字符串中的某个字符oldchar替换为newchar

5.切割

String[] split(regex)将字符串按照一定的规则切割形成字符串数组

6.子串

String substring(int begin);//获取字符串中的子串,从索引begin处开始到结束

String substring(int begin,int end)//获取字符串中指定的子串，包含头begin不包含尾end
7.去除空格，比较

将字符串转换成大写或小写

String toUpperCase()

String toLowerCase()

将字符串两端的多个空格去掉

String trim()

对两个字符串进行自然顺序的比较

int compareTo(String)

str1.compareTo(str2):如果字符串按照字典顺序，str1要大于str2，则返回正数，如果小于则返回负数，注意是按照字符串中的字符顺序比较的，如果已经比较出来了，后面的字符不再参与比较

字符串练习：

1.模拟一个字符串的trim方法，去除字符串两端的空格

思路：建立两个头尾指针，分别从头尾开始检测，当遇到了空格，指针进行自增自减，最后获取两个指针之间的内容，就是去除了两端空格的字符串

class StringTest1 {public static void main(String[] args) {String str="     mytrim    ";System.out.println(str);System.out.println(mytrim(str));}public static String mytrim(String str){int sta=0,end=str.length()-1;//建立两个标志位，分别从头尾开始，while(sta<=end && str.charAt(sta)==' ')//检测到了头部有空格，头部指针自增{sta++;}while(sta<=end && str.charAt(end)==' ')//检测到了尾部有空格，尾部指针自减{end--;}String s=str.substring(sta,end+1);//注意获取子串方法是包含头不包含尾，所以end需要+1来获取最后一个有效字符串return s;}}

2.将字符串中指定的内容进行反转，如：“abcde”  "adcbe"

思路：将字符串转换为字符数组，可以根据数组角标首尾交换位置，完成数组的反转，然后再将转换了的数组转换为字符串

class StringTest2 {public static void main(String[] args) {String str="abcdefg";System.out.println(ReverseString(str,2,4));}public static String ReverseString(String str,int sta,int end)//完成字符串反转的功能{//将字符串转换成字符数组char[] ch=str.toCharArray();//对数组进行反转reverse(ch,sta,end);//将新字符数组转换为字符串return String.valueOf(ch);}private static void reverse(char[] ch,int x,int y)//完成字符数组反转的方法{for(int sta=x,end=y-1;sta<=end;sta++,end--)//end=y-1表示包含头不包含尾{swap(ch,sta,end);}}private static void swap(char[] ch,int x,int y)//调换位置的方法{char temp=ch[x];ch[x]=ch[y];ch[y]=temp;}}

练习3：获取一个字符串在另一个字符串中出现的位置

思路：既要判断字符串是否存在于母字符串中，又要获取字符串在母串中的位置，使用indexOf(),使用计数器，获取一次，计数器增加一次，然后母串从获取到的位置重新找子串

class StringTest3{public static void main(String[] args) {String str="abbcdefbbhgblbb";String key="bb";System.out.println(getLocation_2(str,key));}public static int getLocation(String str,String key){int index=0;//定义初始角标int count=0;//定义计数器while((index=str.indexOf(key,index))!=-1)//当indexOf的返回值不为-1,则说明子串存在于母串中，并且同时获取到了子串在母串中的角标{str=str.substring(index+key.length());//母串不断从新的角标处开始获取System.out.println(str);count++;}return count;}public static int getLocation_2(String str,String key){int index=0;//初始化角标int count=0;//初始化计数器while((index=str.indexOf(key,index))!=-1)//使用indexOf(str,int offset)方法，不断的变换角标，当找到初始位置时，角标就从key存在于母串中之后的位置开始找{index=index+key.length();//角标位从找到子串并超越子串之后的位置查找，这样就不用在内存中不断开辟空间存取新的字符串System.out.println(index);count++;}return count;}}

练习四：获取两个字符串的最大相同子串

思路：用短的字符串和长字符串作对比，如果不相同，短的字符串长度递减，依旧和长字符串作对比，直到获取最长相同子串为止

class StringTest4{   public static void main(String[] args)   {      String s1="abcwerthelloyuiodef";      String s2="zs";      sop(getMaxSbuString(s1,s2));    }   public static String getMaxSbuString(String s1,String s2)   {   //初始化两个字符串，用于表示长短字符串   String max="";   String min="";   max=(s1.length()>s2.length())?s1:s2;//将长字符串赋给max   min=(max==s1)?s2:s1;//将短字符串赋给min   for(int x=0;x<min.length();x++)//外循环控制整个循环的次数，x=0的时候就是整个s2进行内循环   {   //定义每次与长字符串s2比较的子串的头指针y,尾指针z，注意，并不包含z,而是子串到z-1,因为z要取到s2的长度，这样才能获取到最后一个字符，所以z!=s2.length+1for(int y=0,z=min.length()-x;z!=min.length()+1;y++,z++)   {//用临时字符串变量记录每次获取的s2的子串，好用来和长字符串作比较String temp=min.substring(y,z);if(max.contains(temp))//判断s1中是否包含子串return temp;   }   }   return " ";//如果循环没有找到相同字符串，就返回空的字符串   }   public static void sop(String str){System.out.println(str);   }}

StringBuffer

StringBuffer是字符缓冲区，是一个容器,长度可变，可以直接操作多个数据类型

最终可以通过toString()方法变成字符串

在这个容器中可以存储，删除，获取，修改

存储：StringBuffer append()将指定数据添加到已有数据的结尾处

    StringBuffer insert(index,obj)在指定位置添加元素

删除：StringBuffer delete(int start,int end) //包含头不包含尾
StringBuffer deleteCharAt(index)//删除指定位置的字符

获取：

char charAt(index)获取指定位置的字符

int indexOf(String str);获取字符串在StringBuffer中的位置

int lastIndexOf(String str)反向获取str在StringBuffer中的位置

int length()获取长度

String substring(int start,int end)//获取指定位置的字符串

修改：

StringBuffer replace(int start,int end,String str)将容器中指定位置之间的数据替换成str

void  setCharAt(int index,char ch)将指定位置的字符替换成新字符ch，注意此方法没有明确的返回值，只要修改就可以了  

反转：

StringBuffer  reverse();                          

class StringBufferDemo {public static void main(String[] args) {update_method();}public static void update_method(){StringBuffer sb=new StringBuffer("abcde");sb.replace(0,3,"hello");//将容器中的指定位置间的元素替换成指定元素sop(sb.toString());sb.setCharAt(1,'o');//注意此方法没有明确的返回值，只要修改了就好了sop(sb.toString());}public static void delete_method(){StringBuffer sb=new StringBuffer("abcde");//sb.delete(0,3);//包含头不包含尾sop(sb.toString());//sb.delete(0,sb.length());//清除缓冲区sb.deleteCharAt(1);//删除指定位置的字符sop(sb.toString());}public static void add_method(){StringBuffer sb=new StringBuffer();sb.append("abc");//返回的还是StringBuffer对象sb.append(34).append(true).append('b');//方法调用链，因为返回的仍然是本类对象sop(sb.toString());sb.insert(2,"hello");//在2号角标位插入元素sop(sb.toString());}public static void sop(Object obj){System.out.println(obj);}}

JDK1.5版本之后，出现了StringBuilder,与StringBuffer功能相似，不同之处是StringBuffer是线程同步的，安全，而StringBuilder线程不同步

基本数据类型包装类

其他数据类型转换为十进制：parseInt(String,radix),radix代表要转换的进制，值为2,8,16

十进制转换为其他进制：toHexString(),toBinaryString();

class IntDemo {public static void main(String[] args) {int x=Integer.parseInt("3c",16);//将3c转换为10十进制System.out.println(x);int y=Integer.parseInt("123");//将字符串"123"转换为整数型123System.out.println(y+4);System.out.println(Integer.toHexString(12));//将10进制转换为16进制}}

JDK1.5版本之后出现了新特性，基本数据类型的自动升级，自动装箱

出现此新特性之后，Integer x=null.是成立的

class IntDemo1{public static void main(String[] args) {Integer x=4;//自动装箱，4是一个对象，但是可以直接参与运算，相当于Integer x=new Integer(4)int y=x+2;//进行自动拆箱，相当于x.intValue(x)+2,intValue()是获取int型的数Integer a=new Integer("123");Integer b=new Integer(123);System.out.println("a==b="+(a==b));//结果为false，因为是新建了两个新对象，所以不同System.out.println("a.equals(b)="+a.equals(b));//Integer复写了equals方法，比较两个对象中的数值是否相同Integer c=128;Integer d=128;System.out.println("c==d="+(c==d));//结果为false,因为相当于重建了两个对象，指向不同Integer e=127;Integer f=127;System.out.println("e==f="+(e==f));//结果为真，因为这是JDK1.5版本之后的特点，值在byte范围内，如果之前的对象存在，就不会新建对象，而指向之前的对象}}