String类

1. String类

        1.概述

         String是一个特殊的类，一旦被初始化，那么就不能被改变，String类是一个被final修饰的类。

       2.String的初始化

          String s1=”abc”;这个表示的是一个对象，但是不是在内存中创建的，而是在内存的缓冲区(常量池)中创建了一个“abc”对象，只有通过new关键字创建的，才在堆中申请了内存空间，并且在栈中有声明的变量名称。

    当有Strings1=”abc”,String s2=”abc”;都执行的话，当执行了s1后，会在内存的缓冲区(常量池)中创建了”abc”字符串对象，然后在执行s2的时候，那么先去内存缓冲区查找，要是存在了，那么就直接指向此对象，直接使用，所以，这两句话也就纯创建了一个”abc”字符串。

    String str=new String(“xyz”);这是创建了两个对象，一个是先在内存中通过new创建了一个对象，然后在内存缓冲区中又创建了一个字符串“xyz”，然后在内存中的指向了内存缓冲区(常量池)中的对象。

 

   在常量池中只有一个相等的字符串，但是在内存中可以有多个相等的字符串。

 

       3.一道面试题

           String str=new String(“xyz”);此语句产生几个对象，

           如果常量池中已经有“xyz”字符串的话，那么就产生一个对象，要是常量池中没有”xyz”，那么就产生两个对象，一个是咋内存中，一个是在常量池中（内存缓冲区）

    

2. 字符串比较

           有两种比较方法：==和equals。

      ==：比较的是内存地址，equals比较的内容

 

    

[java] view plaincopy

1. public class Text {  

2. public static void main(String[] args) {  

3.   String s1 = "abc";  

4.   String s2 = "abc";  

5.   String str1 = new String("abc");  

6.   String str2 = new String("abc");  

7.   System.out.println(s1 == s2);// true 地址相等  

8.   System.out.println(s1.equals(s2));// true 内容相同  

9.   System.out.println(str1 == str2);// false 地址不相等  

10.   System.out.println(str1.equals(str2));// true 内容相同  

11.   System.out.println(s1 == str2);// false 地址不相等  

12.   System.out.println(s1.equals(str2));// true 内容相同  

13. }  

 

3. 获取

     下面举了一些常用的方法，这些方法还有很多重载的，小想查看全面的，请查看API文档 java.lang.String包，里面方法很全

  

[java] view plaincopy

1. public class getString {  

2.   public static void main(String[] args) {  

3.     String str = "abcdasdfgh";  

4.     // 获取长度  

5.     System.out.println(str.length());  

6.     // 通过位置获取字符  

7.     System.out.println(str.charAt(3));  

8.    

9.     // 通过字符获取位置  

10.     System.out.println(str.indexOf('d'));// 从首位置开始查找，第一个字符d  

11.     System.out.println(str.indexOf('d', 5));// 从位置5开始查找，遇到的第一个字符d  

12.     // 获取子字符串的位置  

13.     System.out.println(str.indexOf("asd"));// 获取字符串asd在str中的位置  

14.   }  

15.    

16. }  

17. 结果：  

18. 10  

19. d  

20. 3  

21. 6  

22. 4  

 

 

4. 判断

下面举了一些常用的判断方法，还有很多重载和其他的方法都不一一举例了，有疑问参考API文档

 

[java] view plaincopy

1. public class judgeString {  

2.   public static void main(String[] agrs) {  

3.     String str = "zhangsan.java";  

4.     // 判断字符串是否为空  

5.     System.out.println(str.isEmpty());// false  

6.     // 判断字符串是否包含某内容  

7.     System.out.println(str.contains("."));// true  

8.     // 判断字符串是否是以指定前缀开始  

9.     System.out.println(str.startsWith("zhang"));// true  

10.     // 判断字符串是否是以指定后缀结束  

11.     System.out.println(str.endsWith(".java"));// true  

12.   }  

13. }  

14.    

 

5. 转换

      1.将字符数组转换成字符串

    构造函数：String(char [] values); String(char []values,start,end);将一部分字符数组转换成字符串

        Static String copyValuesof(char [] );

      2.将字符串转换成字符数组

     toChatArray();

      3.将字节数组转换成字符换

             String(byte [] ); String(byte []values,start,end);

      4.将字符串转换成字节数组

    getBytes();

      5.将基本数据类型转换成字符串

     valuesOf(int  a);

 

[java] view plaincopy

1. public class ZhuanString {  

2.   public static void main(String[] args) {  

3.     String str="abcdef";  

4.         char [] cs={'h','e','l','l','o'};  

5.         //将字符串转换成字符数组  

6.          char [] newcs=str.toCharArray();  

7.         //将字符数组转换成字符串  

8.          System.out.println(new String(cs));  

9.          //将字符串转换成字节数组  

10.          byte [] bs=str.getBytes();  

11.          //将字节数组转换成字符串  

12.          System.out.println(new String(bs));  

13.          //将基本数据类型转换成字符串  

14.          System.out.println(String.valueOf(4));  

15.   }  

16.    

17. }  

 

 

 

6. 分割,替换,截取

   

    

[java] view plaincopy

1.  public class Text {  

2.   public static void main(String[] args) {  

3.     String str="zhangsan,lisi,wangwu";  

4.     //分割  

5.     String [] ss=str.split(",");  

6.     for(String t:ss)  

7.       System.out.print(t+" ");  

8.     //替换  

9.     String s=str.replace('w', 'y');  

10.     String s1=str.replace("zhangsan", "sa");  

11.     //截取  

12.     String s3=str.substring(4);  

13.     String s4=str.substring(2,8);  

14.      

15.     System.out.println("\ns="+s);  

16.     System.out.println("s1="+s1);  

17.     System.out.println("s3="+s3);  

18.     System.out.println("s4="+s4);  

19.   }  

20. }  

21.    

22. 结果：  

23.    

24. zhangsanlisi wangwu  

25. s=zhangsan,lisi,yangyu  

26. s1=sa,lisi,wangwu  

27. s3=gsan,lisi,wangwu  

28. s4=angsan  

 

 

7.去除空格,大小写转换，比较

    

[java] view plaincopy

1.  public class Text {  

2.   public static void main(String[] args) {  

3.     String str="  abc ";  

4.     //取出两边空格  

5.     String  s1=str.trim();  

6.     //大小写转换  

7.     String s2=s1.toUpperCase();//转换成大写  

8.     String s3=s2.toLowerCase();//转换成小写  

9.     //比较  

10.        

11.     System.out.println("s1="+s1);  

12.     System.out.println("s2="+s2);  

13.     System.out.println("s3="+s3);  

14.       System.out.println(s2+"和"+s3+"比较大小="+s2.compareTo(s3));  

15.       //比较的时候是根据字符的ASCII进行的比较  

16.       //小于0表示s2小于s2   

17.       //等于0  表示s2和s3相等    

18.       //大于0  表示s2比s3大    

19.   }  

20. }  

21. 结果：  

22. s1=abc  

23. s2=ABC  

24. s3=abc  

25. ABC和abc比较大小=-32  

26.    

 

 

String的练习

1. 去除空格

     

     模拟取出字符串两边的空格

 

  思路：

 1.判断字符串第一个字符是不是空格，如果是则继续向后判断，直到不是空格，然后记下此标记

 2.逆向判断字符串，也是直到判断不是空格，记下下标

 3，然后截取字符串即可

 

 

[java] view plaincopy

1. public class ThrowSpace {  

2.    

3.   public static void main(String[] args) {  

4.     System.out.print("--");  

5.     String str = "  abcdef  ";  

6.     System.out.print(method(str));  

7.     System.out.print("--");  

8.    

9.   }  

10.    

11.   public static String method(String str) {  

12.     char[] cs = str.toCharArray();  

13.     int x = 0, y = cs.length - 1;  

14.     for (; x < cs.length; x++) {  

15.       if (str.charAt(x) != ' ') {  

16.          break;  

17.       }  

18.     }  

19.     for (; y >= 0; y--) {  

20.       if (str.charAt(y) != ' ') {  

21.          break;  

22.       }  

23.     }  

24.     return str.substring(x , y + 1);  

25.   }  

26.    

27. }  

28. 结果：  

29. --abcdef--  

 

2.     反转

 

 

       模拟反转字符串

 

  思路：

 1.将字符串转换成字节数组

 2.然后利用数组的反转功能，对数组反转

 3.然后将反转后的字符数组转成成字符串，返回即可。

 4.要是范围反转，你们就先取出那些要反转的，然后反转后，那么就在加上不反转的部分

 

 

[java] view plaincopy

1. public class ReverseString {  

2.   public static void main(String[] args) {  

3.     String str="abcdef";  

4.     System.out.println(reverseString(str));  

5.     String str1="123456789";  

6.     System.out.println(reverseString(str1,3,7));  

7.      

8.   }  

9.   /*完全反转*/  

10.   public static String reverseString(String str){  

11.     char [] chs=str.toCharArray();  

12.     reverse(chs);  

13.     return new String(chs);  

14.   }  

15.   /*指定范围反转*/  

16.   public static String reverseString(String str,int start,int end){  

17.      

18.     char [] chs=str.toCharArray();  

19.     String s1=new String(chs,0,start);  

20.     String s2=new String(chs,end,chs.length-end);  

21.     String s3=new String(chs,start,end-start);  

22.     char [] newch=s3.toCharArray();  

23.     reverse(newch);  

24.     return s1+new String(newch)+s2;  

25.   }  

26.   /*反转数组*/  

27.   public static void reverse(char [] cs){  

28.     for(int start=0,end=cs.length-1;start<=end;start++,end--){  

29.       swap(cs,start,end);  

30.     }  

31.   }  

32.   /*交换数组中两个字符位置*/  

33.   public static void swap(char [] cs,int start,int end){  

34.      char temp=cs[start];  

35.      cs[start]=cs[end];  

36.      cs[end]=temp;  

37.   }  

38.    

39. }  

40.    

41. 结果：  

42. fedcba  

43. 123765489  

 

3. 计数

   

    

计算字符串中指定字符的个数

 

    思路：

    1.将字符串转换成数组

     2.定义一个计数器，然后再循环查找数组的元素，每查找到一个，那么计数器增加1

    3.将计算器返回即可

 

 

 

[java] view plaincopy

1.  public class CountString {  

2.    public static void main(String[]args) {  

3.      Stringstr="abcdjasbabsdaeas";  

4.      System.out.println("str中有"+count(str,'a')+"个字符"+'a');  

5.    

6.    }  

7.    /*开始查找计数*/  

8.    public static int count(Stringstr,char c){  

9.      char [] cs=str.toCharArray();  

10.      int count=0;  

11.      for(char cc:cs){  

12.         if(cc==c)  

13.           count++;  

14.      }  

15.      return count;  

16.    }  

17.    

18. }  

19. 结果：  

20. str中有5个字符a  

21.    

 

 

 

4.获取字串

   

  

   获取两个字符串中最大相同子串(按照长度比较)

 

  思路：

    1.将短的字符串按照长度递减的方式获取到，

    2.将获取到得子串去长串中判断是否包含

     3.如果包含则找到。

 

[java] view plaincopy

1. public class getMaxString {  

2.    public static void main(String[] args) {  

3.      String s1="acbdgyangsdds";  

4.      String s2="dayangqxdw";  

5.         System.out.println(getMaxSUbString(s1,s2));  

6.    }  

7.    /*获取最大相同字符串*/  

8.    public static String getMaxSUbString(String s1,String s2){  

9. if(s2.length()>s1.length()){  

10.         String temp=s1;  

11.         s1=s2;  

12.         s2=temp;  

13.      }  

14.      for(int x=0;x<s2.length();x++){  

15.         for(int y=0,z=s2.length()-x;z!=s2.length()+1;y++,z++){  

16.           String temp=s2.substring(y,z);  

17.           if(s1.contains(temp)){  

18.              return temp;  

19.           }  

20.         }  

21.      }  

22.      return "";  

23.    }  

24.    

25. }  

26. 结果：  

27. yang  

28.