String与StringBuffer

  

1、String类

String是比较特殊的数据类型，它不属于基本数据类型，但是可以直接赋值，不使用new关键字进行实例化，但是也可以使用关键字new进行实例化。下面的代码都是合法的：

   String s1 = "this is a string!";

   String s2 = new String("this is another string!");

另外String在使用的使用也不需要使用import语句导入，还可以使用“+”这样的运算符。如果想把字符串连接起来，可以使用“+”完成。例如：

s1+s2

String的一些常用方法我们通过一个例子来完成，下面是例子的代码：

package com.li.common;

 

public class StringTest {

 

       /**

        * @param args

        */

       public static void main(String[] args) {

              StringTest st = new StringTest();

              st.testString();

       }

      

       /*

        * 介绍String的常用方法

        */

       public void testString(){

              String str = "This is a test string!";

              System.out.println("/n用于被测试的字符串为："+str);

             

              System.out.println("/n方法length()用于获取字符串的长度，被测试字符串的长度为：");

              int length = str.length();

              System.out.println(String.valueOf(length));

             

              System.out.println("/n方法equals(Object o)用于判断该字符串是否与目标字符串的内容相同，与字符串/"test/"进行比较的结果为：");

              boolean b = str.equals("test");

              System.out.println(b?"相等":"不相等");

              System.out.println("如果比较的时候不区分大小写，可以使用equalsIgnoreCase(Object o)方法，下面是/"test/"与/"Test/"比较的结果:");

              b = "test".equalsIgnoreCase("Test");

              System.out.println(b?"相等":"不相等");

             

              System.out.println("/n获取字符串中某个位置的字符，可以使用charAt(int index)方法：");

              char c = str.charAt(5);

              System.out.println("/n测试字符串第5个位置的字符为："+String.valueOf(c)+".注意索引从0开始");

             

              System.out.println("/n获取子串的方法有两个：subString(int fromindex)和substring(int fromindex,int endindex)");

              System.out.println("第一个方法获取从fromindex开始之后的子串，第二个方法获取从fromindex开始到endindex结束的子串，索引从0开始,包含fromindex，不包含endindex。");

              String strSub = str.substring(3);

              System.out.println("str.substring(3)的结果为："+strSub);

              strSub = str.substring(3,6);

              System.out.println("str.substring(3,6)的结果为："+strSub);

             

              System.out.println("/n去除字符串前面或者后面的空格，可以使用trim()方法：");

              System.out.println("字符串/"100 01 /"原来的长度为："+"100 01 ".length()+"使用trim()方法之后的长度为："+"100 01 ".trim().length());

             

              printContent("/n/n判断一个字符在字符串中的位置，可以使用indexOf(int ch)和indexOf(int ch,int from)方法" +

                            "，/n如果不存在返回0，第一个方法从字符串开头查找，第二个方法从form为置开始查找，包含该位置");

              int index = str.indexOf('s');

              printMethod("str.indexOf('s')");

              printResult(String.valueOf(index));

              index = str.indexOf('s',6);

              printMethod("/nstr.indexOf('s',6)");

              printResult(String.valueOf(index));

             

              printContent("/n/n判断一个字符在字符串中的位置，可以使用indexOf(String str)和indexOf(String str,int from)方法" +

              "，/n如果不存在返回0，第一个方法从字符串开头查找，第二个方法从form为置开始查找，包含该位置");

              index = str.indexOf("is");

              printMethod("str.indexOf(/"is/")");

              printResult(String.valueOf(index));

             

              index = str.indexOf("is",3);

              printMethod("/nstr.indexOf(/"is/",3)");

              printResult(String.valueOf(index));

             

              index = str.indexOf("is",7);

              printMethod("/nstr.indexOf(/"is/",7)");

              printResult(String.valueOf(index));

             

              printContent("/n与indexOf方法相似，还有lastIndexOf方法，用法基本相同，不同的是开始查找的位置不同，一个从前，一个从后");

             

              printContent("/n判断字符串是否以某个子串为后缀，使用endsWith(String str)");

              b = str.endsWith("test");

              printMethod("str.endsWith(/"test/")");

              printResult(String.valueOf(b));

             

              b = str.endsWith("string!");

              printMethod("/nstr.endsWith(/"string!/")");

              printResult(String.valueOf(b));

             

              printContent("/n/n与endsWith方法功能相似，startWith(String prefix)和" +

                            "/nstartWith(String prefix,int toffset)用于判断是否以某个子串为前缀");

             

              printContent("/n/n替换字符串中的字符，使用replace(char oldChar,char newChar)方法");

              String str2 = str.replace('s','S');

              printMethod("str.replace('s','S')");

              printResult(str2);

             

              printContent("/n/n替换字符串中的第一次出现的某个字串，使用replaceFirst(String oldStr,String newStr)方法");

              str2 = str.replaceFirst("is","IS");

              printMethod("str.replaceFirst(/"is/",/"IS/")");

              printResult(str2);

             

              printContent("/n/n替换字符串中的所有的出现的某个字串，使用replaceAll(String oldStr,String newStr)方法");

              str2 = str.replaceAll("is","IS");

              printMethod("str.replaceAll(/"is/",/"IS/")");

              printResult(str2);

             

              printContent("/n/n可以根据某个特定的格式把字符串分成多个子串，使用split方法," +

                            "/n使用的测试字符串为zhangsan-lisi-wangwu");

              str2 = "zhangsan-lisi-wangwu";

              String strSplit[] = str2.split("-");

              printMethod("str.split(/"-/")");

              for(int i=0;i<strSplit.length;i++)

                     printResult(strSplit[i]+" ");

             

       }

       /*

        * 显示注释的内容

        */

       public void printContent(String str){

              System.out.println(str);

       }

       /*

        * 显示代码

        */

       public void printMethod(String str){

              System.out.print(str);

              for(int i=0;i<30-str.length();i++)

                     System.out.print(" ");

       }

       /*

        * 显示结果

        */

       public void printResult(String str){

              System.out.print(str);

       }

}

需要注意的是String本身是一个常量，一旦一个字符串创建了，它的内容是不能改变的，那么如何解释下面的代码：

   s1+=s2;

这里并不是把字符串s2的内容添加到字符串s1的后面，而是新创建了一个字符串，内容是s1和s2的连接，然后把s1指向了新创建的这个字符串。如果一个字符串的内容经常需要变动，不应该使用String，因为在变化的过程中实际上是不断创建对象的过程。这时候应该使用StringBuffer。

2、StringBuffer

StringBuffer也是字符串，与String不同的是StringBuffer对象创建完之后可以修改内容。有几个构造函数：

public StringBuffer(int);

public StringBuffer(String);

public StringBuffer();

第一种构造函数是创建指定大小的字符串，第二个构造函数是以给定的字符串创建StringBuffer对象，第三个构造函数是默认的构造函数，生成一个空的字符串。

StringBuffer对象创建完之后，大小会随着内容的变化而变化。

StringBuffer的常用方法及其用法如下：

 

   StringBuffer sb = new StringBuffer();

   sb.append("字符串的第一部分");

   /*append方法可以在字符串后面添加各种类型的数据，包括基本数据类型变量和其

    他任意类型的对象*/

 

   for (int i = 0; i < sb.length(); i++)

     System.out.println(sb.charAt(i));

   //length()方法用来获取字符串中字符的个数

   //charAt(int)方法用来获取指定位置的字符

 

   System.out.println(sb.length());

   System.out.println(sb.capacity());

   /*capacity()方法用来获取字符串的容量，当前的输出结果是"8 16"，

    通常是不相等的*/

 

   System.out.println(sb.toString());

   //toString方法把StringBuffer的内容转换成String对象

  

   sb.delete(1, 3);

   System.out.println(sb.toString());

   /*

    delete方法用于删除字符串中的部分字符，第一个参数是删除的第一个字符，第二

    个参数是删除结束的地方，需要注意3点：字符串的第一个字符的索引"0"，第一个

    参数指定的字符会删除，但是第二个参数指定的字符不会删除，此处的运行结果是

    "字符串的第一部分 字的第一部分"。

    */

  

   sb.deleteCharAt(1);

   System.out.println(sb.toString());

   /*

    deleteCharAt删除指定位置的字符，索引也是从零开始，此处的运行结果是"字第

    一部分"，把“的”删掉了

    */

  

   String s3 = sb.substring(2);

   String s4 = sb.substring(2,4);

   System.out.println(s3);

   System.out.println(s4);

   /*

   substring用于获取字符串的字串,第一个方法有一个参数,用于指定开始位置,获取的

   字串是从该位置开始到字符串的结束,第二个方法有两个参数,第一个指定开始位置,第

   二个指定结束位置,与delete方法中的参数用法基本相同，此处输出的结果为："一部

   分 一部"

3、String与基本数据类型之间的转换

不管采用什么方式，用户输入的数据都是以字符串的形式存在，但是在处理的过程中可能需要把输入信息作为数字或者字符来使用，另外不管信息以什么方式存储，最终都必须以字符串的形式展示给用户，所以需要各种数据类型与字符串类型之间的转换。

首先，基本数据类型与String类型对象之间的转换：

从字符串转换成其它类型：

   //字符串与其基本数据类型之间的转换，以int为代表

   //下面的代码把字符串转换成数字

   String input = "111";

   int i = Integer.parseInt(input); //比较常用

   int i2 = new Integer(input).intValue();

   int i3 = Integer.valueOf(input);

   int i4 = new Integer(input);

  

   //下面的代码把数字转换成字符串

   String out = new Integer(i).toString();

   String out2 = String.valueOf(i);

其它对象向字符串转换可以使用每个对象的toString()方法，所有对象都有toString()方法，如果该方法不满足要求，可以重新实现该方法。