Java的String基础总结

前言：java中String类是一个经常使用到的类，我们不能只了解它的简单的几个用法，要熟悉它的各种方法，做到信手拈来，灵活自如！

一.String的特点简介：

• public final classString

     
     
      
      	extends Object  implements Serializable, Comparable<String>, CharSequence
     
     

• String类是final的，不可被继承，一旦定义，不可改变。public final class String；
  
• String类是的本质是字符数组char[]；
  

• String str="abc";   //str是一个类型变量，"abc"是一个对象；

  str="kk";         //"abc"对象内容并没有变化，"abc"内存还在，只不过是str指向"kk"；

• String s1="abc",  String s2=new String("abc");   s1和s2有什么区别？

  s1在内存中有一个对象;s2在内存中有两个对象；

  二.String的方法：(这里只是简单列出比较常用的方法，要多看java的API练习即可)

     

  1.获取
     1.1字符串中包含的字符数，也就是字符串的长度。
          int length():获取长度    注：字符串求长度的length是方法，有括号；字符串数组求长度的length是属性，没括号；
     1.2根据位置获取位置上某个字符。
  

         char charAt(int index)
     1.3根据字符获取该字符在字符串中的位置。
          int indexOf(int ch):返回的是ch在字符串中第一次出现的位置。
          int indexOf(int ch,int fromIndex):从fromIndex指定位置开始，获取ch在字符串中出现的位置。
  
          int indexOf(String str):返回的是str在字符串中第一次出现的位置。
          int indexOf(String str，int fromIndex):从fromIndex指定位置开始，获取str在字符串中出现的位置。
  

     1.4int lastIndexOf(String str):反向索引。

  
  2.判断
     2.1字符串中是否包含某一个子串。
         boolean contains(str);
         特殊之处：indexOf(str):可以索引str第一次出现为止，如果返回-1，表示该str不在字符串中存在。
                所以，也可以用于对指定判断是否包含。
         if(str.indexOf("a")!=-1)

         而且该方法既可以判断，也可以获取出现的位置。

     2.2字符串中是否有内容。 
         boolean isEmpty():原理就是判断长度是否为0。
     2.3字符串是否以指定内容开头。
         boolean startsWith(str);
     2.4字符串是否以指定内容结尾。
         boolean endsWith(str);
     2.5判断字符内容是否相同，复写了object类中的equals方法。
         boolean equals(str);
     2.6判断内容是否相同，并忽略大小写。
          boolean equalsIgnorecase();

  3.转换。
     3.1将字符数组转成字符串。
         构造函数：String(char[])
         String(char[],offset,count):将字符数组中的一部分转成字符串
   
       静态方法：
       static String copyValueOf(char[]);
       static String copyValueOf(char[] data,int offset,int count);

       static String valueOf(char[]);
   
     3.2将字符串转成字符组
         char[] tocharArray();

     3.3将字节数组转成字符串。
         String(byte[])
         String(byte[],offset,count):将字节数组中的一部分转成字符串
   
      3.4将字符串转成字节数组。
           byte[] getBytes()

      3.5将基本数据类型转成字符串，
           static String valueOf(int)
           static String valueOf(double)

          // 3+"" 与 String.valueOf(3)的值是一样的
   
           特殊：字符串和字节数组在转换过程中，是可以指定编码的。

  4.替换
       String replace(oldchar,newchar);

  5.切割
       String[] split(String regex); //根据给定正则表达式的匹配拆分此字符串。

  6.子串。获取字符串中的而一部分
       String subString(begin);
       String subString(begin,end);  //包含头，不包含尾

  7.转换，去除空格，比较。
    7.1将字符串转成大写或小写
          String toUpperCsae() 大转小
          String toLowerCsae() 小转大

   7.2将字符串两端的多个空格去除
         String trim();

   7.3对两个字符串进行自然顺序的比较
        int compareTo(String str);

        compareToIgnore(String str); 忽略大小写比较

  三. String池

         Java运行时会维护一个String Pool（String池），JavaDoc翻译很模糊“字符串缓冲区”。String池用来存放运行时中产生的各种字符串，并且池中的字符串的内容不重复。而一般对象不存在这个缓冲池，并且创建的对象仅仅存在于方法的堆栈区。下面是个系统内存示意图：

  
  

  四.认识空格、空串、null
  看以下例子：
• new字符串都会在池中（池中原来没有，有则不会）和堆中创建对象；直接指定或使用纯字符串相连来创建String对象，则仅仅会检查维护String池中的字符串，池中没有就在池中创建一个，有则罢了！但绝不会在堆栈区再去创建该String对象。

• public class StringTest { 
      public static void main(String args[]) { 
          //在池中和堆中分别创建String对象"abc",s1指向堆中对象 
          String s1 = new String("abc"); 
          //s2直接指向池中对象"abc" 
          String s2 = "abc"; 
          //在堆中新创建"abc"对象，s3指向该对象 
          String s3 = new String("abc"); 
          //在池中创建对象"ab" 和 "c"，并且s4指向池中对象"abc" 
          String s4 = "ab" + "c"; 
          //c指向池中对象"c" 
          String c = "c"; 
          //在堆中创建新的对象"abc"，并且s5指向该对象 
          String s5 = "ab" + c; 
  
          String s6 = "ab".concat("c"); 
          String s7 = "ab".concat(c); 
  
          System.out.println("------------实串-----------"); 
          System.out.println(s1 == s2); //false 
          System.out.println(s1 == s3); //false 
          System.out.println(s2 == s3); //false 
          System.out.println(s2 == s4); //true 
          System.out.println(s2 == s5); //false 
          System.out.println(s2 == s6); //false 
          System.out.println(s2 == s7); //false 
  
          String b1 = new String(""); 
          String b2 = ""; 
          String b3 = new String(""); 
          String b4 = "".intern(); 
          String b5 = "" + ""; 
          String b6 = "".concat(""); 
          String b7 = "  ".trim(); 
          String b8 = "  "; 
          String b9 = "    ".trim(); 
  
          System.out.println("------------空串-----------"); 
          System.out.println(b1 == b2);  //false 
          System.out.println(b1 == b3);  //false 
          System.out.println(b2 == b3);  //false 
          System.out.println(b2 == b4);  //true 
          System.out.println(b2 == b5);  //true* 
          System.out.println(b2 == b6);  //true* 
          System.out.println(b2 == b7);  //false* 
          System.out.println("-----a----"); 
          System.out.println(b2.equals(b7));  //true 
          System.out.println(b7 == b8);  //false 
          System.out.println(b7 == b9);  //false 
          System.out.println(b7.equals(b9)); //true 
          System.out.println(b9 == null);//false 
  
          System.out.println("b8.trim():"); 
          for (byte b : b8.getBytes()) { 
              System.out.print(">>>" + (int) b + " "); 
          } 
          System.out.println("\nb8.trim():"); 
          for (byte b : b8.trim().getBytes()) { 
              System.out.print(">>>" + (int) b + " "); 
          } 
          System.out.println("\nb9.trim():"); 
          for (byte b : b9.trim().getBytes()) { 
              System.out.print(">>>" + (int) b + " "); 
          } 
      } 
  }

  
  字符串重编码和其他知识点，可参考http://lavasoft.blog.51cto.com/62575/80034/
• 
  
• ---EOF---