String类常用方法示例

1—String简述

• 特点：
  (1)String是类类型变量。
  (2)String类是final类，一旦赋值就不能被改变。
  (3)字符串是由字符组成的，可以看成是字符数组。
  (4)字符串在内存中存储在常量池中。
  (5)凡是被双引号圈起来的内容全是字符串常量。

• String在内存中的特点：
  看下面两条语句：

  String s1="abc";        
  String s2=new String("abc");        
  

  如果内存中没有字符串常量”abc”，s1会新建一个常量并指向它。
  如果内存中已经有常量”abc”,s1就不再新建，而是直接指向该常量。

  而第二条语句 s2，不论内存中有没有该常量，都新建一个。

• String的比较方法 equals ：

  boolean b1= s1==s2;         
  boolean b2= s1.equals(s2);      
  

  第一句，因为s1和s2存储的是字符串的地址，所以比较的也是两个字符串的地址。
  第二句中，因为String 复写了equals方法，所以这里比较的是两个字符串内容是否相同。

  注意：
  字符串s1指向”abc”,字符串s2指向一个new对象，对象指向一个字符串常量。

2—字符串常见方法

1. 常用构造方法：

   String()                    //无参构造函数
   String(s)                   //新建一个字符串。
   String(char [])             //用全部字符数组元素顺序组成一个字符串。 
   String(char [],offset,len)  //用部分字符数组元素顺序组成一个字符串。
   String(byte [])             //用全部字节数组元素顺序组成一个字符串。需要解码为字符。
   String(byte [],offset,len)  //用部分字节数组元素顺序组成一个字符串。需要解码为字符。
   

2. 常用方法：

   boolean  s.equals(Object oo)    //将字符串与指定对象比较。
   boolean  s.equalsIgnoreCase(str)//将字符串与指定对象比较并忽略大小写。
   boolean  s.contains(str)        //判断字符串是否包含指定字符串。
   boolean  s.isEmpty()            //判断字符串是否为空字符串。
   boolean  s.startsWith(str)      //判断字符串是否以指定字符串开头。
   boolean  s.endsWith(str)        //判断字符串是否以指定字符串结尾。
   
   char    charAt(index)           //获取字符串在指定角标位的字符。
   int     s.length()              //获取字符串的长度。
   int     s.indexOf(str)          //获取s中str的开头角标位，不存在返回-1 。
   int     s.indexOf(str,from)     //获取s中从指定角标开始的str的角标位。
   int     s.lastIndexOf(str)      //逆向获取角标位。
   int     s.compareTo(str)        //比较两字符串的每个字符，如果全相等，返回0。
   String  s.substring(index)      //截取字符串，从指定位置到结尾。
   String  s.substring(from,to)    //截取指定始末角标的字符串。
   String  s.toLowerCase()         //字符串转成全小写。
   String  s.toUpperCase()         //字符串转成全大写。
   String  s.trim()                //字符串去掉首尾的多个空格。
   String  s.concat(str)           //将指定字符串连接到当前字符串。
   String  s.replace(char1,char2)  //将字符串中的char1替换为char2。
   String  s.replace(str1,str2)    //将字符串中的str1替换为str2。
   String  String.valueOf(Object oo)//获取对象的字符串表示形式。
   
   String      s.replaceAll(reg,str)   //将符合正则规则的字符串替换成str。
   char []     s.toCharArray()         //将字符串转成字符数组。
   byte []     s.getBytes()            //将字符串转成字节数组。
   String []   s.split(reg)            //将符合正则规则的字符串作为切割符，切割成字符串数组。
   boolean     s.matches(reg)          //判断字符串是否与正则表达式匹配。
   

3. 字符串的常用获取功能。

   class Demo
   {
       public static void main(String [] args)
       {
           String s="abcdabcd";
           System.out.println(s.length());         //打印字符串长度。8
           System.out.println(s.charAt(4));        //打印字符串4角标位上的字符。a
           System.out.println(s.indexOf('a'));     //打印a字符第一次出现的角标位。0
           System.out.println(s.indexOf('a',2));   //打印a字符从2角标位以后第一次出现的位置。4
           System.out.println(s.lastIndexOf('a')); //打印a字符从右往左第一次出现的位置。4
           System.out.println(s.substring(2));     //截取子字符串，从2角标到末尾。cdabcd
           System.out.println(s.substring(2,5));   //截取子字符串，从2角标到5角标。cda
           System.out.println(s.compareTo("abc")); //比较两个字符串，返回一个正整数。5
           System.out.println(s.concat("abc"));    //打印两字符串连接起来的字符串形式。abcdabcdabc
           System.out.println(s.trim());           //打印字符串去掉首尾空格的表示形式。abcdabcd
           System.out.println(s.replace('a','A')); //打印替换所有a字符的新字符串。AbcdAbcd
           System.out.println(s.replace("cd","CD"));//打印替换所有cd字符串的新字符串。abCDabCD
           System.out.println(String.valueOf(s));  //打印s的字符串表示形式。abcdabcd
       }
   }
   

   注意：
   

   1. s.length() 一定要加括号，这和数组的length不同。
      lastIndexOf(str) 虽然是反向索引字符串，但返回的还是找到的子字符串的开头角标位。
      (3)substring(from) 只有一个参数时，截取的是从from到末尾的新字符串。注意此方法名全小写。
      (4)s.compreTo(str) 该方法返回整数，只有在两字符串相等时，才返回0，
      否则返回第一个对应字符不相等的ASCII码整数差。
      如：abcd 与 abad 第三个字符不相等，并且c比a的ASCII码整数大2，所以返回2.
      (5)字符串是final类，所有返回字符串的方法放回的都是一个新字符串。

   知识点：
   –模拟 trim方法，去掉字符串两端空格

   class Demo
   {
       public static void main(String [] args)
       {
           String s="   ni hao   ";
           System.out.println(myTrim(s));
       }
       public static String myTrim(String s)
       {
           int start=0,end=s.length()-1;
           while (start<=end && s.charAt(start)==' ')
               start++;
           while (start<=end && s.charAt(end)==' ')
               end--;
           return s.substring(start,end+1);
       }
   }
   

   注意：
   

   1. 截取字符串时，两个参数包含头不包含尾。

4. 字符串的常用判断功能，如下示例：

   class Demo
   {
       public static void main(String [] args)
       {
           String s="Demo.java";
           System.out.println(s.isEmpty());            //s是否为空，false
           System.out.println(s.contains("java"));     //s是否包含java，true
           System.out.println(s.startsWith("Demo"));   //s是否以Demo开头，true
           System.out.println(s.endsWith(".java"));    //s是否以 .java 结尾，true
           System.out.println(s.equals("demo.java"));  //s是否内容和demo.java 相等，false
           System.out.println(s.equalsIgnoreCase("demo.java"));//不区分大小写时s是否和demo.java 相等，true
       }
   }
   

5. 字符串中的常用转换功能，如下示例：

   class Demo
   {
       public static void main(String [] args)
       {
           char [] chArr={'a','b','c','d','e','f'};
           String s1=new String(chArr);
           String s2=new String(chArr,2,3);    //从0+2角标开始，取三个数组元素组成字符串。
           System.out.println(s1.toUpperCase());//打印s1的大写表示形式。
           System.out.println(s2);
   
           char [] ch=s2.toCharArray();        //将字符串转成字符数组。
   
           byte [] byteArr={11,26,48,56,67,78,89};
           String s3=new String(byteArr);
           String s4=new String(byteArr,2,4);
           System.out.println(s3);
           System.out.println(s4);
       }
   }
   

6. 字符串切割功能。
   

   1. (1)字符串切割是以指定的字符串作为切割符，把字符串切成短字符串，并添加到一个字符串数组中。
      (2)切割符是一种正则规则，这里只简单看做一个短字符串，不考虑复杂的正则规则。

   字符串切割方法示例：

   class Demo
   {
       public static void main(String [] args)
       {
           String s="zhangsan,lisi,wangwu,zhaoliu";
           String [] arr=s.split(","); //对包含多个姓名的字符串切割分段成每个姓名字符串。
           for (String str : arr)      //高级for 循环
           {
               System.out.println(str);
           }
       }
   }
   

   注意：

   1. (1)切割符如果是小数点，需要转义字符转义。
      (2)高级for循环是for循环的一种简写形式。
      (3)split方法实际传递的参数是正则表达式。

3—扩展知识

1. StringBuilder ：字符串缓冲区。
   特点：长度可变，可以添加字符串以及一系列操作。

2. 常用方法：

   int   sb.length()               //缓冲区的长度
   int   sb.indexOf(str)           //str在缓冲区中第一次出现的位置索引
   int   sb.indexOf(str,from)      //str在缓冲区中指定角标以后第一次出现位置的索引
   char  sb.charAt(index)          //缓冲区指定角标上的字符
   
   StringBuilder   sb.reverse()                //将缓冲区内容反转
   StringBuilder   sb.append(Object oo)        //缓冲区添加元素
   StringBuilder   sb.delete(start,end)        //缓冲区指定角标的内容删除
   StringBuilder   sb.deleteCharAt(index)      //删除缓冲区指定角标上的字符
   StringBuilder   sb.insert(offset,Object oo) //从起始位偏移指定长度插入一个元素
   StringBuilder   sb.replace(start,end,str)   //将缓冲区中指定始末的内容替换成字符串str
   
   String  sb.substring(start)         //从指定位置截取字符串内容并返回新的缓冲区
   String  sb.substring(start,end)     //从指定始末位置截取字符串返回到新的缓冲区
   String  sb.toString()               //缓冲区的字符串表示形式
   

3. StringBuilder 方法示例：

   class Demo
   {
       public static void main(String [] args)
       {
           StringBuffer sb=new StringBuffer();
           sb.append("123");           //添加一个字符串
           sb.append(987);             //添加一个整数值
           sb.append(true);            //添加一个布尔值
   
           System.out.println(sb.length());        //打印缓冲区长度
           System.out.println(sb.toString());      //打印缓冲区字符串表示形式
           System.out.println(sb.delete(0,3));     //删除0,1,2角标的字符
   
           System.out.println(sb.replace(3,7,"false"));//替换3,4,5,6角标 "true" 为"false"。
           System.out.println(sb.insert(0,"AAA"));     //从0角标插入字符串
           System.out.println(sb.substring(6));        //截取字符串打印
       }
   }
   

   注意：

   1. (1)StringBuilder 也是可以直接打印的，但是需要用String类型时，需要转成 String 。
      (2)添加的元素都以字符串表示。

4. StringBuffer: 字符串缓冲区。
   StringBuffer 和 StringBuilder 用法基本一致。

   区别： StringBuffer是线程安全的，但是效率低；
   StringBuilder 是线程不安全的，但是效率比较高。
   一般使用 StringBuilder 。

4—String 练习

1. 练习一：
   将字符串指定部分反转。
   先将要反转的部分取出，然后反转，然后replace替换。

   class Demo
   {
       public static void main(String [] args)
       {
           String str="abcd1234abcd";
           String s=reverse(str,4,7);
           System.out.println(s);
       }
       public static String reverse(String str,int start,int end)
       {
           String s=str.substring(start,end+1);    //截取字符串包含头不包含尾，所以要多截取一位。    
           StringBuilder sb=new StringBuilder();   //新建一个字符缓冲区。
           for (int x=0;x<s.length();x++)
           {
               sb.append(s.charAt(x));             //往字符缓冲区添加元素。
           }
           return str.replace(s,sb.reverse().toString());    //返回原字符串替换后的字符串。
       }
   }
   

2. 练习二：
   获取一个字符串在另一个字符串中出现的次数。

   class Demo
   {
       public static void main(String [] args)
       {
           String str="nidnshiwodnsdeshednsme";
           System.out.println(time(str,"dns"));
       }
       public static int time(String str,String s)
       {
           int index=0,count=0;
           while (index!=-1)
           {
               count++;
               index=str.indexOf(s,index+s.length());
           }
           return count;
       }
   }
   

3. 练习三：
   获取两个字符串中最大相同子串

   class Demo
   {
       public static void main(String [] args)
       {
           String str="chfoyhellodutjg";
           String s="dofhelloxga";
           System.out.println(time(str,s));
       }
       public static String time(String str,String s)
       {
           int L = s.length();
           String s0=s;
           while (str.indexOf(s0)==-1)  //当不是整串包含时，才会进入循环。
           {
               L--;
               for (int n=0;n+L<=s.length();n++)
               {
                   s0=s.substring(n,n+L);
                   if (str.indexOf(s0)!=-1)
                       return s0;      //这里返回的只有一个字符子串，也有可能包含相同长度的多个字串。    
               }
           }   
           return s;                  //如果原字符串包含在另一个字符串，就会在这里直接返回。
       }
   }