yezhou

选择优化性能的功能

3.1.    使用参数标记作为存储过程的参数

    调用存储过程时，用参数标记做为参数尽量不要用字符做参数。JDBC驱动调用存储过程时要么象执行其他SQL查询一样执行该过程，要么通过RPC直接调用来优化执行过程。如果象SQL查询那样执行存储过程，数据库服务器先解析该语句，验证参数类型，然后把参数转换成正确的数据类型，显然这种调用方式不是最高效的。
    SQL语句总是做为一个字符串送到数据库服务器上，例如，
“{call getCustName (12345)}”。
在这种情况下，即使程序员设想给getCustName唯一的参数是整型，事实上参数传进数据库的仍旧是字符串。数据库服务器解析该语句，分离出单个参数值12345，然后在把过程当作SQL语言执行之前，将字符串“12345”转换成整型值。
    通过RPC在数据库服务器中调用存储过程，就能避免使用SQL字符串带来的开销。
    情形1
    在这个例子中，就不能使用服务器端的RPC优化调用存储过程。调用的过程包括解析语句，验证参数类型，在执行过程之前把这些参数转换成正确的类型。
CallableStatement cstmt = conn.prepareCall (   "{call getCustName (12345)}"); ResultSet rs = cstmt.executeQuery ();  
    情形2
    在这个例子中，可以使用服务器端RPC优化调用存储过程。由于应用避免了文字参数传递带来的开销，且JDBC能以RPC方式直接在数据库中调用存储过程来优化执行，所以，执行时间也大大地缩短了。
CallableStatement cstmt =
     conn.prepareCall (   "{call getCustName (?)}");cstmt.setLong (1,12345);
ResultSet rs = cstmt.executeQuery();
    JDBC根据不同的用途来优化性能，所以我们需要根据用途在PreparedStatement对象和Statement对象之间做出选择。如果执行一个单独的SQL语句，就选择Statement对象；如果是执行两次或两次以上就选择PreparedStatement对象。
    有时，为了提高性能我们可以使用语句池。当使用语句池时，如果查询被执行一次且可能再也不会被执行，那就使用Statement对象。如果查询很少被执行，但在语句池的生命期内可能再一次被执行，那么使用PreparedSatement。在相同的情形下，如果没有语句池，就使用Statement对象。

3.2.    用批处理而不是用PreparedStatement语句

    更新大量的数据通常是准备一个INSERT语句并多次执行该语句，结果产生大量的网络往返。为了减少JDBC调用次数和提高性能，你可以使用PreparedStatement对象的addBatch()方法一次将多个查询送到数据库里。例如，让我们比较一下下边的例子，情形1和情形2。
    情形1：多次执行PreparedStatement语句
PreparedStatement ps = conn.prepareStatement("INSERT into employees values (?, ?, ?)");
for (n = 0; n < 100; n++) {  
 ps.setString(name[n]); 
 ps.setLong(id[n]);  
 ps.setInt(salary[n]); 
 ps.executeUpdate();
}
    情形2：使用批处理
PreparedStatement ps = 
conn.prepareStatement(   "INSERT into employees values (?, ?, ?)");
for (n = 0; n < 100; n++) {  
ps.setString(name[n]);  
ps.setLong(id[n]);  
ps.setInt(salary[n]);  
ps.addBatch();
}
ps.executeBatch();
    在情形1中，一个PreparedStatement用于多次执行一个INSERT语句。在这个情况下，为了100次插入需要101次网络往返，其中一次用于准备语句，额外100次网络往返用于执行每一个操作。当addBatch()方法的时候，如情形2所述，仅需要两个网络往返，一个准备语句，另一个执行批处理。尽管使用批处理需要更多的数据库CPU运算开销，但性能可由减少的网络往返获得。记住要让JDBC驱动在性能方面有良好的表现，就要减少JDBC驱动和数据库服务器之间的网络通讯量。

3.3.    选择合适的游标

    选择合适的游标能提高应用的灵活性。本节总结了三类游标的性能问题。向前游标对连续读表中所有的行提供了优秀的性能。就检索表数据而言，没有一个检索数据的方法要比向前游标更快。然而，当应用必须处理非连续方式的行时，就不能使用它。
    对需要数据库高层次的并发控制和需要结果集向前和向后滚动能力的应用而言，JDBC驱动使用的无感知游标是最为理想选择。对无感知游标的第一次请求是获取所有的行(或者当JDBC使用“懒惰”方式读时,可以读取部分行)并将它们存储在客户端。那么，第一次请求将会非常慢，特别是当长数据被检索到的时候。后续的请求不再需要网络交通(或当驱动采用懒惰方式时，只有有限的网络交通)并处理得很快。由于第一次请求处理缓慢，无感知游标不应该用于一行数据的单个请求。当要返回长数据时，内存很容易被耗尽，所以开发人员也应该避免使用无感知游标。一些无感知游标的实现是把数据缓存在数据库中的零时表中，避免了性能问题，但是，大多数是把信息缓存在应用本地。
    无感知游标，有时又叫键集驱动的游标，使用标识符，如已经存在于你数据库中的ROWID。当你通过结果集滚动的时候，适合于标识符的数据会被检索到。由于每个请求都产生网络交通量，所以性能将会非常差。然而，返回非连续行不会更多的影响性能。
    为了更进一步说明，我们来看一个通常返回应用1000行数据的应用。在执行时或第一行被请求时，JDBC不会执行由应用提供的SELECT语句。而是JDBC驱动用键标识符替换查询的SELECT列表，例如,ROWID。这个修改的查询将会被驱动执行，并且所有1000键值将会被从数据库中检索出来并被驱动缓存。每一个来自应用对结果行的请求将转到JDBC驱动，为了返回合适的行，JDBC在它本地缓存中查询键值，构造一个类似于“WHERE ROWID=?”包含WHERE的优化的语句，执行这个修改了查询，然后从服务器上检索单个结果行。
    当应用使用来自缓存中的无感知(Insensitive)游标数据时，有感知(Sensitive)游标在动态情形下就是首选的游标模式。

3.4.    有效地使用get方法

    JDBC提供了很多从结果集中检索数据的方法，例如getInt()，getString()，以及getObject()。getObject()方法是最普通的方法，但在没有说明非默认映射时提供了最差的性能。这是因为为了确定被检索值的类型和产生合适的映射，JDBC驱动必须做额外的处理。所以，总是使用能明确数据类型的方法。
    为了更好地提高性能，请提供被检索列的列数字，例如,getString(1),getLong(2),和getInt(3),而不是列名。如果列数字没有说明，网络流量是不受影响的，但转换和查找的成本上升了。例如，假设你使用getString(“foo”)…驱动可能不得不将列的标识符foo转换成大写(如果必要)，并在列列表中用“foo”和所有的列名比较。如果提供了列数字，很大部分的处理都被节省了。
    例如，假如你有一个15列100行的结果集，列名没有包括在结果集中。你感兴趣的有三列，EMPLOEEMENT(字符串)，EMPLOYEENUMBER(长整型)，和SALARY(整型)。如果你说明了getString(“EmployeeName”),getLong(“EmployeeNumber”)和getInt(“Salary”)，每列的列名必须转换成和数据库元数据中匹配的大小写，毫无疑问查询将相应的增加。如果你说明getString(1),getLong(2)，和getInt(15)，性能将会大大地提高。

3.5.    检索自动产生的键

    许多数据库已经隐藏了描述表中每行唯一键的列(又叫伪列)。通常，由于伪列描述了数据的物理磁盘地址，故而在查询中使用这种类型的列存取行是最快的方式。在JDBC3.0以前，应用仅能在插入数据之后立即执行SELECT语句检索到伪列的值。
For example:
//insert rowint 
rowcount = stmt.executeUpdate (   "insert into LocalGeniusList (name) values ('Karen')"); 
// now get the disk address - rowid - for the newly inserted row
ResultSet rs = stmt.executeQuery (   "select rowid from LocalGeniusList where name = 'Karen'");
    这个检索伪列的方法有两个主要的缺点。第一，检索伪列需要通过网络把一个单独的查询语句发送到服务器上执行。第二，由于表中可能没有主键，查询条件可能不能唯一地确定行。在后边的情形中，多个伪列值被返回，应用或许不能确定哪个是最近插入的行。
JDBC规范一个可选的特性是当行插入表时，能检索到行的自动产生的键信息。
For example:
int rowcount = stmt.executeUpdate (   "insert into LocalGeniusList (name) values ('Karen')",
// insert row AND return 
keyStatement.RETURN_GENERATED_KEYS);
ResultSet rs = stmt.getGeneratedKeys (); 
// key is automatically available
    即便该表没主键，这都给应用提供了一个唯一确定行值的最快方法。当存取数据时，检索伪列键的能力给JDBC开发人员提供了灵活性并创造了性能。

4.    管理连接和数据更新

4.1.    管理连接

    连接管理的好坏直接影响到应用的性能。采用一次连接创建多个Statement对象的方式来优化你的应用，而不是执行多次连接。在建立最初的连接之后要避免连接数据源。
    一个不好的编码习惯是执行SQL语时连接和断开好几次。一个连接对象可以有多个Statement对象和它关联。由于Statement对象是定义SQL语句信息的内存存储，它能管理多个SQL语句。此外，你可以使用连接池来显著地提高性能，特别是对那些通过网络连接或通过WWW连接的应用。连接池让你重用连接，关闭连接不是关闭与数据库的物理连接，而是将用完的连接放到连接池中。当一个应用请求一个连接时，一个活动的连接将从连接池中取出重用，这样就避免了创建新连接的而产生的网络I/O。

4.2.    在事务中管理提交

    由于磁盘I/O和潜在的网络I/O，提交事务往往要慢。经常使用WSConnection.setAutoCommit(false)来关闭自动提交设置。
    提交实际上包括了什么呢？数据库服务器必须刷新包含更新的和新数据的磁盘上的每一个数据页。这通常是一个对日志文件连续写的过程，但也是磁盘I/O。默认情况下，当连接到数据源时，自动提交是打开的，由于提交每个操作需要大量的磁盘I/O，自动提交模式通常削弱了性能。此外，大部分数据库没有提供本地的自动提交模式。对这种类型的服务器，JDBC驱动对每一个操作必须明确地给服务器送出COMMIT语句和一个BEGIN TRANSACTION。
    尽管使用事务对应用的性能有帮助，但不要过度地使用。由于为了防止其他用户存取该行而在行上长时间的持有锁将减少吞吐量。短时间内提交事务可以最大化并发量。

4.3.    选择正确的事务模式

    许多系统支持分布式事务；也就是说，事务能跨越多个连接。由于记录日志和所有包含在分布式事务中组件(JDBC驱动，事务监视器和数据库系统)之间的网络I/O，分布式事务要比普通的事务慢四倍。除非需要分布式事务，否则尽量避免使用它们。如果可能就使用本地事务。应该注意的是许多Java应用服务器提供了一个默认的利用分布式事务的事务行为。为了最好的系统性能，把应用设计在运行在单个连接对象之下，除非必要避免分布式事务。

4.4.    使用updateXXX方法

    尽管编程的更新不适用于所有类型的应用，但开发人员应该试着使用编程的更新和删除，也就是说，使用ResultSet对象的updateXXX()方法更新数据。这个方法能让开发人员不需要构建复杂的SQL语句就能更新数据。为了更新数据库，在结果集中的行上移动游标之前，必须调用updateRow()方法。
    在下边的代码片断中，结果集对象rs的Age列的值使用getInt()方法检索出来，updateInt()方法用于用整型值25更新那一列。UpdateRow()方法用于在数据库中更新修改了值的行。 
int n = rs.getInt("Age"); 
// n contains value of Age column in the resultset rs...
rs.updateInt("Age", 25); 
rs.updateRow();
    除了使应用更容易地维护，编程更新通常产生较好的性能。由于指针已经定位在被更新的行上，定位行的所带来的开销就避免了。

4.5.    使用getBestRowIdentifier()

    使用getBestRowIdentifier()(请参阅DatabaseMetaData接口说明)确定用在更新语句的Where子句中的最优的列集合。伪列常常提供了对数据的最快的存取，而这些列仅能通过使用getBestRowIdentifier()方法来确定。
    一些应用不能被设计成利用位置的更新和删除。一些应用或许通过使用可查询的结果列，如调用getPrimaryKeys()或者调用getIndexInfo()找出可能是唯一索引部分的列，使Where子句简洁化。这些方法通常可以工作，但可能产生相当复杂的查询。看看下边的例子：
ResultSet WSrs = WSs.executeQuery    ("SELECT first_name, last_name, ssn, address, city, state, zip    FROM emp");
// fetch data...
WSs.executeUpdate ("UPDATE EMP SET ADDRESS = ?   WHERE first_name = ? and last_name = ? and ssn = ?    and address = ? and city = ? and state = ?    and zip = ?");
// fairly complex query
    应用应该调用getBestRowIdentifier()检索最优集合的能确定明确的记录的列(可能是伪列)。许多数据库支持特殊的列，它们没有在表中被用户明确地定义，但在每一个表中是“隐藏”的列(例如，ROWID和TID)。由于它们是指向确切记录位置的指针，这些伪列通常给数据提供了最快的存取。由于伪列不是表定义的部分，它们不会从getColumns中返回。为了确定伪列是否存在，调用getBestRowIndentifier()方法。
再看一下前边的例子：
...
ResultSet WSrowid = getBestRowIdentifier(... "emp", ...);
...
WSs.executeUpdate ("UPDATE EMP SET ADDRESS = ?  WHERE ROWID = ?";
// fastest access to the data!
    如果你的数据源没有包含特殊的伪列，那么getBestRowIdentifier()的结果集由指定表上的唯一索引组成(如果唯一索引存在)。因此，你不需要调用getIndexInfo来找出最小的唯一索引。

概要
    不管你是处理财务交易还是计划着下一步的行动，你都要知道怎样在Java中建立，使用和显示日期。这需要你简单的查阅一下相应类的API参考：一个日期可以创建3个相关类的对象。这篇文章告诉你你想要知道的内容。（3,000字）
作者：Robert Nielsen
翻译：Cocia Lin

    Java统计从1970年1月1日起的毫秒的数量表示日期。也就是说，例如，1970年1月2日，是在1月1日后的86，400，000毫秒。同样的，1969年12月31日是在1970年1月1日前86，400，000毫秒。Java的Date类使用long类型纪录这些毫秒值.因为long是有符号整数，所以日期可以在1970年1月1日之前，也可以在这之后。Long类型表示的最大正值和最大负值可以轻松的表示290，000，000年的时间，这适合大多数人的时间要求。
Date 类
   Date类可以在java.util包中找到，用一个long类型的值表示一个指定的时刻。它的一个有用的构造函数是Date(),它创建一个表示创建时刻的对象。getTime()方法返回Date对象的long值。在下面的程序中，我使用Date()构造函数创建一个表示程序运行时刻的对象，并且利用getTime()方法找到这个日期代表的毫秒数量：

import java.util.*;

public class Now {
   public static void main(String[] args) {
      Date now = new Date();
      long nowLong = now.getTime();
      System.out.println("Value is " + nowLong);
   }
}

当我运行这个程序后，我得到972,568,255,150.快速确认一下这个数字，起码在一个合理的范围：它不到31年，这个数值相对1970年1月1日到我写这篇文章的时间来说，是合理的。计算机是这个毫秒值表示时间，人们可不愿意说" 我将在996,321,998,34见到你。"幸运的是，Java提供了一个转换Date对象到字符串的途径，表示成传统的形式。我们在下一节讨论DateFormat类，它直观的建立日期字符串。
DateFormat类
 DateFormat类的一个目标是建立一个人们能够识别的字符串。然而，因为语言的差别，不是所有的人希望看到严格的相同格式的日期。法国人更喜欢看到"25 decembre 2000,",但是美国人习惯看到"December 25,2000."所以一个DateFormat的实例创建以后，这个对象包含了日期的显示格式的信息。如果使用用户电脑区域设置缺省的格式，你可以象下面那样，创建DateFormat对象，使用getDateInstance()方法：

DateFormat df = DateFormat.getDateInstance();  

DateFormat类在java.text包中可以找到。
转换成字符串
你可以使用format()方法转换Date对象为一个字符串。下面的示例程序说明了这个问题：

import java.util.*;
import java.text.*;

public class NowString {
   public static void main(String[] args) {
      Date now = new Date();
      DateFormat df = DateFormat.getDateInstance();
      String s = df.format(now);
      System.out.println("Today is " + s);
   }
} 

在上面的代码中，展示了没有参数，使用缺省格式的getDateInstance()方法。Java还提供了几个选择日期格式，你可以通过使用重载的getDateInstance(int style)获得。出于方便的原因，DateFormat提供了几种预置的常量，你可以使用这些常量参数。下面是几个SHORT, MEDIUM, LONG, 和FULL类型的示例：

import java.util.*;
import java.text.*;

public class StyleDemo {
   public static void main(String[] args) {
      Date now = new Date();

      DateFormat df =  DateFormat.getDateInstance();
      DateFormat df1 = DateFormat.getDateInstance(DateFormat.SHORT);
      DateFormat df2 = DateFormat.getDateInstance(DateFormat.MEDIUM);
      DateFormat df3 = DateFormat.getDateInstance(DateFormat.LONG);
      DateFormat df4 = DateFormat.getDateInstance(DateFormat.FULL);
      String s =  df.format(now);
      String s1 = df1.format(now);
      String s2 = df2.format(now);
      String s3 = df3.format(now);
      String s4 = df4.format(now);

      System.out.println("(Default) Today is " + s);
      System.out.println("(SHORT)   Today is " + s1);
      System.out.println("(MEDIUM)  Today is " + s2);
      System.out.println("(LONG)    Today is " + s3);
      System.out.println("(FULL)    Today is " + s4);
   }
}

程序输出如下：

(Default) Today is Nov 8, 2000
(SHORT)   Today is 11/8/00
(MEDIUM)  Today is Nov 8, 2000
(LONG)    Today is November 8, 2000
(FULL)    Today is Wednesday, November 8, 2000

同样的程序，在我的电脑上使用缺省设置运行后，改变区域设置为瑞典，输出如下：

(Default) Today is 2000-nov-08
(SHORT)   Today is 2000-11-08
(MEDIUM)  Today is 2000-nov-08
(LONG)    Today is den 8 november 2000
(FULL)    Today is den 8 november 2000    
 
从这里，你能看到，瑞典的月份不是大写的（虽然November还是november）.还有，LONG和FULL版本在瑞典语中是一样的，但是美国英语却不同。另外，有趣的是，瑞典语单词的星期三,onsdag，没有包含在FULL日期里，英语却包括。
注意你能够使用getDateInstance()方法改变DateFormat实例的语种；但是，在上面的例子中，是通过改变Windows98的控制面板的区域设置做到的。不同的地方的区域设置不同，结果就不同，这样有好处，也有不足，Java程序员应该了解这些。一个好处是Java程序员可以只写一行代码就可以显示日期，而且世界不同地区的电脑运行同样的程序会有不用的日期格式。 但是这也是一个缺点，当程序员希望显示同一种格式的时--这也有可取之处，举例来说，在程序中混合输出文本和日期，如果文本是英文，我们就不希望日期格式是其他的格式，象德文或是西班牙文。如果程序员依靠日期格式编程，日期格式将根据运行程序所在电脑的区域设置不用而不同。
解析字符串
 通过parse()方法，DateFormat能够以一个字符串创立一个Date对象。这个方法能抛出ParseException异常，所以你必须使用适当的异常处理技术。下面的例子程序通过字符串创建Date对象：

import java.util.*;
import java.text.*;

public class ParseExample {
   public static void main(String[] args) {
      String ds = "November 1, 2000";
      DateFormat df = DateFormat.getDateInstance();
      try {
         Date d = df.parse(ds);
      }
      catch(ParseException e) {
         System.out.println("Unable to parse " + ds);
      }
   }
}

在创建一个任意的日期时parse()方法很有用。我将通过另一种方法创建一个任意得日期。同时，你将看到怎样进行基本日期计算，例如计算90天后的另一天。你可以使用GregorianCalendar类来完成这个任务。
GregorianCalendar类
 创建一个代表任意日期的一个途径使用GregorianCalendar类的构造函数，它包含在java.util包中：

GregorianCalendar(int year, int month, int date)

注意月份的表示，一月是0，二月是1，以此类推，是12月是11。因为大多数人习惯于使用单词而不是使用数字来表示月份，这样程序也许更易读，父类Calendar使用常量来表示月份：JANUARY, FEBRUARY,等等。所以，创建Wilbur 和 Orville制造第一架动力飞机的日期（December 17, 1903），你可以使用：

GregorianCalendar firstFlight = new GregorianCalendar(1903, Calendar.DECEMBER, 17); 
出于清楚的考虑，你应该使用前面的形式。但是，你也应该学习怎样阅读下面的短格式。下面的例子同样表示December 17,1903（记住，在短格式中，11表示December）

GregorianCalendar firstFlight = new GregorianCalendar(1903, 11, 17);  

在上一节中，你学习了转换Date对象到字符串。这里，你可以做同样的事情；但是首先，你需要将GregorianCalendar对象转换到Date。要做到这一点，你可以使用getTime()方法，从它得父类Calendar继承而来。GetTime()方法返回GregorianCalendar相应的Date对象。你能够创建GregorianCalendar对象，转换到Date对象，得到和输出相应的字符串这样一个过程。下面是例子：

import java.util.*;
import java.text.*;

public class Flight {

   public static void main(String[] args) {
      GregorianCalendar firstFlight = new GregorianCalendar(1903, Calendar.DECEMBER, 17);   
      Date d = firstFlight.getTime();
      DateFormat df = DateFormat.getDateInstance();
      String s = df.format(d);
      System.out.println("First flight was " + s);
   }
}

有时候创建一个代表当前时刻的GregorianCalendar类的实例是很有用的。你可以简单的使用没有参数的GregorianCalendar构造函数，象这样：

GregorianCalendar thisday = new GregorianCalendar();

一个输出今天日期的例子程序，使用GregorianCalendar对象：

import java.util.*;
import java.text.*;

class Today {
   public static void main(String[] args) {
      GregorianCalendar thisday = new GregorianCalendar(); 
      Date d = thisday.getTime();
      DateFormat df = DateFormat.getDateInstance();
      String s = df.format(d);
      System.out.println("Today is " + s);
   }
}

注意到，Date()构造函数和GregorianCalendar()构造函数很类似：都创建一个对象，条件简单，代表今天。
日期处理
GregorianCalendar类提供处理日期的方法。一个有用的方法是add().使用add()方法，你能够增加象年，月数，天数到日期对象中。要使用add()方法，你必须提供要增加的字段，要增加的数量。一些有用的字段是DATE, MONTH, YEAR, 和 WEEK_OF_YEAR。下面的程序使用add()方法计算未来80天的一个日期。在Jules的<环球80天>是一个重要的数字，使用这个程序可以计算Phileas Fogg从出发的那一天1872年10月2日后80天的日期：

import java.util.*;
import java.text.*;

public class World {
   public static void main(String[] args) {
      GregorianCalendar worldTour = new GregorianCalendar(1872, Calendar.OCTOBER, 2);
      worldTour.add(GregorianCalendar.DATE, 80);
      Date d = worldTour.getTime();
      DateFormat df = DateFormat.getDateInstance();
      String s = df.format(d);
      System.out.println("80 day trip will end " + s);
   }
}

这个例子是想象的，但在一个日期上增加天数是一个普遍的操作：影碟可以租3天，图书馆可以借书21天，商店经常需要将购买的物品在30天内卖出。下面的程序演示了使用年计算：

import java.util.*;
import java.text.*;

public class Mortgage {
   public static void main(String[] args) {
      GregorianCalendar mortgage = new GregorianCalendar(1997, Calendar.MAY, 18);
      mortgage.add(Calendar.YEAR, 15);
      Date d = mortgage.getTime();
      DateFormat df = DateFormat.getDateInstance();
      String s = df.format(d);
      System.out.println("15 year mortgage amortized on " + s);    }
}

    add()一个重要的副作用是它改变的原来的日期。有时候，拥有原始日期和修改后的日期很重要。不幸的是，你不能简单的创建一个GregorianCalendar对象，设置它和原来的相等（equal）。原因是两个变量指向同一个Date()对象地址。如果Date对象改变，两个变量就指向改变后的日期对象。代替这种做法，应该创建一个新对象。下面的程序示范了这种做法：

import java.util.*;
import java.text.*;

public class ThreeDates {
   public static void main(String[] args) {
      GregorianCalendar gc1 = new GregorianCalendar(2000, Calendar.JANUARY, 1);
      GregorianCalendar gc2 = gc1;
      GregorianCalendar gc3 = new GregorianCalendar(2000, Calendar.JANUARY, 1);
      //Three dates all equal to January 1, 2000

      gc1.add(Calendar.YEAR, 1);
      file://gc1 and gc2 are changed

      DateFormat df = DateFormat.getDateInstance();

      Date d1 = gc1.getTime();
      Date d2 = gc2.getTime();
      Date d3 = gc3.getTime();

      String s1 = df.format(d1);
      String s2 = df.format(d2);
      String s3 = df.format(d3);

      System.out.println("gc1 is " + s1);
      System.out.println("gc2 is " + s2);
      System.out.println("gc3 is " + s3);
   }
}

    程序运行后，gc1和gc2被变成2001年（因为两个对象指向同一个Date，而Date已经被改变了）。对象gc3指向一个单独的Date，它没有被改变。
计算复习日期
在这节，你将看到一个依据现实世界的例子。这个详细的程序计算过去一个具体的日期。例如，你阅读这篇文章，你想要记住一个印象深刻的知识点。如果你没有照片一样的记忆力，你就要定期的复习这些新资料，这将帮助你记住它。关于复习系统，Kurt Hanks 和 Gerreld L. Pulsipher在他们的< Five Secrets to Personal Productivity个人能力的5个秘密>中有讨论，建议看过第一眼后马上回顾一下，然后是1天后，1个星期后，1个月后，3个月后，1年后。我的这篇文章，你要马上回顾一下，从现在算起，再就是明天，然后是1个星期，1个月，3个月，1年后。我们的程序将计算这些日期。
这个程序非常有用的，它将是PIM(Personal Information Manager个人信息管理器)的一个组成部分，并将确定复习时间。在下面的程序中，getDates()方法对一个返回日期数组（复习日期）的电子软件很有用。另外，你可以返回单独的一个日期，使用getFirstDay(),getOneDay(),getOneWeek(),getOnMonth()和getOneYear().当时间范围超出这个PIM的ReviewDates的计算范围时ReviewDates类演示了怎样计算时间段。现在，你可以容易的修改它用来处理你需要的时间段，象图书馆借书，录影带租赁和抵押计算。首先，ReviewDates类显示在下面：

import java.util.*;
import java.text.*;

public class ReviewDates {
   private GregorianCalendar firstDay, oneDay, oneWeek, oneMonth, oneQuarter, oneYear;
   final int dateArraySize = 6;

   ReviewDates(GregorianCalendar gcDate) {
      int year = gcDate.get(GregorianCalendar.YEAR);
      int month = gcDate.get(GregorianCalendar.MONTH);
      int date = gcDate.get(GregorianCalendar.DATE);

      firstDay = new GregorianCalendar(year, month, date);
      oneDay = new GregorianCalendar(year, month, date);
      oneWeek = new GregorianCalendar(year, month, date);
      oneMonth = new GregorianCalendar(year, month, date);
      oneQuarter = new GregorianCalendar(year, month, date);
      oneYear = new GregorianCalendar(year, month, date);

      oneDay.add(GregorianCalendar.DATE, 1);
      oneWeek.add(GregorianCalendar.DATE, 7);
      oneMonth.add(GregorianCalendar.MONTH, 1);
      oneQuarter.add(GregorianCalendar.MONTH, 3);
      oneYear.add(GregorianCalendar.YEAR, 1);
   }

   ReviewDates() {
      this(new GregorianCalendar());
   }

   public void listDates() {
      DateFormat df = DateFormat.getDateInstance(DateFormat.LONG);
      Date startDate = firstDay.getTime();
      Date date1 = oneDay.getTime();
      Date date2 = oneWeek.getTime();
      Date date3 = oneMonth.getTime();
      Date date4 = oneQuarter.getTime();
      Date date5 = oneYear.getTime();

      String ss =  df.format(startDate);
      String ss1 = df.format(date1);
      String ss2 = df.format(date2);
      String ss3 = df.format(date3);
      String ss4 = df.format(date4);
      String ss5 = df.format(date5);

      System.out.println("Start date is " + ss);
      System.out.println("Following review dates are:");
      System.out.println(ss1);
      System.out.println(ss2);
      System.out.println(ss3);
      System.out.println(ss4);
      System.out.println(ss5);
      System.out.println();
   }

   public GregorianCalendar[] getDates() {
      GregorianCalendar[] memoryDates = new GregorianCalendar[dateArraySize];
      memoryDates[0] = firstDay;
      memoryDates[1] = oneDay;
      memoryDates[2] = oneWeek;
      memoryDates[3] = oneMonth;
      memoryDates[4] = oneQuarter;
      memoryDates[5] = oneYear;
      return memoryDates;
   }

   public GregorianCalendar getFirstDay() {
      return this.firstDay;
   }

   public GregorianCalendar getOneDay() {
      return this.oneDay;
   }

   public GregorianCalendar getOneWeek() {
      return this.oneWeek;
   }

   public GregorianCalendar getOneMonth() {
      return this.oneMonth;
   }

   public GregorianCalendar getOneQuarter() {
      return this.oneQuarter;
   }

   public GregorianCalendar getOneYear() {
      return this.oneYear;
   }
} 

下面是使用ReviewDates类列出复习日期的例子程序：

import java.util.*;

public class ShowDates {
   public static void main(String[] args) {
      ReviewDates rd = new ReviewDates();
      rd.listDates();

      GregorianCalendar gc = new GregorianCalendar(2001, Calendar.JANUARY, 15);
      ReviewDates jan15 = new ReviewDates(gc);
      jan15.listDates();
   }
}

总结
 这篇文章介绍了关于日期处理的3个重要的类：Date,DateFormat,GregorianCalendar.这些类让你创建日期，转换成字符串，和计算日期基本元素。处理Java中的日期问题，这篇文章只是冰山一角。可是，我在这里介绍的类和方法不仅仅是你学习高级技术的跳板，这些类和方法本身就可以处理很多通常的日期相关的任务
关于作者
 Robert Nielsen是SCJP。他拥有硕士学位，专攻计算机教育，并且在计算机领域执教多年。他也在各样的杂志上发表过很多计算机相关的文章。
关于译者
Cocia Lin(cocia@163.com)是程序员。他拥有学士学位，现在专攻Java相关技术，刚刚开始在计算机领域折腾。

这篇文章是在我发表过的<计算Java时间>(译者:已经翻译完成)的基础上的。在这里，我列出那篇文章几个你应该熟悉得关键点。如果这几点你不太清楚，我建议你读一下<计算Java时间>，了解一下。
1. Java计算时间依靠1970年1月1日开始的毫秒数.                                                                                                                                                              
2. Date类的构造函数Date()返回代表当前创建的时刻的对象。Date的方法getTime()返回一个long值在数值上等于1970年1月1日之前或之后的时刻。

3. DateFormat类用来转换Date到String,反之亦然。静态方法getDateInstance()返回DateFormat的缺省格式；getDateInstance(DateFormat.FIELD)返回指定的DateFormat对象格式。Format(Date d)方法返回String表示日期，例如＂January 1,2002.＂反过来，parse(String s)方法返回以参数字符串表示的Date对象。

4. format()方法返回的字符串格式根据不同地区的时间设置而有所不同。

5. GregorianCalendear类有两个重要的构造函数：GregorianCalerdar(),返回代表当前创建时间的对象；GregorianCalendar(int year,int month,int date)返回代表任意日期的对象。GregorianCalendar类的getTime()方法返回日期对象。Add(int field,int amount)方法通过加或减时间单位，象天数，月数或年数来计算日期。

GregorianCalendar和 时间
 两个GregorianCalendar的构造函数可以用来处理时间。前者创建一个表示日期，小时和分钟的对象：

GregorianCalendar(int year, int month, int date, int hour, int minute)

第二个创建一个表示一个日期，小时，分钟和秒：

GregorianCalendar(int year, int month, int date, int hour, int minute, int second)

首先，我应该提醒一下，每一个构造函数需要时间信息中的日期信息(年，月，日)。如果你想说2:30 p.m.,你必须指出日期。
同样，每一个GregorianCalendar构造函数创建一个在时间上使用毫秒计算的对象。所以，如果你的构造函数只提供年，月，日参数，那小时，分钟，秒和毫秒的值将被置0.

DateFormat和时间
你可以使用静态方法getDateTimeInstance(int dateStyle,int timeStyle)来建立DateFormat对象来显示时间和日期。这个方法表明你想要的日期和时间格式。如果你喜欢使用缺省格式，可以使用getDateTimeInstance()来代替它。
你可以使用静态方法getTimeInstance(int timeStyle)创建DateFormat对象来显示正确的时间。
下面的程序示范了getDateTimeInstance()和getTimeInstance()怎样工作：

import java.util.*;
import java.text.*;

public class Apollo {
   public static void main(String[] args) {
      GregorianCalendar liftOffApollo11 = new GregorianCalendar(1969, Calendar.JULY, 16, 9, 32);
      Date d = liftOffApollo11.getTime();
      DateFormat df1 = DateFormat.getDateTimeInstance(DateFormat.MEDIUM, DateFormat.MEDIUM);
      DateFormat df2 = DateFormat.getTimeInstance(DateFormat.SHORT);
      String s1 = df1.format(d);
      String s2 = df2.format(d);
      System.out.println(s1);
      System.out.println(s2);
   }
}  
       
在我的电脑上，上面的程序显示如下：

Jul 16, 1969 9:32:00 AM
9:32 AM
(输出根据你所在得地区有所不同)

计算时间间隔
     你可能有时需要计算过去的时间；例如，给你开始和结束时间，你想知道制造流程的持续时间。一个出租公司按小时或天数出租东西，计算时间对他们也很有用。同样的，在金融界，经常需要计算重要的支付时间。
将问题复杂化，人类至少是用两种方法计算时间。你可以说一天已经结束当24小时过去了，或者日历从今天翻到明天。我们将讨论我们想到的这两种情况。

时间段，情况 1：严格时间单位
在这种情况中，只有24小时过去，这天才过去，60分钟过去，这个小时才过去，60秒过去，这个分钟才过去，以此类推。在这个方法中，23小时的时间将被认为是0天。
使用这种方法计算时间段，你从计算过去的毫秒开始。为了做到这一点，首先转换每个日期为从1970年1月1日起得毫秒数。你可以从第二个毫秒值中减去第一个毫秒值。这里有一个简单的计算：

import java.util.*;

public class ElapsedMillis {
   public static void main(String[] args) {
      GregorianCalendar gc1 = new GregorianCalendar(1995, 11, 1, 3, 2, 1);
      GregorianCalendar gc2 = new GregorianCalendar(1995, 11, 1, 3, 2, 2);
      // the above two dates are one second apart
      Date d1 = gc1.getTime();
      Date d2 = gc2.getTime();
      long l1 = d1.getTime();
      long l2 = d2.getTime();
      long difference = l2 - l1;
      System.out.println("Elapsed milliseconds: " + difference);
   }
}    

上面的程序打印如下：

Elapsed milliseconds: 1000

这个程序也带来一点混淆。GregorianCalendar类的getTime()返回一个Date对象，Date类的getTime()方法返回从1970年1月1日到这个时间的long类型的毫秒数值。虽然他们的方法名字相同，返回值却不一样！
下面的程序片断用简单的整数除法转换毫秒到秒：

long milliseconds = 1999;
long seconds = 1999 / 1000;

这种方法舍去小数部分转换毫秒到秒，所以1,999毫秒等于1秒，2,000毫秒等于2秒。
计算更大的单位-例如天数，小时和分钟-给定一个时间数值，可以使用下面的过程：
1. 计算最大的单位，减去这个数值的秒数
2. 计算第二大单位，减去这个数值的秒数
3. 重复操作直到只剩下秒
例如,如果你的时间的10,000秒，你想知道这个数值相应的是多少小时，多少分钟，多少秒，你从最大的单位开始：小时。10,000除以3600（一个小时的秒数）得到小时数。使用整数除法，答案是2小时（整数除法中小数舍去）计算剩下的秒数，10,000-(3,600 x 2) = 2,800秒。所以你有2小时和2,800秒。
将2,800秒转换成分钟，2,800除以60。使用整数除法，答案是46。2,800 - (60 x 46) = 40秒。最后答案是2小时，46分，40秒。
下面的Java程序使用上面的计算方法：

import java.util.*;

public class Elapsed1 {
   public void calcHMS(int timeInSeconds) {
      int hours, minutes, seconds;
      hours = timeInSeconds / 3600;
      timeInSeconds = timeInSeconds - (hours * 3600);
      minutes = timeInSeconds / 60;
      timeInSeconds = timeInSeconds - (minutes * 60);
      seconds = timeInSeconds;
      System.out.println(hours + " hour(s) " + minutes + " minute(s) " + seconds + " second(s)");
   }

   public static void main(String[] args) {
      Elapsed1 elap = new Elapsed1();
      elap.calcHMS(10000);
   }
} 

输出结果如下：

2 hour(s) 46 minute(s) 40 second(s)

上面的程序甚至在时间少于一个小时也可以正确的计算小时数。例如，你用上面的程序计算1,000秒，输出入下：
0 hour(s) 16 minute(s) 40 second(s)
举一个现实世界的例子，下面的程序计算阿波罗11飞到月球使用得时间：

import java.util.*;

public class LunarLanding {

   public long getElapsedSeconds(GregorianCalendar gc1, GregorianCalendar gc2) {
      Date d1 = gc1.getTime();
      Date d2 = gc2.getTime();
      long l1 = d1.getTime();
      long l2 = d2.getTime();
      long difference = Math.abs(l2 - l1);
      return difference / 1000;
   }

   public void calcHM(long timeInSeconds) {
      long hours, minutes, seconds;
      hours = timeInSeconds / 3600;
      timeInSeconds = timeInSeconds - (hours * 3600);
      minutes = timeInSeconds / 60;
      System.out.println(hours + " hour(s) " + minutes + " minute(s)" );
   }

   public static void main(String[] args) {
      GregorianCalendar lunarLanding = new GregorianCalendar(1969, Calendar.JULY, 20, 16, 17);
      GregorianCalendar lunarDeparture = new GregorianCalendar(1969, Calendar.JULY, 21, 13, 54);
      GregorianCalendar startEVA = new GregorianCalendar(1969, Calendar.JULY, 20, 22, 56);
      GregorianCalendar endEVA = new GregorianCalendar(1969, Calendar.JULY, 21, 1, 9);

      LunarLanding apollo = new LunarLanding();

      long eva = apollo.getElapsedSeconds(startEVA, endEVA);
      System.out.print("EVA duration = ");
      apollo.calcHM(eva);

      long lunarStay = apollo.getElapsedSeconds(lunarLanding, lunarDeparture);
      System.out.print("Lunar stay = ");
      apollo.calcHM(lunarStay);
   }
}         

上面程序输出如下：

EVA duration = 2 hour(s) 13 minute(s)
Lunar stay = 21 hour(s) 37 minute(s)

目前为止，我们计算的基础公式是这样的：1分钟=60秒，1小时=60分，1天=24小时。
"1个月=？天，1年=？天"怎么办？
月份的天数有28，29，30，31；一年可以是365或366天。因此，当你试图计算严格单位的月份和年时，问题就产生了。例如，如果你使用月份的平均天数（近似30.4375），并且计算下面的时间间隔:

* July 1, 2:00 a.m. to July 31, 10:00 p.m.
* February 1, 2:00 a.m. to February 29, 10:00 p.m.

第一个计算结果是1个月；第二个结果是0个月！
所以，在计算严格单位时间的月份和年份是要想好。

时间段，情况 2:时间单位变化
时间单位的变化相当的简单：如果你要统计天数，你可以简单的统计日期变化次数。例如，如果某事15日开始，17日结束，经过2天。（日期先是便到16，再到17）同样的，一个步骤下午3：25开始，4：10 p.m结束，历时1个小时，因为小时数值变了一次（从3到4）。
图书馆经常使用这种习惯计算时间。例如，如果你从图书馆接一本书，我不能占有这本书最少24小时，会认为图书馆这样才给你算一天。而是，我的账号上记录我借书的日期。日期以变成下一天，我就已经结这本书一天了，即使总计不足24小时。
当使用单位的变化来计算时间段，通常感觉计算的时间没有多于一个时间单位。例如，如果9:00 p.m.我借了一本图书馆的书，第二天中午还回去，我能算出我借了这本书一天了。可是，有一种感觉在问："1天和几个小时呢？"这本说总计借出15个小时，答案是一天还差9个小时呢？因此，这篇文章里，我将以一个时间单位变化计算时间。

单位变化的时间算法
 这是你怎样计算两个日期的时间变化：
1. 制作两个日期的拷贝。Close()方法能制作拷贝。
2. 使用日期拷贝，将所有的小于时间单位变化的部分设置成它的最小单位。例如，如果计算天数，那么将小时，分钟，秒和毫秒设置成0。这种情况中，使用clear()方法将时间值设置称他们各自的最小值。
3. 取出较早的日期，将你要计算的单位加1，重复直到两个日期相等。你加1的次数就是答案。可以使用before()和after()方法，他们返回boolean值，来判断是否一个日期在另一个日期之前或之后。
下面的类的方法用来计算天数和月数。

import java.util.*;

public class ElapsedTime {

   public int getDays(GregorianCalendar g1, GregorianCalendar g2) {
      int elapsed = 0;
      GregorianCalendar gc1, gc2;

      if (g2.after(g1)) {
         gc2 = (GregorianCalendar) g2.clone();
         gc1 = (GregorianCalendar) g1.clone();
      }
      else   {
         gc2 = (GregorianCalendar) g1.clone();
         gc1 = (GregorianCalendar) g2.clone();
      }

      gc1.clear(Calendar.MILLISECOND);
      gc1.clear(Calendar.SECOND);
      gc1.clear(Calendar.MINUTE);
      gc1.clear(Calendar.HOUR_OF_DAY);

      gc2.clear(Calendar.MILLISECOND);
      gc2.clear(Calendar.SECOND);
      gc2.clear(Calendar.MINUTE);
      gc2.clear(Calendar.HOUR_OF_DAY);

      while ( gc1.before(gc2) ) {
         gc1.add(Calendar.DATE, 1);
         elapsed++;
      }
      return elapsed;
   }

   public int getMonths(GregorianCalendar g1, GregorianCalendar g2) {
      int elapsed = 0;
      GregorianCalendar gc1, gc2;

      if (g2.after(g1)) {
         gc2 = (GregorianCalendar) g2.clone();
         gc1 = (GregorianCalendar) g1.clone();
      }
      else   {
         gc2 = (GregorianCalendar) g1.clone();
         gc1 = (GregorianCalendar) g2.clone();
      }

      gc1.clear(Calendar.MILLISECOND);
      gc1.clear(Calendar.SECOND);
      gc1.clear(Calendar.MINUTE);
      gc1.clear(Calendar.HOUR_OF_DAY);
      gc1.clear(Calendar.DATE);

      gc2.clear(Calendar.MILLISECOND);
      gc2.clear(Calendar.SECOND);
      gc2.clear(Calendar.MINUTE);
      gc2.clear(Calendar.HOUR_OF_DAY);
      gc2.clear(Calendar.DATE);

      while ( gc1.before(gc2) ) {
         gc1.add(Calendar.MONTH, 1);
         elapsed++;
      }
      return elapsed;
   }
}

你可以在上面的类中补充另外的方法来处理小时和分钟。同样，计算时间段的算法能更高效一些，尤其是时间相隔很长。可是，作为介绍目的，这个算法有短小和简单的优势。
下面的例子使用ElapsedTime类来计算两个日期之间的天使，而后是月数：

import java.util.*;

public class Example {
   public static void main(String[] args) {
      GregorianCalendar gc1 = new GregorianCalendar(2001, Calendar.DECEMBER, 30);
      GregorianCalendar gc2 = new GregorianCalendar(2002, Calendar.FEBRUARY, 1);

      ElapsedTime et = new ElapsedTime();
      int days = et.getDays(gc1, gc2);
      int months = et.getMonths(gc1, gc2);

      System.out.println("Days = " + days);
      System.out.println("Months = " + months);
   }
}

当计算时，上面的程序可能有用，例如，最近的航班。它显示下面的输出：

Days = 33
Months = 2

(OK,关于航班的计算有些夸张；这个天数算法很适合像图书馆借书这样的应用，你看到了她怎样工作)

import java.util.ArrayList;

import java.util.Collections;
import java.util.Comparator;
import java.util.List;
/*
 * 当前文件： TestCollections.java
 * 创建日期： 2005-8-10
 * 版 本 号： 1.0
 * 作 者： kang1
 *
 */

/**
 * 亲爱的kang1，请您在此详细描述我的用途.
 */

class BookType{
 String idsn;
 String name;
 /**
  * @param idsn
  * @param name
  */
 public BookType(String idsn, String name)
 {
  super();
  this.idsn = idsn;
  this.name = name;
 }
 /**
  * @return Returns the idsn.
  */
 public String getIdsn()
 {
  return idsn;
 }
 /**
  * @param idsn The idsn to set.
  */
 public void setIdsn(String idsn)
 {
  this.idsn = idsn;
 }
 /**
  * @return Returns the name.
  */
 public String getName()
 {
  return name;
 }
 /**
  * @param name The name to set.
  */
 public void setName(String name)
 {
  this.name = name;
 }
}
public class TestCollections
{

 public static void main(String[] args)
 {
  List list=new ArrayList();
  list.add(new BookType("1","k"));
  list.add(new BookType("5","z"));
  list.add(new BookType("4","g"));
  
  Comparator OrderIsdn = new Comparator(){
   public int compare(Object o1, Object o2){
    BookType b1=(BookType)o1;
    BookType b2=(BookType)o2;
    return (b1.getIdsn().hashCode()-b2.getIdsn().hashCode());
   }
  };
  
  Comparator OrderName = new Comparator(){
   public int compare(Object o1, Object o2){
    BookType b1=(BookType)o1;
    BookType b2=(BookType)o2;
    return (b1.getName().hashCode()-b2.getName().hashCode());
   }
  };
  
  Collections.sort(list,OrderName);
  Collections.reverse(list);
  
  for(int i=0;i<list.size();i++){
   BookType ss=(BookType)list.get(i);
   System.out.print(ss.getIdsn());
   System.out.println(ss.getName());
  }
  
 }
}

要实现排序功能,一般有两种途径,这里对基本类型不适用,基本类型一般有Arrays中的静态方法.

1.对象本身实现Comparable接口,那么该类的实例就是可以排序的.
有关Comparable: http://blog.csdn.net/treeroot/archive/2004/09/09/99613.aspx
只要实现了Comparable接口,就可以调用Collections的sort方法对集合中的元素排序.

2.指定一个Comparator,也就是实现了Comparator的类的一个实例.
但是Java本身只提供了一个Comparator的实现,就是Collections.reverseOrder().
该方法返回的是一个已经实现了Comparable接口的反序.

看一下Comparator的全部内容:

public interface Comparator {
　　int compare(Object o1, Object o2);
　　boolean equals(Object obj);
}
定义了两个方法,其实我们一般都只需要实现compare方法就行了,因为类都是默认从Object继承
所以会使用Object的equals方法.
Comparator一般都作为一个匿名类出现,对于没有实现Comparable的对象的集合,排序的时候
需要指定一个Comparator.

这里举例说明
对于实现了Comparable的类我们就用最简单的Integer
List list=new ArrayList();
list.add(new Integer(3));
list.add(new Integer(53));
list.add(new Integer(34));
Collections.sort(list);

对于没有实现Comparable的,我们就用Object,按照hashCode大小来排序.
List list= new ArrayList();
list.add(new Object());
list.add(new Object());
list.add(new Object());
Collections.sort(list,new Comparator(){ public int compare(Object o1, Object o2){
　　　　　　　　　　　　　　　　　　　　return (o1.hashCode()-o2.hashCode());
　　　　　　　　　　　　　　　 })

Collections和Arrays一样是一个不可实例化的类，提供了一些静态方法来操作Collection。

1.排序 sort
public static void sort(List list)
public static void sort(List list, Comparator c)
用于对List排序，可以使用自然排序，也可以指定Comparator，返回的是从小到大的有序List。

2.二分查找 binarySearch
public static int binarySearch(List list, Object key)
public static int binarySearch(List list, Object key, Comparator c)
应用和排序一样，List必须是有序的，否则改方法无作用。

3.反转
public static void reverse(List list)
适用于List,返回的List和原来的顺序相反

4.打乱顺序
public static void shuffle(List list)
public static void shuffle(List list, Random rnd)
就是把原来的List的顺序随机弄乱。

5.元素直接置换
public static void swap(List list, int i, int j)
这个方法显得有点牵强，我觉得没有必要出现在API里面，实现就是一条语句：
list.set(i, list.set(j, list.get(i)));

6.填充
public static void fill(List list, Object obj)
把List中的元素全部用一个值填充

7.拷贝
public static void copy(List dest, List src)
把源List拷贝到目的List，目的List必须足够大

8.最小值
public static Object min(Collection coll)
public static Object min(Collection coll, Comparator comp)

9.最大值
public static Object max(Collection coll)
public static Object max(Collection coll, Comparator comp)

10.移动
public static void rotate(List list, int distance)
元素右移，有点像 int a=0xff>>8的味道

11.替换
public static boolean replaceAll(List list, Object oldVal, Object newVal)
看方法名就知道了

12.求子List
public static int indexOfSubList(List source, List target)
public static int lastIndexOfSubList(List source, List target)
和String类的indexOf和lastIndexOf类似

13.同步
public static Collection synchronizedCollection(Collection c)
public static List synchronizedList(List list)
public static Map synchronizedMap(Map m)
public static Set synchronizedSet(Set s)
public static SortedMap synchronizedSortedMap(SortedMap m)
public static SortedSet synchronizedSortedSet(SortedSet s)
因为Collection框架中的类大部分都是未经过同步的，可以通过这些方法同步
注意这里没有使用方法重载，因为那么命名不同。另外，返回的虽然是一个同步了的Collection
但是通过迭代器访问时仍然需要自己同步，因为迭代器返回没有被同步。

14.只读
public static Collection unmodifiableCollection(Collection c)
public static List unmodifiableList(List list)
public static Map unmodifiableMap(Map m)
public static Set unmodifiableSet(Set s)
public static SortedMap unmodifiableSortedMap(SortedMap m)
public static SortedSet unmodifiableSortedSet(SortedSet s)
这些方法返回一个只读的Collection，我发现这个有的时候真的特别有用，如果你试图调用修改
方法，会获得一个UnsupportedOperationException系统异常。

15.常量
public static final List EMPTY_LIST = new EmptyList()
public static final Map EMPTY_MAP = new EmptyMap()
public static final Set EMPTY_SET = new EmptySet()
这些常量就是表示空的集合，本身不是null，但是不包含任何元素。

16.单元素集合
public static Set singleton(Object o)
public static List singletonList(Object o)
public static Map singletonMap(Object key, Object value)
这些集合只含有一个元素。

17.多元素集合
public static List nCopies(int n, Object o)
返回一个List，含有n个相同的元素

18.比较器常量
public static Comparator reverseOrder()
这个比较器和自然顺序的排序相反。

19.最后2个
public static ArrayList list(Enumeration e)
public static Enumeration enumeration(final Collection c)
List和Enumeration的转换，由于Enumeration属于过时的API，应该没有什么机会用到他们。

整个方法都在这里，主要是对List的操作，Set和Map的相对少一些。

/*
 * 当前文件： DesEncrypt.java
 * 创建日期： 2005-7-29
 * 版 本 号： 1.0
 * 作 者： kang1
 *
 */
package com.chuangs.pai.utilities;

import java.security.Key;
import java.security.SecureRandom;
import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;

/**
 *
 * 使用DES加密与解密,可对byte[],String类型进行加密与解密
 * 密文可使用String,byte[]存储.
 *
 * 方法:
 *  void getKey(String strKey)    从strKey的字条生成一个Key
 *
 *  String getEncString(String strMing)  对strMing进行加密,返回String密文
 *  String getDesString(String strMi)  对strMin进行解密,返回String明文
 *
 * byte[] getEncCode(byte[] byteS)   byte[]型的加密
 * byte[] getDesCode(byte[] byteD)   byte[]型的解密
 */

public class DesEncrypt
{ 
 Key key;
 
 /**
  * 根据参数生成KEY
  * @param strKey
  */
 public void getKey(String strKey)
 {
  try{
   KeyGenerator _generator = KeyGenerator.getInstance("DES");
   _generator.init(new SecureRandom(strKey.getBytes()));
   this.key = _generator.generateKey();
   _generator=null;
  }catch(Exception e){
   e.printStackTrace();
  }  
 }
 /**
  * 加密 String明文输入,String密文输出
  * @param strMing
  * @return
  */
 public String getEncString(String strMing)
 {
  byte[] byteMi = null;
  byte[] byteMing = null;
  String strMi = "";
  BASE64Encoder base64en = new BASE64Encoder();
  try
  {
   byteMing = strMing.getBytes("UTF8");
   byteMi = this.getEncCode(byteMing);
   strMi = base64en.encode(byteMi);
  }
  catch(Exception e)
  {
   e.printStackTrace();
  }
  finally
  {
   base64en = null;
   byteMing = null;
   byteMi = null;
  }
  return strMi;
 }
 /**
  * 解密 以String密文输入,String明文输出
  * @param strMi
  * @return
  */
 //
 public String getDesString(String strMi)
 {
  BASE64Decoder base64De = new BASE64Decoder();
  byte[] byteMing = null;
  byte[] byteMi = null;
  String strMing = "";
  try
  {
   byteMi = base64De.decodeBuffer(strMi);
   byteMing = this.getDesCode(byteMi);
   strMing = new String(byteMing, "UTF8");
  }
  catch(Exception e)
  {
   e.printStackTrace();
  }
  finally
  {
   base64De = null;
   byteMing = null;
   byteMi = null;
  }
  return strMing;
 }
 /**
  * 加密 以byte[]明文输入,byte[]密文输出
  * @param byteS
  * @return
  */
 ///byte明文,加密成byte密文
 private byte[] getEncCode(byte[] byteS)
 {
  byte[] byteFina = null;
  Cipher cipher;
  try
  {
   cipher = Cipher.getInstance("DES");
   cipher.init(Cipher.ENCRYPT_MODE, key);
   byteFina = cipher.doFinal(byteS);
  }
  catch(Exception e)
  {
   e.printStackTrace();
  }
  finally
  {
   cipher = null;
  }
  return byteFina;
 }
 /**
  * 解密 以byte[]密文输入,以byte[]明文输出
  * @param byteD
  * @return
  */
 //byte密文,加密成byte明文
 private byte[] getDesCode(byte[] byteD)
 {
  Cipher cipher;
  byte[] byteFina=null;
  try{
   cipher = Cipher.getInstance("DES");
   cipher.init(Cipher.DECRYPT_MODE, key);
   byteFina = cipher.doFinal(byteD);
  }catch(Exception e){
   e.printStackTrace();
  }finally{
   cipher=null;
  }
  return byteFina;
  
 }

}

1.问题的起源
　　每个国家（或区域）都规定了计算机信息交换用的字符编码集，如美国的 ASCII，中国的 GB2312-80，日本的 JIS 等，作为该国家/区域内信息处理的基础，有着统一编码的重要作用。字符编码集按长度分为 SBCS（单字节字符集），DBCS（双字节字符集）两大类。早期的软件（尤其是操作系统），为了解决本地字符信息的计算机处理，出现了各种本地化版本（L10N），为了区分，引进了 LANG，Codepage 等概念。但是由于各个本地字符集代码范围重叠，相互间信息交换困难；软件各个本地化版本独立维护成本较高。因此有必要将本地化工作中的共性抽取出来，作一致处理，将特别的本地化处理内容降低到最少。这也就是所谓的国际化（I18N）。各种语言信息被进一步规范为 Locale 信息。处理的底层字符集变成了几乎包含了所有字形的 Unicode。

　　现在大部分具有国际化特征的软件核心字符处理都是以 Unicode 为基础的，在软件运行时根据当时的 Locale/Lang/Codepage 设置确定相应的本地字符编码设置，并依此处理本地字符。在处理过程中需要实现 Unicode 和本地字符集的相互转换，甚或以 Unicode 为中间的两个不同本地字符集的相互转换。这种方式在网络环境下被进一步延伸，任何网络两端的字符信息也需要根据字符集的设置转换成可接受的内容。

　　Java 语言内部是用 Unicode 表示字符的，遵守 Unicode V2.0。Java 程序无论是从/往文件系统以字符流读/写文件，还是往 URL 连接写 HTML 信息，或从 URL 连接读取参数值，都会有字符编码的转换。这样做虽然增加了编程的复杂度，容易引起混淆，但却是符合国际化的思想的。

　　从理论上来说，这些根据字符集设置而进行的字符转换不应该产生太多问题。而事实是由于应用程序的实际运行环境不同，Unicode 和各个本地字符集的补充、完善，以及系统或应用程序实现的不规范，转码时出现的问题时时困扰着程序员和用户。

2.GB2312-80，GBK，GB18030-2000 汉字字符集
　　其实解决 JAVA 程序中的汉字编码问题的方法往往很简单，但理解其背后的原因，定位问题，还需要了解现有的汉字编码和编码转换。

　　GB2312-80 是在国内计算机汉字信息技术发展初始阶段制定的，其中包含了大部分常用的一、二级汉字，和 9 区的符号。该字符集是几乎所有的中文系统和国际化的软件都支持的中文字符集，这也是最基本的中文字符集。其编码范围是高位0xa1－0xfe，低位也是 0xa1-0xfe；汉字从 0xb0a1 开始，结束于 0xf7fe；

　　GBK 是 GB2312-80 的扩展，是向上兼容的。它包含了 20902 个汉字，其编码范围是 0x8140-0xfefe，剔除高位 0x80 的字位。其所有字符都可以一对一映射到 Unicode 2.0，也就是说 JAVA 实际上提供了 GBK 字符集的支持。这是现阶段 Windows 和其它一些中文操作系统的缺省字符集，但并不是所有的国际化软件都支持该字符集，感觉是他们并不完全知道 GBK 是怎么回事。值得注意的是它不是国家标准，而只是规范。随着 GB18030-2000国标的发布，它将在不久的将来完成它的历史使命。

　　GB18030-2000(GBK2K) 在 GBK 的基础上进一步扩展了汉字，增加了藏、蒙等少数民族的字形。GBK2K 从根本上解决了字位不够，字形不足的问题。它有几个特点：

　　●它并没有确定所有的字形，只是规定了编码范围，留待以后扩充。

　　●编码是变长的，其二字节部分与 GBK 兼容；四字节部分是扩充的字形、字位，其编码范围是首字节 0x81-0xfe、二字节0x30-0x39、三字节 0x81-0xfe、四字节0x30-0x39。

　　●它的推广是分阶段的，首先要求实现的是能够完全映射到 Unicode 3.0 标准的所有字形。

　　●它是国家标准，是强制性的。

　　现在还没有任何一个操作系统或软件实现了 GBK2K 的支持，这是现阶段和将来汉化的工作内容。

3.JSP/Servlet 汉字编码问题及在 WAS 中的解决办法
　　3.1 常见的 encoding 问题的现象

　　网上常出现的 JSP/Servlet encoding 问题一般都表现在 browser 或应用程序端，如:

　　●浏览器中看到的 Jsp/Servlet 页面中的汉字怎么都成了 ’?’ ?

　　●浏览器中看到的 Servlet 页面中的汉字怎么都成了乱码？

　　●JAVA 应用程序界面中的汉字怎么都成了方块？

　　●Jsp/Servlet 页面无法显示 GBK 汉字。

　　●Jsp/Servlet 不能接收 form 提交的汉字。

　　●JSP/Servlet 数据库读写无法获得正确的内容。

　　隐藏在这些问题后面的是各种错误的字符转换和处理（除第3个外，是因为 Java font 设置错误引起的）。解决类似的字符 encoding 问题，需要了解 Jsp/Servlet 的运行过程，检查可能出现问题的各个点。

　　3.2 JSP/Servlet web 编程时的 encoding 问题

　　运行于Java 应用服务器的 JSP/Servlet 为 Browser 提供 HTML 内容，其过程如下图所示：

　　其中有字符编码转换的地方有：

　　a.JSP 编译。Java 应用服务器将根据 JVM 的 file.encoding 值读取 JSP 源文件，并转换为内部字符编码进行 JSP 编译，生成 JAVA 源文件，根据 file.encoding 值写回文件系统。如果当前系统语言支持 GBK，那么这时候不会出现 encoding 问题。如果是英文的系统，如 LANG 是 en_US 的 Linux, AIX 或 Solaris，则要将 JVM 的 file.encoding 值置成 GBK 。系统语言如果是 GB2312，则根据需要，确定要不要设置 file.encoding，将 file.encoding 设为 GBK 可以解决潜在的 GBK 字符乱码问题。

　　b.Java 需要被编译为 .class 才能在 JVM 中执行，这个过程存在与a.同样的 file.encoding 问题。从这里开始 servlet 和 jsp 的运行就类似了，只不过 Servlet 的编译不是自动进行的。

　　c.Servlet 需要将 HTML 页面内容转换为 browser 可接受的 encoding 内容发送出去。依赖于各 JAVA App Server 的实现方式，有的将查询 Browser 的 accept-charset 和 accept-language 参数或以其它猜的方式确定 encoding 值，有的则不管。因此 constant-encoding 也许是最好的解决方法。对于中文网页，可在 JSP 或 Servlet 中设置 contentType="text/html; charset=GB2312"；如果页面中有GBK字符，则设置为contentType="text/html; charset=GBK"，由于IE 和 Netscape对GBK的支持程度不一样，作这种设置时需要测试一下。

　　因为16位 JAVA char在网络传送时高8位会被丢弃，也为了确保Servlet页面中的汉字（包括内嵌的和servlet运行过程中得到的）是期望的内码，可以用 PrintWriter out=res.getWriter() 取代 ServletOutputStream out=res.getOutputStream(), PrinterWriter 将根据contentType中指定的charset作转换(ContentType需在此之前指定！);也可以用OutputStreamWriter封装 ServletOutputStream 类并用write(String)输出汉字字符串。

对于 JSP，JAVA Application Server 应当能够确保在这个阶段将嵌入的汉字正确传送出去。

　　d.这是 URL 字符 encoding 问题。如果通过 get/post 方式从 browser 返回的值中包含汉字信息， servlet 将无法得到正确的值。SUN的 J2SDK 中，HttpUtils.parseName 在解析参数时根本没有考虑 browser 的语言设置，而是将得到的值按 byte 方式解析。这是网上讨论得最多的 encoding 问题。因为这是设计缺陷，只能以 bin 方式重新解析得到的字符串；或者以 hack HttpUtils 类的方式解决。参考文章 2、3 均有介绍，不过最好将其中的中文 encoding GB2312、 CP1381 都改为 GBK，否则遇到 GBK 汉字时，还是会有问题。

　　Servlet API 2.3 提供一个新的函数 HttpServeletRequest.setCharacterEncoding 用于在调用 request.getParameter(“param_name”) 前指定应用程序希望的 encoding，这将有助于彻底解决这个问题。

　　WebSphere Application Server 对标准的 Servlet API 2.x 作了扩展，提供较好的多语言支持。上述c,d情况，WAS 都要查询 Browser 的语言设置，在缺省状况下zh、zh-cn 等均被映射为 JAVA encoding CP1381（注意：CP1381 只是等同于 GB2312 的一个 codepage，没有 GBK 支持）。这样做我想是因为无法确认 Browser 运行的操作系统是支持GB2312, 还是 GBK，所以取其小。但是实际的应用系统还是要求页面中出现 GBK 汉字，最著名的是朱总理名字中的“?”(rong2 ，0xe946，\u9555)，所以有时还是需要将 Encoding/Charset 指定为 GBK。当然 WAS 中变更缺省的 encoding 没有上面说的那么麻烦，针对 a,b，参考文章 5 ），在 Application Server 的命令行参数中指定 -Dfile.encoding=GBK 即可； 针对 d，在 Application Server 的命令行参数中指定-Ddefault.client.encoding=GBK。如果指定了-Ddefault.client.encoding=GBK，那么c情况下可以不再指定charset。

　　3.3 数据库读写时的 encoding 问题

　　JSP/Servlet 编程中经常出现 encoding 问题的另一个地方是读写数据库中的数据。

　　流行的关系数据库系统都支持数据库 encoding，也就是说在创建数据库时可以指定它自己的字符集设置，数据库的数据以指定的编码形式存储。当应用程序访问数据时，在入口和出口处都会有 encoding 转换。对于中文数据，应当保证数据的完整性。GB2312，GBK，UTF-8 等都是可选的数据库 encoding；如果选择 ISO8859-1(8-bit SBCS)，那么应用程序在写数据之前须将 16Bit 的一个汉字或 Unicode 拆分成两个 8-bit 的字符，读数据之后则需将两个字节合并起来，同时还有判别其中的 SBCS 字符。没有充分利用数据库 encoding 的作用，反而增加了编程的复杂度，ISO8859-1不是推荐的数据库 encoding。JSP/Servlet编程时，可以先用数据库管理系统提供的功能检查其中的中文数据是否正确。

　　然后应当注意的是读出来的数据的 encoding，JAVA 程序中一般得到的是 Unicode。写数据时则相反。

　　3.4 定位问题时常用的技巧

　　定位中文encoding问题通常采用最笨的也是最有效的办法——在你认为有嫌疑的程序处理后打印字符串的内码。通过打印字符串的内码，你可以发现什么时候中文字符被转换成Unicode，什么时候Unicode被转回中文内码，什么时候一个中文字成了两个 Unicode 字符，什么时候中文字符串被转成了一串问号，什么时候中文字符串的高位被截掉了……

　　取用合适的样本字符串也有助于区分问题的类型。如：”aa啊aa?aa” 等中英相间、GB、GBK特征字符均有的字符串。一般来说，英文字符无论怎么转换或处理，都不会失真（如果遇到了，可以尝试着增加连续的英文字母长度）。

4.结束语
　　其实 JSP/Servlet 的中文encoding 并没有想像的那么复杂，虽然定位和解决问题没有定规，各种运行环境也各不尽然，但后面的原理是一样的。了解字符集的知识是解决字符问题的基础。不过，随着中文字符集的变化，不仅仅是 java 编程，中文信息处理中的问题还是会存在一段时间的。

5.参考文章
1) Character Problem Review
2) Java 编程技术中汉字问题的分析及解决
3) NLS Characters in WebSphere: SBCS/DBCS display on same page
4) GB18030
5) Setting language encoding in web applications: Websphere applications Server
作者简介
　　张建芳，软件工程师，毕业于北京理工大学计算机应用学院，有多年中文本地化经验。您可通过 jfzhang@usa.net 与他联系。