package net.java2000.sql;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.math.BigDecimal;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.sql.Time;
import java.sql.Timestamp;

/**
 * 使用PreparedStatement向数据库插入数据。
 *
 * @author 赵学庆，Java世纪网(java2000.net)
 *
 */
public class DBInsertPreparedStatement {

  public static void main(String[] args) {
    Connection connection = null; // 从其它地方获取链接
    try {
      // INSERT语句
      String sql = "INSERT INTO my_table (col_string) VALUES(?)";
      // 构造PerparedStatement
      PreparedStatement pstmt = connection.prepareStatement(sql);

      // 循环插入10行数据
      for (int i = 0; i < 10; i++) {
        // 设置参数的值
        pstmt.setString(1, "row " + i);

        // 插入数据
        pstmt.executeUpdate();
      }
    } catch (SQLException e) {
    }

    // 演示各种参数的设置方法。
    try {
      // Prepare a statement to insert a record
      String sql = "INSERT INTO mysql_all_table("
        + "col_boolean,"
        + "col_byte,"
        + "col_short,"
        + "col_int,"
        + "col_long,"
        + "col_float,"
        + "col_double,"
        + "col_bigdecimal,"
        + "col_string,"
        + "col_date,"
        + "col_time,"
        + "col_timestamp,"
        + "col_asciistream,"
        + "col_binarystream,"
        + "col_blob) "
        + "VALUES(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)";

      PreparedStatement pstmt = connection.prepareStatement(sql);

      // Set the values
      pstmt.setBoolean(1, true);
      pstmt.setByte(2, (byte) 123);
      pstmt.setShort(3, (short) 123);
      pstmt.setInt(4, 123);
      pstmt.setLong(5, 123L);
      pstmt.setFloat(6, 1.23F);
      pstmt.setDouble(7, 1.23D);
      pstmt.setBigDecimal(8, new BigDecimal(1.23));
      pstmt.setString(9, "a string");
      pstmt.setDate(10, new java.sql.Date(System.currentTimeMillis()));
      pstmt.setTime(11, new Time(System.currentTimeMillis()));
      pstmt.setTimestamp(12, new Timestamp(System.currentTimeMillis()));

      // 设置字符流
      File file = new File("infilename1");
      FileInputStream is = new FileInputStream(file);
      pstmt.setAsciiStream(13, is, (int) file.length());

      // 设置二进制字节流
      file = new File("infilename2");
      is = new FileInputStream(file);
      pstmt.setBinaryStream(14, is, (int) file.length());

      // 设置blob
      file = new File("infilename3");
      is = new FileInputStream(file);
      pstmt.setBinaryStream(15, is, (int) file.length());

      // 插入数据
      pstmt.executeUpdate();
    } catch (SQLException e) {
    } catch (FileNotFoundException e) {
    }
  }
}

 　　
package org.zhizao.file;
　　import java.io.File;
　　public class FileTest {
　　public static void main(String[] args) throws Exception {
　　System.out.println(Thread.currentThread().getContextClassLoader().getResource(""));
　　System.out.println(FileTest.class.getClassLoader().getResource(""));
　　System.out.println(ClassLoader.getSystemResource(""));
　　System.out.println(FileTest.class.getResource(""));
　　System.out.println(FileTest.class.getResource("/")); //Class文件所在路径
　　System.out.println(new File("/").getAbsolutePath());
　　System.out.println(System.getProperty("user.dir"));
　　}
}

2.2服务器中的Java类获得当前路径
　　(1).Weblogic
　　WebApplication的系统文件根目录是你的weblogic安装所在根目录。例如：如果你的weblogic安装在c:\bea \weblogic700.....那么，你的文件根路径就是c:\.所以，有两种方式能够让你访问你的服务器端的文件：a.使用绝对路径：比如将你的参数文件放在c:\yourconfig\yourconf.properties，直接使用 new FileInputStream("yourconfig/yourconf.properties");b.使用相对路径：相对路径的根目录就是你的 webapplication的根路径，即WEB-INF的上一级目录，将你的参数文件放在yourwebapp\yourconfig \yourconf.properties，这样使用：new FileInputStream("./yourconfig/yourconf.properties");这两种方式均可，自己选择。
　　(2).Tomcat
　　在类中输出System.getProperty("user.dir");显示的是%Tomcat_Home%/bin
　　(3).Resin
　　不是你的JSP放的相对路径,是JSP引擎执行这个JSP编译成SERVLET的路径为根.比如用新建文件法测试File f = new File("a.htm");这个a.htm在resin的安装目录下
　　(4).如何读相对路径哪?
　　在Java文件中getResource或getResourceAsStream均可
　　例：getClass().getResourceAsStream(filePath);//filePath可以是" /filename",这里的/代表web发布根路径下WEB-INF/classes默认使用该方法的路径是：WEB-INF/classes。已经在 Tomcat中测试。
　　总结：
　　通过上面内容的使用，可以解决在Web应用服务器端，移动文件，查找文件，复制删除文件等操作，同时对服务器的相对地址，绝对地址概念更加清晰。建议参考URI,的RFC标准文挡。同时对Java.io.File. Java.net.URI.等内容了解透彻对其他方面的理解可以更加深入和透彻。

关于路径问题的类
一种方式：要创建一个新对象才能获取

package org.zhizao.test;
/**
*
* java类获取web应用的根目录
*
*/
public class PathUtil {

/**
   * @param args
   */
public static void main(String[] args)throws Exception {
   PathUtil p = new PathUtil();
   System.out.println(p.getWebClassesPath());
   System.out.println(p.getWebInfPath());
   System.out.println(p.getWebRoot());
}

public String getWebClassesPath() {
   String path = getClass().getProtectionDomain().getCodeSource()
     .getLocation().getPath();
   return path;

}

public String getWebInfPath() throws IllegalAccessException{
   String path = getWebClassesPath();
   if (path.indexOf("WEB-INF") > 0) {
    path = path.substring(0, path.indexOf("WEB-INF")+8);
   } else {
    throw new IllegalAccessException("路径获取错误");
   }
   return path;
}

public String getWebRoot() throws IllegalAccessException{
   String path = getWebClassesPath();
   if (path.indexOf("WEB-INF") > 0) {
    path = path.substring(0, path.indexOf("WEB-INF/classes"));
   } else {
    throw new IllegalAccessException("路径获取错误");
   }
   return path;
}
}

第二种方式：写在在静态方法里，无需new一个对象

package org.zhizao.util;
/**
* 路径工具
* 2009-10-10
* @author IXR
* @version 1.0
*/
public class PathUtil {
/**
* 获取程序根目录磁盘路径(Java EE版)
* 注:如果是WEB项目在会返回WebRoot的根路径../
*    而不是../WEB-INF/classes/
* @return 根目录磁盘路径
*/
public static String getRootPath(){
String path = null;
try {
   path = PathUtil.class.getResource("/").toURI().getPath();
   path = path.substring(1, path.length()-1);
   String str = "WEB-INF/classes";
   int i = path.indexOf(str);
   if(i > 0){
    path = path.substring(0, i);
   }
} catch (Exception e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
}
return path;
}

编写正则表达式不仅仅是一种技巧，更是一种艺术 ——Jeffrey Friedl

本文中，我将介绍一些正则表达式中使用默认的java.util.regex包的常见缺点。我将解释为什么回缩（backtracking）既是使用正则表达式进行模式匹配的基础，又是应用程序代码中的常见瓶颈；为什么在使用贪婪模式和勉强模式要学会谨慎，以及它是你正则表达式优化的要素。然后我会介绍优化正则表达的技巧，并讨论通过Java模式匹配引擎运行新的正则表达式时会发生什么。

基于本文的目的，我假设你已经有使用正则表达式的经验，并且对在Java代码中优化它们抱有很大的兴趣。本文主题包括简单和自动优化优化技巧，以及如何使用抢占量子（possessive quantifiers）、独立分组（independent grouping）和环视（lookarounds）优化贪婪模式和勉强模式（greedy and reluctant quantifiers）。关于Java中正则表达式的介绍，请参考本文的资源部分。

Java模式匹配引擎和回缩（The Java pattern-matching engine and backtracking）

java.util.regex包使用一种称为非确定性的有限自动机（Nondeterministic Finite Automaton，简称为NFA）的模式匹配引擎。之所以称之为非确定性的，是因为当尝试使用输入的字符串匹配一个正则表达式时，每一个字符会因为正则表达式的不同部分而被多次检查。这也是一种在。NET、PHP、Perl、Python和Ruby被广泛使用的引擎。它将大部分的权利交到了程序员手里，提供了宽范围的量词和其他专有的结构如环视（lookarounds），在后面部分将会讨论。

NFA在本质上使用回缩。通常情况下，并非只有一种方式在给定的字符串上使用正则表达式，因此模式匹配引擎会尝试所有情况，直到它宣布失败。为了更好的理解NFA和回缩（backtracking），考虑下面的例子：正则表达式是“sc（ored|ared|oring）x”，输入字符串是“scared”。

首先引擎会寻找“sc”，由于在输入字符串的起始两个字符，因此会立即找到。然后，它会从输入字符串的第三个字符开始尝试匹配“ored”。没有匹配项，它就回到第三个字符，尝试“ared”。找到匹配，于是它继续向前，尝试匹配“x”。不能找到匹配，它将返回第三个字符，寻找“oring”。仍然没有匹配，于是它就返回到输入字符串的第二个字符，开始寻找另外一个“sc”。一直到达输入字符串的结束，它将宣布失败。

回缩的优化小技巧（Optimization tips for backtracking）

通过上面的例子，你已经看到了NFA如何使用回缩进行模式匹配的，同时你也会发现回缩存在的一个问题。甚至在上面十分简单的例子中，引擎为了将输入字符串匹配到正则表达式不得不回退数次。不难想象，如果回缩使失去控制，将会对你的应用程序的性能发生什么样的影响。优化正则表达式的一个重要部分就是最小化回缩的数量。

Java模式匹配引擎有一些可以自由支配的优化规则，并可以自动应用它们。在本文稍后的部分我将会讨论其中的一些规则。不幸的是，你不能总是依赖引擎来优化你的正则表达式。在上面的例子中，正则表达式的确可以相当快地匹配，但是在多数情况中，对于引擎自动优化来说，表达式过于复杂，而输入字符串也过大。

由于回缩，在现实场景中正则表达式有时候会遇到花费数小时完成匹配的情况。更惨的是，引擎会花费比匹配成功更长的时间声明正则表达式不匹配输入字符串。牢记这个重要的事实。当你想要测试正则表达式的速度时，使用其不能匹配的字符串进行测试。其中，特别是使用几乎匹配的字符串，因为它们会消耗最长的时间。

现在，我们考虑一些可以优化正则表达式的针对回缩的方法。

优化正则表达式的简单方法（Simple ways to optimize regular expressions）

在本文后面的部分，我会介绍更加复杂的方法，你可以使用它们优化Java中的正则表达式。不过，作为开始，这里是一些可以节省时间的简单优化方式：1、如果在程序中多次使用同一个正则表达式，一定要用Pattern.compile（）编译，代替直接使用Pattern.matches（）。如果一次次对同一个正则表达式使用Pattern.matches（），例如在循环中，没有编译的正则表达式消耗比较大。因为matches（）方法每次都会预编译使用的表达式。另外，记住你可以通过调用reset（）方法对不同的输入字符串重复使用Matcher对象。

2、留意选择（Beware of alternation）。类似“（X|Y|Z）”的正则表达式有降低速度的坏名声，所以要多留心。首先，考虑选择的顺序，那么要将比较常用的选择项放在前面，因此它们可以较快被匹配。另外，尝试提取共用模式；例如将“（abcd|abef）”替换为“ab（cd|ef）”。后者匹配速度较快，因为NFA会尝试匹配ab，如果没有找到就不再尝试任何选择项。（在当前情况下，只有两个选择项。如果有很多选择项，速度将会有显著的提升。）选择的确会降低程序的速度。在我的测试中，表达式“。*（abcd|efgh|ijkl）。*”要比调用String.indexOf（）三次——每次针对表达式中的一个选项——慢三倍。

3、获取每次使用引起小损失的分组。如果你实际并不需要获取一个分组内的文本，那么就使用非捕获分组。例如使用“（？：X）”代替“（X）”。

让引擎完成优化（Let the engine do the work for you）

如上面我所提到的，java.util.regex包可以编译正则表达式时对其优化。例如，正则表达式中包含了一个必须在输入字符串中出现的字符串（或者整个表达式都不匹配），引擎有时会首先搜索该字符串，如果没有找到匹配就会报告失败，不再检查整个正则表达式。

另外非常有用地自动优化正则表达式的方式让引擎根据正则表达式中的期望长度检查输入字符串的长度。例如，表达式“\d{100}”是内在优化的，以致于如果输入字符串不是100个字符，引擎就会报告失败，而不再考察整个正则表达式。

无论何时编写复杂的正则表达式时，尝试找出一种编写方式使引擎可以识别和优化这些特殊情况。例如，不要在分组或选择中隐藏命令字符串，因为引擎不会识别它们。若有可能，指定你想要匹配的输入字符串的长度也是相当有用的，如上例所示。

优化贪婪模式和勉强模式（Optimizing greedy and reluctant quantifiers）

你已经有了如何优化正则表达式的基本概念，其中一些方式可以让引擎来完成优化。现在我们讨论优化贪婪模式和勉强模式。贪婪模式量词如“*”或“+”，会首先从输入字符串中尝试匹配尽可能多的字符，即使这意味着字符串中的剩下的内容已经不足以匹配正则表达式的其余部分。如果是这样，贪婪模式量词就会回缩，返回字符，知道可以完全匹配或者没有字符了。勉强（或者lazy）模式，另一方面，会首先尝试匹配输入字符串中尽可能少的字符。

那么举个例子，比如说你想优化一个子表达式“。*a”。如果字符a在输入字符串临近结尾处，使用贪婪模式量词“*”较好。如果这个字符在输入字符串的开始位置附近，使用勉强模式的量词“*？”好一些，可以将子表达式改为“。*？a”。通常情况下，我注意到勉强模式比贪婪模式稍微快一些。

另外一个编写正则表达式技巧是比较明确的。尽量少使用普通的子结构像“。*”，因为它们会引起很多回缩，特别是剩余的表达式不能匹配输入字符串时。例如，如果你想获取输入字符串中两个a之间的内容，可以使用“a（[^a]*）a”代替“a（。*）a”。

抢占量子和独立分组（Possessive quantifiers and independent grouping）

抢占量子和独立分组是优化正则表达式最有用的操作符。无论何时使用它们你都可以戏剧性地改善表达式的运行时间。抢占量子由额外的“+”表示，例如表达式中“X？+”、“X*+”和“X++”。独立分组的符号是“（？>X）”。

我曾经同时使用抢占量子和独立分组成功地将正则表达式的运行从几分钟减少几秒钟。两种操作符都会使模式匹配引擎的针对分组的回缩行为失去作用。它们会尝试匹配它们的表达式就像贪婪模式一样，但是如果不能匹配，它们不会返回已经匹配的字符，即使引起整个表达式失败。

它们之间的差异是非常微妙的。你最好通过比较抢占量子“（X）*+”和独立分组“（？>X）*”来了解。前者，抢占量子会取消针对X子表达式和“*”量词的回缩。后者，只有针对X子表达式的回缩会取消，而分组之外的“*”操作符，不受独立分组的影响，还是可以任意回缩。

你怎么优化这个正则表达式？（How would you optimize this regular expression？）

现在我们看一个优化的例子。假如你尝试在一个长输入字符串中匹配子表达式“[^a]*a”，输入字符串中只有重复出现的字母b.这个表达式将会失败，因为输入字符串没有包含字母a.因为模式匹配引擎不知道这一点，你会尝试匹配表达式“[^a]*”。因为“*”是一个贪婪模式量词，它会获取所有字符直到输入字符串结束，然后开始回退，寻找匹配时每次返回一个字符。

当不能再回缩时，这个表达式就会失败，这会花费不少时间。更坏的是，因为“[^a]*”获取所有不是a的字符，即使回缩作用也不大。

解决方法是将表达式由“[^a]*a”改为“[^a]*+a”，使用抢占量子“*+”。新表达式会更快失败，因为一旦它阐释匹配所有非a子符，它不回缩；于是在此处匹配失败。

环视结构（Lookaround constructs）

如果你想写一个匹配除某些字符之外的任意字符的正则表达式，可以很轻松写出类似“[^abc]*”这样的表达式，它表示：匹配除a、b或c之外的任意字符。但是，如果你想匹配如“cab”或“cba”而不是“abc”这样的字符串时应该怎么做呢？

对于这种情况，你可以使用环视结构（lookaround constructs）。java.util.regex包包含了四种类型：1、正向向前寻找（Positive lookahead）：“（？=X）”

2、负向向前寻找（Negative lookaheade）：“（？！X）”

3、正向向后寻找（Positive lookbehind）：“（？<=X）”

4、负向向后寻找（Negative lookbehind）：“（？<！X）”

此处正向（Positive）是指你希望表达式匹配，而负向（Negative）则表示你不想表达式匹配。向前查找（Lookahead）是指你想搜索输入字符串中当前位置的右面部分。向后查找（Lookbehind）则是指搜索当前位置的左面部分。请紧记，环视结构只是向前或向后看，实际上并不改变输入字符串的当前位置。比如说，你可以在表达式“（（？！abc）。）*”使用负向向前寻找操作符“？！”匹配任何除“abc”外的任何顺序的字符。

实战环视结构（Lookarounds in practice）

在编写正则表达式时，环视结构可以在更细节上提供帮助，在匹配性能会有明显的效果。代码1演示了一个非常简单的例子：使用正则表达式匹配HTML域。

代码1. 匹配HTML域Regular expression： "" Input string 1： "" Input string 2： ""

代码1中的正则表达式的目的是匹配HTML的image标签中的src属性的内容。我特意简化了这个表达式，假定在src之后没有其他属性，这样可以将精力集中到性能上。

这个表达式匹配输入的字符串“string 1”时速度足够快，但是尝试匹配输入字符串“string 2”并宣布失败时花费了很长时间（随着输入字符串的长度成指数增长）。它匹配失败是因为输入字符串结尾没有“/>”。为了优化这个表达式，看一下第一个“。*”结构。它匹配“src”之前的任何属性，但是太普通并且匹配次数太多了。事实上，这个结构应该只匹配除“src”之外的属性。

重写的表达式“”处理大且不匹配的字符串的速度要比原来的快将近100倍。

为什么不是lazy模式？

你可能会认为我会使用勉强模式“。*？”优化代码1中的正则表达式。事实上，“”能够轻易地匹配第一个遇到的“src=”。这个解决方案在该正则表达式可以匹配的时候能够正常工作。如果它不能匹配输入字符串，然而，它将开始回缩，然后消耗和贪婪模式同样长的时间。记住，首先使用不能匹配的字符串测试正则表达式。

注意StackOverflowError（A note about the StackOverflowError）

有时regex包中的Pattern类会抛出StackOverflowError.这是已知的bug #5050507的表现，它自从Java 1.4就存在于java.util.regex包中。这个bug仍然存在，因为它是“won't fix”的状态。这个错误的出现是因为，Pattern类把一个正则表达式编译为一个用来寻找匹配的小程序。这个程序被递归调用，有时太多的递归就会导致该错误的出现。更多细节请参考bug描述。看起来大部分是在使用选择（alternation）的出现。

如果你碰到了这个错误，尝试重写正则表达式，或者分为几个子表达式，然后分别单独执行。后者有时设置会提高性能。

总结（In conclusion）

正则表达式不应该花费数小时匹配，特别是应用程序只有几秒时间时。在本文中，我介绍了java.util.regex包的一些弱点，并且向你展示了如何克服这些弱点。像回缩（backtracking）这样的简单瓶颈只需要一些小小的技巧，而像贪婪模式和勉强模式（greedy and reluctant quantifiers）这样的罪魁祸首就需要更加仔细的考虑。在某些情况下，你可以完全替换它们，而在另外一些情况下，可以使用“环视（lookaround）”。无论哪种方式，你已经掌握了一些正则表达式的提升速度的技巧。

　　已经创建了数据库连接Connection conn;

　　方法一、使用java.sql.Date实现比较简单的yyyy-mm-dd格式日期。

　　java.sql.Date不支持时间格式。切记不要使用new java.sql.Date(int year,int month,int date),因为还要处理时间差问题。

　　PreparedStatement pstmt = conn.prepareStatement("insert into book (name,buydate) values (?,?)");

　　java.sql.Date buydate=java.sql.Date.valueOf("2005-06-08");
　　pstmt.setString(1, "Java编程思想");
　　pstmt.setDate(2,buydate );
　　pstmt.execute();

　　方法二、使用java.sql.Timestamp,同上不使用new Timestamp(....)

　　PreparedStatement pstmt = conn.prepareStatement("insert into book (name,buydate) values (?,?)");

　　java.sql.Timestamp buydate=java.sql.Timestamp.valueOf("2004-06-08 05:33:99");
　　pstmt.setString(1, "Java编程思想");
　　pstmt.setTimestamp(2,buydate );
　　pstmt.execute();

　　方法三、使用oracle 的to_date内置函数

PreparedStatement pstmt = conn.prepareStatement("insert into book (name,buydate) values (?,to_date(?, 'yyyy-mm-dd hh24:mi:ss')");
　　String buydate="2004-06-08 05:33:99";
　　pstmt.setString(1, "Java编程思想");
　　pstmt.setString(2,buydate );
　　pstmt.execute();

　　附:oracle日期格式参数 含义说明
　　d: 一周中的星期几
　　day: 天的名字，使用空格填充到9个字符
　　dd: 月中的第几天
　　ddd: 年中的第几天
　　dy: 天的简写名
　　iw: ISO标准的年中的第几周
　　iyyy: ISO标准的四位年份
　　yyyy: 四位年份
　　yyy,yy,y: 年份的最后三位，两位，一位
　　hh: 小时，按12小时计
　　hh24: 小时，按24小时计
　　mi: 分
　　ss: 秒
　　mm: 月
　　mon: 月份的简写
　　month: 月份的全名
　　w: 该月的第几个星期
　　ww: 年中的第几个星期

我的一点点理解:
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 != s2s1 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 == s2s1 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 这个迷乱的家伙所迷惑！
它输出：equalsWHY!!!
把程序简单的更改一下：

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 equalsOh 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, CharSequencepublic final class StringBuffer implements Serializable, CharSequence很明显的，小弟少了一些东东，不过这不会干扰它的前途StringBuffer 不是由 String 继承来的不过要注意兄弟它也是 final 啊，本是同根生看看他的方法吧，这么多稳定可靠的方法，用起来比顽皮的 String 要有效率的多? 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 wisdomstr.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对象的时候。