引用

J2EE开发环境配置个人总结

   一连两三天，虽然不能说一刻不停的在搞，但也几乎已经虚脱了。还好终于搞定，乘着劲我觉得很有必要终结一下。

    我使用的是eclipse3.0的IDE，自然在学习到j2ee部分必须要装很多插件，而且有很多版本对应问题，一般提供插件下载的网站都会有说明，请留意。此文建立在jdk和eclipse已正确安装并使用的前提下，并且所用软件均为免费且广为认可的。（eclipse3.0.1+tomcat5.0.16+tomcatPluginV31+emf-sdo-runtime-2.0.1+org.objectweb.lomboz_3.0.1.N20050106）

    我第一个安装的是jsp服务器tomcat5.0，可以在http://tomcat.apache.org/下载，这个的安装比较简单，安装完成后只需在系统环境变量中添加CATALINA_HOME=F:\Java\Tomcat 5.0（我的安装目录）就行了。之后可以运行bin目录下的startup.bat（直接双击或在DOS中运行）并在浏览器中以地址http://localhost:8080/测试就OK了。为使tomcat能和eclipse整合到一起，还需要下载并安装tomcat插件tomcatPlugin（下载地址http://www.sysdeo.com/eclipse/tomcatplugin

）。正常的话ec启动后会新出现三个功能菜单start Tomcat, stop Tomcat和reatart Tomcat, 还必须在窗口\首选项中导入tomcat的安装路径。

5.1.4 LayoutManager 布局管理器(1)

　　java为了实现跨平台的特性并且获得动态的布局效果，java将容器内的所有组件安排给一个"布局管理器"负责管理，如：排列顺序，组件的大小、位置，当窗口移动或调整大小后组件如何变化等功能授权给对应的容器布局管理器来管理，不同的布局管理器使用不同算法和策略，容器可以通过选择不同的布局管理器来决定布局。

　　 布局管理器主要包括：FlowLayout，BorderLayout，GridLayout，CardLayout，GridBagLayout

　　例5．3
　　　　import java.awt.*;
　　　　public class ExGui{
　　　　　　　　private Frame f;
　　　　　　　　private Button b1;
　　　　　　　　private Button b2;
　　　　　　　　public static void main(String args[]){
　　　　　　　　　　　　ExGui that = new ExGui();
　　　　　　　　　　　　that.go();
　　　　}

　　　　　　　　public void go(){
　　　　　　　　　　　　f = new Frame("GUI example");
　　　　　　　　　　　　f.setLayout(new FlowLayout());
　　　　　　　　　　　　//设置布局管理器为FlowLayout
　　　　　　　　　　　　b1 = new Button("Press Me");
　　　　　　　　　　　　//按钮上显示字符"Press Me"
　　　　　　　　　　　　b2 = new Button("Don't Press Me");
　　　　　　　　　　　　f.add(b1);
　　　　　　　　　　　　f.add(b2);
　　　　　　　　　　　　f.pack();
　　　　　　　　　　　　//紧凑排列，其作用相当于setSize()，即让窗口
　　　　　　　　　　　　尽量小，小到刚刚能够包容住b1、b2两个按钮
　　　　　　　　　　　　f.setVisible(true);
　　　　　　　　}
　　　　}

　　1. FlowLayout

　　FlowLayout 是Panel，Applet的缺省布局管理器。其组件的放置规律是从上到下、从左到右进行放置，如果容器足够宽，第一个组件先添加到容器中第一行的最左边，后续的组件依次添加到上一个组件的右边，如果当前行已放置不下该组件，则放置到下一行的最左边。

　　构造方法主要下面几种：
　　FlowLayout(FlowLayout.RIGHT,20,40);
　　/*第一个参数表示组件的对齐方式，指组件在这一行中的位置是居中对齐、居右对齐还是居左对齐，第二个参数是组件之间的横向间隔，第三个参数是组件之间的纵向间隔，单位是象素。*/
　　FlowLayout(FlowLayout.LEFT);
　　//居左对齐，横向间隔和纵向间隔都是缺省值5个象素
　　FlowLayout();
　　//缺省的对齐方式居中对齐，横向间隔和纵向间隔都是缺省值5个象素

　　例5．4
　　　　import java.awt.*;
　　　　public class myButtons{
　　　　　public static void main(String args[])
　　　　　{
　　　　　　　　Frame f = new Frame();
　　　　　　　　f.setLayout(new FlowLayout());
　　　　　　　　Button button1 = new Button("Ok");
　　　　　　　　Button button2 = new Button("Open");
　　　　　　　　Button button3 = new Button("Close");
　　　　　　　　f.add(button1);
　　　　　　　　f.add(button2);
　　　　　　　　f.add(button3);
　　　　　　　　f.setSize(300,100);
　　　　　　　　f.setVisible(true);
　　　　　}
　　　　}

　　当容器的大小发生变化时，用FlowLayout管理的组件会发生变化，其变化规律是：组件的大小不变，但是相对位置会发生变化。例如上图中有三个按钮都处于同一行，但是如果把该窗口变窄，窄到刚好能够放下一个按钮，则第二个按钮将折到第二行，第三个按钮将折到第三行。按钮"Open"本来在按钮"OK"的右边，但是现在跑到了下面，所以说"组件的大小不变，但是相对位置会发生变化"。

　　2. BorderLayout

　　BorderLayout 是Window，Frame和Dialog的缺省布局管理器。BorderLayout布局管理器把容器分成5个区域：North，South，East，West和Center，每个区域只能放置一个组件。

　　例5．5
　　　　import java.awt.*;
　　　　public class buttonDir{
　　　　　public static void main(String args[]){
　　　　　　Frame f = new Frame("BorderLayout");
　　　　　　f.setLayout(new BorderLayout());
　　　　　　f.add("North", new Button("North"));
　　　　　　//第一个参数表示把按钮添加到容器的North区域
　　　　　　f.add("South", new Button("South"));
　　　　　　//第一个参数表示把按钮添加到容器的South区域
　　　　　　f.add("East", new Button("East"));
　　　　　　//第一个参数表示把按钮添加到容器的East区域
　　　　　　f.add("West", new Button("West"));
　　　　　　//第一个参数表示把按钮添加到容器的West区域
　　　　　　f.add("Center", new Button("Center"));
　　　　　　//第一个参数表示把按钮添加到容器的Center区域
　　　　　　f.setSize(200,200);
　　　　　　f.setVisible(true);
　　　　　}
　　　　}

　　在使用BorderLayout的时候，如果容器的大小发生变化，其变化规律为：组件的相对位置不变，大小发生变化。例如容器变高了，则North、South区域不变，West、Center、East区域变高；如果容器变宽了，West、East区域不变，North、Center、South区域变宽。不一定所有的区域都有组件，如果四周的区域（West、East、North、South区域）没有组件，则由Center区域去补充，但是如果Center区域没有组件，则保持空白。

　　3. GridLayout

　　使容器中各个组件呈网格状布局，平均占据容器的空间。

　　例5．6
　　　　import java.awt.*;
　　　　public class ButtonGrid {
　　　　public static void main(String args[]) {
　　　　　　Frame f = new Frame("GridLayout");
　　　　　　f.setLayout(new GridLayout(3,2));
　　　　　　　　　　　　　　　　 //容器平均分成3行2列共6格
　　　　　　f.add(new Button("1")); //添加到第一行的第一格
　　　　　　f.add(new Button("2")); //添加到第一行的下一格
　　　　　　f.add(new Button("3")); //添加到第二行的第一格
　　　　　　f.add(new Button("4")); //添加到第二行的下一格
　　　　　　f.add(new Button("5")); //添加到第三行的第一格
　　　　　　f.add(new Button("6")); //添加到第三行的下一格
　　　　　　f.setSize(200,200);
　　　　　　f.setVisible(true);
　　　　}
　　　　}
5.1.4 LayoutManager 布局管理器(2)

　　 4. CardLayout

　　CardLayout布局管理器能够帮助用户处理两个以至更多的成员共享同一显示空间，它把容器分成许多层，每层的显示空间占据整个容器的大小，但是每层只允许放置一个组件，当然每层都可以利用Panel来实现复杂的用户界面。牌布局管理器（CardLayout）就象一副叠得整整齐齐的扑克牌一样，有54张牌，但是你只能看见最上面的一张牌，每一张牌就相当于牌布局管理器中的每一层。

　　例5．7
　　import java.awt.*;
　　import java.awt.event.*; //事件处理机制，下一节的内容
　　public class ThreePages implements MousListener {
　　　　CardLayout layout=new CardLayout(); //实例化一个牌布局管理器对象
　　　　Frame f=new Frame("CardLayout");
　　　　Button page1Button;
　　　　Label page2Label; //Label是标签，实际上是一行字符串
　　　　TextArea page3Text; //多行多列的文本区域
　　　　Button page3Top;
　　　　Button page3Bottom;

　　public static void main(String args[])
　　{ new ThreePages().go(); }

　　Public void go()
　　{ 　　f.setLayout(layout); //设置为牌布局管理器layout
　　　　f.add(page1Button=new Button("Button page"),"page1Button"); /*第二个参数"page1Button"表示的是你对这层牌所取的名字*/
　　　　page1Button.addMouseListener(this); //注册监听器
　　　　f.add(page2Label=new Label("Label page"),"page2Label");
　　　　page2Label.addMouseLisener(this); //注册监听器
　　　　Panel panel=new Panel();
　　　　panel.setLayout(new BorderLayout());
　　　　panel.add(page3Text=new TextArea("Composite page"),"Center");
　　　　page3Text.addMouseListener(this);
　　　　panel.add(page3Top=new Button("Top button") , "North");
　　　　page3Top.addMouseListener(this);
　　　　panel.add(page3Bottom=new Button("Bottom button") ,"South");
　　　　page3Bottom.addMouseListener(this);
　　　　f.add(panel,"panel");
　　　　f.setSize(200,200);
　　　　f.setVisible(true);
　　}
　　……
　　}

　　5．容器的嵌套

　　在复杂的图形用户界面设计中，为了使布局更加易于管理，具有简洁的整体风格，一个包含了多个组件的容器本身也可以作为一个组件加到另一个容器中去，容器中再添加容器，这样就形成了容器的嵌套。下面是一个容器嵌套的例子。

　　例5．8
　　　　import java.awt.*;
　　　　public class ExGui3{
　　　　private Frame f;
　　　　private Panel p;
　　　　private Button bw,bc;
　　　　private Button bfile,bhelp;
　　　　　　　public static void main(String args[])
　　　　　　　{
　　　　　　　　　ExGui3 gui = new ExGui3();
　　　　　　　　　gui.go();
　　　　　　　}

　　　　public void go(){
　　　　　　　f = new Frame("GUI example 3");
　　　　　　　bw=new Button("West");
　　　　　　　bc=new Button("Work space region");
　　　　　　　f.add(bw,"West");
　　　　　　　f.add(bc,"Center");
　　　　　　　p = new Panel();
　　　　　　　f.add(p,"North");
　　　　　　　bfile= new Button("File");
　　　　　　　bhelp= new Button("Help");
　　　　　　　p.add(bfile);
　　　　　　　p.add(bhelp);
　　　　　　　f.pack();
　　　　　　　f.setVisible(true);
　　　　}
　　　　}

　　小 结：

　　　1．Frame是一个顶级窗口。Frame的缺省布局管理器为BorderLayout。

　　　2．Panel 无法单独显示，必须添加到某个容器中。 Panel 的缺省布局管理器为FlowLayout。

　　　3．当把Panel 作为一个组件添加到某个容器中后，该Panel 仍然可以有自己的布局管理器。因此，可以利用Panel 使得BorderLayout 中某个区域显示多个组件，达到设计复杂用户界面的目的 。

　　　4．如果采用无布局管理器 setLayout(null)，则必须使用setLocation(),setSize(),setBounds()等方法手工设置组件的大小和位置，此方法会导致平台相关，不鼓励使用。

　　5.2 AWT事件处理模型

　　上一节中的主要内容是如何放置各种组件，使图形界面更加丰富多彩，但是还不能响应用户的任何操作，要能够让图形界面接收用户的操作，就必须给各个组件加上事件处理机制。在事件处理的过程中，主要涉及三类对象：

　　◇ Event-事件，用户对界面操作在java语言上的描述，以类的形式出现，例如键盘操作对应的事件类是KeyEvent。

　　◇ Event Source-事件源，事件发生的场所，通常就是各个组件，例如按钮Button。

　　◇ Event handler-事件处理者，接收事件对象并对其进行处理的对象

　　例如，如果用户用鼠标单击了按钮对象button，则该按钮button就是事件源，而java运行时系统会生成ActionEvent类的对象actionE，该对象中描述了该单击事件发生时的一些信息，然后，事件处理者对象将接收由java运行时系统传递过来的事件对象actionE并进行相应的处理。

　　由于同一个事件源上可能发生多种事件，因此java采取了授权处理机制(Delegation Model)，事件源可以把在其自身所有可能发生的事件分别授权给不同的事件处理者来处理。比如在Canvas对象上既可能发生鼠标事件，也可能发生键盘事件，该Canvas对象就可以授权给事件处理者一来处理鼠标事件，同时授权给事件处理者二来处理键盘事件。有时也将事件处理者称为监听器，主要原因也在于监听器时刻监听着事件源上所有发生的事件类型，一旦该事件类型与自己所负责处理的事件类型一致，就马上进行处理。授权模型把事件的处理委托给外部的处理实体进行处理，实现了将事件源和监听器分开的机制。事件处理者（监听器）通常是一个类，该类如果要能够处理某种类型的事件，就必须实现与该事件类型相对的接口。例如例5.9中类ButtonHandler之所以能够处理ActionEvent事件，原因在于它实现了与ActionEvent事件对应的接口ActionListener。每个事件类都有一个与之相对应的接口。

　　将事件源对象和事件处理器（事件监听器）分开。
　　　　
　　打个不太恰当的比喻，比如说有一位李先生，李先生可能会发生很多法律纠纷，可能是民事法律纠纷，也可能是刑事法律纠纷，那么李先生可以请律师，他可以授权王律师负责帮他打民事法律的官司，同时也可以授权张律师帮他打刑事法律的官司。这个请律师的过程从李先生的角度来看，就是授权的过程，而从王律师和张律师的角度来看，一旦被授权，他们就得时刻对李先生负责，"监听"着李先生，一旦发生民事纠纷了，王律师就要马上去处理，而一旦发生刑事纠纷了，张律师就要马上进行处理。此时此刻，李先生就是事件源，王律师是一个事件处理者，张律师是另外一个事件处理者，民事纠纷和刑事纠纷就是不同类型的事件。
　　

　　例5.9
　　　　import java.awt.*;
　　　　import java.awt.event.*;
　　　　public class TestButton {
　　　　public static void main(String args[])
　　　　{
　　　　　　Frame f = new Frame("Test");
　　　　　　Button b = new Button("Press Me!");
　　　　　　b.addActionListener(new ButtonHandler()); /*注册监听器进行授权，该方法的参数是事件处理者对象，要处理的事件类型可以从方法名中看出，例如本方法要授权处理的是ActionEvent，因为方法名是addActionListener。*/
　　　　　　f.setLayout(new FlowLayout()); //设置布局管理器
　　　　　　f.add(b);
　　　　　　f.setSize(200,100);
　　　　　　f.setVisible(true);
　　　　　　}
　　　　}
　　　　class ButtonHandler implements ActionListener {
　　　　//实现接口ActionListener才能做事件ActionEvent的处理者
　　　　public void actionPerformed(ActionEvent e)
　　　　//系统产生的ActionEvent事件对象被当作参数传递给该方法
　　　　{
　　　　　　System.out.println("Action occurred");
　　　　//本接口只有一个方法，因此事件发生时，系统会自动调用本方法，需要做的操作就把代码写在则个方法里。
　　　　}
　　　　}

　　使用授权处理模型进行事件处理的一般方法归纳如下：

　　1．对于某种类型的事件XXXEvent, 要想接收并处理这类事件，必须定义相应的事件监听器类，该类需要实现与该事件相对应的接口XXXListener；

　　2．事件源实例化以后，必须进行授权，注册该类事件的监听器，使用addXXXListener(XXXListener ) 方法来注册监听器。

equals 方法（是String类从它的超类Object中继承的）被用来检测两个对象是否相等，即两个对象的内容是否相等。
==用于比较引用和比较基本数据类型时具有不同的功能：
比较基本数据类型，如果两个值相同，则结果为true
而在比较引用时，如果引用指向内存中的同一对象，结果为true

从thinking in java电子版中摘了一段:
1. 检查对象是否相等
关系运算符==和!=也适用于所有对象，但它们的含义通常会使初涉Java领域的人找不到北。下面是一个例子：


//: Equivalence.java

public class Equivalence {
public static void main(String[] args) {
Integer n1 = new Integer(47);
Integer n2 = new Integer(47);
System.out.println(n1 == n2);
System.out.println(n1 != n2);
}
} ///:~

其中，表达式System.out.println(n1 == n2)可打印出内部的布尔比较结果。一般人都会认为输出结果肯定先是true，再是false，因为两个Integer对象都是相同的。但尽管对象的内容相同，句柄却是不同的，而==和!=比较的正好就是对象句柄。所以输出结果实际上先是false，再是true。这自然会使第一次接触的人感到惊奇。
若想对比两个对象的实际内容是否相同，又该如何操作呢？此时，必须使用所有对象都适用的特殊方法equals()。但这个方法不适用于“主类型”，那些类型直接使用==和!=即可。下面举例说明如何使用：


//: EqualsMethod.java

public class EqualsMethod {
public static void main(String[] args) {
Integer n1 = new Integer(47);
Integer n2 = new Integer(47);
System.out.println(n1.equals(n2));
}
} ///:~

正如我们预计的那样，此时得到的结果是true。但事情并未到此结束！假设您创建了自己的类，就象下面这样：


//: EqualsMethod2.java

class Value {
int i;
}

public class EqualsMethod2 {
public static void main(String[] args) {
Value v1 = new Value();
Value v2 = new Value();
v1.i = v2.i = 100;
System.out.println(v1.equals(v2));
}
} ///:~

此时的结果又变回了false！这是由于equals()的默认行为是比较句柄。所以除非在自己的新类中改变了equals()，否则不可能表现出我们希望的行为。不幸的是，要到第7章才会学习如何改变行为。但要注意equals()的这种行为方式同时或许能够避免一些“灾难”性的事件。
大多数Java类库都实现了equals()，所以它实际比较的是对象的内容，而非它们的句柄。

初学 Java 有段时间了，感觉似乎开始入了门，有了点儿感觉
但是发现很多困惑和疑问而且均来自于最基础的知识
折腾了一阵子又查了查书，终于对 String 这个特殊的对象有了点感悟

大家先来看看一段奇怪的程序：
public class TestString {
    public static void main(String[] args) {
        String s1 = "Monday";
        String s2 = "Monday";
    }
}
这个程序真是简单啊！可是有什么问题呢？

1. 来自 String 的忧虑
上面这段程序中，到底有几个对象呢？
可能很多人脱口而出：两个，s1 和 s2
为什么？
String 是 final 类，它的值不可变。
看起来似乎很有道理，那么来检测一下吧，稍微改动一下程序
就可以看到结果了：

public class TestString {
    public static void main(String[] args) {
        String s1 = "Monday";
        String s2 = "Monday";
        if (s1 == s2)
            System.out.println("s1 == s2");
        else
            System.out.println("s1 != s2");
    }
}
呵呵，很多人都会说已经不止两个对象了
编译并运行程序，输出：s1 == s2
啊！
为什么 s1 == s2 ?
== 分明是在说：s1 与 s2 引用同一个 String 对象 -- "Monday"!

2. 千变万化的 String
再稍微改动一下程序，会有更奇怪的发现：
public class TestString {
    public static void main(String[] args) {
        String s1 = "Monday";
        String s2 = new String("Monday");
        if (s1 == s2)
            System.out.println("s1 == s2");
        else
            System.out.println("s1 != s2");
        if (s1.equals(s2))
            System.out.println("s1 equals s2");
        else
            System.out.println("s1 not equals s2");
    }
}
我们将 s2 用 new 操作符创建
程序输出：
s1 != s2
s1 equals s2
嗯，很明显嘛
s1 s2分别引用了两个"Monday"String对象
可是为什么两段程序不一样呢？

3. 在 String 的游泳池中游泳
哈哈，翻了翻书终于找到了答案：
原来，程序在运行的时候会创建一个字符串缓冲池
当使用 s2 = "Monday" 这样的表达是创建字符串的时候，程序首先会
在这个String缓冲池中寻找相同值的对象，在第一个程序中，s1先被
放到了池中，所以在s2被创建的时候，程序找到了具有相同值的 s1
将 s2 引用 s1 所引用的对象"Monday"

第二段程序中，使用了 new 操作符，他明白的告诉程序：
“我要一个新的！不要旧的！”与是一个新的"Monday"Sting对象被创
建在内存中。他们的值相同，但是位置不同，一个在池中游泳
一个在岸边休息。哎呀，真是资源浪费，明明是一样的非要分开做什么呢？

4. 继续潜水
再次更改程序：
public class TestString {
    public static void main(String[] args) {
        String s1 = "Monday";
        String s2 = new String("Monday");
        s2 = s2.intern();
        if (s1 == s2)
            System.out.println("s1 == s2");
        else
            System.out.println("s1 != s2");
        if (s1.equals(s2))
            System.out.println("s1 equals s2");
        else
            System.out.println("s1 not equals s2");
    }
}
这次加入：s2 = s2.intern();
哇！程序输出：
s1 == s2
s1 equals s2
原来，程序新建了 s2 之后，又用intern()把他打翻在了池里
哈哈，这次 s2 和 s1 有引用了同样的对象了
我们成功的减少了内存的占用

5. == 与 equals() 的争斗
String 是个对象，要对比两个不同的String对象的值是否相同
明显的要用到 equals() 这个方法
可是如果程序里面有那么多的String对象，有那么多次的要用到 equals ，
哦，天哪，真慢啊
更好的办法：
把所有的String都intern()到缓冲池去吧
最好在用到new的时候就进行这个操作
String s2 = new String("Monday").intern();
嗯，大家都在水池里泡着了吗？哈哈
现在我可以无所顾忌的用 == 来比较 String 对象的值了
真是爽啊，又快又方便！

String 啊 String ，让我说你什么好呢？
你为我们 Java 程序员带来所有的困扰还不够吗？
看看 String 这一次又怎么闹事儿吧

1. 回顾一下坏脾气的 String 老弟

例程1：
class Str {
    public static void main(String[] args) {
        String s = "Hi!";
        String t = "Hi!";
        if (s == t)
            System.out.println("equals");
        else
System.out.println("not equals");
    }
}

程序输出什么呢？
如果看客们看过我的《来自 String 的困惑》之一
相信你很快会做出正确的判断：
程序输出：equals

2. 哦，天哪，它又在搅混水了

例程2：
class Str {
    public static void main(String[] args) {
        String s = "HELLO";
        String t = s.toUpperCase();
        if (s == t)
            System.out.println("equals");
        else
            System.out.println("not equals");
    }
}
那么这个程序有输出什么呢？
慎重！再慎重！不要被 String 这个迷乱的家伙所迷惑！
它输出：equals
WHY!!!

把程序简单的更改一下：
class Str2 {
    public static void main(String[] args) {
        String s = "Hello";
        String t = s.toUpperCase();
        if (s == t)
            System.out.println("equals");
        else
            System.out.println("not equals");
    }
}
你可能会说：不是一样吗？
不！千真万确的，不一样！这一次输出：not equals

Oh MyGOD!!!
谁来教训一下这个 String 啊！

3. 你了解你的马吗？
“要驯服脱缰的野马，就要了解它的秉性”牛仔们说道。
你了解 String 吗？

解读 String 的 API ，可以看到：
toUpperCase() 和 toLowerCase() 方法返回一个新的String对象，
它将原字符串表示字符串的大写或小写形势；
但是要注意：如果原字符串本身就是大写形式或小写形式，那么返回原始对象。
这就是为什么第二个程序中 s 和 t 纠缠不清的缘故

对待这个淘气的、屡教不改的 String ，似乎没有更好的办法了
让我们解剖它，看看它到底有什么结构吧：

(1) charAt(int n) 返回字符串内n位置的字符，第一个字符位置为0，
最后一个字符的位置为length()-1，访问错误的位置会扔出一块大砖头：
StringIndexOutOfBoundsException 真够大的

(2) concat(String str) 在原对象之后连接一个 str ，但是返回一个新的 String 对象

(3) EqualsIgnoreCase(String str) 忽略大小写的 equals 方法
这个方法的实质是首先调用静态字符方法toUpperCase() 或者 toLowerCase()
将对比的两个字符转换，然后进行 == 运算

(4) trim() 返回一个新的对象，它将原对象的开头和结尾的空白字符切掉
同样的，如果结果与原对象没有差别，则返回原对象

(5) toString() String 类也有 toString() 方法吗？
真是一个有趣的问题，可是如果没有它，你的 String 对象说不定真的不能用在
System.out.println() 里面啊
小心，它返回对象自己

String 类还有很多其他方法，掌握他们会带来很多方便
也会有很多困惑，所以坚持原则，是最关键的

4. 我想买一匹更好的马
来购买更驯服温和的 String 的小弟 StringBuffer 吧
这时候会有人反对：它很好用，它效率很高，它怎么能够是小弟呢？
很简单，它的交互功能要比 String 少，如果你要编辑字符串
它并不方便，你会对它失望
但这不意味着它不强大
public final class String implements Serializable, Comparable, CharSequence
public final class StringBuffer implements Serializable, CharSequence
很明显的，小弟少了一些东东，不过这不会干扰它的前途

StringBuffer 不是由 String 继承来的
不过要注意兄弟它也是 final 啊，本是同根生

看看他的方法吧，这么多稳定可靠的方法，用起来比顽皮的 String 要有效率的多
?br /> Java 为需要改变的字符串对象提供了独立的 StringBuffer 类
它的实例不可变（final），之所以要把他们分开
是因为，字符串的修改要求系统的开销量增大，
占用更多的空间也更复杂，相信当有10000人挤在一个狭小的游泳池里游泳
而岸边又有10000人等待进入游泳池而焦急上火
又有10000人在旁边看热闹的时候，你这个 String 游泳池的管理员也会焦头烂额

在你无需改变字符串的情况下，简单的 String 类就足够你使唤的了，
而当要频繁的更改字符串的内容的时候，就要借助于宰相肚里能撑船的
StringBuffer 了

5. 宰相肚里能撑船
(1) length() 与 capacity()
String 中的 length() 返回字符串的长度
兄弟 StringBuffer 也是如此，他们都由对象包含的字符长度决定

capacity()呢？
public class TestCapacity {
    public static void main(String[] args)｛
        StringBuffer buf = new StringBuffer("it was the age of wisdom,");
        System.out.println("buf = " + buf);
        System.out.println("buf.length() = " + buf.length());
        System.out.println("buf.capacity() = " + buf.capacity());
        String str = buf.toString();
        System.out.println("str = " + str);
        System.out.println("str.length() = " + str.length());
        buf.append(" " + str.substring(0,18)).append("foolishness,");
        System.out.println("buf = " + buf);
        System.out.println("buf.length() = " + buf.length());
        System.out.println("buf.capacity() = " + buf.capacity());
        System.out.println("str = " + str);
    }
}
程序输出：
buf = it was the age of wisdom.
buf.length() = 25
buf.capacity() = 41
str = it was the age of wisdom
str.length() = 25
buf = it was the age of wisdom, it was the age of foolishness,
buf.length() = 56
buf.capacity() = 84
str = it was the age of wisdom,

可以看到，在内容更改之后，capacity也随之改变了
长度随着向字符串添加字符而增加
而容量只是在新的长度超过了现在的容量之后才增加
StringBuffer 的容量在操作系统需要的时候是自动改变的
程序员们对capacity所能够做的仅仅是可以在初始化 StringBuffer对象的时候