Java中String类的用法

Java中的String类的使用

1、所在位置：java.lang.String

2、和 StringBuffer 类 、StringBuilder 类 一样，都被声明为 public final ，

   因此都不能被继承

3、String 类型的对象是常量，即一旦创建一个String对象，那么其中的字符串内容

   就不能被改变

4、一个字符串常量本身就是一个String对象，值得注意的是，如果Java程序当中多处出现

   字符串常量如"Hello"时，则Java编译程序时只会创建一个String对象，也就是说所有

   的字符串常量"Hello"将使用同一个String对象，如：

   String str1 = "Hello" ;

   String str2 = "Hello" ;

   String str3 = new String ("Hello") ;

   String str4 = new String ("Hello") ;

   则         ① str1 与 str2 是指向同一个对象的， 表达式 str1==str2 的值是true ；

      ② str3 与 str4 并不指向同一个对象， 表达式 str3==str4 的值是false；

      ③ str1 与 str3 也不指向同一个对象， 表达式 str1==str3 的值是false；

5、String类实例对象的构造方法

   public String (参数列表) ;

   根据参数的不同型成不同的构造方法

   (1).public String () ;

     用来创建一个字符串对象，但是没有任何字符内容

     需要注意的是，空字符串与null是不同的：

     如 String str1= new String();

        String str2 = null ;

        那么 str1 引用变量实际已经指向了一个String类型的对象                而 str2 却不指向任何一个对象，即语句二并没有为任何对象开辟空间

   (2).public String (byte[] bytes)

       public String (char[] value)

   (3).public String (String original)          public String (StringBuffer buffer)

     以上两个构造函数都是形成参数对象的一个副本，即新创建的字符串对象的内容

     和参数对象的内容完全一致，但是不允许参数对象为null

     注意，虽然 public String (String original) 创建的新的对象的内容与original

     完全一致，但是并不直接返回original的引用，而是再心创建一个内容不变的新对象         

6、String 类的众多方法中，常用的方法如下：

   （1）public int length() ;  返回字符串长度

   （2）public char charAt(int index) ; 返回指定索引处的char值

   （3）public int compareTo(String another) ;

        按照Unicode码值的大小逐字符的比较两字符串的大小，

        如果源串较小，则返回一个小于0的值；

        如果相等，则返回0，否则返回一个大于0的值            <有必要对对该方法做一个解释>

         实际上该方法是逐一比较两字符串中的字符，当遇到某个位置索引(如K)处的

         字符不相同，那么就返回：this.charAt(k) - another.charAt(k) 的值

         所以就有了上述结果，如果两个字符串的长度不同，而且正好一个字符串是另一个

         较长字串的前导串，那么这是就返回两字符串的长度差：

              this.length()-another.length() 的值

         public int compareToIgnoreCase(String another)

         该方法和是一个方法大同小异，只是忽略了字符串的大小写，即将两字符串全化成

         大写或小写之后再进行比较

   （4）pulbic String concat(String str)

        将字符串str拼接到当前字符串后面，将新形成的字符串作为返回值，

        注意当前字符串并不发生改变，如：

        String str1 = "Hello" ;

        String str2 = str1.concat("World") ;

        System.out.println("str2") ;   // HelloWorld

        System.out.println("str1") ;   // Hello

   （5）public boolean equals(Object obj)

        public boolean equalsIgnoreCase(String str)

        两者都是用来比较两个字符串的内容是否相同，

        但是 equals 区分大小写，而equalsIgnoreCase 不区分大小写；

        equals方法在Object类当中已经存在了，可见该方法是一个重写方法；

   （6）public int indexOf(int ch) 

        返回指定字符ch在当前字符串中第一次出现的位置索引

        public int indexOf(String str)

        返回指定的子串str在当前字符串中第一次出现的位置索引

        public int lastIndexOf(int ch)

        返回指定字符ch在当前字符串中最后一次出现的位置索引

        public int lastIndexOf(String str)

        返回指定的子串str在当前字符串中最后一次出现的位置索引

        注意：

        ①以上四个方法，如果当前串中没有指定的内容，则返回-1

        ②上述的 int ch 指的是字符的Unicode值，由于int和char型的变量存在

          一个自动相互转化的规则，所以 int ch 可以直接写成char ch

   （7）public String toUpperCase()  将当前字符串中的所有的字符全变成大写

        public String toLowerCase()  将当前字符串中的所有的字符全变成小写

        如果该方法形成的字符串和当前字符串的内容完全一致的话，就直接返回当前

        字符串对象的引用

   （8）public String trim()       

        返回当前字符串的副本，并且忽略前导空格和尾部空格

   （9）public String substring(int beginIndex)

        在当前字符串中，截取 从beginIndex索引处到结尾的字串，并返回

        public String substring(int beginIndex , int endIndex)

        在当前字符串中，截取 从beginIndex索引处到endIndex-1处的字符串，并返回

  （10）static String valueOf(int [也可以是其他基本数据类型或数组])

        将指定的数据转换成String类型，如：

        int i = 123 ;           String str = String.valueOf(i) ;

        **********************************************************************

        有一个问题要特别的注意一下：

        （10）中提到的方法String valueOf(参数)中的参数可以是一个实例对象

        ① 首先我们知道由于Object类当中含有方法 ： public String toString（） ；

           所以任何一个类都会继承这个方法

        ② 在Object类中的toString（）方法的原意是根据对象的内容创建一个字符串对象，                并将其引用返回【但是在父类的toString（）方法体中只是创建一个含有类名和

           该类名散列码的字符序列的String对象，所以在子类当中可以重写这个方法】，

           如果说调用该方法的对象本身就是一个String对象的话，就直接返回当前对象的引用，

           而不是再创建一个字符串对象，像这样当方法不改变原字符串时，就直接返回当前

           字符串对象的引用的情况几乎都是成立的                ③ （10）中的static String valueOf(对象），的方法体中实际就是调用了

            该对象的toString（）方法

        ④ 如果为valueOf(null)，则直接返回字符串“null”

        ⑤ 还要注意的是 输出方法 ：  System.out.println(参数)

                                    System.out.print(参数)

           当参数为基本数据类型或null时，上述两个方法就会先调用                                     string.valueOf(基本数据)；                       将值转换成String类型，在将之输出即可

           当参数为一个对象时，上述两个方法就会先调用

                        toString（）；                      将对象转换成String类型，在将之输出即可

        ⑥ 所以句⑤可知只要一个对象当中重写了toString（）方法的话                          那么就可以用两个输出方法，将该对象输出了

  （11）public String split(String separator)

        将一个字符串按照指定的分隔符分隔，返回分隔后形成的String数组

        如：

        String str = "123:232:dfsd" ;

        String [ ] newStr = str.split(":") ;

  （12）public String replace(char oldChar , newChar)

        字符替换方法，如果当前的字符串中并没有oldChar字符的话，则直接返回当前字符

        串对象的引用

  （13） public static String format(String format , Object....args) ;

         创建格式化字符串的方法，具体的使用方法见书

  （14）public boolean isEmpty（）   判定字符串对象是否是个空字符串

  （15）public byte[] getBytes()

        该方法返回当前字符串所对应的字节数组：              即 创建一个byte数组，数组元素就是每个字符的Unicode值，如：

        String str1 = "A" ;

        byte [] b1 = str1.getBytes() ;

        String str2 = "李";             byte [] b2 = str2.getBytes() ;

        由于按照Unicode编码，字符"A"在内存当中只占一个字节，对应的Unicode数值是65

        所以b1数组中只有一个元素b[0]=65

        而"李"是占两个字节的，所以b2数组中有两个元素，分别存储每个字节对应的Unicode

        编码 b2[0]=-64 ; b2[1]=-18

   （16）public char[] toCharArray()

         该方法根据当前字符对象的字符序列创建一个字符数组

7、这里介绍如何将字符串转换成基本数据类型

   ① 类java.lang.Boolean 成员方法

           public static boolean parseBoolean(String s)                  该方法先将s的字符序列化成小写字符；再进行判断，如果与"true"相同，则返回true

      否则返回false

   ② 类java.lang.Byte 成员方法

           public static byte parseByte(String s) throws NumberFormatException

   ③ 类java.lang.Short 成员方法

           public static short parseShort(String s) throws NumberFormatException

   ④ 类java.lang.Integer 成员方法

           public static int parseInt(String s) throws NumberFormatException

   ⑤ 类java.lang.Long 成员方法

           public static long parseLong(String s) throws NumberFormatException

        需要注意的是，这里的s不能以'L'或'l'结尾,否则出现异常

   ⑥ 类java.lang.Float 成员方法

           public static float parseFloat(String s)throws NumberFormatException

   ⑦ 类java.lang.Double 成员方法

           public static double parseDouble(String s)throws NumberFormatException

     上述的转换方法中的字符对象中的字符序列必须符合对应的基本数据类型的数据格式

     否则就会抛出异常

8、<字符串池>

   ① Java程序当中可以有许多字符串对象，这些字符串对象中的一部分在<字符串池>中，由

      <字符串池>来统一维护

   ② 在字符串池当中，具有相同的字符串序列的对象只有一个，即如果一些字符串对象在字符              串池中，并且其内容都相同的话，那么这些对象都是同一个对象

   ③ 有三类字符串对象位于字符串池当中，包括

           字符串直接量 、

           有限个字符串直接量进行"+"运算，而创建的字符串对象

           由java.lang.String 的成员方法intern（）创建的字符串对象

      [注意:String a0 = "123";

            String str = a0 + "456" ;

            字符串对象str并不在字符串池当中，虽然a0指向一个字符串直接量，但是               a0 本身不是一个字符串直接量，所以str并不在字符串池当中]

    ④ public String intern（）

       1.该方法首先判断当前字符串是否已经在字符串池中，如果当前的字符串对象的字符

         序列已经存在与字符串池中了，那么就返回字符串池中的具有该字符序列的对象

       2.如果当前的字符串对象的字符序列在字符串池内，并没找到，那么程序就会在字符串池

         中自动创建一个字符串对象，并返回该字符串对象的引用

       3.由于在字符串池当中的具有相同字符序列的对象只有一个，那么就可以通过如下的方式

         来判断两个任意的字符对象的内容是否相同：

            设 s1 与 s2 是两个字符串类型的变量

               s1.intern() == s2.intern()