5.1任务1 聊天系统的字符串对象信息处理

任务目标

• 了解 java.lang 包
• 掌握String类的使用
• 掌握StringBuffer类的使用

5.1.2 任务陈述

字符串信息处理是聊天系统中信息交互的基本形式，这体现为一种字符信息流，关于流的概念将会在情景10中介绍。当然，聊天系统中还会有其它的信息交互形式，例如语音信息和视频信息的处理，它们体现为一种字节信息流。

字符信息流中的字符串信息处理的基本对象涉及String类的实例，但这个实例一旦产生，其中含有的字符串内容和长度就会固定下来，对这个实例对象是不可以改变字符串信息的，如果遇到大量的字符串信息的变化，就会产生大量的String类的实例对象，这样就会耗费很多系统资源。对此解决的方案是采用另一个StringBuffer类的实例，该对象含有的字符串信息是可以通过操作该对象的方法进行字符串信息的添加和修改的。

所以，聊天系统中的字符串信息处理可以通过这种方式进行，即对于字符串信息不断变化的处理过程，使用StringBuffer类的实例对象进行处理，处理结果不再变化，将其转为字符串对象的固定形式，也就是String类的实例对象，最后将其用于传递或存储。

5.1.3相关知识点

1. 字符和字符串

字符和字符串处理是Java程序设计中必须面对的，即使在图形程序中也需要对像文件名和其它对象名进行处理。由于字符和字符串是词的基本数据结构，而词又是人们日常交流的基本单位，在Java中，将字符串作为对象来处理，java.lang包中包含String和StringBuffer两个类，它们封装了字符串的数据结构，都可以表示一个字符串。

单个字符可以用char类型表示，由于Java使用Unicode编码表示字符串中的字符，char类型的长度是16位的。例如：

char ch='a';
char two='2';

要是表示多个字符，可以使用char数组表示：

char data[] = {'a', 'b', 'c'};

可以将char数组传递给String类的构造方法，创建String实例对象：

String str = new String(data);
System.out.println(str);

上述语句会打印出"abc"。

字符串常量是用双引号括起来的一串字符，由于String对象可以为常量，因此可以直接用双引号括起的字符串常量创建String对象。例如：

String strName ="Hello World";

String对象实例等同于字符串常量。

要想更好的掌握字符串的处理，需要首先从进一步的了解String类开始。

2. String 类

String 类代表字符串，而它的对象表示一个字符串常量，意味着对象在创建之后不能改变，这样可以共享它们。String类的结构如图所示：

创建String类的对象需要用到String类的构造方法，而其构造方法的重载如下：

  构造方法                  说明
  String()                  初始化一个新创建的 String 对象，它表示一个空字符串。
  String(String value)      它将新建一个字符串作为指定字符串的副本。
  String (char [ ]  value)  它将根据字符数组构造一个新字符串。
  String (char [ ]  value,  分配一个新的 String，它包含来自该字符数组参数的一个子数组的字符。
     int offset,int count)  offset 参数是子数组第一个字符的索引，count 参数指定子数组的长度。
  String(byte [ ] value)    它将通过转换指定的字节数组新建一个字符串。
  String(byte[] bytes,      构造一个新的 String，方法是使用指定的字符集解码字节的指定子数组。
    int offset,int length)  offset 表示要解码的首字节的索引，length 表示要解码的字节数。

下面的代码片断使用了构造方法：

char chars[] = {'a', 'b', 'c', 'd', 'e', 'f'};
String str = new String(chars,1,4);   // 表示构造String对象时从chars数组下标1开始，取长度为4个字符。
byte ascii[] = {65,66,67,68,69,70};
String s=new String(ascii,2,3);  //表示构造String对象时从ascii数组下标2开始，取长度为3个字节，字符串对象是"CDE"。

⑴ 提取字符

从String的对象中提取字符，String类提供的方法如下：

  方法                                     说明
char charAt(int index)           返回指定索引处的 char 值。
void getChars(int srcBegin,      将字符从此字符串复制到目标字符数组中。要复制的第一个
    int srcEnd,char[] dst        字符在索引 srcBegin 处；要复制的最后一个字符在索引
    int dstBegin)                srcEnd-1 处（因此要复制的字符总数是 srcEnd-srcBegin）。
                                 要复制到 dst 子数组的字符从索引 dstBegin 处开始，并结
                                 束于索引：dstbegin + (srcEnd-srcBegin) - 1。
char[] toCharArray()             将此字符串转换为一个新的字符数组。
byte[] getBytes()                使用平台默认的字符集将此 String 解码为字节序列，并将
                                 结果存储到一个新的字节数组中。
byte[] getBytes(String charsetName) 使用指定的字符集将此 String 解码为字节序列，并将结果
                                 存储到一个新的字节数组中。charsetName为受支持的字符集。

下面代码片断使用了提取字符方法：

String strName ="Hello World";
strName.charAt(1);//返回字符e。
int start=6;
int end=11;
char chars[]=new char[end-start]
strName.getChars(start,end,chars,0);//提取字符串"World"到字符数组chars中。
char data[]=strName.toCharArray();  //将字符串"Hello World"转换为字符数组。
String strName ="ABCDEF";
Byte ascii[]= strName.getBytes();   //将字符串"ABCDEF"按默认字符集解码为字节序列
                                    //{65,66,67,68,69,70}保存在字节数组ascii中。

⑵ 字符串比较

比较两个字符串，String类提供的方法如下：

    方法                                      说明

boolean equals(Object anObject)    比较此字符串与指定的对象。当且仅当该参数不为 null，并且
                                   是表示与此对象相同的字符序列的 String 对象时，结果才为true。

boolean equalsIgnoreCase(String anotherString) 将此 String 与另一个 String 进行比较，不考虑大小写。
                                   如果两个字符串的长度相等，并且两个字符串中的相应字符都相等。
                                   （忽略大小写），则认为这两个字符串是相等的。       
int compareTo(String anotherString) 按字典顺序比较两个字符串。该比较基于字符串中各个字符的
                                   Unicode 值。将此 String 对象表示的字符序列与参数字符串所
                                   表示的字符序列进行比较。如果按字典顺序此 String 对象在参
                                   数字符串之前，则比较结果为一个负整数。如果按字典顺序此 
                                   String 对象位于参数字符串之后，则比较结果为一个正整数。
                                   如果这两个字符串相等，则结果为 0；
int compareToIgnoreCase(String str) 不考虑大小写，按字典顺序比较两个字符串。此方法返回一个整
                                   数，它的正负号是调用 compareTo 的正负号，调用时使用了字
                                  符串的规范化版本，其大小写差异已通过对每个字符调用
                                  Character.toLowerCase(Character.toUpperCase(character))
                                  得以消除。
boolean regionMatches(int toffset,  测试两个字符串区域是否相等。该 String 对象的一个子字符串
    String other,int ooffset,int len)  与参数 other 的一个子字符串进行比较。如果这两个子字符串
                                 表示相同的字符序列，则结果为 true。要比较的 String 对象
                                 的子字符串从索引 toffset 处开始，长度为 len。 要比较的
                                 other 的子字符串从索引 ooffset 处开始，长度为 len。

String intern()                 返回字符串对象的规范化表示形式。一个初始时为空的字符串
                                池，它由类 String 私有地维护。 Intern能够改进大型字符串
                                对象的比较性能。

清单 5-1 字符串比较

1: import javax.swing.JOptionPane;
2: public class StringCompare {
3:    public static void main(String args[]){
4:      String str1,str2,str3,str4,output;
5:      str1=new String("Hello World");
6:      str2=new String("Good Morning!");
7:      str3=new String("Happy New Year!");
8:      str4=new String("happy new year!");
9:      output="str1="+str1+"\nstr2="+str2+"\nstr3="+str3+
10:             "\nstr4="+str4+"\n\n";
11:     if(str1.equals("Hello World")){
12:         output+="str1 等于 \"Hello World\"\n";
13:     }
14:     else{
15:         output+="str1 不等于 \"Hello World\"\n";
16:     }
17:     if (str3.equalsIgnoreCase(str4)){
18:         output+="str3 等于 str4 \n";          
19:     }
20:     else{
21:         output+="str3 不等于 str4 \n";         
22:     }
23:     output+=
24:         "\nstr1与str2比较，结果是"+str1.compareTo(str2)+
25:         "\nstr2与str1比较，结果是"+str2.compareTo(str1)+
26:         "\nstr1与str1比较，结果是"+str1.compareTo(str1)+
27:         "\nstr3与str4比较，结果是"+str3.compareTo(str4)+
28:         "\nstr4与str3比较，结果是"+str4.compareTo(str3)+
29:         "\n\n";
30:     if (str3.regionMatches(0, str4, 0, 5)){
31:         output+="str3与str4的前5个字符匹配";
32:     }
33:     else{
34:         output+="str3与str4的前5个字符不匹配";
35:     }
36:     JOptionPane.showMessageDialog(null, output,"构造器",
37:                              JOptionPane.INFORMATION_MESSAGE);
38:     System.exit(0);
39:  }
40:}

运行结果如图所示:

⑶ 在字符串中定位字符和子字符串

经常需要在一个字符串中搜索一个字符或字符集，String类利用indexOf和lastIndexOf两个方法来搜索某个特定的字符或子串:

      方法                                              说明
int indexOf(int ch)                          返回指定字符在此字符串中第一次出现处的索引。
int indexOf(int ch, int fromIndex)           从指定的索引开始搜索，返回在此字符串中第一次出现指定字符
                                             处的索引。
int indexOf(String str)                      返回第一次出现的指定子字符串在此字符串中的索引。
int indexOf(String str,int fromIndex)        从指定的索引处开始，返回第一次出现的指定子字符串在此字符串中的索引。
int lastIndexOf(int ch)                      返回最后一次出现的指定字符在此字符串中的索引。 
int lastIndexOf(int ch,int fromIndex)        从指定的索引处开始进行后向搜索，返回最后一次出现的指定字
                                             符在此字符串中的索引。
int lastIndexOf(String str)                  返回在此字符串中最右边出现的指定子字符串的索引。
int lastIndexOf(String str,int fromIndex)    从指定的索引处开始向后搜索，返回在此字符串中最后一次出现
                                             的指定子字符串的索引。

清单5-2 在字符串中搜索字符和子串

1: import javax.swing.*;
2: public class StringIndex {
3:   public static void main(String args[]){
4:    String statement="Java is a object oriented programming language";
5:    String output="'i'的索引位置是"+statement.indexOf('i');
6:    output +="\n'o'的索引位置是"+statement.indexOf('o',1);
7:    output +="\n'$'的索引位置是"+statement.indexOf('$');
8:    output +="\n\n'i'的反向索引位置是"+statement.lastIndexOf('i');
9:    output +="\n'o'的反向索引位置是"+statement.lastIndexOf('o',30);
10:   output +="\n'$'的反向索引位置是"+statement.lastIndexOf('$');
11:   output +="\n\n'object'的索引位置是"+statement.indexOf("object");
12:   output +="\n\n'object'的反向索引位置是”
13：               +statement.lastIndexOf("object");
14：  JOptionPane.showMessageDialog(null, output,"字符串搜索",
15：                               JOptionPane.INFORMATION_MESSAGE);
16:   System.exit(0);       
17:  }
18:}

运行结果如图所示：

⑷ 提取子字符串

可以使用String类的substring方法提取一部分字符串，产生一个新的String对象，它是已存在String对象的部分复制。

       方法                                                说明
String substring(int beginIndex)          返回一个新的字符串，它是此字符串的一个子字符串。该子字符串
                                          始于指定索引处的字符，一直到此字符串末尾。
String substring(int beginIndex,int endIndex)  返回一个新字符串，它是此字符串的一个子字符串。该子字符串从
                                          指定的 beginIndex 处开始，一直到索引 endIndex - 1 处的字符。

清单5-3 在字符串中提取子串

1: import javax.swing.*;
2: public class SubString {
3:   public static void main(String args[]){
4:      String statement="Java is a object oriented programming language";
5:      String output="从索引位置为20处到末尾的子串是: "+"\""
6:                              +statement.substring(20)+"\"\n";
7:      output +="从索引位置为0处到6处的子串是"+"\""
8:                                +statement.substring(0,6)+"\"\n";
9:      JOptionPane.showMessageDialog(null, output,"字符串抽取",
10:                                     JOptionPane.INFORMATION_MESSAGE);
11:     System.exit(0);     
12:  }
13:}

运行结果如图所示：

⑸ 连接字符串

String类的concat方法连接两个String对象，并且从两个原始String对象包含的字符返回一个新的String对象。

        方法                                      说明
String concat(String str)           将指定字符串联到此字符串的结尾。如果参数字符串的长度
                                    为 0，则返回此 String 对象。否则，创建一个新的 String 
                                    对象，用来表示由此 String 对象表示的字符序列和由参数
                                    字符串表示的字符序列串联而成的字符序列。

清单 5-4 字符串连接

1: import javax.swing.*;
2: public class StringConcatenation {
3:  public static void main(String args[]){
4:      String str1=new String("Java is a object oriented");
5:      String str2=new String(" programming language");
6:      String str3=new String("Java is a object oriented");
7:      String str4=new String(" programming language");
8:      String output="str1="+str1+"\nstr2="+str2;
9:      output += "\n\nstr3="+str3+"\nstr4="+str4;
10:     output += "\n\n连接结果： str1.concat(str2)="+str1.concat(str2);
11:     output += "\n连接之后的str1="+str1;
12:     output += "\n\n连接结果： str3+str4="+str3+str4;
13:     output += "\n连接之后的str3="+str3;
14:     JOptionPane.showMessageDialog(null, output,"字符串连接",
15:                                    JOptionPane.INFORMATION_MESSAGE);
16:     System.exit(0);     
17:  }
18:}

运行结果如图所示：

从以上结果可看出，String类的concat方法与+操作符的作用相同。而当使用+连接字符串和数字值时，数字值会转换成它们的字串形式。例如：

 System.out.println("3+5="+3+5);//显示3+5=35，而不是3+5=8

⑹ 融合字符串的方法

String类提供了一些方法，返回String对象的复制或者一个字符数组。

                方法                                         说明
String replace(char oldChar,char newChar)  返回一个新的字符串，它是通过用 newChar 替换此字符串中
                                           出现的所有 oldChar 而生成的。
String toUpperCase()                       使用默认语言环境的规则将此 String 中的所有字符都转换
                                           为大写。
String toLowerCase()                       使用默认语言环境的规则将此 String 中的所有字符都转换
                                           为小写。
String trim()                              返回字符串的副本，忽略前导空格和尾部空格。
String toString()                          返回此对象本身（它已经是一个字符串！）。
valueOf(boolean b)                         返回 boolean、char、char数组、double、float、int、long、
valueOf(char c)                            Object 参数的字符串表示形式。它们都为静态方法（static）。
valueOf(char[] data)
valueOf(char[] data, int offset,int count)
valueOf(double d)
valueOf(float f)
valueOf(int i)
valueOf(long l)
valueOf(Object obj)

清单 5-5 字符串融合

1: import javax.swing.*;
2: public class StringMiscellaneous {
3:  public static void main(String args[]){
4:      String str1,str2,str3,output;
5:      str1 = new String("hello world");
6:      str2 = new String("HAPPY BIRTHDAY");
7:      str3 = new String("  you and me  ");
8:      output = "str1="+str1+"\nstr2="+str2+"\nstr3="+str3;
9:      output += "\n\nstr1中用L替换l:"+str1.replace('l','L');
10:     output += "\n\nstr1.toUpperCase()="+str1.toUpperCase()+
11:               "\nstr2.toLowerCase()="+str2.toLowerCase();
12:     output += "\n\nstr3使用trim之后:\""+str3.trim()+"\"";
13:     output += "\n\nstr1="+str1.toString();
14:     JOptionPane.showMessageDialog(null, output,"字符串融合",
15:                               JOptionPane.INFORMATION_MESSAGE);
16:     System.exit(0);     
17: }
18:}

运行结果如图所示：

清单5-6 String类valueOf方法

1: import javax.swing.*;
2: public class StringValueOf {
3:  public static void main(String args[]){
4:      char chars[]={'A','B','C','D','E','F','G'};
5:      boolean bool=true;
6:      char c='X';
7:      int i=5;
8:      long l=45004500;
9:      float f=5.6f;
10:     double d=67.678;
11:     Object o="happy";
12:     String output = "字符数组chars="+String.valueOf(chars);
13:     output += "\n数组中一部分="+String.valueOf(chars,2,4);
14:     output += "\n布尔类型="+String.valueOf(bool);                  
15:     output += "\n字符类型="+String.valueOf(c);
16:     output += "\n整型="+String.valueOf(i);
17:     output += "\n长整型="+String.valueOf(l);
18:     output += "\n浮点型="+String.valueOf(f);
19:     output += "\n双精度型="+String.valueOf(d);
20:     output += "\n对象类型="+String.valueOf(o);
21:     JOptionPane.showMessageDialog(null, output,"字符串valueOf方法",
22:                               JOptionPane.INFORMATION_MESSAGE);
23:     System.exit(0);     
24:  }
25:}

运行结果如图所示：

3. StringBuffer 类

尽管String类提供了许多处理字符串的方法，而String对象一旦创建，它的内容就不会改变，代表一个定长的字符串序列。为了创建和维护动态的字符串信息，Java使用StringBuffer类的对象代表可变长的可更改的字符串序列。每个StringBuffer都会按照其容量存储一定数目的字符，如果超限，StringBuffer就会自动调整大小为附加的字符分配空间。StringBuffer类的结构如图所示:

⑴ StringBuffer构造方法

     方法                                      说明
StringBuffer()                   构造一个其中不带字符的字符串缓冲区，其初始容量为 16 个字符。
StringBuffer(int capacity)       构造一个不带字符，但具有指定初始容量capacity的字符串缓冲区。
StringBuffer(String str)         构造一个字符串缓冲区，并将其内容初始化为指定的字符串内容。该
                                 字符串的初始容量为 16 加上字符串参数的长度。

清单 5-7 StringBuffer类的构造方法

1: import javax.swing.*;
2: public class StringBufferConstructors {
3:   public static void main(String args[]){
4:      StringBuffer strbf1,strbf2,strbf3;
5:      strbf1=new StringBuffer();
6:      strbf2=new StringBuffer(20);
7:      strbf3=new StringBuffer("Happy New Year!");
8:      String output="StringBuffer1=\""+strbf1.toString()+"\""+
9:                    "\nStringBuffer2=\""+strbf2.toString()+"\""+
10:                    "\nStringBuffer3=\""+strbf3+"\"";
11:     JOptionPane.showMessageDialog(null, output,"StringBuffer构造方法",
12:                                      JOptionPane.INFORMATION_MESSAGE);
13:     System.exit(0);
14:  }
15:}

运行结果如图所示：

⑵ StringBuffer的length、capacity、setLength、ensureCapacity方法

      方法                                说明
int length()                       返回长度（字符数）。
int capacity()                     返回当前容量。容量指可用于最新插入的字符的存储量，超
                                   过这一容量就需要再次进行分配。
void setLength(int newLength)      设置字符序列的长度。序列将被更改为一个新的字符序列，
                                   新序列的长度由参数指定。
void ensureCapacity(int minimumCapacity)  确保容量至少等于指定的最小值。

清单 5-8 StringBuffer类的length和capacity方法

1: import javax.swing.*;
2: public class StringBufferCapLen {
3:   public static void main(String args[]){
4:      StringBuffer stringbuffer = new StringBuffer("Nice to meet you!");
5:      String output="字符串=\""+stringbuffer.toString()+"\""+
6:                    "\n长度="+stringbuffer.length()+
7:                    "\n容量="+stringbuffer.capacity();
8:      stringbuffer.ensureCapacity(89);
9:      output +="\n\n新的容量 ="+stringbuffer.capacity();
10:     stringbuffer.setLength(12);
11:     output +="\n\n新的长度 ="+stringbuffer.length()+
12:              "\n字符串=\""+stringbuffer.toString()+"\"";
13:     JOptionPane.showMessageDialog(null,output,
14:           "StringBuffer的长度和容量方法",JOptionPane.INFORMATION_MESSAGE);
15:     System.exit(0);
16:  }
17:}

运行结果如图所示：

⑶ StringBuffer的charAt、setCharAt、getChars和reverse方法

      方法                            说明
char charAt(int index)     返回此序列中指定索引处的 char 值。第一个 char 值在索引 0
                           处，第二个在索引 1 处，依此类推，这类似于数组索引。
void setCharAt(int index,  将给定索引处的字符设置为 ch。此序列将被转换，以表示等同于
           char ch)        原字符序列的新字符序列，唯一的不同在于新序列在 index 处包含 ch。

void getChars(int srcBegin,  将字符从此序列复制到目标字符数组 dst。要复制的第一个字符
    int srcEnd, char[] dst,  在索引 srcBegin 处；要复制的最后一个字符在索引 srcEnd-1
    int dstBegin)            处。要复制的字符总数为 srcEnd-srcBegin。

StringBuffer reverse()      将此字符序列用其反转形式取代。

清单 5-9 StringBuffer类的charAt、setCharAt、getChars和reverse方法

1: import javax.swing.*;
2: public class StringBufferChars {
3:   public static void main(String args[]){
4:      StringBuffer stringbuffer = new StringBuffer("Hello World");
5:      String output="字符串=\""+stringbuffer.toString()+"\""+
6:                    "\n在0处的字符："+stringbuffer.charAt(0)+
7:                    "\n在8处的字符：="+stringbuffer.charAt(8);
8:      char charArray[]=new char[stringbuffer.length()];
9:      stringbuffer.getChars(0, stringbuffer.length(), charArray,0);
10:     output +="\n\n字符为：";
11:     for (int i=0;i<charArray.length;i++){
12:         output += charArray[i];         
13:     }
14:     stringbuffer.setCharAt(0,'h');
15:     stringbuffer.setCharAt(8,'R');
16:     output +="\n\n字符串=\""+stringbuffer.toString()+"\"";
17:     stringbuffer.reverse();
18:     output +="\n\n字符串=\""+stringbuffer.toString()+"\"";
19:     JOptionPane.showMessageDialog(null, output,"StringBuffer的字符方法",
20:                                          JOptionPane.INFORMATION_MESSAGE);
21:     System.exit(0);
22:  }
23:}

运行结果如图所示：

⑷ StringBuffer的append方法

     方法                                             说明
StringBuffer append(boolean b)       将 boolean 参数的字符串表示形式追加到序列。
StringBuffer append(char c)          将 char 参数的字符串表示形式追加到此序列。
StringBuffer append(char[] str)      将 char 数组参数的字符串表示形式追加到此序列。
StringBuffer append(char[] str,      将 char 数组参数的子数组的字符串表示形式追加到此序列。将
      int offset,int len)            char 数组 str 中的字符按顺序追加到此序列的内容中，从索引
                                     offset 开始。此字符的长度将增加 len。
StringBuffer append(double d)        将 double 参数的字符串表示形式追加到此序列。
StringBuffer append(float f)         将 float 参数的字符串表示形式追加到此序列。
StringBuffer append(int i)           将 int 参数的字符串表示形式追加到此序列。
StringBuffer append(long lng)        将 long 参数的字符串表示形式追加到此序列。
StringBuffer append(Object obj)      追加 Object 参数的字符串表示形式。
StringBuffer append(String str)      将指定的字符串追加到此字符序列。
StringBuffer append(StringBuffer sb) 将指定的StringBuffer 追加到此序列中。

清单5-10 StringBuffer类的append方法

1: import javax.swing.*;
2: public class StringBufferAppend {     
3:    public static void main(String[] args) {
4:      Object object="you and me";
5:      String str="How about";
6:      char charArray[]={'A','B','C','D','E','F'};
7:      boolean bool=false;
8:      char ch='Y';
9:      int iNum=6;
10:     long lNum=12345678;
11:     float fNum=4.5f;
12:     double dNum=34.567;
13:     StringBuffer stringbuffer=new StringBuffer();
14:     stringbuffer.append(object);
15:     stringbuffer.append(" ");
16:     stringbuffer.append(charArray);
17:     stringbuffer.append(" ");
18:     stringbuffer.append(charArray,0,4);
19:     stringbuffer.append(" ");
20:     stringbuffer.append(bool);
21:     stringbuffer.append(" ");
22:     stringbuffer.append(ch);
23:     stringbuffer.append(" ");
24:     stringbuffer.append(iNum);
25:     stringbuffer.append(" ");
26:     stringbuffer.append(lNum);
27:     stringbuffer.append(" ");
28:     stringbuffer.append(fNum);
29:     stringbuffer.append(" ");
30:     stringbuffer.append(dNum);      
31:     String output ="\n字符串=\""+stringbuffer.toString()+"\"";
32:     JOptionPane.showMessageDialog(null, output,"StringBuffer的append方法",
33:                                   JOptionPane.INFORMATION_MESSAGE);
34:     System.exit(0);
35:  }
36:}

运行结果如图所示：

⑸ StringBuffer的insert和delete方法

  方法                                            说明
StringBuffer insert(int offset,        将 boolean 参数的字符串表示形式插入此序列中。
                boolean b)
StringBuffer insert(int offset,        将 char 参数的字符串表示形式插入此序列中。
                   char c)
StringBuffer insert(int offset,        将 char 数组参数的字符串表示形式插入此序列中。
             char[] str)

StringBuffer insert(int index,        将 str 数组参数的子数组的字符串表示形式插入此序列中。
  char[] str,　int offset,　int len)  其中子数组从指定的 offset 开始，包含 len 个 char。子
                                      数组的字符将被插入 index 所指示的位置。此序列的长度将
                                      增加 len 个 char。
StringBuffer insert(int offset,       将 double 参数的字符串表示形式插入此序列中。
                  double d)
StringBuffer insert(int offset,       将 float 参数的字符串表示形式插入此序列中。 
                   float f)

StringBuffer insert(int offset,       将 int 参数的字符串表示形式插入此序列中。
                   int i)   
StringBuffer insert(int offset,       将 long 参数的字符串表示形式插入此序列中。
                  long l)
StringBuffer insert(int offset,       将 Object 参数的字符串表示形式插入此字符序列中。
               Object obj)
StringBuffer insert(int offset,       将字符串插入此字符序列中。
               String str)
StringBuffer delete(int start,        移除此序列的子字符串中的字符。该子字符串从指定的
                  int end)            start 处开始，一直到索引 end - 1 处的字符，如果不存在
                                      这种字符，则一直到序列尾部。
StringBuffer deleteCharAt(int index)  移除此序列指定位置的 char。此序列将缩短一个 char。

清单 5-11 StringBuffer类的insert和delete方法

1: import javax.swing.*;
2: public class StringBufferInsertDelete {
3:   public static void main(String[] args) {
4:      Object object="you and me";
5:      String str="How about";
6:      char charArray[]={'A','B','C','D','E','F'};
7:      boolean bool=false;
8:      char ch='Y';
9:      int iNum=6;
10:     long lNum=12345678;
11:     float fNum=4.5f;
12:     double dNum=34.567;
13:     StringBuffer stringbuffer=new StringBuffer();
14:     stringbuffer.insert(0,object);
15:     stringbuffer.insert(0," ");
16:     stringbuffer.insert(0,charArray);
17:     stringbuffer.insert(0," ");
18:     stringbuffer.insert(0,charArray,0,4);
19:     stringbuffer.insert(0," ");
20:     stringbuffer.insert(0,bool);
21:     stringbuffer.insert(0," ");
22:     stringbuffer.insert(0,ch);
23:     stringbuffer.insert(0," ");
24:     stringbuffer.insert(0,iNum);
25:     stringbuffer.insert(0," ");
26:     stringbuffer.insert(0,lNum);
27:     stringbuffer.insert(0," ");
28:     stringbuffer.insert(0,fNum);
29:     stringbuffer.insert(0," ");
30:     stringbuffer.insert(0,dNum);        
31:     String output ="\n插入后的字符串=\""+stringbuffer.toString()+"\"";
32:     stringbuffer.deleteCharAt(9);
33:     stringbuffer.delete(3,7);
34:     output +="\n\n删除后的字符串=\""+stringbuffer.toString()+"\"";
35:     JOptionPane.showMessageDialog(null, output,
36:       "StringBuffer的insert和delete方法",JOptionPane.INFORMATION_MESSAGE);
37:     System.exit(0);
38:  }
39:}

运行结果如图所示：

5.1.4 子任务

１.子任务１—聊天系统中的固定字符串对象信息处理

聊天系统中的信息处理，定义一个结构类，用于包含有关用户之间的消息信息，样例代码如下：

1: public class DushiMessage {
2:    public String to;
3:    public String from;
4:    public String text;
5:    public DushiMessage(String t, String f, String txt) {
6:      to = t;
7:      from = f;
8:      text = txt;
9:    }
10:}

在类的属性变量定义中，to、from和text的数据类型都声明为String，用于用户之间的信息交互，而DushiMessage类封装了属性信息，用于数据对象传递。

在DushiServerConnection类中，实现了sendStoredMess()方法，其中对DushiMessage类型的数据进行了处理，这个方法将发送所有被存储的消息，样例代码如下：

1:   protected void sendStoredMess(){
2:      DushiMessage message;
3:      Vector messages = new Vector();
4:      Enumeration e = server.messages.elements();
5:      while (e.hasMoreElements()) {
6:          message = (DushiMessage) e.nextElement();
7:          if (message.to.equals(user.name)) {
8:              messages.add(message);
9:              server.messages.remove(message);
10:         }
11:     }
12:     super.sendStoredMess(messages);
13:  }

清单 5-12 DushiMessage.java

清单 5-13 DushiServerConnection.java

2.子任务2— 聊天系统中的可变字符串对象信息处理

聊天系统经常处理可变字符串对象信息，样例代码片段如下：

1: private void updateInformationLabel(String userName,String userRoom,int totalUserCount){
2:      StringBuffer stringbuffer = new StringBuffer();
3:      stringbuffer.append("用户名: ");
4:      stringbuffer.append(userName);
5:      stringbuffer.append("       ");
6:      stringbuffer.append("房间名: ");
7:      stringbuffer.append(userRoom);
8:      stringbuffer.append("       ");
9:      stringbuffer.append("用户编号: ");
10:     stringbuffer.append(totalUserCount);
11:     stringbuffer.append("       "); 
12:     informationLabel.setText(stringbuffer.toString());      
13: }

5.1.5 扩展知识点

１. Java的API文档

要想更详细的了解每一个Java系统类包和每一个系统类的用法，必须参阅Java的API技术文档，有Java SE API、Java EE API等。这些文档可从www.oracle.com网站下载或在线查阅：

在这些API页面中，左上部可选择某个系统类包，在左下部可选择接口或类或异常，而右边可列出接口、类或异常的详细描述及用法。在Java的程序设计中，程序员离不开这些API文档。

2. Java 包

在前面的情景任务中，已经使用了Java的包，本知识点为了深刻理解包的概念将对其进一步描述。

包是类的容器，用于保证类名空间的一致性，它是以层次结构组织的，在定义一个新类时，包可以被明确的声明，使用关键字package进行包的定义。

⑴ package语句

Java中的包在操作系统的管理上就是一个文件夹，其中存放class文件，而文件夹要成为包，必须在Java源文件的首行使用package语句进行声明，它将告诉编译生成的类（class文件）属于哪个包中。在 Java程序的开发过程中，Java源文件的包结构与编译后的类文件的包结构是相同的，而且目录名和包名是完全一致的。package语句的格式如下：

package packagename1[.packagename2[.packagename3]];

Java是区分大小写的，包名一律采用小写，不同层次的包名之间采用圆点（.）分隔，这种层次反映了Java开发系统的文件系统结构，例如：

package com.hotdon.mem;

在Windows系统上，源文件和类文件存放目录如下：

..\src\com\hotdon\mem

..\bin\com\hotdon\mem

而在Linux系统上，源文件和类文件存放目录与以上类似，但写法不同:

../src/com/hotdon/mem
../bin/ com/hotdon/mem

包的概念解决了类的命名空间的冲突，但也为编译和运行带来一定的麻烦，对应的类放进包中，在运行时如何找到这个类，在概念上读者必须清晰。

对于整个包结构的根，Java编译器确定的是保存在CLASSPATH环境变量中的项，每个项之间使用分号（;）分隔。这些项既包含了Java的系统类库的根，也可以是自定义的类包结构的根。对于没有声明包结构的类，将其放在一个无名的缺省包中，如果在其存放源文件的目录下，在命令行窗口上使用javac命令编译这些源文件并且使用java命令后跟类名执行，其之所以能工作是因为缺省的当前目录的根（.）在CLASSPATH环境变量中。如果一个类中声明了包结构，例如：

package com.hotdon.mem;
public class memberLogin {
  public static void main(String[] args){
      System.out.println("会员登录应用程序");
   }
}

这时在命令行窗口（当前开发路径下）使用javac命令编译时需要带参数：

javac –sourcepath src src\com\hotdon\mem\memberLogin.java –d bin

其中-sourcepath src指定源文件的位置，–d bin指定class文件的存放位置。

在命令行窗口使用java命令执行时，需要将存放类文件的包结构的根在CLASSPATH环境变量中设定，例如：开发路径\bin（c:\MyJava\bin），这样可以在任意目录下执行：

java com.hotdon.mem.memberLogin

⑵ import语句

Java源文件的首行语句是package，其后就是一组import语句，引用类或包中的所有类，使其直接可用，格式如下：

import package1[.package2].(classname|*);

在此，package1是最外层包的名称，package2是由圆点（.）分隔的第二层包的名字，最后是由圆点（.）分隔类名，或者是由星号（*）表示整个包中的所有类。例如：

import javax.swing.*; 
import java.util.Date;

通常推荐在import语句中指明需要引用的具体类，这时因为对一个大包引用所有类（*），虽然不影响运行性能，但是会影响编译速度。

在前面讲过，Java基本的语言功能的类包含在java.lang包中，编译器默认地为所有程序引入这个包，不需要（import java.lang.*;）显式声明。

⑶ Java包的访问限制

类与包是封装和限定命名空间及属性、方法作用域的两种策略。包是类和其它包的容器，而类是属性和方法代码的容器。类是Java中最小单元，如果引入包，则类单元之间分为四种情况：

• 同一个包中的子类
• 同一个包中的非子类
• 不同包中的子类
• 不同包中的非子类

通过public | protected | private或默认的修饰限定，以public修饰的单元，可以从任何位置访问；以private修饰的单元，不能从类外访问；以protected修饰的单元，可以被同一包中的类及子类与不同包中的子类访问；默认没有修饰的单元，只能被同一个包中的类及子类访问。

3. Java 类库的结构

Java不仅是编程语言，也是一个开发平台，同时还是一个程序发布平台，Java的运行环境包含了完整的系统类文件包，根据项目的不同，Java平台划分为J2SE、J2EE和J2ME三种平台，了解每一种平台的类库结构，是学好它们的重要基础，这是因为Java中的重量级的设计理念来自于这些系统类库。系统类按照功能划分为不同包，根据用户的类的设计不同，通过import语句组分别引用系统包中的不同类。

⑴ J2SE类库结构

J2SE是Java 2 Standard Edition，主要是为台式机和工作站提供一个开发和运行的平台，它是学习Java的入门，也是学习其它平台的基础。J2SE类库的外层包的分类如图所示：

每个外层包展示的第二层包如图所示：

⑵ J2EE类库结构 J2EE是Java 2 Enterprise Edition，主要是为企业级应用提供一个应用服务器的运行和开发平台，J2EE是在J2SE的基础上对javax包进行了扩充，现在的名称是Java Enterprise Edition，简称JEE。如图所示：

4. Java.lang 包中的基本语言和系统类

Java编程中系统自动默认引用的包就是java.lang包，它是Java编程的基础，以下分几部分介绍：

⑴ 基本语言和系统类

涉及对象、类、虚拟机和操作系统内部的功能，图中描述了它们的关系：其中实线和带箭头的实线表示双向关联和单向关联关系；而带箭头的虚线表示依赖关系。

• Object：是类层次结构的根类。每个类都使用 Object 作为超类。所有对象（包括数组）都实现这个类的方法。
• Class：它的实例表示正在运行的 Java 应用程序中的类和接口。Class 没有公共构造方法，Class 对象是在加载类时由 Java 虚拟机以及通过调用类加载器中的 defineClass 方法自动构造的。
• Cloneable：它是一个空接口，以指示 Object.clone() 方法可以合法地对实现该接口的类的实例进行按字段复制。该类可以返回它自身的一个拷贝。
• ClassLoader：它是一个抽象类，负责加载类的对象。封装一个到虚拟机类加载器的接口，用于从特定输入流加载Java类文件。
• SecurityManager：它是一个允许应用程序实现安全策略的类，允许应用程序在执行一个可能不安全或敏感的操作前确定该操作是什么，以及是否是在允许执行该操作的安全上下文中执行它。应用程序可以允许或不允许该操作。
• System：它是一个由final修饰的类，不能被实例化，但它包含一些有用的静态类字段和静态方法。在 System 类提供的设施中，有标准输入、标准输出和错误输出流；对外部定义的属性和环境变量的访问；加载文件和库的方法；还有快速复制数组的一部分的实用方法。提供一个挂接程序与运行虚拟机的操作系统交互。
• Runtime：每个 Java 应用程序都有一个 Runtime 类实例，使应用程序能够与其运行的环境相连接。可以通过 getRuntime 方法获取当前运行时。 应用程序不能创建自己的 Runtime 类实例。
• Process：由ProcessBuilder.start() 和 Runtime.exec 方法创建一个本机进程，并返回 Process 子类的一个实例，该实例可用来控制进程并获取相关信息。
• Compiler：主要支持 Java 到本机代码的编译器及相关服务。根据设计，Compiler 类不做任何事情，它充当一个 JIT 编译器实现的占位符。

⑵ 错误和异常类

Java中的程序执行不正常，被认为是错误或异常，它们通过三个类及其子类来体现，如图所示：带空心箭头的实线表示继承关系。

• Throwable：是 Java 语言中所有错误或异常的超类。只有当对象是此类（或其子类之一）的实例时，才能通过 Java 虚拟机或者 Java throw 语句抛出。
• Error：不应该捕获的严重问题。
• Exception：是所有应该捕获的异常类的基类。

⑶ 包装类

出于性能方面的考虑，Java采用了原始数据类型，像byte、short、int、long、char、float、double和boolean，这些数据类型不属于对象层次树的一部分。它们只是通过值传递给方法，而不是采用引用传递。但在Java的程序设计中，一切都是对象，而且针对Java的特定类，只能进行对象处理，例如Vector、Enumeration等，在后面情景任务中将会详细讲述，这时，需要创建原始数据类型的对象，而在Java中为每个原始数据类型提供了相应的包装类。

 原始数据类型                包装类
 byte（字节）                 Byte
 char（字符）                 Character
 int（整型）                  Integer
 long（长整型）               Long
 float（浮点型）              Float
 double（双精度）             Double
 boolean（布尔）              Boolean
 short（短整型）              Short

包装类不但用于封装java原始数据类型，并使用方法调用执行数学操作。如图所示描述这些类和它们的关系。带空心箭头的实线表示继承关系；而带空心箭头的虚线表示实现关系。

⑷ Java中的反射类

Java提供了通过反射功能在运行时能够动态检查一个类的描述，这个包括类的属性和方法，而方法里当然包含构造方法。图中描述了涉及反射的主要类和接口。它们位于java.lang.reflect包中。

⑸ 垃圾回收

java.lang.ref包提供了一组类，支持在某种程度上与垃圾回收器之间的交互。组成此垃圾回收器交互的类如图所示。