Java.lang 包——字符串类 (String, StringBuffer)

先提及一下数组， 与 C++ 不同的是， Java 中所有的数组都是动态分配存储空间。一但分配了存储空间，就不能在程序中改变数组长度，但可以用 new 重新分配空间。在 Java 中，数组是一种类，有自己的属性和方法。比较常用的是 length 方法，用于返回数组的长度。



回忆一下严蔚敏 C 语言描述的《数据结构》（第二版），都有哪几种数据结构？

常见的是：

1.       线性表（包括顺序表和链表）

2.       堆栈和队列

3.       串

4.       数组和广义表

5.       树和二叉树

6.       图



既然数组在 Java 中封装成类，不难发现，其实这些数据结构在 java 中全部封装成了类。串也不例外，所以也封装成了类。



字符串类—— String 类和 StringBuffer 类

程序中用到的字符串可以分为两类：

1.       String 类：创建之后不能再修改和变动的字符串常量。

String 被 java 的开发者构造得非常接近基本数据类型，换句话说，在很多时候可以象使用基本数据类型一样来使用 String 类，例如：

// 声明了一个空字符串 s

String s ；

String ss = ” 创建了一个字符串 ”;

// 声明了一个空字符串 s

String s = new String();

String ss = new String(” 创建了一个字符串 ”);

String []sa = new String[]{” 创建了一个字符串 ”, “ 数组 ”};



常用的方法有：

int length()                            // 返回字符串长度

boolean equals(Object anObject)          // 比较字符串相等

String substring(int beginIndex)           // 返回从 beginindex 开始的子串。

String substring(int beginIndex,int endIndex) // 返回从 beginIndex 到 endIndex 的子串

char charAt(int index)                   // 返回 index 指定位置的字符

int indexOf(String str)                   // 返回 str 在字符串第一次出现的位置

String replace(char oldChar,char newChar)  // 替换字符串中所有的 oldChar 子串

更多方法请查阅本文《附录 1 ： String 类的常用方法》



2.       StringBuffer 类：创建之后可以修改和变动的字符串变量。即能插入字符，也能追加字符到串尾。 StringBuffer 类对象的长度是可变的（即 StringBuff 是可变长的字符串对象 ）。

常用方法有：

int length();                   // 获取当前对象的长度

int capacity();                 // 获取当前对象的容量。

StringBuff append( …… );        // 将对象，字符串等添加到 StringBuff 对象中去。

StringBuff insert(int offset, …… );  // 将对象，字符串等插入到指定的位置。

其中主要的方法是 append 和 insert ，可以重载和接收任何类型的数据。





String 类和 StringBuffer 类都在 java 的 lang 包中，并被定义为最终类，不能再派生子类。





如果你只是了解一下，可以到此为止。如果你想深入理解字符串类，请继续下去。

本文框架（本文由以下内容构成）：

String 类（构造方法，常用方法，实例）

StringBuffer 类（构造方法，常用方法，实例）

字符串类总结（特点比较）

附录 1 ： String 类的常用方法（表格形式，方便查询）

附录 2 ： StringTokenizer 类（扩展知识）



String 类

一、 String 类——常用构造方法

String()                用来创建一个空的字符串常量

String(String str)         利用一个已经存在的字符串常量，来创建一个新的 String 对象

String(StringBuffer buf)  利用一个已经存在的 StringBuffer 对象，来创建新的 String 对象

String(char c[])          利用已经存在的字符数组的内容，来创建新的 String 对象

其原型是：

1.       用扩在双引号 (“”) 里面的一串字符串做参数构造字符串 

Public String(String value);

2.       用字符作为构造函数

Public String(char value[]);

Public String(char value, int offset, int count);

3.       用指定的缓冲字符串对象 buffer 构造字符串对象

Public String(StringBuffer buffer);

4.       用字节数组作为参数构造字符串

Public String(byte[] bytes);

Public String(byte[] bytes, String enc);

Public String(byte[] bytes, int offset, int length);

Public String(byte[] bytes, int offset, int length, String enc);

举例

String str = new String(“I like Java”);

Char ch[] = {‘a’, ‘b’, ‘c’, ‘d’, ‘e’};

String s1 = new String(ch);           // s1 为 ”abcde”

String s2 = new String(ch, 2, 3);        // s2 为 ”cde”

StringBuffer buff = new StringBuffer();

Buff.append(“a”);

Buff.append(“5.6”);

String s1 = new String(buff);           // s1 为 ”a5.6”



二、 String 类——常用方法

1 ，求字符串长度

public int Length()                  // 用于获得当前字符串对象中字符的个数

例： String s = “ 欢迎使用 java 语言 ”;

Int len = s.length();

结果： len = 10

注： java 采用 Unicode 编码，每个字符为 16 为长，因此汉字和其他符号一样只占用一个字符。



2 ，字符串连接

public String concat(String str)       // 用于将字符串 str 连接在当前字符串的尾部，并返回新的字符串

例： “to”.concat(“get”).concat(“her”) 的返回值为 ”together” 。

例： String str = “hello”;

str = str + “world” +2;

str 的值为 ”hello world 2”;

注：利用 ” + ” ，编译器讲自动把非字符串转换为字符串再进行连接。



3 ，字符串比较

boolean equals(Object o)      // 用于将当前字符串与方法参数列表中给出的字符串对象 o 作比较，若相同则返回 true ，否则返回 false ，区分大小写

boolean equalsIgnoreCase(String str)    // 用于将当前字符串与方法参数列表中给出的字符串对象 str 作比较，若相同则返回 true ，否则返回 false ，不区分大小写

int compareTo(String str)      // 用于将当前字符串与参数中字符串对象 str 作比较，若完全相同则返回 0 ；若按字母顺序大于参数字符串，则返回一个大于 0 的整数；反之，则返回一个小于 0 的整数

int compareTo(Object object)

int compareToIgnoreCase(String str)

例： String str3 = “This”;

String str2 = “That”;

System.out.println(“ 结果 1 ： ”+str3.equals(“this”)+”,”+str3.equalsIgnoreCase(”this”));

System.out.println(“ 结果 2 ： ”+str2. compareTo (“that”)+”,”+str2. compareTo IgnoreCase(”that”));

输出：结果 1 ： false, true;

  结果 2 ： -32,0;

注：在前文《 Java.lang 包—— Object 类》中使用关系运算符“ == ”判定两个 object ，作为继承了 object 类的字符串类，同理也可以用“ == ”判定两个字符串是否相等，并且其使用规则也一样。



4 ，转化字符串的大小写

Public String toLowerCase()              // 将字符串中所有的大写字母转换成小写

Public String toUpperCase() ，             // 将字符串中所有的小写字母转换成大写

例如： StringCaseChange.java

public class StringCaseChange

{

      public static void main(String[] args)

      {

            String str = "Hello world.This is a Java code.";

            // 声明并初始化字符串

            System.out.println("The str is :");

             System.out.println(str);

            System.out.println("to UpperCase:");

            System.out.println(str.toUpperCase());

            // 字符串对象 str 调用 toUpperCase() 方法，并输出返回值

            System.out.println(str.toLowerCase());

            // 字符串对象 str 调用 toLowerCase() 方法，并输出返回值

             System.out.println(str);

             // 输出原字符串 str

      }

}



5 ，字符串截取

public char charAt(int index)            // 返回 index 指定位置的字符

public String subString(int start)         // 返回从 start 开始的子串。

public String subString(int start, int end)  // 返回从 start 到 end 的子串

例：   String str = “hello world”;

      char charValue = str.charAt(2);

      String s1 = str.subString(2);

      String s2 = str.subString(6, 11);

结果： charValue = ‘1’;

      s1 = “llo world”;

      s2 = “world”;

注： start 和 end 的位置需特别小心。



6 ，判断一个字符的前缀和后缀

public boolean startsWith(String prefix)    // 用于判断当前字符串的前缀，是否是指定的字符串对象 str ，若是则返回 true ，否则返回 false

public boolean endsWith(String suffix)    // 用于判断当前字符串的后缀，是否是指定的字符串对象 str ，若是则返回 true ，否则返回 false

public boolean startsWith(String prefix, int offset)

注：偏移量从 0 开始计数。



综合例子 1 ： String 类对象的创建及使用 StringDemo.java

public class StringDemo

{

      String str1 = "Hello world!This is Java code."; // 声明并初始化字符串 str1

      String str2;                             // 声明字符串 str2

      String str3 = new String("This is Java code."); // 声明并初始化字符串 str3

      public StringDemo()

      {

             str2 = new String("This is Java code.");

            // 创建字符串对象 str2 并初始化

            System.out.println("str1 is: "+str1);

            System.out.println("str2 is: "+str2);

            System.out.println("str3 is: "+str3+"\n");

            System.out.println("Each item of str1 is:");

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

            {   // 使用 charAt() 方法得到 String 字符串中指定位置的字符，并利用循环分别输出

                char c = str1.charAt(i);

                System.out.print("\""+c+"\",");

                if((i+1)==0) System.out.println();

            }

            System.out.println();

            byte b[] = str1.getBytes();

            // 使用 String 类的 getBytes() 方法，得到 str1 中所有字符对应的 Unicode 编码，并存入 byte 型数组 b 中

            System.out.println("Change each item of str1 to unicode is:");

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

            {   // 利用循环分别输出 str1 中，所有元素对应的字符的 Unicode 编码

                System.out.print(b[i]+",");

                if((i+1)==0) System.out.println();

            }

            System.out.println();

            System.out.print("The result of comparing str2 and str3 is:");

            System.out.println(str2.equals(str3));

            // 将字符串对象 str2 与 str3 进行比较，并将返回值输出

            System.out.println("\nReplace all charcters \"a\" to \"e\" in str2");

            System.out.println("The result of str2.replace() is:"+str2.replace('a','e'));

            // 将字符串 str2 调用 replace() 方法的结果输出

            System.out.println("str2 is: "+str2+"\n");

            System.out.print("The result of whether str1 is beginning with \"Hello\":");

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

            System.out.print("The result of whether str3 is end with \"code.\":");

            System.out.println(str3.startsWith("code."));

      }

      public static void main(String[] args)

      {

            StringDemo stringDemo = new StringDemo();

      }

}



综合例子 2 ： String 类部分方法测试 StringMethodDemo.java

public class StringMethodDemo

{

      public static void main(String[] args)

      {

            String str1 = "abc";

            String str2 = "aab";

            String str3 = "abd";

            String str4 = "abc";

            String str5 = "ABC";

            String str6 = "abcdefgabcde";

            // 以上完成字符串的声明及初始化

            int i = str1.compareTo(str2);

            int j = str1.compareTo(str3);

            int k = str1.compareTo(str4);

            // 以上调用 String 的 compareTo() 方法来比较字符串

            System.out.println("str1 is:"+str1);

            System.out.println("str2 is:"+str2);

             System.out.println("str3 is:"+str3);

            System.out.println("str4 is:"+str4);

            System.out.println("str5 is:"+str5);

            System.out.println("str6 is:"+str6);

            System.out.print("The result of str1 compareTo str2 is:");

            System.out.println(i);

            System.out.print("The result of str1 compareTo str3 is:");

            System.out.println(j);

            System.out.print("The result of str1 compareTo str4 is:");

            System.out.println(k);

            System.out.print("The result of str1 equals str5 is:");

            System.out.println(str1.equals(str5));

            // 调用 String 的 equals() 方法来比较字符串

            System.out.print("The result of str1 equalsIgnoreCase str5 is:");

            System.out.println(str1.equalsIgnoreCase(str5));

            // 调用 String 的 equalsIgnoreCase() 方法来比较字符串

            int m = str6.indexOf((int)'d');

            // 调用 String 的 indexOf() 方法，返回字符 'd' 第一次出现的位置

            System.out.println("The char \"d\" first appear position is :"+m);

            int n = str6.indexOf((int)'d',4);

            // 调用 String 的 indexOf() 方法，返回字符 'd' 从第四位后，首次出现的位置

            System.out.println("After 4th position The char\"d\"appear position is:"+n);

      }

}





三、 String 类——查找指定字符、字符串和替换

由于检索对字符串特别重要，为突出其重要性，故单独列出。

1 ，查找字符

int indexOf(char a)             // 用于查找并返回当前字符串中，某个特定字符 a 第一次出现的位置

int indexOf(char a,int b)         // 用于从当前字符串中，自 b 位个字符之后向后查找并返回某个特定字符 a 第一次出现的位置

int lastIndexOf(char a)          // 用于查找并返回当前字符串中，某个特定字符 a 最后一次出现的位置

int lastIndexOf(char a, int b)    // 用于从当前字符串中，自 b 位个字符之后向后查找并返回某个特定字符 a 最后一次出现的位置





2 ，查找字符串

int indexOf(String str)        // 用于查找并返回当前字符串中，某个特定字符串 str 第一次出现的位置

int indexOf(String str,int a)     // 用于从当前字符串中，自 a 位个字符之后向后查找并返回某个特定字符串 str 第一次出现的位置

int lastIndexOf(String str)      // 用于查找并返回当前字符串中，某个特定字符串 str 最后一次出现的位置

int lastIndexOf(String str int a)  // 用于从当前字符串中，自 a 位个字符之后向后查找并返回某个特定字符串 str ，最后一次出现位置

例如： StringSearchDemo.java

public class StringSearchDemo

{

      public static void main(String[] args)

      {

            String str1 = "Hello world.This is a Java code.we will program Java code.";

            String searchStr = "Java code";

            // 以上声明创建了字符串对象

            int i = str1.indexOf(searchStr);

            // 在字符串 str1 中，查找并返回字符串对象 searchStr 的位置

             int j = str1.indexOf(searchStr,str1.indexOf("we"));

            // 在字符串 str1 中，从字符串 "we" 开始，查找并返回字符串对象 searchStr 的位置

            int m = str1.lastIndexOf(searchStr);

            // 在字符串 str1 中，查找并返回字符串对象 searchStr 最后一次出现的位置

            System.out.println("str1 is:"+str1);

            System.out.println("searchStr is:"+searchStr);

            System.out.println("i = str1.indexOf(searchStr):"+i);

            System.out.println("j=str1.indexOf(searchStr,str1.indexOf(\"we\")):"+j);

            System.out.println("m = str1.lastIndexOf(searchStr):"+m);

      }

}

3 ，替换字符（包括字符串）

String replace(char c1,char c2)   // 用于将当前字符串中的所有 c1 指定的字符替换为 c2 指定的字符，并返回新的字符串



四、 String 类——字符串转换为字节数组或字符数组

1 ，字节数组

byte [] getBytes();

byte [] getBytes(String enc);    //enc 是字符集编码

2 ，字符数组

char [] toCharArray();

char [] toCharArray(int srcBegin, int srcEnd, char[] dst, int dstBegin);

例： byte byteArr[];

    char charArr[];

     String str = "This is s test string";

     byteArr = str.getBytes();

     charArr = str.toCharArray();

源码： StringToArray.java

public class StringToArray{

         public static void main(String[] args){

                   String s="ABCDE";

                   byte b[]=s.getBytes();

                   System.out.println("\t"+s);

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

                            System.out.print("\t"+b[i]);

                   System.out.println();

                   char ch0[]=s.toCharArray();

                   myPrint(ch0);

                   char ch1[]=new char[3];

                   s.getChars(1,4,ch1,0);

                   myPrint(ch1);

         }

         static void myPrint(char[] obj){

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

                            System.out.print("\t"+obj[i]);

                   System.out.println();

         }

}



StringBuffer 类

StringBuffer 类是可变字符串类，创建 StringBuffer 类的对象后，可以随意修改、变更字符串的内容。每个 StringBuffer 类 的对象，都能够存储指定容量的字符串，如果字符串的长度超过了 StringBuffer 类对象的容量，则该对象的容量会自动的扩大。

一、 StringBuffer 类——构造方法

StringBuffer()          // 用于创建一个空的 StringBuffer 对象

StringBuffer(int length)  // 用于创建一个长度为 length 的 StringBuffer 对象

StringBuffer(String str)    // 返回一个字符串，初始化为 s ，长度为 s.length()+16 个字节

例： StringBuffer sb = new StringBuffer();

StringBuffer sb = new StringBuffer(32);

StringBuffer sb = new StringBuffer(“I like this”);

注：系统为 String 类对象分配内存是，按照对象中所含字符的实际个数等量分配。而 StringBuffer 类对象分配内存时，出去字符所占空间外，再另加 16 个字符大小的缓冲区。



二、StringBuffer 类——主要方法（全为 public ）

1 ，获得长度、容量和设置长度

int capacity()                // 用于获取可变字符串的当前容量，值为字符串长度 +16

void setLength(int a)          // 用于设置当前可变字符串的长度

int length()                  // 用于获取可变字符串的长度，值为字符串长度

例： StringBuffer buf = new StringBuffer(“0123”);

buf.length() = 4;

buf.capacity() = 4 + 16 = 20;

一般 StringBuffer 的长度 (length) 是指存储在其中的字符个数，容量 (capacity) 是指缓冲区所能容纳的最大字符数。



2 ， append 、 replace 、 reverse

StringBuffer append(Object obj) // 将对象参数以字符串的方式，加入到当前可变字符串中

StringBuffer append(String str)  // 将给定的字符串，追加到当前可变字符串中

StringBuffer append(StringBuffer sb)    // 将给定的可变字符串，追加到当前可变字符串中

StringBuffer replace(int a,int b,String str)// 使用新的字符串 str ，替换当前可变字符串中，起始位置为 a ，结束位置为 b 之间的内容

StringBuffer reverse(int start, int end, String str)

注： append 共有 11 个方法，上面仅列出常见的 3 个。





3 ， insert 、 delete

StringBuffer insert(int offset,Object obj) // 将对象参数以字符串的方式，插入到当前可变字符串中指定位置

StringBuffer insert(int offset,String str)    // 将给定字符串，插入到当前可变字符串中指定位置

StringBuffer delete(int a,int b)           // 用于删除掉当前可变字符串中，起始位置为 a ，结束位置为 b 之间的内容

StringBuffer deleteCharAt(int a)          // 用于删除指定索引位置处的字符

void setCharAt(int a,char ch)    // 将给定字符 ch ，插入到当前可变字符串中指定索引位置处



4 ，其他

String toString()                       // 获得一个字符串常量来代表当前可变字符串

String substring(int start)

String substring(int start , int end);

注： insert 共有 10 个方法，上面仅列出常见的 2 个。





三、实例

1，  StringBuffer 类的创建和使用

例如： StringBuffer 类对象的创建及使用 StringBufferDemo.java

public class StringBufferDemo

{

      StringBuffer strBuf1 = new StringBuffer("Hello world!");

      // 声明、创建并初始化 StringBuffer 类的对象 strBuf1

      StringBuffer strBuf2;

      // 声明 StringBuffer 类的对象 strBuf2

      StringBuffer strBuf3 = new StringBuffer(10);

      // 声明并创建 StringBuffer 类的对象 strBuf3 ，并设定其长度为 10

      public StringBufferDemo()

      {

            strBuf2 = new StringBuffer("This is Java code.");

            // 创建并初始化 StringBuffer 类的对象 strBuf2

            strBuf3 = new StringBuffer("Hello");

            // 创建并初始化 StringBuffer 类的对象 strBuf3

            String output = "strBuf1:"+strBuf1.toString()+"\nlength="+ strBuf1.

                                    length()+"\ncapacity="+strBuf1.capacity();

            // 使用 StringBuffer 类的方法 toString() ，将 StringBuffer 类对象转化为 String

              型字符串

            // 使用 StringBuffer 类的方法 length() ，来获得该可变字符串的长度

            // 使用 StringBuffer 类的方法 capacity() ，来获得该可变字符串的最大存储容量

            System.out.println(output);

            strBuf1.setLength(30);

            // 使用 StringBuffer 类的方法 setLength() ，来设置可变字符串的长度

            System.out.print("After add strBuf1's length,");

            System.out.println("strBuf1's capacity is:"+strBuf1.length());

            strBuf1.ensureCapacity(60);

            // 使用 StringBuffer 类的方法 ensureCapacity() ，来设置可变字符串的最大存储容量

            System.out.print("Set strBuf1's capacity,");

            System.out.println("Now strBuf1's capacity is:"+strBuf1.capacity());

             System.out.println();

            System.out.println("strBuf2:"+strBuf2.toString());

            System.out.println("Char at 0 in strBuf2 is:"+strBuf2.charAt(0));

            System.out.println("Char at 9 in strBuf2 is:"+strBuf2.charAt(9));

             char ch[] = new char[strBuf2.length()];

            strBuf2.getChars(8,12,ch,0);

            // 使用 StringBuffer 类的方法 getChars() ，来获取 strBuf2 中第 8 ～ 12 位的字符

            System.out.println("The char from 8 to 12 is:");

            for(int i=0;i<4;i++)

             {

                   System.out.print("\""+ch[i]+"\",");

            }

            System.out.println("\n");

            System.out.println("strBuf3:"+strBuf3.toString());

            System.out.print("After append string to strBuf3,");

            strBuf3.append(" world.StringBufferDemo!");

            // 使用 StringBuffer 类的方法 append() ，在 strBuf3 末尾插入字符串

            System.out.println("New strBuf3:\n"+strBuf3.toString());

            System.out.print("After set the 5th char,");

            strBuf3.setCharAt(11,'!');

            // 使用 StringBuffer 类的方法 setCharAt() ，来更改 strBuf3 中第 11 位的字符

            System.out.println("the new strBuf3:\n"+strBuf3.toString());

      }

      public static void main(String[] args)

      {

            StringBufferDemo stringBufferDemo = new StringBufferDemo();

      }

}



2 ， StringBuffer 类的插入和删除操作

例如： StringBuffer 类插入和删除方法的使用 InsertDeleteDemo.java

public class InsertDeleteDemo

{

      public static void main(String[] args)

      {

            String str = "Hello";

             // 声明并初始化字符串对象 str

            char ch[] = {'a','b','c','d','e','f','g'};

            // 声明并初始化字符数组 ch

            boolean b = true;

            // 声明并初始化布尔型变量 b

            int a = 10000;

            // 声明并初始化整型变量 a

            float f = 24.24f;

             // 声明并初始化单精度变量 f

            double d = 33.3333;

            // 声明并初始化双精度变量 d

            StringBuffer buffer = new StringBuffer();

            // 声明并初始化可变字符串对象 buffer

            buffer.insert(0,d);

            // 使用 StringBuffer 类中 insert() 方法，向 buffer 第 0 个位置插入各种类型值

            buffer.insert(0," ");

            buffer.insert(0,f);

            buffer.insert(0," ");

            buffer.insert(0,a);

            buffer.insert(0," ");

            buffer.insert(0,b);

            buffer.insert(0," ");

            buffer.insert(0,ch);

            buffer.insert(0," ");

            buffer.insert(0,str);

            System.out.println(buffer.toString()+"\n");

            buffer.deleteCharAt(6);

            // 使用 StringBuffer 类中 deleteCharAt() 方法，删除 buffer 中第 6 个位置的字符

             System.out.println(buffer.toString()+"\n");

            buffer.delete(5,12);

            // 使用 StringBuffer 类中 delete() 方法，删除 buffer 中第 5 个位置至第 11 位置之间的字符

            System.out.println(buffer.toString()+"\n");

      }

}



字符串类总结

1，  如果创建一个字符串，不打算修改它，用 String 。

2，  如果创建一个字符串，计划修改它，用 StringBuffer 。

3，  String 比 StringBuffer 执行效率高。

4，  StringBuffer 比 String 方便。





附录1 ：String 类的常用方法

方法
说明

char charAt(int index)
获取给定的Index 处的字符

int compareTo(String anotherString)
按照字典的方式比较两个字符串

int compareToIgnoreCase(String str)
按照字典的方式比较两个字符串, 忽略大小写

String concat(String str )
将给定的字符串连接到这个字符串的末尾

static String copyValueOf(char[ ] data)
创建一个和给定字符数组相同的String 对象

static String copyValueOf(char[ ]data ,int offset,int count)
使用偏移量，创建一个和给定字符数组相同的String 对象

boolean equals(Object anObject)
将这个String 对象和另一个对象String 进行比较

boolean equalsIgnoreCase(Sting anotherString)
将这个String 对象和另一个对象String 进行比较, 忽略大小写

void getChars(getChars(int strbegin,int strend,char[ ] data,int offset)
将这个字符串的字符拷贝到目的数组

int indexOf(int char)
产生这个字符串中出现给定字符的第一个位置的索引

int indexOf(int ch,int fromIndex)
从给定的索引处开始，产生这个字符串中出现给定字符的第一个位置的索引

int indexOf(String str)
产生这个字符串中出现给定子字符的第一个位置的索引

int indexOf(String str,int fromIndex)
从给定的索引处开始，产生这个字符串中出现给定子字符的第一个位置的索引

int length( )
产生这个字符串的长度

boolean regionMatches(boolean ignoreCase,int toffset,String other,int ooffset,int len)
检查两个字符串区域是否相等，允许忽略大小写

String replace(char oldChar,char newChar)
通过将这个字符串中的odChar 字符转换为newChar 字符来创建一个新字符串

boolean starsWith(String prefix)
检查这个字符串是否以给定的前缀开头

boolean starsWith(String prefix,int toffset)
从给定的索引处开头，检查这个字符串是否以给定的前缀开头

String substring(int strbegin)
产生一个新字符串，它是这个字符串的子字符串

String substring(int strbegin,int strend)
产生一个新字符串，它是这个字符串的子字符串，允许指定结尾处的索引

char[ ] toCharArray( )
将这个字符串转换为新的字符数组

String toLowerCase( )
将这个String 对象中的所有字符变为小写

String toString( )
返回这个对象（它已经是一个字符串）

String toUpperCase( )
将这个String 对象中的所有字符变为大写

String trim( )
去掉字符串开头和结尾的空格

static String valueOf(int i)
将int 参数转化为字符串返回。该方法有很多重载方法，用来将基本数据类型转化为字符串。如：static String valueOf(float f) ，static String valueOf(long l) 等






附录 2 ： StringTokenizer 类

Java 语言中，提供了专门用来分析字符串的类 StringTokenizer （位于 java.util 包中）。该类可以将字符串分解为独立使用的单词，并称之为语言符号。语言符号之间由定界符（ delim ）或者是空格、制表符、换行符等典型的空白字符来分隔。其他的字符也同样可以设定为定界符。

1 ， StringTokenizer 类的构造方法

StringTokenizer(String str)       // 为字符串 str 构造一个字符串分析器。使用默认的定界符，即空格符（如果有多个连续的空格符，则看作是一个）、换行符、回车符、 Tab 符号等

StringTokenizer(String str, String delim)  // 为字符串 str 构造一个字符串分析器，并使用字符串 delim 作为定界符



2 ， StringTokenizer 类的主要方法

String nextToken()             // 用于逐个获取字符串中的语言符号（单词）

boolean hasMoreTokens()       // 用于判断所要分析的字符串中，是否还有语言符号，如果有则返回 true ，反之返回 false

int countTokens()              // 用于得到所要分析的字符串中，一共含有多少个语言符号



3 ，举例说明 StringTokenizer 类、类中方法的使用。程序分析两个字符串，统计字符串中单词的个数。

例如： StringTokenizer 类的使用 StringTokenizerDemo.java

import java.util.*;

public class StringTokenizerDemo

{

       public static void main(String[] args)

      {

            String str1 = "Hello world!This is Java code,stringTokenizer Demo.";

            // 声明并初始化字符串 str1

            String str2 = "How to use StringTokenizer?StringTokenizer?";

            // 声明并初始化字符串 str2

            StringTokenizer strT1 = new StringTokenizer(str1," ,.!");

            // 创建 StringTokenizer 类的对象 strT1, 并构造字符串 str1 的分析器

            // 以空格符、 "," 、 "." 及 "!" 作为定界符

            StringTokenizer strT2 = new StringTokenizer(str2," ?");

            // 创建 StringTokenizer 类的对象 strT2, 并构造字符串 str2 的分析器

            // 以空格符及 "?" 作为定界符

            int num1 = strT1.countTokens();

            // 获取字符串 str1 中语言符号的个数

            int num2 = strT2.countTokens();

            // 获取字符串 str2 中语言符号的个数

            System.out.println("str1 has "+num1+" words.They are:");

            while(strT1.hasMoreTokens())

            {   // 利用循环来获取字符串 str1 中下一个语言符号 , 并输出

                   String str = strT1.nextToken();

                   System.out.print("\""+str+"\" ");

            }

            System.out.println("\nstr2 has "+num2+" words.They are:");

            while(strT2.hasMoreTokens())

            {   // 利用循环来获取字符串 str2 中下一个语言符号 , 并输出

                   String str = strT2.nextToken();

                   System.out.print("\""+str+"\" ");

            }

      }

}