1、 尽量指定类的final修饰符 带有final修饰符的类是不可派生的。
如果指定一个类为final，则该类所有的方法都是final。Java编译器会寻找机会内联（inline）所有的 final方法（这和具体的编译器实现有关）。此举能够使性能平均提高50% 。

2、 尽量重用对象。
特别是String 对象的使用中，出现字符串连接情况时应用StringBuffer 代替。由于系统不仅要花时间生成对象，以后可能还需花时间对这些对象进行垃圾回收和处理。因此，生成过多的对象将会给程序的性能带来很大的影响。

3、 尽量使用局部变量，调用方法时传递的参数以及在调用中创建的临时变量都保存在栈（Stack）中，速度较快。
其他变量，如静态变量、实例变量等，都在堆（Heap）中创建，速度较慢。另外，依赖于具体的编译器/JVM，局部变量还可能得到进一步优化。请参见《尽 可能使用堆栈变量》。

4、 不要重复初始化变量
默认情况下，调用类的构造函数时， Java会把变量初始化成确定的值：所有的对象被设置成null，整数变量（byte、short、int、long）设置成0，float和 double变量设置成0.0，逻辑值设置成false。当一个类从另一个类派生时，这一点尤其应该注意，因为用new关键词创建一个对象时，构造函数链 中的所有构造函数都会被自动调用。

5、 在JAVA + ORACLE 的应用系统开发中，java中内嵌的SQL语句尽量使用大写的形式，以减轻ORACLE解析器的解析负担。

6、 Java 编程过程中，进行数据库连接、I/O流操作时务必小心，在使用完毕后，即使关闭以释放资源。
因为对这些大对象的操作会造成系统大的开销，稍有不慎，会导致严重的后果。

7、 由于JVM的有其自身的GC机制，不需要程序开发者的过多考虑，从一定程度上减轻了开发者负担，但同时也遗漏了隐患，过分的创建对象会消耗系统的大量内 存，严重时会导致内存泄露，因此，保证过期对象的及时回收具有重要意义。
JVM回收垃圾的条件是：对象不在被引用；然而，JVM的GC并非十分的机智，即使对象满足了垃圾回收的条件也不一定会被立即回收。所以，建议我们在对象 使用完毕，应手动置成null。

8、 在使用同步机制时，应尽量使用方法同步代替代码块同步。

9、 尽量减少对变量的重复计算

10、尽量采用lazy loading 的策略，即在需要的时候才开始创建。

11、慎用异常
异常对性能不利。抛出异常首先要创建一个新的对象。Throwable接口的构造函数调用名为fillInStackTrace()的本地 （Native）方法，fillInStackTrace()方法检查堆栈，收集调用跟踪信息。只要有异常被抛出，VM就必须调整调用堆栈，因为在处理过 程中创建了一个新的对象。 异常只能用于错误处理，不应该用来控制程序流程。

12、不要在循环中使用：
Try {
} catch() {
}
应把其放置在最外层。

13、StringBuffer 的使用：
StringBuffer表示了可变的、可写的字符串。
有三个构造方法 :
StringBuffer (); //默认分配16个字符的空间
StringBuffer (int size); //分配size个字符的空间
StringBuffer (String str); //分配16个字符+str.length()个字符空间
你可以通过StringBuffer的构造函数来设定它的初始化容量，这样可以明显地提升性能。

这里提到的构造函数是StringBuffer(int length)，length参数表示当前的StringBuffer能保持的字符数量。你也可以使用ensureCapacity(int minimumcapacity)方法在StringBuffer对象创建之后设置它的容量。首先我们看看StringBuffer的缺省行为，然后再找 出一条更好的提升性能的途径。
StringBuffer在内部维护一个字符数组，当你使用缺省的构造函数来创建StringBuffer对象的时候，因为没有设置初始化字符长 度，StringBuffer的容量被初始化为16个字符，也就是说缺省容量就是16个字符。当StringBuffer达到最大容量的时候，它会将自身 容量增加到当前的2倍再加2，也就是（2*旧值+2）。如果你使用缺省值，初始化之后接着往里面追加字符，在你追加到第16个字符的时候它会将容量增加到 34（2*16+2），当追加到34个字符的时候就会将容量增加到70（2*34+2）。无论何事只要StringBuffer到达它的最大容量它就不得 不创建一个新的字符数组然后重新将旧字符和新字符都拷贝一遍――这也太昂贵了点。所以总是给StringBuffer设置一个合理的初始化容量值是错不了 的，这样会带来立竿见影的性能增益。StringBuffer初始化过程的调整的作用由此可见一斑。所以，使用一个合适的容量值来初始化 StringBuffer永远都是一个最佳的建议。

14、合理的使用Java类 java.util.Vector。
简单地说，一个Vector就是一个java.lang.Object实例的数组。Vector与数组相似，它的元素可以通过整数形式的索引访问。但 是，Vector类型的对象在创建之后，对象的大小能够根据元素的增加或者删除而扩展、缩小。请考虑下面这个向Vector加入元素的例子：
Object bj = new Object();
Vector v = new Vector(100000);
for(int I=0;
I<100000; I++) { v.add(0,obj); }

除非有绝对充足的理由要求每次都把新元素插入到Vector的前面，否则上面的代码对性能不利。在默认构造函数中，Vector的初始存储能力 是10个元素，如果新元素加入时存储能力不足，则以后存储能力每次加倍。Vector类就对象StringBuffer类一样，每次扩展存储能力时，所有 现有的元素都要复制到新的存储空间之中。下面的代码片段要比前面的例子快几个数量级：
Object bj = new Object();
Vector v = new Vector(100000);
for(int I=0; I<100000; I++) { v.add(obj); }

同样的规则也适用于Vector类的remove()方法。由于Vector中各个元素之间不能含有“空隙”，删除除最后一个元素之外的任意其 他元素都导致被删除元素之后的元素向前移动。也就是说，从Vector删除最后一个元素要比删除第一个元素“开销”低好几倍。

假设要从前面的Vector删除所有元素，我们可以使用这种代码：
for(int I=0; I<100000; I++)
{
v.remove(0);
}

但是，与下面的代码相比，前面的代码要慢几个数量级：
for(int I=0; I<100000; I++)
{
v.remove(v.size()-1);
}

从Vector类型的对象v删除所有元素的最好方法是：
v.removeAllElements();

假设Vector类型的对象v包含字符串“Hello”。考虑下面的代码，它要从这个Vector中删除“Hello”字符串：
String s = “Hello”;
int i = v.indexOf(s);
if(I != -1) v.remove(s);

这些代码看起来没什么错误，但它同样对性能不利。在这段代码中，indexOf()方法对v进行顺序搜索寻找字符串 “Hello”，remove(s)方法也要进行同样的顺序搜索。改进之后的版本是：
String s = “Hello”;
int i = v.indexOf(s);
if(I != -1) v.remove(i);

这个版本中我们直接在remove()方法中给出待删除元素的精确索引位置，从而避免了第二次搜索。一个更好的版本是：
String s = “Hello”; v.remove(s);

最后，我们再来看一个有关Vector类的代码片段：
for(int I=0; I++;I < v.length)

如果v包含100,000个元素，这个代码片段将调用v.size()方法100,000次。虽然size方法是一个简单的方法，但它仍旧需要 一次方法调用的开销，至少JVM需要为它配置以及清除堆栈环境。在这里，for循环内部的代码不会以任何方式修改Vector类型对象v的大小，因此上面 的代码最好改写成下面这种形式：
int size = v.size(); for(int I=0; I++;I<size)

虽然这是一个简单的改动，但它仍旧赢得了性能。毕竟，每一个CPU周期都是宝贵的。

15、当复制大量数据时，使用System.arraycopy()命令。

16、代码重构：增强代码的可读性。

17、不用new关键词创建类的实例
用new关键词创建类的实例时，构造函数链中的所有构造函数都会被自动调用。但如果一个对象实现了Cloneable接口，我们可以调用它的 clone()方法。clone()方法不会调用任何类构造函数。
在使用设计模式（Design Pattern）的场合，如果用Factory模式创建对象，则改用clone()方法创建新的对象实例非常简单。例如，下面是Factory模式的一个 典型实现：
public static Credit getNewCredit() {
return new Credit();
}
改进后的代码使用clone()方法，如下所示：
private static Credit BaseCredit = new Credit();
public static Credit getNewCredit() {
return (Credit) BaseCredit.clone();
}
上面的思路对于数组处理同样很有用。

18、乘法和除法,用移位操作替代乘法操作可以极大地提高性能。

19、在JSP页面中关闭无用的会话。
一个常见的误解是以为session在有客户端访问时就被创建，然而事实是直到某server端程序调用 HttpServletRequest.getSession(true)这样的语句时才被创建，注意如果JSP没有显示的使用 <%@pagesession=”false”%> 关闭session，则JSP文件在编译成Servlet时将会自动加上这样一条语句HttpSession session = HttpServletRequest.getSession(true);这也是JSP中隐含的session对象的来历。由于session会消耗内 存资源，因此，如果不打算使用session，应该在所有的JSP中关闭它。
对于那些无需跟踪会话状态的页面，关闭自动创建的会话可以节省一些资源。使用如下page指令：<%@ page session=”false”%>

20、JDBC与I/O
如果应用程序需要访问一个规模很大的数据集，则应当考虑使用块提取方式。默认情况下，JDBC每次提取32行数据。举例来说，假设我们要遍历一个5000 行的记录集，JDBC必须调用数据库157次才能提取到全部数据。如果把块大小改成512，则调用数据库的次数将减少到10次。

21、Servlet与内存使用
许多开发者随意地把大量信息保存到用户会话之中。一些时候，保存在会话中的对象没有及时地被垃圾回收机制回收。从性能上看，典型的症状是用户感到系统周期 性地变慢，却又不能把原因归于任何一个具体的组件。如果监视JVM的堆空间，它的表现是内存占用不正常地大起大落。
解决这类内存问题主要有二种办法。第一种办法是，在所有作用范围为会话的Bean中实现HttpSessionBindingListener接口。这 样，只要实现valueUnbound()方法，就可以显式地释放Bean使用的资源。

另外一种办法就是尽快地把会话作废。大多数应用服务器都有设置会话作废间隔时间的选项。另外，也可以用编程的方式调用会话的 setMaxInactiveInterval()方法，该方法用来设定在作废会话之前，Servlet容器允许的客户请求的最大间隔时间，以秒计。

22、使用缓冲标记
一些应用服务器加入了面向JSP的缓冲标记功能。例如，BEA的WebLogic Server从6.0版本开始支持这个功能，Open Symphony工程也同样支持这个功能。JSP缓冲标记既能够缓冲页面片断，也能够缓冲整个页面。当JSP页面执行时，如果目标片断已经在缓冲之中，则 生成该片断的代码就不用再执行。页面级缓冲捕获对指定URL的请求，并缓冲整个结果页面。对于购物篮、目录以及门户网站的主页来说，这个功能极其有用。对 于这类应用，页面级缓冲能够保存页面执行的结果，供后继请求使用。

23、选择合适的引用机制
在典型的JSP应用系统中，页头、页脚部分往往被抽取出来，然后根据需要引入页头、页脚。当前，在JSP页面中引入外部资源的方法主要有两 种：include指令，以及include动作。
include指令：例如<%@ include file=”copyright.html” %>。该指令在编译时引入指定的资源。在编译之前，带有include指令的页面和指定的资源被合并成一个文件。被引用的外部资源在编译时就确定， 比运行时才确定资源更高效。
include动作：例如<jsp:include page=”copyright.jsp” />。该动作引入指定页面执行后生成的结果。由于它在运行时完成，因此对输出结果的控制更加灵活。但时，只有当被引用的内容频繁地改变时，或者在对 主页面的请求没有出现之前，被引用的页面无法确定时，使用include动作才合算。

24、及时清除不再需要的会话
为了清除不再活动的会话，许多应用服务器都有默认的会话超时时间，一般为30分钟。当应用服务器需要保存更多会话时，如果内存容量不足，操作系统会把部分 内存数据转移到磁盘，应用服务器也可能根据“最近最频繁使用”（Most Recently Used）算法把部分不活跃的会话转储到磁盘，甚至可能抛出“内存不足”异常。在大规模系统中，串行化会话的代价是很昂贵的。当会话不再需要时，应当及时 调用HttpSession.invalidate()方法清除会话。HttpSession.invalidate()方法通常可以在应用的退出页面调 用。

25、不要将数组声明为：public static final 。

26、HashMap的遍历效率讨论
经常遇到对HashMap中的key和value值对的遍历操作，有如下两种方法：Map<String, String[]> paraMap = new

HashMap<String, String[]>();
…………….//第一个循环
Set<String> appFieldDefIds = paraMap.keySet();
for (String appFieldDefId : appFieldDefIds) {
String[] values = paraMap.get(appFieldDefId);
……
}

//第二个循环
for(Entry<String, String[]> entry : paraMap.entrySet()){
String appFieldDefId = entry.getKey();
String[] values = entry.getValue();
…….
}

第一种实现明显的效率不如第二种实现。
分析如下 Set<String> appFieldDefIds = paraMap.keySet(); 是先从HashMap中取得keySet

代码如下：
public Set<K> keySet() {
Set<K> ks = keySet;
return (ks != null ? ks : (keySet = new KeySet()));
}

private class KeySet extends AbstractSet<K> {
public Iterator<K> iterator() {
return newKeyIterator();
}
public int size() {
return size;
}
public boolean contains(Object o) {
return containsKey(o);
}
public boolean remove(Object o) {
return HashMap.this.removeEntryForKey(o) != null;
}
public void clear() {
HashMap.this.clear();
}
}
其实就是返回一个私有类KeySet, 它是从AbstractSet继承而来，实现了Set接口。

再来看看for/in循环的语法
for(declaration : expression)
statement

在执行阶段被翻译成如下各式
for(Iterator<E> #i = (expression).iterator(); #i.hashNext();){
declaration = #i.next();
statement
}

因此在第一个for语句for (String appFieldDefId : appFieldDefIds) 中调用了HashMap.keySet().iterator()

而这个方法调用了newKeyIterator()

Iterator<K> newKeyIterator() {
return new KeyIterator();
}
private class KeyIterator extends HashIterator<K> {
public K next() {
return nextEntry().getKey();
}
}

所以在for中还是调用了

在第二个循环for(Entry<String, String[]> entry : paraMap.entrySet())中使用的Iterator是如下的一个内部类

private class EntryIterator extends HashIterator<Map.Entry<K,V>> {
public Map.Entry<K,V> next() {
return nextEntry();
}
}

此时第一个循环得到key，第二个循环得到HashMap的Entry效率就是从循环里面体现出来的第二个循环此致可以直接取key和value值 而第一个循环还是得再利用HashMap的get(Object key)来取value值现在看看HashMap的get(Object key)方法
public V get(Object key) {
Object k = maskNull(key);
int hash = hash(k);
int i = indexFor(hash, table.length); //Entry[] table
Entry<K,V> e = table;
while (true) {
if (e == null)
return null;
if (e.hash == hash && eq(k, e.key))
return e.value;
e = e.next;
}
}
其实就是再次利用Hash值取出相应的Entry做比较得到结果，所以使用第一中循环相当于两次进入HashMap的Entry

中而第二个循环取得Entry的值之后直接取key和value，效率比第一个循环高。其实按照Map的概念来看也应该是用第二个循环好一点，它本 来就是key和value的值对，将key和value分开操作在这里不是个好选择。

27、array(数组) 和 ArryList的使用
array（[]）：最高效；但是其容量固定且无法动态改变；
ArrayList：容量可动态增长；但牺牲效率；
基于效率和类型检验，应尽可能使用array，无法确定数组大小时才使用ArrayList！
ArrayList是Array的复杂版本
ArrayList内部封装了一个Object类型的数组，从一般的意义来说，它和数组没有本质的差别，甚至于ArrayList的许多方法，如 Index、IndexOf、Contains、Sort等都是在内部数组的基础上直接调用Array的对应方法。
ArrayList存入对象时，抛弃类型信息，所有对象屏蔽为Object，编译时不检查类型，但是运行时会报错。
注：jdk5中加入了对泛型的支持，已经可以在使用ArrayList时进行类型检查。
从这一点上看来，ArrayList与数组的区别主要就是由于动态增容的效率问题了

28、尽量使用HashMap 和ArrayList ,除非必要，否则不推荐使用HashTable和Vector ，后者由于使用同步机制，而导致了性能的开销。

准备工作

1. 下载jad.exe文件：http://www.varaneckas.com/sites/default/files/jad/jad158g.win.zip
2. 下载jadeclipse插件：http://prdownloads.sourceforge.net/jadclipse/net.sf.jadclipse_3.3.0.jar?download
3. JadClipse 官网：http://jadclipse.sourceforge.net/wiki/index.php/Main_Page

安装

1. 将jad.exe解压到指定目录。如:c:\java\jad
2. 将jadeclipse插件net.sf.jadclipse_3.3.0.jar 拷贝到myeclipse安装目录\Genuitec\Common\plugins\目录下。
3. 在myeclipse安装目录下dropins/创建eclipse文件夹，然后在eclipse文件夹中分别创建features、plugins文件夹，将net.sf.jadclipse_3.3.0.jar 分别拷贝到features和plugins文件夹中。
4. 重新启动myeclipse后，配置jadeclipse插件
5. 在eclipse窗口下，点击Window > Preferences > Java > JadClipse > Path to Decompiler。（设置jad的绝对路径，如 C:\java\Jad\jad.exe)。Use Eclipse code formatter(overrides Jad formatting instructions)选项打勾，与格式化出来的代码样式一致。
6. 在eclipse窗口下，点击Window > Preferences > Java > JadClipse > Misc，将Convert Unicode strings into ANSI strings选项打勾，避免反编译后可能出现的中文乱码。

For future HTTP servlet projects, we recommend you use JSP instead of the older JHTML standard.

貌似jhtml语言在当今社会已经被jsp替代了！

JHTML (Java within Hypertext Markup Language，超文本标记语言中的Java程序)是在网页(用超文本标记语言HTML写的页面)中把Java程序包括进去使其作为网页一部分的标准。网站开发者可以用Java编程语言写一个小程序并把它插入到网页当中。当用户请求这个页面时，一直注意着带文件后缀.jhtml的请求的网站服务器将把代码传给一个专门的Java程序，它是专门设计用于处理JHTML的。这个叫做PageCompileServlet的程序调用Java编译器，再由Java编译器就快速地编译代码。(如果这个代码在以前就已经由早些的页面请求被编译，这个步骤就可以省略了。)然后这段代码就被执行，它会在被发送给请求者之前以某种方式修改网页的内容。
JHTML与ASP和PHTML在原理上是一样的，它们都是在服务器端将网页内容改变，传送到客户端的内容仍然是HTML语言写成的内容，这与在客户端执行的JavaScript有本本质的不同，在客户端执行时，必须将程序源代码传送到客户端的计算机上，开发者辛苦写成的源代码就这样被用户得到了，而在服务器端执行就不会出现这种问题，因为客户端得到的只是HTML语言写成的网页，舍此无二。JHTML还可以通过Java数据库连接（JDBC）接口访问 Web数据库。如果要使用JHTML，您必须确认在服务器端已经安装了Java编译器，否则无法执行。
JHTML要求在Web服务器端安装Java编译器。JHTML是JavaSoft的Java网络服务器应用程序接口的一部分。

但是另外一种异常：runtime exception，也称运行时异常，我们可以不处理。当出现这样的异常时，总是由虚拟机接管。比如：我们从来没有人去处理过 NullPointerException异常，它就是运行时异常，并且这种异常还是最常见的异常之一。

关于这两类异常的使用，网上存在着一些辩论：http://www.javaeye.com/topic/2038。合理的使用这两类异常，有利于我们写程序时代码的健壮性和合理性。看完上面的链接里的那些辩论之后，自己总结如下：
1． 当要决定是采用checked exception还是Unchecked exception的时候，你要问自己一个问题，“如果这种异常一旦抛出，客户端会做怎样的补救？”
2． 保护封装性（Preserve encapsulation）
3． 不要创建没有意义的异常（Try not to create new custom exceptions if they do not have useful information for client code.）
4． 总是要做一些清理工作（Always clean up after yourself）
5． 不要使用异常来控制流程（Never use exceptions for flow control）
6． 在异常的底层记录日志（Log exceptions just once ）

另外，网上还有一篇相关的文章：http://amyer.javaeye.com/blog/147509

例如，要输出 Vector v 的所有元素，可使用以下方法：

for (Enumeration e = v.elements(); e.hasMoreElements();){	
     System.out.println(e.nextElement());
}

Enumeration这些方法主要通过向量的元素、哈希表的键以及哈希表中的值进行枚举。枚举也用于将输入流指定到 SequenceInputStream 中。

使用Enumeration遍历Hashtable：

Hashtable hash=new Hashtable();  
hash.put( "abc","1");   
hash.put("ddd","1");   
hash.put( "asdf","2");   
Enumeration enumkey = hash.keys() ;   
while(enumkey.hasMoreElements()){    
    String str=(String)enumkey.nextElement();    
    System.out.println("--------"+str);    
    System.out.println("========="+hash.get( str));   
}
enumkey = hash.keys() ;   
while(enumkey.hasMoreElements()){    
     String str=(String)enumkey.nextElement();    
     System.out.println("--------"+str);    
     System.out.println("========="+hash.get( str));   
}

从上面的代码可以看出遍历一个枚举对象有两种方法，一种是for循环一种是使用while，应该特别注意使用for循环的方法与普通的for循环有点差异。

为了读取枚举值中的内容，还可以使用IO输入流SequenceInputStream 将内容输出。
在Servlet中，通过request.getParameterNames()可以获取到请求中的附加参数的枚举值：

Enumeration enume = request.getParameterNames();	
PrintWriter out = response.getWriter();	
out.write("");	
out.write("");	
out.write("");	
out.write("servlet演示");
out.write("");	
out.write("");	
out.write("");	
out.write("传递的参数信息:");	
while (enume.hasMoreElements()) {		
          String paramName = enume.nextElement().toString();		
          out.write(paramName + "=" + request.getParameter(paramName));	
}	
out.write("");	
out.write("");

注：此接口的功能与 Iterator 接口的功能是重复的。此外，Iterator 接口添加了一个可选的移除操作，并使用较短的方法名。新的实现应该优先考虑使用 Iterator 接口而不是 Enumeration 接口。

JPA通过JDK 5.0注解或XML描述对象－关系表的映射关系，并将运行期的实体对象持久化到数据库中。JPA ORM规范有SUN引入，主要是因为两个原因：其一，简化现有Java EE和Java SE应用的对象持久化的开发工作；其二，Sun希望整合对ORM技术，实现天下归一。目前Hibernate 3.2、TopLink 10.1.3以及OpenJPA都提供了JPA的实现。

JPA支持XML和JDK 5.0注解两种元数据的形式，元数据描述对象和表之间的映射关系，框架据此将实体对象持久化到数据库表中；JPA通过面向对象而非面向数据库的查询语言查询数据。

JPA 的目标之一是制定一个可以由很多供应商实现的API，并且开发人员可以编码来实现该API，而不是使用私有供应商特有的API。因此开发人员只需使用供应商特有的API来获得JPA规范没有解决但应用程序中需要的功能。尽可能地使用JPA API，但是当需要供应商公开但是规范中没有提供的功能时，则使用供应商特有的API。

JPA是需要Provider来实现其功能的，Hibernate就是JPA Provider中很强的一个，目前来说应该无人能出其右。从功能上来说，JPA现在就是Hibernate功能的一个子集。

JPA提供一种标准的OR映射解决方案，该解决方案完全集成到EJB3。0兼容的容器中，目前，Hibernate、spring、OpenJPA、Toplink、Entitymanager都实现了JPA。

JPA主要通过JDK 5.0注解和XML，来实现对象持久化的操作，通过看JPA代码就可以看到有很多的注解，这再次说明java注解在java 技术中是多么重要。要想理解现在的一些开源框架，完全有必要掌握java的基础知识，只有这样才能知其所以然！有必好好学习java注解和发射等知识！

网上有传智播客JPA详解视频教程：http://www.itcast.cn/itcast_static/JPAVideo.htm

Java中提供3个内置注释类型
a. Override ，只能用于方法（不能用于类，包声明或者其他构造）
作用：可以保证编译时候Override函数的声明正确性
用法：
@Override
public void fun(){..}

b.Deprecated 同样只能作用与方法
作用：对不应再使用的方法进行注解
用法：@Deprecated public void fun{…}

c.SupressWarnings 可以注释一段代码
作用：关闭特定的警告信息，例如你在使用泛型的时候未指定类型
用法： @SupressWarnings(value={“unchecked”})

Java中还提供了四种元注释，专门负责注释其他的注释

@Target 表示该注释可以用于什么地方。可用的ElementType参数包括：
CONSTRUCTOR : 构造器的声明
FIELD : 域声明（包括enum实例）
LOCAL_VARIABLE : 局部变量声明
METHOD : 方法声明
PACKAGE : 包声明
PARAMETER : 参数声明
TYPE : 类、接口 （包括注解类型) 或enum声明

@Retention 表示需要在什么级别保存该注释信息。可选的RetentionPoicy参数包括：
SOURCE : 注释将被编译器丢掉
CLASS : 注释在class文件中可用，但会被VM丢弃
RUNTIME : VM将在运行时也保留注释，因此可以通过反射机制读取注释的信息。

@Documented 将注释包含在JavaDoc中
@Inheried 允许子类继承父类中的注释。

在Java中定义自己的注释

Java语言支持一种新的类型——注释类型（annotation type），跟普通类差不多，在类中以符号（ @ ）的形式注释其他 Java 代码，用@interface 申明自定义注释类型。

package com.javachen.annotation;
 
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
 
/**
 * 用户自定义标签,带有成员变量的MyTag
 */
@Documented //将注释包含在JavaDoc中
@Inherited //允许子类继承父类中的注释。
@Target(value = {ElementType.METHOD,ElementType.CONSTRUCTOR})//标注这个注释使用的范围
@Retention(value = RetentionPolicy.RUNTIME)//要想使用反射得到注释信息，这个注释必须使用
public @interface MyTag {
	String name()  default "javachen";//给自定义注释类的成员加上默认值
	int age()  default 24;
}

注意：在自定义注释中只有一个成员时，方法名应该为value
使用标签最终是为了帮助开发人员提取注释信息，然后根据不同需求做进一步处理，下面我们来看看如何获取注释信息。

package com.javachen.annotation;
 
import java.lang.annotation.Annotation;
 
public class TagTest {
	@MyTag(name = "MyTag", age = 1)
	public void test() {
	}
 
	@Override //可以保证编译时候Override函数的声明正确性
	public String toString() {
		return super.toString();
	}
 
	@Deprecated //对不应再使用的方法进行注解
	public String notToUse() {
		return super.toString();
	}
 
	public static void main(String[] args) {
		TagTest tt = new TagTest();
		try {
			Annotation[] annotation = tt.getClass().getMethod("test")
					.getAnnotations();
			for (Annotation tag : annotation) {
				System.out.println("Tag is:" + tag);
				System.out.println("tag.name()" + ((MyTag) tag).name());
				System.out.println("tag.age()" + ((MyTag) (tag)).age());
			}
		} catch (NoSuchMethodException e) {
			e.printStackTrace();
		}
	}
}

需要注意的一点是，在执行这段代码之前我们还有一点小工作要做，还需要给我们的自定义标签MyTag加上一个说明标签，@ Retention, 表明注释信息将可以在运行时刻通过反射机制得到。如果不加入这个标签，上面的代码将没有任何输出。

如何使用反射读取注释

在以前的JDK版本中，我们可以使用反射得到类的方法、方法的参数以及其它的类成员等信息。那么在J2SE5.0中同样也可以象方法一样得到注释的各种信息。
在使用反射之前必须使用import java.lang.reflect.* 来导入和反射相关的类。

如果要得到某一个类或接口的注释信息，可以使用如下代码：
Annotation annotation = TestAnnotation.class.getAnnotation(MyAnnotation.class);

如果要得到全部的注释信息可使用如下语句：
Annotation[] annotations = TestAnnotation.class.getAnnotations();
或
Annotation[] annotations = TestAnnotation.class.getDeclaredAnnotations();

getDeclaredAnnotations与getAnnotations类似，但它们不同的是getDeclaredAnnotations 得到的是当前成员所有的注释，不包括继承的。而getAnnotations得到的是包括继承的所有注释。

如果要得到其它成员的注释，可先得到这个成员，然后再得到相应的注释。如得到myMethod的注释。
Method method = TestAnnotation.class.getMethod(“myMethod”, null);
Annotation annotation = method.getAnnotation(MyAnnotation.class);

注：要想使用反射得到注释信息，这个注释必须使用
@Retention(value = RetentionPolicy.RUNTIME)进行注释。

下面是原英文文章，呵呵，很久没有读英文读物了，大概还是看得懂的。

CONTENTS

• What Is a Native Method?
• Uses for Native Methods
• Benefits and Trade-Offs
• How Does This Magic Work?
• Summary

What Is a Native Method?

Simply put, a native method is the Java interface to non-Java code. It is Java’s link to the “outside world.” More specifically, a native method is a Java method whose implementation is provided by non-Java code, most likely C (see Figure 30.1). This feature is not special to Java. Most languages provide some mechanism to call routines written in another language. In C++, you must use the extern "C" stmt to signal that the C++ compiler is making a call to C functions. It is common to see the qualifier pascal in many C compilers to signal that the calling convention should be done in a Pascal convention, rather than a C convention. FORTRAN and Pascal have similar facilities, as do most other languages.

Figure 30.1 : A native method is a Java method whose implementation is provided by non-java code.

In Java, this is done via native methods. In your Java class, you mark the methods you wish to implement outside of Java with the native method modifier-much like you would use the public or static modifiers. Then, rather than supplying the method’s body, you simply place a semicolon in its place. As an example, the following class defines a variety of native methods:

public class IHaveNatives
{
native public void Native1( int x ) ;
native static public long Native2() ;
native synchronized private float Native3( Object o ) ;
native void Native4( int[] ary ) throws Exception ;
}

This sample class shows a number of possible native methods. As you may have noticed, native methods look much like any other Java method, except a single semicolon is in the place of the method body. Naturally, the body of the method is implemented outside of Java. What you basically define is the interface into this external method. This method declaration describes the Java view of some foreign code.

The only thing special about this declaration is that the keyword native is used as a modifier. Every other Java method modifier can be used along with native, except abstract. This is logical, because the native modifier implies that an implementation exists, and the abstract modifier insists that there is no implementation. Your native methods can be static methods, thus not requiring the creation of an object (or instance of a class). This is often convenient when using native methods to access an existing C-based library. Naturally, native methods can limit their visibility with the public, private, private protected, protected, or unspecified default access. Native methods can also be synchronized (see Chapter 7, “Concurrency and Synchronization”). In the case of a synchronized native method, the Java VM will perform the monitor locking prior to entering the native method implementation code. So, as in Java, the developer is not burdened with doing the actual monitor locking and unlocking.

The example uses a variety (although not all) of types. This is because a native method can be passed any Java type. There is no special procedure within the Java code to pass data to the native method. However, the developer of native methods must be careful that his native methods behave properly when manipulating Java datatypes. Native methods do not undergo the same kinds of checking as a Java method, and they can easily corrupt a Java datatype if care is not taken (see Chapter 31, “The Native Method Interface”).

A native method can accept and return any of the Java types-including class types. Of course, the power of exception handling is also available to native methods. The implementation of the native method can create and throw exceptions similar to a Java method. When a native method receives complex types, such as class types (such as Object in the example) or array types (such as the int[] in the example), it has access to the contents of those types. However, the method used to access the contents may vary depending on the Java implementation being used. The major point to remember is that you can access all the Java features from your native implementation code, but it may be implementation-dependent and will surely not be as convenient or easy as it can be done from Java.

The presence of native methods does not affect how other classes call those methods. The caller does not even realize it is calling a native method, so no special code is generated, and the calling convention is the same as for any other method-the calling depends on the method being virtual or static. The Java virtual machine will handle all the details to make the call in the native method implementation. One minor exception may be with the methods marked with the final modifier. The Java implementation may take advantage of a final method and choose to inline its code. It would be doubtful that this could be achieved with a native final method, but this is an optimization issue, not one of functionality. When a class containing native methods is subclassed, the subclass will inherit the native method and also will have the capability of overriding the native method-even with a Java method (that is, the overridden method can be implemented in Java). If a native method is also marked with the final modifier, a subclass is still prevented from overriding it.

Native methods are very powerful, because they effectively extend the Java virtual machine. In fact, your Java code already uses native methods. In the current implementation from Sun, native methods are used in many places to interface to the underlying operating system. This enables a Java program to go beyond the confines of the Java Runtime. With native methods, a Java program can virtually do any application level task.

Uses for Native Methods

Java is a wonderful language to use. However, there are times when you either must interface with existing code, can’t express the task in Java, or need the absolute best performance.

Accessing Outside the Java Environment

There are times where a Java application (or applet) must communicate with the environment outside of Java. This is, perhaps, the main reason for the existence of native methods. For starters, the Java implementation will need to communicate with the underlying system. That underlying system may be an operating system such as Solaris or Win32, or it may be a Web browser, or it may be custom hardware, such as a PDA, Set-top-device, and so forth. Regardless of what is under Java, there must be a mechanism to communicate with that system. At some point in a Java program, there will be that point where Java meets the outside world, an interface between Java and non-Java worlds. Native methods provide a simple clean approach to providing this interface without burdening the rest of the Java application with special knowledge.

Accessing the Operating System

The Java virtual machine describes a system that the Java program can rely on to be there. This virtual machine supports the Java Language and its runtime library. It may be composed of an interpreter or can be libraries linked to native code. Regardless of its form, it is not a complete system and often relies on an existing system underneath to provide a lot of support. More than likely, a full-fledged operating system, such as Solaris or Win32, resides beneath it. The use of native methods enables the Java Runtime to be written in Java yet have access to the underlying operating system, or even the parts of the Java virtual machine that may be written in a language such as C. Further, if a Java feature does not encapsulate an operating system feature needed by an application, native methods can be used to access this feature.

Embedded Java

It is conceivable to see a Java virtual machine embedded inside another program. Several WWW browsers come to mind. Perhaps this enclosing program is not implemented in Java. The Java Runtime may need to access the enclosing program for services to support the Java environment. Once again, native methods provide a clean interface for this access to the surrounding program. Furthermore, the vendor of the program may wish to expose some features of the program to a Java applet. The vendor would simply need to create a set of Java classes containing native methods, which provide the interface for the Java application into the program. The native method implementation would then be the “glue” between the Java applet and the internals of the enclosing program.

Custom Hardware

Another important possible application of native methods being used to access a non-Java world is providing Java programs access to custom hardware. Perhaps a Java virtual machine is running within a PDA or Set-Top-Device. A lot of what would normally be in an operating system may exist in hardware or software embedded in ROM, or other custom chip sets. Another possibility is that a computer may be equipped with a dedicated graphics card. It would be ideal to have Java make use of the graphics hardware. A set of Java classes with native methods defined would provide the Java program access to these features.

Sun’s Java

In the current implementation from Sun, the Java interpreter is written in C and can thus talk to the outside environment as any normal C program can. A majority of the Java Runtime is written in Java and may make calls into the interpreter or directly to the outside environment, all via native methods. The application deals mostly with the Java Runtime, but it may also talk to the outside environment via native methods. For example in the class java.lang.Thread the setPriority() method is implemented in Java but calls the method setPriority0(), which is a native method in the Thread class. This native method is implemented in C and resides within the Java virtual machine itself. On the Windows 95 platform this native method will then call (eventually) the Win32 SetPriority() API. This is an example where the native method implementation was provided by the Java virtual machine directly. In most cases the native method implementation resides in an external dynamic link library (discussed in a following section), but the call still goes through the Java virtual machine.

Performance

Another major reason for native methods is performance. The Java language trades some performance for features like its dynamic nature, garbage collecting, and safety. Some Java implementations, like the current crop, may be interpreters, which also add extra overhead. The lost performance can be small as the implementation technology for Java systems improve, but until then and even after there may always be a small performance overhead for certain functionality a Java program may need. This functionality can be pushed down into a native method. That native method can then be implemented efficiently at the native lower level of the system on which the Java virtual machine is running. Once at the native implementation level, the developer can use the best-suited language, such as C or even assembler. In this way, maximum performance can be achieved in those specific areas while the bulk of the application is done within the safe and robust Java virtual machine. One area where you may choose to implement some parts of an application in native methods is time-intensive computations, such as graphics rendering, simulation models, and so forth.

Accessing Existing Libraries

The fact that Java is targeted at the production of platform-neutral code means that the current implementations may not access system features that you may need. An example is a database engine. If you need to, you can use the native method facility to provide your own interface to such libraries. Further, you may want to use Java to write applications that use existing in-house libraries. Again, the use of native methods enables you to make such an interface. This enables you to leverage off your existing code base as well as gradually introduce Java-based applications among your other applications coded in an older language.

Benefits and Trade-Offs

The presense of native methods offers many benefits, the biggest being the extension of Java power. However, there is always a downside to all good things, and native methods definitely have their downsides. Depending on what the goals of your application are, the downsides may not be that terrible. Foremost is the fact that, by definition, the use of native methods defeats several of Java’s main goals: platform neutrality, system safety, and security.

Some of Java’s attractive features help minimize the downsides, however. The best feature of all is that Java is such a nice language to develop in you won’t want to use native methods unless you have to.

Platform Neutrality

Because a native method is implemented in a foreign language, the platform neutrality is limited to the language being used. Most likely, native methods are implemented in C or C++. Although those languages have standards, these standards leave a lot of room for implementation-defined attributes (even compilers on the same system may differ), so your mileage may vary. If the native method accesses the underlying system, you are tying your implementation to that system. For example, the file systems of UNIX and Win32 have some differences. There may even be differences between flavors of UNIX and Win32 (Win95 and WinNT are not identical). Once again, you may sacrifice your platform neutrality with your native method. This may cause you to have to support a limited number of platforms (rather than all Java platforms). Further, for each platform you choose to support, you may (probably will) have to implement several flavors of the native method.

The Java language and runtime provide a number of features that make applications more robust and safe. Java’s memory management, synchronization features, and lack of address manipulation help prevent common programming mistakes from slipping through the development and testing phases of your product. However, once you drop out of Java into a native method, you are, once again, at the mercy of the language and system in which you are implementing the native method. If your native method implemented in C chooses to manipulate an address directly, you risk corrupting some part of memory, perhaps even the Java virtual machine itself.

Security Concerns

Additionally, the Java Language provides features to aid in the writing of secure applications. A Java virtual machine is much more capable of detecting an “evil” Java program than an application in other languages. Once you drop into a native method, the Java virtual machine can no longer verify, catch, or prevent the program from violating the security of the environment in which the Java virtual machine is running. This is the reason a Java-enabled Web browser typically does not allow a nontrusted native method to be called. In today’s browsers, a trusted native method must be present on the local system in a certain location to be executed from an arriving applet (in other words, one loaded from a remote site). For more information on security, in general, see Part 6, “Security.” For more information on how security applies to native methods, see Chapter 33, “Securing Your Native Method Libraries.”

System Safety

Another potential hazard is the fact that a native method is not isolated. When a native method is entered, it not only accesses the environment outside the Java virtual machine, it also freely accesses the Java virtual machine directly. This is a necessary evil. It gives the native method quite a bit of power and flexibility, because it may need access to information kept within the virtual machine to do its job. This flexibility, however, exposes the internals of the Java virtual machine to the native method.

Dependence on the Java Implementation

It should be obvious that the implementation of native methods is also dependent on the Java implementation itself. This means that the native methods you write today for use with the Sun implementation of Java may not work with a Java implementation from another vendor.

The interface used for the Java virtual machine to call out to native methods and the interface that native methods use to access the internal functions and data structures of the Java virtual machine are not, currently, defined by either the Java Language Specification or the Java Virtual Machine Specification. A lot of native methods call back into the Java virtual machine for instantiating new objects, calling Java methods, throwing Java Exceptions, and so forth. Further, the method used to lay out Java types is also not defined. So, although your native method of today knows how to access the fields of an object, this could be different on the Java virtual machine of tomorrow. This oversight can be greatly helped if a standard API is defined for both how a Java program interacts with a native method and how a native method accesses data within the Java virtual machine. Even after such an API, implementation-defined behavior will likely still be present.

Java to the Rescue!

Recall that Java helps to minimize the damage of native methods. When you find yourself in the position that you must use native methods, you can take advantage of Java’s features to help isolate the usage and perhaps maintain a fair amount of Java’s advantages.

The Java Class System

Because Java narrows the use of native facilities to within the confines of a method, it does not affect the design of the program. A program is still a collection of classes and all classes still communicate with each other via their defined interface-that is, the classes’ methods. Thus the callers of native methods do not know they are calling native methods. Because methods are discrete operations on the data of a specific object, they tend to be small chunks of code. This implies that native methods tend to be conceptually small, easily managed, pieces of code.

Java Still Works for You

Java will still perform a variety of duties-such as parameter checking, stack checking, synchronization, and so forth-before entering the actual native code. It greatly aids the developer in writing correct native methods. A native method is capable of creating new objects and calling Java methods, and it can even cause exceptions to be thrown. In the current implementation from Sun, an exception can be created by a native method and registered for throwing. When Java virtual machine gains control back from the native method, usually because of that method returning, the exception will then be thrown.

It’s a good idea to make your native methods as small as possible and have them do a specific task. Do the work that needs to be done and pass the information back into the Java method. It’s also wise to have your Java classes make the native methods private, then provide a public Java method that will call the private native method. This enables the Java method to perform error checks and other data manipulations, freeing your actual native method implementation to focus on its simple task.

How Does This Magic Work?

Much of the magic of making native methods work is provided in the next three chapters. This section provides an introduction, which neglects many of the details but should give you a good frame of reference for understanding the following chapters. If you don’t really want to use native methods, but just want a basic understanding this discussion should satisfy your needs.

Sun’s Implementation

Due to the lack of a well-defined interface between a Java implementation and its surrounding environment, the details of writing native methods will most likely be specific to the implementation of the Java system you are using. The next sections are based on the implementation provided by Sun on the Solaris-Sparc and Win32-Intel platforms.

Using Dynamic Linking

Sun’s Java implementation interfaces to native methods by using the dynamic linking capabilities of the underlying operation system. The Java virtual machine is a complete program, which is already compiled for its respective platform. The nature of Java enables it easily to absorb a Java class and execute its behavior. However, for a compiled native method, things are not so simple. Somehow, the Java virtual machine must be taught how to call this native method. This is done by relying on the implementation of native methods to reside in a dynamic link library, which the operating system magically loads and links into the process that is running the Java virtual machine. On the Solaris platform, such a library is often called shared objects, or shared libraries, or simply dot-so’s (.so’s). On Win32 platforms, they are called dynamic link libraries (DLLs). This chapter uses DLL to refer to both.

Both Solaris and Win32 provide the necessary capabilities to achieve this dynamic linking. The dynamic linking facilities of both Solaris and Win32 are similar in concept, but differ in their details. This chapter does not attempt to describe the two in detail; however, if you wish to do native method programming, you should understand the mechanism used by your platform. On Solaris, you can begin by viewing the manual page on the dlopen() system call, and its relatives. On Win32, start with the help file on LoadLibrary() and its relatives. Further, you should understand the calling conventions and linking convention used by your compiler.

Sometime before a native method is invoked, the Java virtual machine must be told to find, load, and link the necessary DLLs, which contain the native method implementations. This is conveniently achieved by using the static method java.lang.System.loadLibrary( "mystuff" ). It is worth noting here that the name passed is not the actual filename of the DLL. Java maps the passed name into an expected filename, appropriate for the underlying system, of the DLL. In the call described previously, the string "mystuff" is mapped to a DLL named libmystuff.so on Solaris and mystuff.dll on Win32. If you run the Java program under a debugger, Java conveniently maps the same name "mystuff" to libmystuff_g.so and mystuff_g.dll. This enables you to supply two versions of the DLL-one with debug symbols, one without. Java magically finds the right one, dependent on whether you run under a debugger or not.

Defining the Calling Convention

In, essence, Sun defines the method its Java virtual machine will use to call external functions. In order to dynamically link and call the implementation of a native method successfully, the Java virtual machine must know several details. It must know the name of the function within the DLL (the implementation of the native method) to locate the symbol and its entry point. It also must know how to call that function (its return type, number of parameters, and types of parameters). The Java virtual machine expects the functions to be coded in C using the calling conventions appropriate for the underlying architecture (and compiler).

In simple terms, this means the actual function calls Java makes into the DLL must be known names; if you are trying to get Java to call into your existing library, unless your functions magically match the names Java expects (unlikely), you will usually have glue code, which sits between Java and your real functions. Java will call the glue functions, which in turn call in your functions. Alternatively, you can modify your functions to use the names and parameters Java expects, thus eliminating this extra call; however, in practice this is not always feasible, especially when calling existing libraries. Figure 30.2 shows the most likely scenarios of how your code will be segmented.

Figure 30.2 : Java’s use of Dynamic Link Libraries.

The Sun JDK provides a tool, named javah, to help you create your native method implementation functions. The developer of native methods runs javah, passing it the name of a class. javah emits both a header file (.h) and a code file (.c) containing information about each native method and relevant type declarations. The .h file will contain the prototypes of the functions Java will call, and thus expect to find in the DLL. The .c file will contain stubs for each function. Thus, the developer needs to fill in only the details of the functions in the c file and build the DLL appropriately.

How the Virtual Machine Makes It Work

When a class is first used by Java, its class descriptor is loaded into memory. The class descriptor can be thought of as a directory for all services provided by the class-there is only one class descriptor loaded, regardless of how many instances of that class exist. Among its entries is a list of method descriptors, which contain information specific to methods, including where the code is, what parameters they take, and method modifiers.

If a method descriptor has its native modifier set, the block will include a pointer to the function that implements that native method. This function resides in some DLL but will be loaded into the Java processes address space by the operating system. At the time the class descriptor with native methods is loaded, the associated DLL does not have to be loaded, and thus the function pointer will not be set. Sometime prior to a native method being called, the associated DLL should be loaded. This is done via a call to java.system.loadLibrary(). When this call is made, Java will find and load the DLL but will still not resolve symbols; the resolution phase is delayed until the point of use. At the time of a call to a native method, Java will first check to see whether the native method implementation function has already been resolved-that is, its pointer is not null. If it has been previously resolved, the call is performed; otherwise, the resolution of the symbols is attempted. The resolution is performed by making an operating system call to see whether the symbol exists in the caller’s address space. This includes the Java process and any DLLs loaded on its behalf. On Win32, this is done via a GetProcAddress() and on Solaris via a dlsym() call.

If the symbols are correctly resolved, the call is performed as if the Java virtual machine was making a standard C call to its own internal functions. If the resolution fails, the exception java.lang.UnsatisfiedLinkError will be thrown at the point of the native method call.

Summary

You should now have a basic understanding of how native methods enable a Java program to access the outside environment. Whether that consists of an operating system, a browser, or your own existing libraries, your Java code can reach them. It should now be clear that native methods do not come without some cost. You lose a lot of the benefits of the Java language. When there is no choice, however, native methods are there to be used. With the basic understanding of how native methods work you should be ready to tackle the next chapters, which provide more in-depth examples of native methods in action, as well as more tips and tricks to help you.

Java中，反射是一种强大的工具。它使您能够创建灵活的代码，这些代码可以在运行时装配，无需在组件之间进行源代表链接。反射允许我们在编写与执行时，使我们的程序代码能够接入装载到JVM中的类的内部信息，而不是源代码中选定的类协作的代码。这使反射成为构建灵活的应用的主要工具。但需注意的是：如果使用不当，反射的成本很高。

java反射所需要的类
1.Class类：它的实例表示正在运行的java应用程序中的类和接口
2.Constructor类：提供 关于类的单个构造方法的信息以及对他的访问权限。
3.Method类：提供有关类或接口的单独的某个方法的信息
4.Array类：提 供动态创建数组或访问数组的静态方法。
5.Field类：提供有关类或接口的属性的信息，以及对他的动态访问权限。

“ Class ” class

Class class 十分特殊。它和一般 classes 一样继承自 Object ，其实体用以表达 Java 程序运行时的 classes 和 interfaces ， 也用来表达 enum 、 array 、 primitive Java types （ boolean, byte, char, short, int, long, float, double ）以及关键词 void 。当一个 class 被加载，或当加载器（ class loader ）的 defineClass() 被 JVM 调用， JVM 便自动产生一个 Class object 。如果您想借由 “ 修改 Java 标准库源码 ” 来 观察 Class object 的实际生成时机（例如在 Class 的 constructor 内添加一个 println() ），不能够！因为 Class 并没有 public constructor

“ Class ” object 的取得途径

Java 允许我们从多种管道为一个 class 生成对应的 Class object 。下图是 一份整理。

Java classes 各成份所对应的 Reflection APIs

其中出现的 Package 、 Method 、 Constructor 、Field 等等 classes ，都定义于 java.lang.reflect 。

Reflection 的另三个动态性质： (1) 运行时生成 instances ， (2) 执行 期唤起 methods ， (3) 运行时改动 fields 。

在网上找了一些关于反射的相关讲解，没有发现用详细代码加以注释说明反射的一些用法，看来还是不得不自己深入理解之后，自己写一些详细的使用方法，那时候 再把代码贴出来。

在维基百科上找到了关于MIME的介绍：http://zh.wikipedia.org/zh-cn/MIME，这里简要的介绍一下相关知识，便于以后查阅。

按照RFC2045的定义，Base64被定义为：Base64内容传送编码被设计用来把任意序列的8位字节描述为一种不易被人直接识别的形式。（The Base64 Content-Transfer-Encoding is designed to represent arbitrary sequences of octets in a form that need not be humanly readable.）

多用途互联网邮件扩展（MIME，Multipurpose Internet Mail Extensions）是一个互联网标准，它扩展了电子邮件标准，使其能够支持非ASCII字符、二进制格式附件等多种格式的邮件消息。这个标准被定义在RFC 2045、RFC 2046、RFC 2047、RFC 2048、RFC 2049等RFC中。 由RFC 822转变而来的RFC 2822，规定电子邮件标准并不允许在邮件消息中使用7位ASCII字符集以外的字符。正因如此，一些非英语字符消息和二进制文件，图像，声音等非文字消息都不能在电子邮件中传输。MIME规定了用于表示各种各样的数据类型的符号化方法。 此外，在万维网中使用的HTTP协议中也使用了MIME的框架。
IME是通过标准化电子邮件报文的头部的附加领域（fields）而实现的；这些头部的附加领域，描述新的报文类型的内容和组织形式。目前版本是1.0。
内容类型（Content-Type），这个头部领域用于指定消息的类型。一般以下面的形式出现。

Content-Type: [type]/[subtype]; parameter

type有下面的形式。

* Text：用于标准化地表示的文本信息，文本消息可以是多种字符集和或者多种格式的；
* Multipart：用于连接消息体的多个部分构成一个消息，这些部分可以是不同类型的数据；
* Application：用于传输应用程序数据或者二进制数据；
* Message：用于包装一个E-mail消息；
* Image：用于传输静态图片数据；
* Audio：用于传输音频或者音声数据；
* Video：用于传输动态影像数据，可以是与音频编辑在一起的视频数据格式。

subtype用于指定type的详细形式。content-type/subtype配对的集合和与此相关的参数，将随着时间而增长。为了确保这些值在一个有序而且公开的状态下开发，MIME使用Internet Assigned Numbers Authority (IANA)作为中心的注册机制来管理这些值。常用的subtype值如下所示：

* text/plain（纯文本）
* text/html（HTML文档）
* application/xhtml+xml（XHTML文档）
* image/gif（GIF图像）
* image/jpeg（JPEG图像）
* image/png（PNG图像）
* video/mpeg（MPEG动画）
* application/octet-stream（任意的二进制数据）
* application/pdf（PDF文档）
* application/msword（Microsoft Word文件）
* message/rfc822（RFC 822形式）
* multipart/alternative（HTML邮件的HTML形式和纯文本形式，相同内容使用不同形式表示）
* application/x-www-form-urlencoded（使用HTTP的POST方法提交的表单）
* multipart/form-data（同上，但主要用于表单提交时伴随文件上传的场合）

此外，尚未被接受为正式数据类型的subtype，可以使用x-开始的独立名称（例如application/x-gzip）。vnd-开始的固有名称也可以使用（例：application/vnd.ms-excel）。

parameter可以用来指定附加的信息，更多情况下是用于指定text/plain和text/htm等的文字编码方式的charset参数。 MIME根据type制定了默认的subtype，当客户端不能确定消息的subtype的情况下，消息被看作默认的subtype进行处理。Text默认是text/plain，Application默认是application/octet-stream而Multipart默认情况下被看作 multipart/mixed。
内容传输编码（Content-Transfer-Encoding），这个区域使指定ASCII以外的字符编码方式成为可能。形式如下：

Content-Transfer-Encoding: [mechanism]

其中，mechanism的值可以指定为“7bit”，“8bit”，“binary”，“quoted- printable”，“base64”。

详细的介绍，可以参阅：http://zh.wikipedia.org/zh-cn/MIME

你还可以观看本网站内的同类文章：

1. 什么是KPI？

它的特点：
JVM 不变，JAVA 和 C++不断的融合， 5.0 里有许多和 C++ 类似。留下的只是思想。 程序员的开发工作越来越简单。
泛型增强了java的类型安全，可以在编译期间对容器内的对象进行类型检查，在运行 期不必进行类型的转换。而在j2se5 之前必须在运行期动态进行容器内对象的检 查及转换，泛型是编译时概念，运行时没有泛型。
泛型减少含糊的容器，可以定义什么类型的数据放入容器。
一个例子：
ArrayList aList = new ArrayList();
aList.add(new Integer(1));
// …
Integer myInteger = aList.get(0);

我们可以看到，在这个简单的例子中，我们在定义 aList 的时候指明了它是一个 直接受 Integer 类型的 ArrayList，当我们调用 aList.get(0)时，我们已经不再需要 先显式的将结果转换成 Integer，然后再赋值给 myInteger 了。而这一步在早先的 Java 版本中是必须的。也许你在想，在使用 Collection 时节约一些类型转换就是 Java 泛型的全部吗？远不止。单就这个例子而言，泛型至少还有一个更大的好处， 那就是使用了泛型的容器类变得更加健壮：早先，Collection 接口的 get()和 Iterator 接口的 next()方法都只能返回 Object 类型的结果，我们可以把这个结果强制转换 成任何 Object 的子类，而不会有任何编译期的错误，但这显然很可能带来严重 的运行期错误，因为在代码中确定从某个 Collection 中取出的是什么类型的对象 完全是调用者自己说了算，而调用者也许并不清楚放进 Collection 的对象具体是 什么类的；就算知道放进去的对象“应该”是什么类，也不能保证放到 Collection的对象就一定是那个类的实例。现在有了泛型，只要我们定义的时候指明该Collection 接受哪种类型的对象，编译器可以帮我们避免类似的问题溜到产品中。

声明及实例化泛型类：
HashMap hm = new HashMap(); 编译类型的泛型和运行时类型的泛型一定要一致。没有多态。 不能使用原始类型
GenList nList = new GenList(); //编译错误
J2SE 5.0 目前不支持原始类型作为类型参数(type parameter)
定义泛型接口：
public interface GenInterface {
void func(T t);
}
定义泛型类：
public class ArrayList { … }
public class GenMap { … }

类的静态方法不能使用泛型，因为泛型类是在创建对象的时候产生的。

泛型通配符
List<? extends Object> 往下匹配
List<? super Number> 往下上匹配

泛型的一些局限性
不能实例化泛型
T t = new T(); //error
不能实例化泛型类型的数组
T[] ts= new T[10]; //编译错误 不能实例化泛型参数数
Pair[] table = new Pair(10); // ERROR
类的静态变量不能声明为类型参数类型
public class GenClass {
private static T t; //编译错误

}
泛型类不能继承自 Throwable 以及其子类
public GenExpection extends Exception{} //编译错误 不能用于基础类型 int 等
Pair //error
不同泛型间不能相互赋值，没有多态
泛型类型不可以被“重载”；也就是说，和普通类型一样在一个作用域内，泛型类型必须被唯一地命名。

package com.javachen.util.string;
 
import java.util.regex.Pattern;
 
/**
 *
 * @author javachen
 * @date 2010.1.26
 */
public class StringUtil {
	public static String escape(String src) {
		int i;
		char j;
		StringBuffer tmp = new StringBuffer();
		tmp.ensureCapacity(src.length() * 6);
		for (i = 0; i < src.length(); i++) {
			j = src.charAt(i);
			if (Character.isDigit(j) || Character.isLowerCase(j)
					|| Character.isUpperCase(j))
				tmp.append(j);
			else if (j < 256) {
				tmp.append("%");
				if (j < 16)
					tmp.append("0");
				tmp.append(Integer.toString(j, 16));
			} else {
				tmp.append("%u");
				tmp.append(Integer.toString(j, 16));
			}
		}
		return tmp.toString();
	}
 
	public static String unescape(String src) {
		StringBuffer tmp = new StringBuffer();
		tmp.ensureCapacity(src.length());
		int lastPos = 0, pos = 0;
		char ch;
		while (lastPos < src.length()) {
			pos = src.indexOf("%", lastPos);
			if (pos == lastPos) {
				if (src.charAt(pos + 1) == 'u') {
					ch = (char) Integer.parseInt(src
							.substring(pos + 2, pos + 6), 16);
					tmp.append(ch);
					lastPos = pos + 6;
				} else {
					ch = (char) Integer.parseInt(src
							.substring(pos + 1, pos + 3), 16);
					tmp.append(ch);
					lastPos = pos + 3;
				}
			} else {
				if (pos == -1) {
					tmp.append(src.substring(lastPos));
					lastPos = src.length();
				} else {
					tmp.append(src.substring(lastPos, pos));
					lastPos = pos;
				}
			}
		}
		return tmp.toString();
	}
 
	/**
	 * 将字符串 source 中的 oldStr 替换为 newStr, 并以大小写敏感方式进行查找
	 *
	 * @param source
	 *            需要替换的源字符串
	 * @param oldStr
	 *            需要被替换的老字符串
	 * @param newStr
	 *            替换为的新字符串
	 */
	public static String replace(String source, String oldStr, String newStr) {
		return replace(source, oldStr, newStr, true);
	}
 
	/**
	 * 将字符串 source 中的 oldStr 替换为 newStr, matchCase 为是否设置大小写敏感查找
	 *
	 * @param source
	 *            需要替换的源字符串
	 * @param oldStr
	 *            需要被替换的老字符串
	 * @param newStr
	 *            替换为的新字符串
	 * @param matchCase
	 *            是否需要按照大小写敏感方式查找
	 */
	public static String replace(String source, String oldStr, String newStr,
			boolean matchCase) {
		if (source == null) {
			return null;
		}
		// 首先检查旧字符串是否存在, 不存在就不进行替换
		if (source.toLowerCase().indexOf(oldStr.toLowerCase()) == -1) {
			return source;
		}
		int findStartPos = 0;
		int a = 0;
		while (a > -1) {
			int b = 0;
			String str1, str2, str3, str4, strA, strB;
			str1 = source;
			str2 = str1.toLowerCase();
			str3 = oldStr;
			str4 = str3.toLowerCase();
			if (matchCase) {
				strA = str1;
				strB = str3;
			} else {
				strA = str2;
				strB = str4;
			}
			a = strA.indexOf(strB, findStartPos);
			if (a > -1) {
				b = oldStr.length();
				findStartPos = a + b;
				StringBuffer bbuf = new StringBuffer(source);
				source = bbuf.replace(a, a + b, newStr) + "";
				// 新的查找开始点位于替换后的字符串的结尾
				findStartPos = findStartPos + newStr.length() - b;
			}
		}
		return source;
	}
 
	/**
	 * 清除字符串结尾的空格.
	 *
	 * @param input
	 *            String 输入的字符串
	 * @return 转换结果
	 */
	public static String trimTailSpaces(String input) {
		if (isEmpty(input)) {
			return "";
		}
 
		String trimedString = input.trim();
		if (trimedString.length() == input.length()) {
			return input;
		}
		return input.substring(0, input.indexOf(trimedString)
				+ trimedString.length());
	}
 
	/**
	 * Change the null string value to "", if not null, then return it self, use
	 * this to avoid display a null string to "null".
	 *
	 * @param input
	 *            the string to clear
	 * @return the result
	 */
	public static String clearNull(String input) {
		return isEmpty(input) ? "" : input;
	}
 
	/**
	 * Return the limited length string of the input string (added at:April 10,
	 * 2004).
	 *
	 * @param input
	 *            String
	 * @param maxLength
	 *            int
	 * @return String processed result
	 */
	public static String limitStringLength(String input, int maxLength) {
		if (isEmpty(input))
			return "";
 
		if (input.length() < = maxLength) {
			return input;
		} else {
			return input.substring(0, maxLength - 3) + "...";
		}
 
	}
 
	/**
	 * 判断字符串是否全是数字字符.
	 *
	 * @param input
	 *            输入的字符串
	 * @return 判断结果, true 为全数字, false 为还有非数字字符
	 */
	public static boolean isNumeric(String input) {
		if (isEmpty(input)) {
			return false;
		}
 
		for (int i = 0; i < input.length(); i++) {
			char charAt = input.charAt(i);
 
			if (!Character.isDigit(charAt)) {
				return false;
			}
		}
		return true;
	}
 
	/**
	 * 转换由表单读取的数据的内码(从 ISO8859 转换到 gb2312).
	 *
	 * @param input
	 *            输入的字符串
	 * @return 转换结果, 如果有错误发生, 则返回原来的值
	 */
	public static String ISO2GBK(String input) {
		try {
			byte[] bytes = input.getBytes("ISO8859-1");
			return new String(bytes, "GBK");
		} catch (Exception ex) {
		}
		return input;
	}
 
	/**
	 * 转换由表单读取的数据的内码到 ISO(从 GBK 转换到ISO8859-1).
	 *
	 * @param input
	 *            输入的字符串
	 * @return 转换结果, 如果有错误发生, 则返回原来的值
	 */
	public static String GBK2ISO(String input) {
		return changeEncoding(input, "GBK", "ISO8859-1");
	}
 
	/**
	 * 转换字符串的内码.
	 *
	 * @param input
	 *            输入的字符串
	 * @param sourceEncoding
	 *            源字符集名称
	 * @param targetEncoding
	 *            目标字符集名称
	 * @return 转换结果, 如果有错误发生, 则返回原来的值
	 */
	public static String changeEncoding(String input, String sourceEncoding,
			String targetEncoding) {
		if (input == null || input.equals("")) {
			return input;
		}
 
		try {
			byte[] bytes = input.getBytes(sourceEncoding);
			return new String(bytes, targetEncoding);
		} catch (Exception ex) {
		}
		return input;
	}
 
	/**
	 * 将单个的 ' 换成 ''; SQL 规则:如果单引号中的字符串包含一个嵌入的引号,可以使用两个单引号表示嵌入的单引号.
	 */
 
	public static String replaceSql(String input) {
		return replace(input, "'", "''");
	}
 
	/**
	 * 对给定字符进行 URL 编码
	 */
	public static String encode(String value) {
		if (isEmpty(value)) {
			return "";
		}
 
		try {
			value = java.net.URLEncoder.encode(value, "GB2312");
		} catch (Exception ex) {
			ex.printStackTrace();
		}
 
		return value;
	}
 
	/**
	 * 对给定字符进行 URL 解码
	 *
	 * @param value
	 *            解码前的字符串
	 * @return 解码后的字符串
	 */
	public static String decode(String value) {
		if (isEmpty(value)) {
			return "";
		}
 
		try {
			return java.net.URLDecoder.decode(value, "GB2312");
		} catch (Exception ex) {
			ex.printStackTrace();
		}
 
		return value;
	}
 
	/**
	 * 判断字符串是否未空, 如果为 null 或者长度为0, 均返回 true.
	 */
	public static boolean isEmpty(String input) {
		return (input == null || input.length() == 0);
	}
 
	/**
	 * 获得输入字符串的字节长度(即二进制字节数), 用于发送短信时判断是否超出长度.
	 *
	 * @param input
	 *            输入字符串
	 * @return 字符串的字节长度(不是 Unicode 长度)
	 */
	public static int getBytesLength(String input) {
		if (input == null) {
			return 0;
		}
 
		int bytesLength = input.getBytes().length;
		return bytesLength;
	}
 
	/**
	 * 检验字符串是否未空, 如果是, 则返回给定的出错信息.
	 *
	 * @param input
	 *            输入的字符串
	 * @param errorMsg
	 *            出错信息
	 * @return 空串返回出错信息
	 */
	public static String isEmpty(String input, String errorMsg) {
		if (isEmpty(input)) {
			return errorMsg;
		}
		return "";
	}
 
	/**
	 * 判断是否为质数
	 *
	 * @param x
	 * @return
	 */
	public static boolean isPrime(int x) {
		if (x <= 7) {
			if (x == 2 || x == 3 || x == 5 || x == 7)
				return true;
		}
		int c = 7;
		if (x % 2 == 0)
			return false;
		if (x % 3 == 0)
			return false;
		if (x % 5 == 0)
			return false;
		int end = (int) Math.sqrt(x);
		while (c <= end) {
			if (x % c == 0) {
				return false;
			}
			c += 4;
			if (x % c == 0) {
				return false;
			}
			c += 2;
			if (x % c == 0) {
				return false;
			}
			c += 4;
			if (x % c == 0) {
				return false;
			}
			c += 2;
			if (x % c == 0) {
				return false;
			}
			c += 4;
			if (x % c == 0) {
				return false;
			}
			c += 6;
			if (x % c == 0) {
				return false;
			}
			c += 2;
			if (x % c == 0) {
				return false;
			}
			c += 6;
		}
		return true;
	}
 
	/**
	 * 返回指定字节长度的字符串
	 *
	 * @param str
	 *            String 字符串
	 * @param length
	 *            int 指定长度
	 * @return String 返回的字符串
	 */
	public static String toLength(String str, int length) {
		if (str == null) {
			return null;
		}
		if (length <= 0) {
			return "";
		}
		try {
			if (str.getBytes("GBK").length <= length) {
				return str;
			}
		} catch (Exception ex) {
		}
		StringBuffer buff = new StringBuffer();
 
		int index = 0;
		char c;
		length -= 3;
		while (length > 0) {
			c = str.charAt(index);
			if (c < 128) {
				length--;
			} else {
				length--;
				length--;
			}
			buff.append(c);
			index++;
		}
		buff.append("...");
		return buff.toString();
	}
 
	/**
	 * 判断是否为整数
	 *
	 * @param str
	 *            传入的字符串
	 * @return 是整数返回true,否则返回false
	 */
	public static boolean isInteger(String str) {
		Pattern pattern = Pattern.compile("^[-\\+]?[\\d]*$");
		return pattern.matcher(str).matches();
	}
 
	/**
	 * 判断是否为浮点数，包括double和float
	 *
	 * @param str
	 *            传入的字符串
	 * @return 是浮点数返回true,否则返回false
	 */
	public static boolean isDouble(String str) {
		Pattern pattern = Pattern.compile("^[-\\+]?[.\\d]*$");
		return pattern.matcher(str).matches();
	}
 
	/**
	 * 判断输入的字符串是否符合Email样式.
	 *
	 * @param str
	 *            传入的字符串
	 * @return 是Email样式返回true,否则返回false
	 */
	public static boolean isEmail(String str) {
		Pattern pattern = Pattern
				.compile("^\\w+([-+.]\\w+)*@\\w+([-.]\\w+)*\\.\\w+([-.]\\w+)*$");
		return pattern.matcher(str).matches();
	}
 
	/**
	 * 判断输入的字符串是否为纯汉字
	 *
	 * @param str
	 *            传入的字符窜
	 * @return 如果是纯汉字返回true,否则返回false
	 */
	public static boolean isChinese(String str) {
		Pattern pattern = Pattern.compile("[\u0391-\uFFE5]+$");
		return pattern.matcher(str).matches();
	}
}

Big5字与Unicode的互换:

public static String big5ToUnicode(String s){
        try{
            return new String(s.getBytes("ISO8859_1"), "Big5");
        }
        catch (UnsupportedEncodingException uee){
            return s;
        }
    }
 
    public static String UnicodeTobig5(String s){
        try{
            return new String(s.getBytes("Big5"), "ISO8859_1");
        }
        catch (UnsupportedEncodingException uee){
            return s;
        }
    }
 
    public static String toHexString(String s){
        String str="";
        for (int i=0; i

转译特殊符号标签:

public static String filter(String value)
        {
            if(value == null || value.length() == 0)
                return value;
            StringBuffer result = null;
            String filtered = null;
            for(int i = 0; i < value.length(); i++)
            {
                filtered = null;
                switch(value.charAt(i))
                {
                case 60: // '<'
                    filtered = "<";
                    break;
 
                case 62: // '>'
                    filtered = ">";
                    break;
 
                case 38: // '&'
                    filtered = "&";
                    break;
 
                case 34: // '"'
                    filtered = """;
                    break;
 
                case 39: // '\''
                    filtered = "'";
                    break;
                }
                if(result == null)
                {
                    if(filtered != null)
                    {
                        result = new StringBuffer(value.length() + 50);
                        if(i > 0)
                            result.append(value.substring(0, i));
                        result.append(filtered);
                    }
                } else
                if(filtered == null)
                    result.append(value.charAt(i));
                else
                    result.append(filtered);
            }
 
            return result != null ? result.toString() : value;
        }

判断字符是否属于中文 :

//  GENERAL_PUNCTUATION 判断中文的“号
 //  CJK_SYMBOLS_AND_PUNCTUATION 判断中文的。号
 //  HALFWIDTH_AND_FULLWIDTH_FORMS 判断中文的，号
   public static boolean isChinese(char c) {
      Character.UnicodeBlock ub = Character.UnicodeBlock.of(c);
      if (ub == Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS
        || ub == Character.UnicodeBlock.CJK_COMPATIBILITY_IDEOGRAPHS
        || ub == Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A
        || ub == Character.UnicodeBlock.GENERAL_PUNCTUATION
        || ub == Character.UnicodeBlock.CJK_SYMBOLS_AND_PUNCTUATION
        || ub == Character.UnicodeBlock.HALFWIDTH_AND_FULLWIDTH_FORMS){
       return true;
      }
      return false;
   }
   public static void isChinese(String strName) {
      char[] ch = strName.toCharArray();
      for (int i = 0; i < ch.length; i++) {
    char c = ch[i];
    if(isChinese(c)==true){
     System.out.println(isChinese(c));
    return;
   }else{
     System.out.println(isChinese(c));
     return ;
    }
   }
   }

人民币转成大写 :

/**
     * 人民币转成大写
     *
     * @param value
     * @return String
     */
    public static String hangeToBig(double value)
    {
        char[] hunit = { '拾', '佰', '仟' }; // 段内位置表示
        char[] vunit = { '万', '亿' }; // 段名表示
        char[] digit = { '零', '壹', '贰', '叁', '肆', '伍', '陆', '柒', '捌', '玖' }; // 数字表示
        long midVal = (long) (value * 100); // 转化成整形
        String valStr = String.valueOf(midVal); // 转化成字符串
 
        String head = valStr.substring(0, valStr.length() - 2); // 取整数部分
        String rail = valStr.substring(valStr.length() - 2); // 取小数部分
 
        String prefix = ""; // 整数部分转化的结果
        String suffix = ""; // 小数部分转化的结果
        // 处理小数点后面的数
        if (rail.equals("00"))
        { // 如果小数部分为0
            suffix = "整";
        }
        else
        {
            suffix = digit[rail.charAt(0) - '0'] + "角" + digit[rail.charAt(1) - '0'] + "分"; // 否则把角分转化出来
        }
        // 处理小数点前面的数
        char[] chDig = head.toCharArray(); // 把整数部分转化成字符数组
        char zero = '0'; // 标志'0'表示出现过0
        byte zeroSerNum = 0; // 连续出现0的次数
        for (int i = 0; i < chDig.length; i++)
        { // 循环处理每个数字
            int idx = (chDig.length - i - 1) % 4; // 取段内位置
            int vidx = (chDig.length - i - 1) / 4; // 取段位置
            if (chDig[i] == '0')
            { // 如果当前字符是0
                zeroSerNum++; // 连续0次数递增
                if (zero == '0')
                { // 标志
                    zero = digit[0];
                }
                else if (idx == 0 && vidx > 0 && zeroSerNum < 4)
                {
                    prefix += vunit[vidx - 1];
                    zero = '0';
                }
                continue;
            }
            zeroSerNum = 0; // 连续0次数清零
            if (zero != '0')
            { // 如果标志不为0,则加上,例如万,亿什么的
                prefix += zero;
                zero = '0';
            }
            prefix += digit[chDig[i] - '0']; // 转化该数字表示
            if (idx > 0)
                prefix += hunit[idx - 1];
            if (idx == 0 && vidx > 0)
            {
                prefix += vunit[vidx - 1]; // 段结束位置应该加上段名如万,亿
            }
        }
 
        if (prefix.length() > 0)
            prefix += '圆'; // 如果整数部分存在,则有圆的字样
        return prefix + suffix; // 返回正确表示
    }

Exif是英文Exchangeable Image File(可交换图像文件)的缩写，最初由日本电子工业发展协会(JEIDA –Japan Electronic

Industry Development Association) 制订，目前的最新版本是发表于2002年04月的2.21 版。
Exif 文件实际是JPEG文件的一种，遵从JPEG标准，只是在文件头信息中增加了有关拍摄信息的内容和索引图。所以你可以使用任何支持JPEG格式的图像工具软件观看或修改Exif文件，但，打开时可能看不到Exif信息，一旦修改，Exif信息可能丢失。简单来说，EXIF 信息就是由数码相机在拍摄过程中采集一系列的信息，然后把信息放置在我们熟知的 JPEG/TIFF 文件的头部，也就是说 EXIF 信息是镶嵌在 JPEG/TIFF 图像文件格式内的一组拍摄参数，主要包括摄影时的光圈、快门、ISO、时间等各种与当时摄影条件相关的讯息，相机品牌型号，色彩编码，拍摄时录制的声音以及全球定位系统（GPS）等信息。简单的说，它就好像是傻瓜相机的日期打印功能一样，只不过 EXIF 信息所记录的资讯更为详尽和完备。

Exif 文件包含的信息

Image Description 图像描述、来源. 指生成图像的工具
Artist作者 有些相机可以输入使用者的名字
Make 生产者 指产品生产厂家
Model 型号 指设备型号
Orientation方向 有的相机支持，有的不支持
XResolution/YResolution X/Y方向分辨率 本栏目已有专门条目解释此问题。
ResolutionUnit分辨率单位 一般为PPI
Software软件 显示固件Firmware版本
DateTime日期和时间
YCbCrPositioning 色相定位
ExifOffsetExif信息位置，定义Exif在信息在文件中的写入，有些软件不显示。
ExposureTime 曝光时间 即快门速度
FNumber光圈系数
ExposureProgram曝光程序 指程序式自动曝光的设置，各相机不同,可能是Sutter Priority（快门优先）、Aperture Priority（快门优先）等等。
ISO speed ratings感光度
ExifVersionExif版本
DateTimeOriginal创建时间
DateTimeDigitized数字化时间
ComponentsConfiguration图像构造（多指色彩组合方案）
CompressedBitsPerPixel(BPP)压缩时每像素色彩位 指压缩程度
ExposureBiasValue曝光补偿。
MaxApertureValue最大光圈
MeteringMode测光方式， 平均式测光、中央重点测光、点测光等。
Lightsource光源 指白平衡设置
Flash是否使用闪光灯。
FocalLength焦距，一般显示镜头物理焦距，有些软件可以定义一个系数，从而显示相当于35mm相机的焦距 MakerNote(User Comment)作者标记、说明、记录
FlashPixVersionFlashPix版本 （个别机型支持）
ColorSpace色域、色彩空间
ExifImageWidth(Pixel X Dimension)图像宽度 指横向像素数
ExifImageLength(Pixel Y Dimension)图像高度 指纵向像素数
Interoperability IFD通用性扩展项定义指针 和TIFF文件相关，具体含义不详
FileSource源文件 Compression压缩比。

java 读取图片的 Exif 数据代码
package image.read;
import com.drew.metadata.*;
import com.drew.metadata.exif.*;
import com.drew.imaging.jpeg.JpegProcessingException;
import java.io.*;
import java.util.Iterator;

public class EXIFReader {

public static void main(String args[]) throws FileNotFoundException {
File f = new File(“c:\\b.jpg”);
try {
ExifReader er = new ExifReader(f);
Metadata exif = er.extract();
Iterator itr = exif.getDirectoryIterator();
while (itr.hasNext()) {
Directory directory = (Directory) itr.next();

System.out.println(“EXIF版本：”+ directory.getString(ExifDirectory.TAG_EXIF_VERSION));
System.out.println(“相机品牌：”+ directory.getString(ExifDirectory.TAG_MAKE));
System.out.println(“相机型号：”+ directory.getString(ExifDirectory.TAG_MODEL));
System.out.println(“光 圈 值：”+ directory.getString(ExifDirectory.TAG_FNUMBER));
System.out.println(“快    門：”+ directory.getString(ExifDirectory.TAG_EXPOSURE_TIME));
System.out.println(“感 光 度：”+ directory.getString(ExifDirectory.TAG_ISO_EQUIVALENT));
System.out.println(“软    件：”+ directory.getString(ExifDirectory.TAG_SOFTWARE));
System.out.println(“原始拍摄时间：”+ directory.getString(ExifDirectory.TAG_DATETIME_ORIGINAL));
System.out.println(“数字化时间：”+ directory.getString(ExifDirectory.TAG_DATETIME_DIGITIZED));
System.out.println(“方    向：”+ directory.getString(ExifDirectory.TAG_ORIENTATION));
System.out.println(“图片宽度：”+ directory.getString(ExifDirectory.TAG_EXIF_IMAGE_WIDTH));
System.out.println(“图片高度：”+ directory.getString(ExifDirectory.TAG_EXIF_IMAGE_HEIGHT));
System.out.println(“水平分辨率：”+ directory.getString(ExifDirectory.TAG_X_RESOLUTION));
System.out.println(“垂直分辨率：”+ directory.getString(ExifDirectory.TAG_Y_RESOLUTION));
System.out.println(“垂直分辨率：”+ directory.getString(ExifDirectory.TAG_EXPOSURE_BIAS));
break;

// 获得全部metadata
/*
* Iterator tags = directory.getTagIterator(); while
* (tags.hasNext()) { Tag tag = (Tag) tags.next();
* System.out.println(tag); } if (directory.hasErrors()) {
* Iterator errors = directory.getErrors(); while
* (errors.hasNext()) { System.out.println(“ERROR:   ” +
* errors.next()); } }
*/
}
} catch (JpegProcessingException e) {
System.err.println(“not   jpeg   file”);
}
}

}

public class DisplayDate {
public static void main(String[] args){
Date today;
Calendar now;
DateFormat f1,f2;
String s1,s2;

System.out.println(“\n显示Date类的相关用法”);

today = new Date();
System.out.println(“new Date()= \t”+ today);

System.out.println(“\n用DateFormat类显示各种日期格式”);

//显示各种日期格式
f1 = DateFormat.getDateInstance();
s1 = f1.format(today);
System.out.println(“DateFormat.getDateInstance()= \t”+s1);

f1 = DateFormat.getDateInstance(DateFormat.LONG,Locale.CHINA);
s1 = f1.format(today);
System.out.println(“DateFormat.getDateInstance(DateFormat.LONG,Locale.CHINA)= \t”+ s1);

f1 = DateFormat.getDateInstance(DateFormat.MEDIUM,Locale.CHINA);
s1 = f1.format(today);
System.out.println(“DateFormat.getDateInstance(DateFormat.MEDIUM,Locale.CHINA)= \t”+ s1);

f1 = DateFormat.getDateInstance(DateFormat.SHORT,Locale.CHINA);
s1 = f1.format(today);
System.out.println(“DateFormat.getDateInstance(DateFormat.SHORT,Locale.CHINA)= \t” + s1);

System.out.println(“\n用DateFormat类显示各种时间格式”);

//显示各种时间格式
f1 = DateFormat.getTimeInstance();
s1 = f1.format(today);
System.out.println(“DateFormat.getTimeInstance()= \t”+s1);

f1 = DateFormat.getTimeInstance(DateFormat.LONG,Locale.CHINA);
s1 = f1.format(today);
System.out.println(“DateFormat.getTimeInstance(DateFormat.LONG,Locale.CHINA)= \t”+s1);

f1 = DateFormat.getTimeInstance(DateFormat.MEDIUM,Locale.CHINA);
s1 = f1.format(today);
System.out.println(“DateFormat.getTimeInstance(DateFormat.MEDIUM,Locale.CHINA)= \t”+s1);

f1 = DateFormat.getTimeInstance(DateFormat.SHORT,Locale.CHINA);
s1 = f1.format(today);
System.out.println(“DateFormat.getTimeInstance(DateFormat.SHORT,Locale.CHINA)= \t”+s1);

System.out.println(“\n显示Calendar的相关时间用法”);

now = Calendar.getInstance();
today = now.getTime();
System.out.println(“Calendar.getInstance().getTime()= \t”+ today.toString());

}
}

程序运行结果显示如下：

显示Date类的相关用法
new Date()= Fri May 02 13:29:32 CST 2003

用DateFormat类显示各种日期格式
DateFormat.getDateInstance()= 2003-5-2
DateFormat.getDateInstance(DateFormat.LONG,Locale.CHINA)= 2003年5月2日
DateFormat.getDateInstance(DateFormat.MEDIUM,Locale.CHINA)= 2003-5-2
DateFormat.getDateInstance(DateFormat.SHORT,Locale.CHINA)= 03-5-2

用DateFormat类显示各种时间格式
DateFormat.getTimeInstance()= 13:29:32
DateFormat.getTimeInstance(DateFormat.LONG,Locale.CHINA)= 下午01时29分32秒
DateFormat.getTimeInstance(DateFormat.MEDIUM,Locale.CHINA)= 13:29:32
DateFormat.getTimeInstance(DateFormat.SHORT,Locale.CHINA)= 下午1:29

显示Calendar的相关时间用法
Calendar.getInstance().getTime()= Fri May 02 13:29:33 CST 2003
java中关于时间日期操作的常用函数
1.计算某一月份的最大天数
Calendar time=Calendar.getInstance();
time.clear();
time.set(Calendar.YEAR,year);
time.set(Calendar.MONTH,i-1);//注意,Calendar对象默认一月为0
int day=time.getActualMaximum(Calendar.DAY_OF_MONTH);//本月份的天数
注：在使用set方法之前，必须先clear一下，否则很多信息会继承自系统当前时间
2.Calendar和Date的转化
(1) Calendar转化为Date
Calendar cal=Calendar.getInstance();
Date date=cal.getTime();
(2) Date转化为Calendar
Date date=new Date();
Calendar cal=Calendar.getInstance();
cal.setTime(date);
3.格式化输出日期时间
Date date=new Date();
SimpleDateFormat df=new SimpleDateFormat(“yyyy-MM-dd hh:mm:ss”);
System.out.println(df.format(date));
4.计算一年中的第几星期
(1)计算某一天是一年中的第几星期
Calendar cal=Calendar.getInstance();
cal.set(Calendar.YEAR, 2006);
cal.set(Calendar.MONTH, 8);
cal.set(Calendar.DAY_OF_MONTH, 3);
int weekno=cal.get(Calendar.WEEK_OF_YEAR);
(2)计算一年中的第几星期是几号
SimpleDateFormat df=new SimpleDateFormat(“yyyy-MM-dd”);
Calendar cal=Calendar.getInstance();
cal.set(Calendar.YEAR, 2006);
cal.set(Calendar.WEEK_OF_YEAR, 1);
cal.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);
System.out.println(df.format(cal.getTime()));
输出:
2006-01-02
5.add()和roll()的用法
(1)add()方法
SimpleDateFormat df=new SimpleDateFormat(“yyyy-MM-dd”);
Calendar cal=Calendar.getInstance();
cal.set(Calendar.YEAR, 2006);
cal.set(Calendar.MONTH, 8);
cal.set(Calendar.DAY_OF_MONTH, 3);
cal.add(Calendar.DATE, -4);
Date date=cal.getTime();
System.out.println(df.format(date));
cal.add(Calendar.DATE, 4);
date=cal.getTime();
System.out.println(df.format(date));
输出：
2006-08-30
2006-09-03
(2)roll方法
cal.set(Calendar.YEAR, 2006);
cal.set(Calendar.MONTH, 8);
cal.set(Calendar.DAY_OF_MONTH, 3);
cal.roll(Calendar.DATE, -4);
date=cal.getTime();
System.out.println(df.format(date));
cal.roll(Calendar.DATE, 4);
date=cal.getTime();
System.out.println(df.format(date));
输出：
2006-09-29
2006-09-03
可见，roll()方法在本月内循环，一般使用add()方法；
6.计算两个任意时间中间的间隔天数
(1)传进Calendar对象

/** *//**计算两个时间之间相隔天数
* @param startday 开始时间
* @param endday 结束时间
* @return
*/
public int getIntervalDays(Calendar startday,Calendar endday)…{
//确保startday在endday之前
if(startday.after(endday))…{
Calendar cal=startday;
startday=endday;
endday=cal;
}
//分别得到两个时间的毫秒数
long sl=startday.getTimeInMillis();
long el=endday.getTimeInMillis();

long ei=el-sl;
//根据毫秒数计算间隔天数
return (int)(ei/(1000*60*60*24));
}

(2)传进Date对象
/** *//**计算两个时间之间相隔天数
* @param startday 开始时间
* @param endday 结束时间
* @return
*/
public int getIntervalDays(Date startday,Date endday)…{
//确保startday在endday之前
if(startday.after(endday))…{
Date cal=startday;
startday=endday;
endday=cal;
}
//分别得到两个时间的毫秒数
long sl=startday.getTime();
long el=endday.getTime();

long ei=el-sl;
//根据毫秒数计算间隔天数
return (int)(ei/(1000*60*60*24));
}同理，可以用相同的方法计算出任意两个时间相隔的小时数，分钟数，秒钟数等
注：以上方法是完全按时间计算，有时并不能令人满意，如：
startday=”2006-10-11 20:00:00″
endday=”2006-10-12 8:00:00″
计算结果为0，但是我们也许相让计算结果变为1，此时可以用如下方法实现：
在传参之前，先设定endday的时间，如：
endday.set(Calendar.HOUR_OF_DAY, 23);
endday.set(Calendar.MINUTE, 59);
endday.set(Calendar.SECOND, 59);
endday.set(Calendar.MILLISECOND, 59);
这样再传进去startday,endday，则结果就如我们所愿了。不过，如果嫌以上方法麻烦，可以参考以下方法：
(3)改进精确计算相隔天数的方法
public int getDaysBetween (Calendar d1, Calendar d2) …{
if (d1.after(d2)) …{ // swap dates so that d1 is start and d2 is end
java.util.Calendar swap = d1;
d1 = d2;
d2 = swap;
}
int days = d2.get(Calendar.DAY_OF_YEAR) – d1.get(Calendar.DAY_OF_YEAR);
int y2 = d2.get(Calendar.YEAR);
if (d1.get(Calendar.YEAR) != y2) …{
d1 = (Calendar) d1.clone();
do …{
days += d1.getActualMaximum(Calendar.DAY_OF_YEAR);//得到当年的实际天数
d1.add(Calendar.YEAR, 1);
} while (d1.get(Calendar.YEAR) != y2);
}
return days;
}

这是我面试时候遇到的问题，刚开始的时候，思维就陷入了定势：用String的getBytes（）方法将字符串转化为byte数组，然后在遍历数组，每次遍历的时候要判断当前字符是字母还是汉字，面试的时候想着用正则判断汉字，却忘了正则表达式是怎样的。结果思路对了，就差不知道判断中文的正则怎样写了！

现在，想了想怎样实现上门的要求。找到实现的方法如下：

package stringTest;

import java.io.UnsupportedEncodingException;

public class SplitString {
/**
* 按字节截取字符串
*
* @param orignal
*            原始字符串
* @param count
*            截取位数
* @return 截取后的字符串
* @throws UnsupportedEncodingException
*             使用了JAVA不支持的编码格式
*/
public String substring(String orignal, int count)
throws UnsupportedEncodingException {
// 原始字符不为null，也不是空字符串
if (orignal != null && !”".equals(orignal)) {
// 将原始字符串转换为GBK编码格式
orignal = new String(orignal.getBytes(), “GBK”);
// 要截取的字节数大于0，且小于原始字符串的字节数
if (count > 0 && count < orignal.getBytes(“GBK”).length) {
StringBuffer buff = new StringBuffer();
char c;
for (int i = 0; i < count; i++) {
// charAt(int index)也是按照字符来分解字符串的
c = orignal.charAt(i);
buff.append(c);
if (isChineseChar(c)) {
// 遇到中文汉字，截取字节总数减1
–count;
}
}
return buff.toString();
}
}
return orignal;
}

/**
* 判断是否是一个中文汉字
*
* @param c
*            字符
* @return true表示是中文汉字，false表示是英文字母
* @throws UnsupportedEncodingException
*             使用了JAVA不支持的编码格式
*/
public boolean isChineseChar(char c) throws UnsupportedEncodingException {
// 如果字节数大于1，是汉字
// 以这种方式区别英文字母和中文汉字并不是十分严谨，但在这个题目中，这样判断已经足够了
return String.valueOf(c).getBytes(“GBK”).length > 1;
}

public static void main(String[] args) {
String st = “test中dd文dsaf中男大3443n中国43中国人0ewldfls=103″;
SplitString ss = new SplitString();

try {
System.out.println(“使用重写的subString截取：”+ss.substring(st, 5));
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
}
}
这里区别英文字母和中文汉字并不是十分严谨，使用的方法是：

return String.valueOf(c).getBytes(“GBK”).length > 1;

当然，还有其他的办法可以判别。这只u是解决办法之一，后来看了看String的其他方法，发现还有一种更简单的解决办法：

package stringTest;

import java.io.UnsupportedEncodingException;

public class SplitString {
String SplitStr;
int SplitByte;
public SplitString(String str, int bytes) {
SplitStr = str;
SplitByte = bytes;
System.out.println(“The String is:’” + SplitStr + “‘;SplitBytes=”
+ SplitByte + “;The String length:” + SplitStr.length());
}
public void SplitIt() {
int loopCount;

loopCount = (SplitStr.length() % SplitByte == 0)
? (SplitStr.length() / SplitByte)
: (SplitStr.length() / SplitByte + 1);
System.out.println(“Will Split into ” + loopCount);
for (int i = 1; i <= loopCount; i++) {
if (i == loopCount) {

System.out.println(SplitStr.substring((i – 1) * SplitByte,
SplitStr.length()));
} else {

System.out.println(SplitStr.substring((i – 1) * SplitByte,
(i * SplitByte)));
}
}
}

public static void main(String[] args) {
String st = “test中dd文dsaf中男大3443n中国43中国人0ewldfls=103″;
SplitString ss = new SplitString(st, 4);
ss.SplitIt();
}
}
这种方法使用的是String的subString方法，好处是不用关注当前的字符是字母还是汉字了。

　　架构师实际上就是软件的总体设计师。首席设计师就是总设计师，打个通俗的比方：邓小平是中国改革开放的总设计师，我们用现在的说法可以讲，邓小平是中国改革开放的首席架构师。架构师的形成一定是在实践中积累起来的，而并非上了几次培训班，读了几本书就可以成功的，架构师是在工程实践中培养出来的!

　　架构师也并非是万能的。架构师是客户需求和开发者之间的桥梁。在软件行业中，一般提到的架构师是技术架构师，而忽略了领域架构师或者讲是领域工程师的概念。一个好的领域专家一定是业务领域的架构师，他能够给出某一个业务领域的架构，我们可以称为业务架构，只有技术架构和业务架构紧密结合才有可能真正创造出一个好的系统!

　　近年来，软件领域也渐渐地流行起架构师的角色，特别是对一些大型软件产品或项目的开发，这一角色显得很关键，因为缺乏好的软件架构师而导致项目失败的例子不胜枚举，一个没有经验和能力的架构师也会使项目失败的速度加快。

　　软件架构师的重要作用

　　软件架构师在整个软件开发过程中都起着重要的作用，并随着开发进程的推进而其职责或关注点不断地变化，在需求阶段，软件架构师主要负责理解和管理非功能性系统需求，比如软件的可维护性、性能、复用性、可靠性、有效性和可测试性等等，此外，架构师还要经常审查和客户及市场人员所提出的需求，确认开发团队所提出的设计;在需求越来越明确后，架构师的关注点开始转移到组织开发团队成员和开发过程定义上;在软件设计阶段，架构师负责对整个软件体系结构、关键构件、接口和开发政策的设计;在编码阶段，架构师则成为详细设计者和代码编写者的顾问，并且经常性地要举行一些技术研讨会、技术培训班等;随着软件开始测试、集成和交付，集成和测试支持将成为软件架构师的工作重点;在软件维护开始时，软件架构师就开始为下一版本的产品是否应该增加新的功能模块进行决策。

　　如何成为优秀的软件架构师

　　显而易见，在软件开发过程中，一个优秀软件架构师的重要性是不应低估的。那么如何成为优秀的软件架构师呢?

　　首先必须具有丰富的软件设计与开发经验，这有助于理解并解释所进行的设计是如何映射到实现中去。

　　其次要具有领导能力与团队协作技能，软件架构师必须是一个得到承认的技术领导，能在关键时候对技术的选择作出及时、有效的决定。

　　第三是具有很强的沟通能力，呵呵，其时这一点好象什么鬼角色都最好具备，软件架构师需要与各路人马经常打交道，客户、市场人员、开发人员、测试人员、项目经理、网络管理员、数据库工程师等等，而且在很多角色之间还要起沟通者的作用。在技术能力方面，软件架构师最重要也是最需求掌握的知识是构件通信机制方面的知识，比如远程过程调用、JAVARMI、CORBA、COM/DCOM、各种标准的通信协议、网络服务、面对对象数据库、关系数据库等等，另外，架构师应时刻注意新软件设计和开发方面的发展情况，并不断探索更有效的新方法。开发语言、设计模式和开发平台不断很快地升级，软件架构师需要吸收这些新技术新知识，并将它们用于软件系统开发工作中。当然，行业的业务知识对软件架构师也是很重要的，有助于设计出一个满足客户需求的体系结构，优秀的软件架构师常常因为要尽快获得对行业业务的理解而必须快速学习并且进行敏锐的观察。

上面的描述是枯燥乏味的，但作为一个架构师，在整个软件系统的开发过程中是乐趣无穷的，因为这个角色很具有挑战性，有时需要左右逢源八面玲珑，有时又需要果断坚定不留情面。在国内，较少软件企业拥有独立的架构师，通常一个软件高手身兼数职，既是项目经理，又是软件架构师，还是软件开发者，有时还要客串一个测试人员，这对软件的开发周期和产品质量是不利的，有时一个人的观点立场是很片面的，而且繁重的工作、沉重的压力会影响一个人的情绪，情绪会影响决策，决策影响结果，所以值得我们三思而后行。

　　构架师自我培养过程

　　构架师不是通过理论学习可以搞出来的，不过不学习相关知识那肯定是不行的。总结构架师自我培养过程大致如下，仅供参考。

　　1、构架师胚胎(程序员)

　　学习的知识是语言基础、设计基础、通信基础等，应该在大学完成，内容包括java、c、c++、uml、RUP、XML、socket通信(通信协议)——学习搭建应用系统所必须的原材料。

　　2、构架师萌芽(高级程序员)

　　学习分布式系统、组建等内容，可以在大学或第一年工作时间接触，包括分布式系统原理、ejb、corba、com/com+、webservice(研究生可以研究网络计算机、高性能并发处理等内容)

　　3、构架师幼苗(设计师)

　　应该在掌握上述基础之上，结合实际项目经验，透彻领会应用设计模式，内容包括设计模式(c++版本、java版本)、ejb设计模式、J2EE构架、UDDI、软件设计模式等。在此期间，最好能够了解软件工程在实际项目中的应用以及小组开发、团队管理。

　　4、软件构架师的正是成型在于机遇、个人努力和天赋软件构架师其实是一种职位，但一个程序员在充分掌握软构架师所需的基本技能后，如何得到这样的机会、如何利用所掌握的技能进行应用的合理构架、如何不断的抽象和归纳自己的构架模式、如何深入行业成为能够胜任分析、构架为一体的精英人才这可不是每个人都能够遇上的馅饼……

JAVA系统架构师应该看的几本书

Thinking in Java
Effective Java

UML基础、案例与应用
UML入门提高

软件工匠
设计模式——可复用面向对象软件的基础

重构-改善既有代码的设计
敏捷软件开发-原则、模式、实践

企业应用架构模式
Expert One-on-One J2EE Development without EJB
 
软件工程——实践者的研究方法
软件领导－－成功开发软件的指导准则

后面的两本书，其实已经有点属于项目经理的范畴了，不过还不是很深入，看看对做成功的系统架构师是很有好处。

企业应用的系统架构师应该关注的几个方面

数据持久层的设计
 在Spring和Hibernate，ibatis出来以前，几乎每家公司都有自己的一套方法和架构，而架构师的50％的精力也会集中到这上面，EJB只是增加架构师的负担。在Spring出来以后，基本上，大多数的架构师都从重复设计这个轮子的无用功中解脱出来了。Rod的轮子太好用了，基本上，大家只要套上去就行了，或者，剩下最重要的事情，是选择一个合适的数据库连接池的开源项目吧

MVC架构的具体设计
 MVC只是个概要的概念，具体如何实现的具体技术很多，根据项目设计最恰当的架构

大并发性访问
 使用缓存，在数据量达到一定程度时，使用集群技术，优先考虑利用服务器的集群，其次是硬件集群，最后才是应用本身加入集群功能

超大数据量返回结果
 尽量使用分页，优化SQL语句，循环处理数据时尽可能共用对象，只保留关键数据，及时释放内存占用

超大文件的读取和生成
 尽可能快的读取大文件，并进行分析。写入大文件时，如何及时释放内存。学会适当利用操作系统的命令行资源来更快完成任务。
 
多线程的应用和管理
 线程池的管理和监控，线程的启动（包括定时启动），结束，回收，线程资源的释放
 
用户界面可用性设计
 平衡速度和可用性，恰当的使用异步和同步技术，展现关键数据为重点

分布式的数据交流和集成
 选择恰当的数据交互方式，从最泛滥低效的Web Service到最实用的文件共享

群集系统的管理
 如何确保缓存的同步？如何确保对象唯一性？如何保证各台机器的同步？
 是否采用EJB?如何利用J2EE的特性（例如JNDI)

复杂的业务规则
 规则引擎和工作流引擎场景和应用
 
其实，作为一个真正的系统架构师，不应该局限于企业应用的系统，这种系统往往有数据库的局限性，有时候，应该考虑是否可以横向跨越，直接对其它系统做一些架构考虑，在没有丰富的实战经验的前提下，而只是看了其它人的系统和代码，就能够给出有效的设计指导。
上面的描述是枯燥乏味的，但作为一个架构师，在整个软件系统的开发过程中是乐趣无穷的，因为这个角色很具有挑战性，有时需要左右逢源八面玲珑，有时又需要果断坚定不留情面。在国内，较少软件企业拥有独立的架构师，通常一个软件高手身兼数职，既是项目经理，又是软件架构师，还是软件开发者，有时还要客串一个测试人员，这对软件的开发周期和产品质量是不利的，有时一个人的观点立场是很片面的，而且繁重的工作、沉重的压力会影响一个人的情绪，情绪会影响决策，决策影响结果，所以值得我们三思而后行。

二、增强MyEclipse的代码自动提示功能

1. 打开MyEclipse ，然后“window”→“Preferences”

2. 选择“java”，展开，“Editor”，选择“Content Assist”。

3. 选择“Content Assist”，然后看到右边，右边的“Auto-Activation”下面的“Auto Activation triggers for java”这个选项。其实就是指触发代码提示的就是“.”这个符号。

4. “Auto Activation triggers for java”这个选项，在“.”后加“.abcdefghijklmnopqrstuvwxyz(,<”，方便后面的查找 修改。然后“apply”，点击“OK”。

收集了一些关于解决 MyEclipse 的耗内存的办法，经测试非常有效，整理出来，希望可以方便更多的朋友。

1、老是弹出Quick update error 、关闭myeclipse的Quick Update自动更新功能
这个问题的解决办法是关闭自动更新
Windows > Preferences > MyEclipse Enterprise Workbench > Community Essentials,
把选项 “Search for new features on startup”的前勾去掉即可。

2 、关闭updating indexes
Window > Preferences > Myeclipse Enterprise Workbench > Maven4Myeclipse > Maven>
禁用Download repository index updates on startup 。
如果是myeclipse7.5：
（1）关掉maven自动更新：
window-preferences-MyEclipse Enterprise Workbench-Maven4MyEclipse-Maven,
关闭所有Download和Update开头的选项，共四项（去掉前面的勾）
（2）关闭更新调度：window –> preferences –> General –> Startup and Shutdown –> Automatic Updates Scheduler（去掉前面的勾）
（3）window –> preferences –>Myeclipse Dashboard,关闭Show……on start

3 、关闭MyEclipse的自动validation
validation有一堆，什么xml、jsp、jsf、js等等，我们没有必要全部都去自动校验一下，
只是需要的时候才会手工校验一 下，速度立马提升好几个档次
windows > perferences > myeclipse > validation
将Build下全部勾取消
如果你需要验证某个文件的时候，我们可以单独去验证它。方法是：
在需要验证的文件上( 右键 -> MyEclipse -> Run   Validation 。

4、 启动优化，关闭不需要使用的模块
一个系统20%的功能往往能够满足80%的需求，MyEclipse也不例外，我们在大多数时候只需要20%的系统功能，
所以可以将一些不使用的模块禁止 加载启动。
Window > Preferences > General > Startup andy Shutdown 在这里列出的是MyEclipse启动时加载的模块
我这里只让它加载tomcat5 勾选 MyEclipse EASIE Tomcat 5 。
怎样才能知道哪些启动项有用呢？我现在把我知道的启动项用处说一下，还有很多不懂的，
希望大家懂的回复在下面    啊：
WTP ：一个跟myeclipse差不多的东西，主要差别是 WTP 是免费的，如果使用myeclipse，这个可以取消
Mylyn：组队任务管理工具，类似于 CVS ，以任务为单位管理项目进度，没用到的可以取消
Derby：一种保存成 jar 形式的数据库，我没用到，取消
一大排以 MyEclipse EASIE 打头的启动项：myeclipse 支持的服务器，只选自己用的，其他取消，
比如我只选了    tomcat 。

5 、去掉MyEclipse的拼写检查（如果你觉的有用可以不去）
拼写检查会给我们带来不少的麻烦，我们的方法命名都会是单词的缩写，他也会提示有错，
所以最好去掉，没有多大的用处
Window > perferences > General > Editors > Text Editors > Spelling > 将Enable spell checking复选框的勾选去掉。

6 、去掉MyEclipse繁杂的自带插件自动加载项
Window > perferences > General > Startup and Shutdown > 将Plug-ins activated on startup
中的复选框有选择性的勾   选去掉。

7 、修改MyEclipse编辑JSP页面时的编辑工具
Window > perferences > General > Editors > File Associations >
在File types 中选择 *.jsp > 在Associated editors 中将”MyEclipse JSP Editor”设置为默认。

创建型模式
1、FACTORY—追MM少不了请吃饭了，麦当劳的鸡翅和肯德基的鸡翅都是MM爱吃的东西，虽然口味有所不同，但不管你带MM去麦当劳或肯德基，只管向服务员说“来四个鸡翅”就行了。麦当劳和肯德基就是生产鸡翅的Factory
工厂模式：客户类和工厂类分开。消费者任何时候需要某种产品，只需向工厂请求即可。消费者无须修改就可以接纳新产品。缺点是当产品修改时，工厂类也要做相应的修改。如：如何创建及如何向客户端提供。
2、BUILDER—MM最爱听的就是“我爱你”这句话了，见到不同地方的MM,要能够用她们的方言跟她说这句话哦，我有一个多种语言翻译机，上面每 种语言都有一个按键，见到MM我只要按对应的键，它就能够用相应的语言说出“我爱你”这句话了，国外的MM也可以轻松搞掂，这就是我的“我爱 你”builder。（这一定比美军在伊拉克用的翻译机好卖）
建造模式：将产品的内部表象和产品的生成过程分割开来，从而使一个建造过程生成具有不同的内部表象的产品对象。建造模式使得产品内部表象可以独立的变化，客户不必知道产品内部组成的细节。建造模式可以强制实行一种分步骤进行的建造过程。
3、FACTORY METHOD—请MM去麦当劳吃汉堡，不同的MM有不同的口味，要每个都记住是一件烦人的事情，我一般采用Factory Method模式，带着MM到服务员那儿，说“要一个汉堡”，具体要什么样的汉堡呢，让MM直接跟服务员说就行了。
工厂方法模式：核心工厂类不再负责所有产品的创建，而是将具体创建的工作交给子类去做，成为一个抽象工厂角色，仅负责给出具体工厂类必须实现的接口，而不接触哪一个产品类应当被实例化这种细节。
4、PROTOTYPE—跟MM用QQ聊天，一定要说些深情的话语了，我搜集了好多肉麻的情话，需要时只要copy出来放到QQ里面就行了，这就是我的情话prototype了。（100块钱一份，你要不要）
原始模型模式：通过给出一个原型对象来指明所要创建的对象的类型，然后用复制这个原型对象的方法创建出更多同类型的对象。原始模型模式允许动态的增加 或减少产品类，产品类不需要非得有任何事先确定的等级结构，原始模型模式适用于任何的等级结构。缺点是每一个类都必须配备一个克隆方法。
5、SINGLETON—俺有6个漂亮的老婆，她们的老公都是我，我就是我们家里的老公Sigleton，她们只要说道“老公”，都是指的同一个人，那就是我(刚才做了个梦啦，哪有这么好的事)
单例模式：单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例单例模式。单例模式只应在有真正的“单一实例”的需求时才可使用。
结构型模式

6、ADAPTER—在朋友聚会上碰到了一个美女Sarah，从香港来的，可我不会说粤语，她不会说普通话，只好求助于我的朋友kent了，他作为我和Sarah之间的Adapter，让我和Sarah可以相互交谈了(也不知道他会不会耍我)

适配器（变压器）模式：把一个类的接口变换成客户端所期待的另一种接口，从而使原本因接口原因不匹配而无法一起工作的两个类能够一起工作。适配类可以根据参数返还一个合适的实例给客户端。
7、BRIDGE—早上碰到MM，要说早上好，晚上碰到MM，要说晚上好；碰到MM穿了件新衣服，要说你的衣服好漂亮哦，碰到MM新做的发型，要说你的头发好漂亮哦。不要问我“早上碰到MM新做了个发型怎么说”这种问题，自己用BRIDGE组合一下不就行了
桥梁模式：将抽象化与实现化脱耦，使得二者可以独立的变化，也就是说将他们之间的强关联变成弱关联，也就是指在一个软件系统的抽象化和实现化之间使用组合/聚合关系而不是继承关系，从而使两者可以独立的变化。
8、COMPOSITE—Mary今天过生日。“我过生日，你要送我一件礼物。”“嗯，好吧，去商店，你自己挑。”“这件T恤挺漂亮，买，这条裙子好 看，买，这个包也不错，买。”“喂，买了三件了呀，我只答应送一件礼物的哦。”“什么呀，T恤加裙子加包包，正好配成一套呀，小姐，麻烦你包起 来。”“……”，MM都会用Composite模式了，你会了没有？
合成模式：合成模式将对象组织到树结构中，可以用来描述整体与部分的关系。合成模式就是一个处理对象的树结构的模式。合成模式把部分与整体的关系用树结构表示出来。合成模式使得客户端把一个个单独的成分对象和由他们复合而成的合成对象同等看待。
9、DECORATOR—Mary过完轮到Sarly过生日，还是不要叫她自己挑了，不然这个月伙食费肯定玩完，拿出我去年在华山顶上照的照片，在背 面写上“最好的的礼物，就是爱你的Fita”，再到街上礼品店买了个像框（卖礼品的MM也很漂亮哦），再找隔壁搞美术设计的Mike设计了一个漂亮的盒子 装起来……，我们都是Decorator，最终都在修饰我这个人呀，怎么样，看懂了吗？
装饰模式：装饰模式以对客户端透明的方式扩展对象的功能，是继承关系的一个替代方案，提供比继承更多的灵活性。动态给一个对象增加功能，这些功能可以再动态的撤消。增加由一些基本功能的排列组合而产生的非常大量的功能。
10、FACADE—我有一个专业的Nikon相机，我就喜欢自己手动调光圈、快门，这样照出来的照片才专业，但MM可不懂这些，教了半天也不会。幸 好相机有Facade设计模式，把相机调整到自动档，只要对准目标按快门就行了，一切由相机自动调整，这样MM也可以用这个相机给我拍张照片了。
门面模式：外部与一个子系统的通信必须通过一个统一的门面对象进行。门面模式提供一个高层次的接口，使得子系统更易于使用。每一个子系统只有一个门面类，而且此门面类只有一个实例，也就是说它是一个单例模式。但整个系统可以有多个门面类。
11、FLYWEIGHT—每天跟MM发短信，手指都累死了，最近买了个新手机，可以把一些常用的句子存在手机里，要用的时候，直接拿出来，在前面加 上MM的名字就可以发送了，再不用一个字一个字敲了。共享的句子就是Flyweight，MM的名字就是提取出来的外部特征，根据上下文情况使用。
享元模式：FLYWEIGHT在拳击比赛中指最轻量级。享元模式以共享的方式高效的支持大量的细粒度对象。享元模式能做到共享的关键是区分内蕴状态和 外蕴状态。内蕴状态存储在享元内部，不会随环境的改变而有所不同。外蕴状态是随环境的改变而改变的。外蕴状态不能影响内蕴状态，它们是相互独立的。将可以 共享的状态和不可以共享的状态从常规类中区分开来，将不可以共享的状态从类里剔除出去。客户端不可以直接创建被共享的对象，而应当使用一个工厂对象负责创 建被共享的对象。享元模式大幅度的降低内存中对象的数量。
12、PROXY—跟MM在网上聊天，一开头总是“hi,你好”,“你从哪儿来呀？”“你多大了？”“身高多少呀？”这些话，真烦人，写个程序做为我的Proxy吧，凡是接收到这些话都设置好了自动的回答，接收到其他的话时再通知我回答，怎么样，酷吧。
代理模式：代理模式给某一个对象提供一个代理对象，并由代理对象控制对源对象的引用。代理就是一个人或一个机构代表另一个人或者一个机构采取行动。某 些情况下，客户不想或者不能够直接引用一个对象，代理对象可以在客户和目标对象直接起到中介的作用。客户端分辨不出代理主题对象与真实主题对象。代理模式 可以并不知道真正的被代理对象，而仅仅持有一个被代理对象的接口，这时候代理对象不能够创建被代理对象，被代理对象必须有系统的其他角色代为创建并传入。
行为模式
13、CHAIN OF RESPONSIBLEITY—晚上去上英语课，为了好开溜坐到了最后一排，哇，前面坐了好几个漂亮的MM哎，找张纸条，写上“Hi,可以做我的女朋友 吗？如果不愿意请向前传”，纸条就一个接一个的传上去了，糟糕，传到第一排的MM把纸条传给老师了，听说是个老处女呀，快跑!
责任链模式：在责任链模式中，很多对象由每一个对象对其下家的引用而接
起来形成一条链。请求在这个链上传递，直到链上的某一个对象决定处理此请求。客户并不知道链上的哪一个对象最终处理这个请求，系统可以在不影响客户端 的情况下动态的重新组织链和分配责任。处理者有两个选择：承担责任或者把责任推给下家。一个请求可以最终不被任何接收端对象所接受。
14、COMMAND—俺有一个MM家里管得特别严，没法见面，只好借助于她弟弟在我们俩之间传送信息，她对我有什么指示，就写一张纸条让她弟弟带给 我。这不，她弟弟又传送过来一个COMMAND，为了感谢他，我请他吃了碗杂酱面，哪知道他说：“我同时给我姐姐三个男朋友送COMMAND，就数你最小 气，才请我吃面。”
命令模式：命令模式把一个请求或者操作封装到一个对象中。命令模式把发出命令的责任和执行命令的责任分割开，委派给不同的对象。命令模式允许请求的一 方和发送的一方独立开来，使得请求的一方不必知道接收请求的一方的接口，更不必知道请求是怎么被接收，以及操作是否执行，何时被执行以及是怎么被执行的。 系统支持命令的撤消。
15、INTERPRETER—俺有一个《泡MM真经》，上面有各种泡MM的攻略，比如说去吃西餐的步骤、去看电影的方法等等，跟MM约会时，只要做一个Interpreter，照着上面的脚本执行就可以了。
解释器模式：给定一个语言后，解释器模式可以定义出其文法的一种表示，并同时提供一个解释器。客户端可以使用这个解释器来解释这个语言中的句子。解释 器模式将描述怎样在有了一个简单的文法后，使用模式设计解释这些语句。在解释器模式里面提到的语言是指任何解释器对象能够解释的任何组合。在解释器模式中 需要定义一个代表文法的命令类的等级结构，也就是一系列的组合规则。每一个命令对象都有一个解释方法，代表对命令对象的解释。命令对象的等级结构中的对象 的任何排列组合都是一个语言。
16、ITERATOR—我爱上了Mary，不顾一切的向她求婚。
Mary：“想要我跟你结婚，得答应我的条件”
我：“什么条件我都答应，你说吧”
Mary：“我看上了那个一克拉的钻石”
我：“我买，我买，还有吗？”
Mary：“我看上了湖边的那栋别墅”
我：“我买，我买，还有吗？”
……
迭代子模式：迭代子模式可以顺序访问一个聚集中的元素而不必暴露聚集的内部表象。多个对象聚在一起形成的总体称之为聚集，聚集对象是能够包容一组对象 的容器对象。迭代子模式将迭代逻辑封装到一个独立的子对象中，从而与聚集本身隔开。迭代子模式简化了聚集的界面。每一个聚集对象都可以有一个或一个以上的 迭代子对象，每一个迭代子的迭代状态可以是彼此独立的。迭代算法可以独立于聚集角色变化。
17、MEDIATOR—四个MM打麻将，相互之间谁应该给谁多少钱算不清楚了，幸亏当时我在旁边，按照各自的筹码数算钱，赚了钱的从我这里拿，赔了钱的也付给我，一切就OK啦，俺得到了四个MM的电话。

调停者模式：调停者模式包装了一系列对象相互作用的方式，使得这些对象不必相互明显作用。从而使他们可以松散偶合。当某些对象之间的作用发生改 变时，不会立即影响其他的一些对象之间的作用。保证这些作用可以彼此独立的变化。调停者模式将多对多的相互作用转化为一对多的相互作用。调停者模式将对象 的行为和协作抽象化，把对象在小尺度的行为上与其他对象的相互作用分开处理。
18、MEMENTO—同时跟几个MM聊天时，一定要记清楚刚才跟MM说了些什么话，不然MM发现了会不高兴的哦，幸亏我有个备忘录，刚才与哪个MM说了什么话我都拷贝一份放到备忘录里面保存，这样可以随时察看以前的记录啦。
备忘录模式：备忘录对象是一个用来存储另外一个对象内部状态的快照的对象。备忘录模式的用意是在不破坏封装的条件下，将一个对象的状态捉住，并外部化，存储起来，从而可以在将来合适的时候把这个对象还原到存储起来的状态。
19、OBSERVER—想知道咱们公司最新MM情报吗？加入公司的MM情报邮件组就行了，tom负责搜集情报，他发现的新情报不用一个一个通知我们，直接发布给邮件组，我们作为订阅者（观察者）就可以及时收到情报啦
观察者模式：观察者模式定义了一种一队多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态上发生变化时，会通知所有观察者对象，使他们能够自动更新自己。
20、STATE—跟MM交往时，一定要注意她的状态哦，在不同的状态时她的行为会有不同，比如你约她今天晚上去看电影，对你没兴趣的MM就会说“有 事情啦”，对你不讨厌但还没喜欢上的MM就会说“好啊，不过可以带上我同事么？”，已经喜欢上你的MM就会说“几点钟？看完电影再去泡吧怎么样？”，当然 你看电影过程中表现良好的话，也可以把MM的状态从不讨厌不喜欢变成喜欢哦。
状态模式：状态模式允许一个对象在其内部状态改变的时候改变行为。这个对象看上去象是改变了它的类一样。状态模式把所研究的对象的行为包装在不同的状 态对象里，每一个状态对象都属于一个抽象状态类的一个子类。状态模式的意图是让一个对象在其内部状态改变的时候，其行为也随之改变。状态模式需要对每一个 系统可能取得的状态创立一个状态类的子类。当系统的状态变化时，系统便改变所选的子类。
21、STRATEGY—跟不同类型的MM约会，要用不同的策略，有的请电影比较好，有的则去吃小吃效果不错，有的去海边浪漫最合适，单目的都是为了得到MM的芳心，我的追MM锦囊中有好多Strategy哦。
策略模式：策略模式针对一组算法，将每一个算法封装到具有共同接口的独立的类中，从而使得它们可以相互替换。策略模式使得算法可以在不影响到客户端的 情况下发生变化。策略模式把行为和环境分开。环境类负责维持和查询行为类，各种算法在具体的策略类中提供。由于算法和环境独立开来，算法的增减，修改都不 会影响到环境和客户端。
22、TEMPLATE METHOD——将执行步骤称为(Template method)，但每个步骤针对不同的情况，都有不一样的做法，这就要看你随机应变啦(具体实现)；
模板方法模式：模板方法模式准备一个抽象类，将部分逻辑以具体方法以及具体构造子的形式实现，然后声明一些抽象方法来迫使子类实现剩余的逻辑。不同的 子类可以以不同的方式实现这些抽象方法，从而对剩余的逻辑有不同的实现。先制定一个顶级逻辑框架，而将逻辑的细节留给具体的子类去实现。
23、VISITOR—情人节到了，要给每个MM送一束鲜花和一张卡片，可是每个MM送的花都要针对她个人的特点，每张卡片也要根据个人的特点来挑， 我一个人哪搞得清楚，还是找花店老板和礼品店老板做一下Visitor，让花店老板根据MM的特点选一束花，让礼品店老板也根据每个人特点选一张卡，这样 就轻松多了；
访问者模式：访问者模式的目的是封装一些施加于某种数据结构元素之上的操作。一旦这些操作需要修改的话，接受这个操作的数据结构可以保持不变。访问者 模式适用于数据结构相对未定的系统，它把数据结构和作用于结构上的操作之间的耦合解脱开，使得操作集合可以相对自由的演化。访问者模式使得增加新的操作变 的很容易，就是增加一个新的访问者类。访问者模式将有关的行为集中到一个访问者对象中，而不是分散到一个个的节点类中。当使用访问者模式时，要将尽可能多 的对象浏览逻辑放在访问者类中，而不是放到它的子类中。访问者模式可以跨过几个类的等级结构访问属于不同的等级结构的成员类。

student表
student_id vchar(36) primary key
name vchar(128) not null 学生名称
memo vchar(256)    备注

class表
class_id vchar(36) primary key
name vchar(128) not null 班级名称
memo vchar(256) 备注

该表预先插入两条记录 （

stu_to_class表 (表明学生属于哪个班级）
student_id    primary key
class_id    primary key

2.创建应用，完成下面页面

（1）student的增加、删除、修改页面（要求添加的时候，同时选定该学生所属的班级,主键guid）
（2）查询页面，输入搜索关键字，列出学生表中（名称，备注字段中含有该关键字）所有的学生信息，并且导出excel格式的学生清单(选做)。

虽 然JavaScript与Java有紧密的联系，但却是两个公司开发的不同的两个产品。Java是SUN公司推出的新一代面向对象的程序设计语言，特别适 合于Internet应用程序开发；而JavaScript是Netscape公司的产品，其目的是为了扩展Netscape Navigator功能,而开发的一种可以嵌入Web页面中的基于对象和事件驱动的解释性语言, 它的前身是Live Script；而Java的前身是Oak语言。下面对两种语言间的异同作如下比较：

基于对象和面向对象
Java是一种真正的面向对象的语言，即使是开发简单的程序，必须设计对象。
JavaScript是种脚本语言，它可以用来制作与网络无关的，与用户交互作用的复杂软件。它是一种基于对象（Object Based）和事件驱动（Event Driver）的编程语言。因而它本身提供了非常丰富的内部对象供设计人员使用。
解释和编译
两种语言在其浏览器中所执行的方式不一样。Java的源代码在传递到客户端执行之前，必须经过编译，因而客户端上必须具有相应平台上的仿真器或解释器，它可以通过编译器或解释器实现独立于某个特定的平台编译代码的束缚。
JavaScript是一种解释性编程语言，其源代码在发往客户端执行之前不需经过编译，而是将文本格式的字符代码发送给客户编由浏览器解释执行。
强变量和弱变量
两种语言所采取的变量是不一样的。
Java采用强类型变量检查，即所有变量在编译之前必须作声明。如:
Integer x;
String y;
x=1234;
x=4321;

其中X=1234说明是一个整数，Y=4321说明是一个字符串。
JavaScript中变量声明，采用其弱类型。即变量在使用前不需作声明，而是解释器在运行时检查其数据类型，如：

x=1234;

y＝”4321″;

前者说明x为其数值型变量，而后者说明y为字符型变量。

代码格式不一样
Java是一种与HTML无关的格式，必须通过像HTML中引用外媒体那么进行装载，其代码以字节代码的形式保存在独立的文档中。
JavaScript的代码是一种文本字符格式，可以直接嵌入HTML文档中，并且可动态装载。编写HTML文档就像编辑文本文件一样方便。
嵌入方式不一样
在HTML文档中，两种编程语言的标识不同，JavaScript使用<Script>…</Script>来标识，而Java使用<applet>…</applet>来标识。
静态联编和动态联编
Java采用静态联编，即Java的对象引用必须在编译时的进行，以使编译器能够实现强类型检查。
JavaScript采用动态联编，即JavaScript的对象引用在运行时进行检查，如不经编译则就无法实现对象引用的检查。

Stack 类
Stack继承自 Vector，实现一个后进先出的堆栈。Stack提供5个额外的方法使得Vector得以被当作堆栈使用。基本的push和pop方法，还有peek方 法得到栈顶的元素，empty方法测试堆栈是否为空，search方法检测一个元素在堆栈中的位置。Stack刚创建后是空栈。

3）map映射
映射与集或列表有明显区别，映射中每个项都是成对的。映射中存储的每个对象都有一个相关的关键字（Key）对象，关键字决定了对象在映射中的存储位置，检索对象时必须提供相应的关键字，就像在字典中查单词一样。关键字应该是唯一的。map没有继承Collection接口，Map提供key到value的映射。一个Map中 不能包含相同的key，每个key只能映射一个value。Map接口提供3种集合的视图，Map的内容可以被当作一组key集合，一组value集合， 或者一组key-value映射。
Hashtable类
Hashtable继承Map接口，实现一个key-value映射的哈希表。任何非空（non-null）的对象都可作为key或者value。
添加数据使用put(key, value)，取出数据使用get(key)，这两个基本操作的时间开销为常数。
Hashtable 通过initial capacity和load factor两个参数调整性能。通常缺省的load factor 0.75较好地实现了时间和空间的 均衡。增大load factor可以节省空间但相应的查找时间将增大，这会影响像get和put这样的操作。
使用Hashtable的简单示例如下，将1，2，3放到Hashtable中，他们的key分别是”one”，”two”，”three”：
Hashtable numbers = new Hashtable();
numbers.put(“one”, new Integer(1));
numbers.put(“two”, new Integer(2));
numbers.put(“three”, new Integer(3));
要取出一个数，比如2，用相应的key：
Integer n = (Integer)numbers.get(“two”);
System.out.println(“two = ” + n);
由于作为key的对象将通过计算其散列函数来确定与之对应的value的位置，因此任何作为key的对象都必须实现hashCode和equals方 法。hashCode和equals方法继承自根类Object，如果你用自定义的类当作key的话，要相当小心，按照散列函数的定义，如果两个对象相 同，即obj1.equals(obj2)=true，则它们的hashCode必须相同，但如果两个对象不同，则它们的hashCode不一定不同，如 果两个不同对象的hashCode相同，这种现象称为冲突，冲突会导致操作哈希表的时间开销增大，所以尽量定义好的hashCode()方法，能加快哈希 表的操作。
如果相同的对象有不同的hashCode，对哈希表的操作会出现意想不到的结果（期待的get方法返回null），要避免这种问题，只需要牢记一条：要同时复写equals方法和hashCode方法，而不要只写其中一个。
Hashtable是同步的。

HashMap类
HashMap和Hashtable类似，不同之处在于HashMap是非同步的，并且允许null，即null value和null key。，但 是将HashMap视为Collection时（values()方法可返回Collection），其迭代子操作时间开销和HashMap的容量成比 例。因此，如果迭代操作的性能相当重要的话，不要将HashMap的初始化容量设得过高，或者load factor过低。

WeakHashMap类
WeakHashMap是一种改进的HashMap，它对key实行“弱引用”，如果一个key不再被外部所引用，那么该key可以被GC回收。

总结
如果涉及到堆栈，队列等操作，应该考虑用List，对于需要快速插入，删除元素，应该使用LinkedList，如果需要快速随机访问元素，应该使用ArrayList。
如果程序在单线程环境中，或者访问仅仅在一个线程中进行，考虑非同步的类，其效率较高，如果多个线程可能同时操作一个类，应该使用同步的类。
要特别注意对哈希表的操作，作为key的对象要正确复写equals和hashCode方法。
尽量返回接口而非实际的类型，如返回List而非ArrayList，这样如果以后需要将ArrayList换成LinkedList时，客户端代码不用改变。这就是针对抽象编程。

同步性
Vector 是同步的。这个类中的一些方法保证了Vector中的对象是线程安全的。而ArrayList则是异步的，因此ArrayList中的对象并不是线程安全 的。因为同步的要求会影响执行的效率，所以如果你不需要线程安全的集合那么使用ArrayList是一个很好的选择，这样可以避免由于同步带来的不必要的 性能开销。
数据增长
从内部实现机制来讲ArrayList和Vector都是使用数组(Array)来控制集合中的对象。当你向这两种类 型中增加元素的时候，如果元素的数目超出了内部数组目前的长度它们都需要扩展内部数组的长度，Vector缺省情况下自动增长原来一倍的数组长 度，ArrayList是原来的50%,所以最后你获得的这个集合所占的空间总是比你实际需要的要大。所以如果你要在集合中保存大量的数据那么使用 Vector有一些优势，因为你可以通过设置集合的初始化大小来避免不必要的资源开销。
使用模式
在ArrayList和Vector中， 从一个指定的位置（通过索引）查找数据或是在集合的末尾增加、移除一个元素所花费的时间是一样的，这个时间我们用O(1)表示。但是，如果在集合的其他位 置增加或移除元素那么花费的时间会呈线形增长：O(n-i)，其中n代表集合中元素的个数，i代表元素增加或移除元素的索引位置。为什么会这样呢？以为在 进行上述操作的时候集合中第i和第i个元素之后的所有元素都要执行位移的操作。这一切意味着什么呢？
这意味着，你只是查找特定位置的元素或只在集 合的末端增加、移除元素，那么使用Vector或ArrayList都可以。如果是其他操作，你最好选择其他的集合操作类。比如，LinkList集合类 在增加或移除集合中任何位置的元素所花费的时间都是一样的?O(1)，但它在索引一个元素的使用缺比较慢－O(i),其中i是索引的位置.使用 ArrayList也很容易，因为你可以简单的使用索引来代替创建iterator对象的操作。LinkList也会为每个插入的元素创建对象，所有你要 明白它也会带来额外的开销。
最后，在《Practical Java》一书中Peter Haggar建议使用一个简单的数组（Array）来代 替Vector或ArrayList。尤其是对于执行效率要求高的程序更应如此。因为使用数组(Array)避免了同步、额外的方法调用和不必要的重新分 配空间的操作。

Hashtable基本用法概述
Hashtable-哈希表类
以哈希表的形式存储数据,数据的形式是键值对.
特点:
查找速度快,遍历相对慢
键值不能有空指针和重复数据
创建
Hashtable<Integer,String> ht=new Hashtable<Integer,String>();
添值
ht.put(1,”Andy”);
ht.put(2,”Bill”);
ht.put(3,”Cindy”);
ht.put(4,”Dell”);
ht.put(5,”Felex”);
ht.put(6,”Edinburg”);
ht.put(7,”Green”);
取值
String str=ht.get(1);
System.out.println(str);// Andy
对键进行遍历
Iterator it = ht.keySet().iterator();
while (it.hasNext()) {
Integer key = (Integer)it.next();
System.out.println(key);
}
对值进行遍历
Iterator it = ht.values().iterator();
while (it.hasNext()) {
String value =(String) it.next();
System.out.println(value);
}
取Hashtable记录数
Hashtable<Integer,String> ht=new Hashtable<Integer,String>();
ht.put(1,”Andy”);
ht.put(2,”Bill”);
ht.put(3,”Cindy”);
ht.put(4,”Dell”);
ht.put(5,”Felex”);
ht.put(6,”Edinburg”);
ht.put(7,”Green”);
int i=ht.size();// 7
删除元素
Hashtable<Integer,String> ht=new Hashtable<Integer,String>();
ht.put(1,”Andy”);
ht.put(2,”Bill”);
ht.put(3,”Cindy”);
ht.put(4,”Dell”);
ht.put(5,”Felex”);
ht.put(6,”Edinburg”);
ht.put(7,”Green”);
ht.remove(1);
ht.remove(2);
ht.remove(3);
ht.remove(4);
System.out.println(ht.size());// 3

Iterator it = ht.values().iterator();
while (it.hasNext()) {
// Get value
String value =(String) it.next();
System.out.println(value);
}
输出:
3
Green
Edinburg
Felex

java中的hashcode()和equals()方法详解
1. 首先equals()和hashcode()这两个方法都是从object类中继承过来的。
equals()方法在object类中定义如下：
public boolean equals(Object obj) {
return (this == obj);
}
很明显是对两个对象的地址值进行的比较（即比较引用是否相同）。但是我们必需清楚，当String 、Math、还有Integer、Double。。。。等这些封装类在使用equals()方法时，已经覆盖了object类的equals（）方法。比 如在String类中如下：
public boolean equals(Object anObject) {
if (this == anObject) {
return true;
}
if (anObject instanceof String) {
String anotherString = (String)anObject;
int n = count;
if (n == anotherString.count) {
char v1[] = value;
char v2[] = anotherString.value;
int i = offset;
int j = anotherString.offset;
while (n– != 0) {
if (v1[i++] != v2[j++])
return false;
}
return true;
}
}
return false;
}
很明显，这是进行的内容比较，而已经不再是地址的比较。依次类推Double、Integer、Math。。。。等等这些类都是重写了equals()方法的，从而进行的是内容的比较。当然了基本类型是进行值的比较，这个没有什么好说的。
我们还应该注意，Java语言对equals()的要求如下，这些要求是必须遵循的：
• 对称性：如果x.equals(y)返回是“true”，那么y.equals(x)也应该返回是“true”。
• 反射性：x.equals(x)必须返回是“true”。
• 类推性：如果x.equals(y)返回是“true”，而且y.equals(z)返回是“true”，那么z.equals(x)也应该返回是“true”。
• 还有一致性：如果x.equals(y)返回是“true”，只要x和y内容一直不变，不管你重复x.equals(y)多少次，返回都是“true”。
• 任何情况下，x.equals(null)，永远返回是“false”；x.equals(和x不同类型的对象)永远返回是“false”。
以上这五点是重写equals()方法时，必须遵守的准则，如果违反会出现意想不到的结果，请大家一定要遵守。
2. 其次是hashcode() 方法，在object类中定义如下：
public native int hashCode();
说明是一个本地方法，它的实现是根据本地机器相关的。当然我们可以在自己写的类中覆盖hashcode()方法，比如String、Integer、 Double。。。。等等这些类都是覆盖了hashcode()方法的。例如在String类中定义的hashcode()方法如下：
public int hashCode() {
int h = hash;
if (h == 0) {
int off = offset;
char val[] = value;
int len = count;
for (int i = 0; i < len; i++) {
h = 31*h + val[off++];
}
hash = h;
}
return h;
}
解释一下这个程序（String的API中写到）：
s[0]*31^(n-1) + s[1]*31^(n-2) + … + s[n-1]
使用 int 算法，这里 s[i] 是字符串的第 i 个字符，n 是字符串的长度，^ 表示求幂。（空字符串的哈希码为 0。）

3.这里我们首先要明白一个问题：
equals()相等的两个对象，hashcode()一定相等；
equals（）不相等的两个对象，却并不能证明他们的hashcode()不相等。换句话说，equals()方法不相等的两个对象，hashcode()有可能相等。（我的理解是由于哈希码在生成的时候产生冲突造成的）。
反过来：hashcode()不等，一定能推出equals()也不等；hashcode()相等，equals()可能相等，也可能不等。解释 下第3点的使用范围，我的理解是在object、String等类中都能使用。在object类中，hashcode()方法是本地方法，返回的是对象的 地址值，而object类中的equals()方法比较的也是两个对象的地址值，如果equals()相等，说明两个对象地址值也相等，当然 hashcode()也就相等了；在String类中，equals()返回的是两个对象内容的比较，当两个对象内容相等时，
Hashcode()方法根据String类的重写（第2点里面已经分析了）代码的分析，也可知道hashcode()返回结果也会相等。以此 类推，可以知道Integer、Double等封装类中经过重写的equals()和hashcode()方法也同样适合于这个原则。当然没有经过重写的 类，在继承了object类的equals()和hashcode()方法后，也会遵守这个原则。

4.谈到hashcode()和equals()就不能不说到hashset,hashmap,hashtable中的使用，具体是怎样呢，请看如下分析：
Hashset是继承Set接口，Set接口又实现Collection接口，这是层次关系。那么hashset是根据什么原理来存取对象的呢？
在hashset中不允许出现重复对象，元素的位置也是不确定的。在hashset中又是怎样判定元素是否重复的呢？这就是问题的关键所在，经过一下午的查询求证终于获得了一点启示，和大家分享一下，在java的集合中，判断两个对象是否相等的规则是：
1)，判断两个对象的hashCode是否相等
如果不相等，认为两个对象也不相等，完毕
如果相等，转入2
（这一点只是为了提高存储效率而要求的，其实理论上没有也可以，但如果没有，实际使用时效率会大大降低，所以我们这里将其做为必需的。后面会重点讲到这个问题。）
2)，判断两个对象用equals运算是否相等
如果不相等，认为两个对象也不相等
如果相等，认为两个对象相等（equals()是判断两个对象是否相等的关键）
为什么是两条准则，难道用第一条不行吗？不行，因为前面已经说了，hashcode()相等时，equals()方法也可能不等，所以必须用第2条准则进行限制，才能保证加入的为非重复元素。
比如下面的代码：

public static void main(String args[]){
String s1=new String(“zhaoxudong”);
String s2=new String(“zhaoxudong”);
System.out.println(s1==s2);//false
System.out.println(s1.equals(s2));//true
System.out.println(s1.hashCode());//s1.hashcode()等于s2.hashcode()
System.out.println(s2.hashCode());
Set hashset=new HashSet();
hashset.add(s1);
hashset.add(s2);
/*实质上在添加s1,s2时，运用上面说到的两点准则，可以知道hashset认为s1和s2是相等的，是在添加重复元素，所以让s2覆盖了s1;*/
Iterator it=hashset.iterator();
while(it.hasNext())
{
System.out.println(it.next());
}
最后在while循环的时候只打印出了一个”zhaoxudong”。
输出结果为：false
true
-967303459
-967303459
这是因为String类已经重写了equals()方法和hashcode()方法，所以在根据上面的第1.2条原则判定时，hashset认为它们是相等的对象，进行了重复添加。
但是看下面的程序：
import java.util.*;
public class HashSetTest {
public static void main(String[] args)     {
HashSet hs=new HashSet();
hs.add(new Student(1,”zhangsan”));
hs.add(new Student(2,”lisi”));
hs.add(new Student(3,”wangwu”));
hs.add(new Student(1,”zhangsan”));

Iterator it=hs.iterator();
while(it.hasNext())      {
System.out.println(it.next());
}
}
}
class Student    {
int num;
String name;
Student(int num,String name)  {
this.num=num;
this.name=name;
}
public String toString()    {
return num+”:”+name;
}
}
输出结果为：
1:zhangsan
1:zhangsan
3:wangwu
2:lisi
问题出现了，为什么hashset添加了相等的元素呢，这是不是和hashset的原则违背了呢？回答是：没有
因为在根据hashcode()对两次建立的new Student(1,”zhangsan”)对象进行比较时，生成的是不同的哈希码值，所以hashset把他当作不同的对象对待了，当然此时的 equals()方法返回的值也不等（这个不用解释了吧）。那么为什么会生成不同的哈希码值呢？上面我们在比较s1和s2的时候不是生成了同样的哈希码 吗？原因就在于我们自己写的Student类并没有重新自己的hashcode()和equals()方法，所以在比较时，是继承的object类中的 hashcode()方法，呵呵，各位还记得object类中的hashcode()方法比较的是什么吧！！
它是一个本地方法，比较的是对象的地址（引用地址），使用new方法创建对象，两次生成的当然是不同的对象了（这个大家都能理解吧。。。），造 成的结果就是两个对象的hashcode()返回的值不一样。所以根据第一个准则，hashset会把它们当作不同的对象对待，自然也用不着第二个准则进 行判定了。那么怎么解决这个问题呢？？
答案是：在Student类中重新hashcode()和equals()方法。
例如：
class Student {
int num;
String name;
Student(int num,String name) {
this.num=num;
this.name=name;
}
public int hashCode() {
return num*name.hashCode();
}
public boolean equals(Object o) {
Student s=(Student)o;
return num==s.num && name.equals(s.name);
}
public String toString() {
return num+”:”+name;
}
}
根据重写的方法，即便两次调用了new Student(1,”zhangsan”)，我们在获得对象的哈希码时，根据重写的方法hashcode()，获得的哈希码肯定是一样的（这一点应该没有疑问吧）。
当然根据equals()方法我们也可判断是相同的。所以在向hashset集合中添加时把它们当作重复元素看待了。所以运行修改后的程序时，我们会发现运行结果是：
1:zhangsan
3:wangwu
2:lisi
可以看到重复元素的问题已经消除。
关于在hibernate的pojo类中，重新equals()和hashcode()的问题：
1)，重点是equals，重写hashCode只是技术要求（为了提高效率）
2)，为什么要重写equals呢，因为在java的集合框架中，是通过equals来判断两个对象是否相等的
3)，在hibernate中，经常使用set集合来保存相关对象，而set集合是不允许重复的。我们再来谈谈前面提到在向hashset集合中添加元素时,怎样判断对象是否相同的准则，前面说了两条，其实只要重写equals()这一条也可以。
但当hashset中元素比较多时，或者是重写的equals()方法比较复杂时，我们只用equals()方法进行比较判断，效率也会非常低， 所以引入了hashcode()这个方法，只是为了提高效率，但是我觉得这是非常有必要的（所以我们在前面以两条准则来进行hashset的元素是否重复 的判断）。
比如可以这样写：
public int hashCode(){
return  1;}//等价于hashcode无效
这样做的效果就是在比较哈希码的时候不能进行判断，因为每个对象返回的哈希码都是1，每次都必须要经过比较equals()方法后才能进行判断是否重复，这当然会引起效率的大大降低。
我有一个问题，如果像前面提到的在hashset中判断元素是否重复的必要方法是equals()方法（根据网上找到的观点），但是这里并没有涉及到关于哈希表的问题，可是这个集合却叫hashset，这是为什么？？
我想，在hashmap,hashtable中的存储操作，依然遵守上面的准则。
散列表的概念

1、散列表
设所有可能出现的关键字集合记为U(简称全集)。实际发生(即实际存储)的关键字集合记为K（|K|比|U|小得多）。
散列方法是使用函数h将U映射到表T[0..m-1]的下标上（m=O(|U|)）。这样以U中关键字为自变量，以h为函数的运算结果就是相应结点的存储地址。从而达到在O(1)时间内就可完成查找。
其中：
① h：U→{0，1，2，…，m-1} ，通常称h为散列函数(Hash Function)。散列函数h的作用是压缩待处理的下标范围，使待处理的|U|个值减少到m个值，从而降低空间开销。
② T为散列表(Hash Table)。
③ h(Ki)(Ki∈U)是关键字为Ki结点存储地址(亦称散列值或散列地址)。
④ 将结点按其关键字的散列地址存储到散列表中的过程称为散列(Hashing)

3、散列表的冲突现象
（1）冲突
两个不同的关键字，由于散列函数值相同，因而被映射到同一表位置上。该现象称为冲突(Collision)或碰撞。发生冲突的两个关键字称为该散列函数的同义词(Synonym)。
【例】上图中的k2≠k5，但h(k2)=h(k5)，故k2和K5所在的结点的存储地址相同。

（2）安全避免冲突的条件
最理想的解决冲突的方法是安全避免冲突。要做到这一点必须满足两个条件：
①其一是|U|≤m
②其二是选择合适的散列函数。
这只适用于|U|较小，且关键字均事先已知的情况，此时经过精心设计散列函数h有可能完全避免冲突。

（3）冲突不可能完全避免
通常情况下，h是一个压缩映像。虽然|K|≤m，但|U|>m，故无论怎样设计h，也不可能完全避免冲突。因此，只能在设计h时尽可能使冲突最少。同时还需要确定解决冲突的方法，使发生冲突的同义词能够存储到表中。

（4）影响冲突的因素
冲突的频繁程度除了与h相关外，还与表的填满程度相关。
设m和n分别表示表长和表中填人的结点数，则将α=n/m定义为散列表的装填因子(Load Factor)。α越大，表越满，冲突的机会也越大。通常取α≤1。

2>. Out　stream
1) ByteArrayOutputStream：把信息存入内存中的一个缓冲区中
2) FileOutputStream：把信息存入文件中
3) PipedOutputStream：实现了pipe的概念，主要在线程中使用
4) SequenceOutputStream：把多个OutStream合并为一个OutStream
=======================================================================
1.2 以Unicode字符为导向的stream
以Unicode字符为导向的stream，表示以Unicode字符为单位从stream中读取或往stream中写入信息。以Unicode字符为导向的stream包括下面几种类型：
1>. Input　Stream
1) CharArrayReader：与ByteArrayInputStream对应
2) StringReader：与StringBufferInputStream对应
3) FileReader：与FileInputStream对应
4) PipedReader：与PipedInputStream对应

2>. Out　Stream
1) CharArrayWrite：与ByteArrayOutputStream对应
2) StringWrite：无与之对应的以字节为导向的stream
3) FileWrite：与FileOutputStream对应
4) PipedWrite：与PipedOutputStream对应
以字符为导向的stream基本上对有与之相对应的以字节为导向的stream。两个对应类实现的功能相同，字是在操作时的导向不同。如 CharArrayReader：和ByteArrayInputStream的作用都是把内存中的一个缓冲区作为InputStream使用，所不同的是前者每次从内存中读取一个字节的信息，而后者每次从内存中读取一个字符。
=======================================================================
1.3 两种不现导向的stream之间的转换
InputStreamReader和OutputStreamReader：把一个以字节为导向的stream转换成一个以字符为导向的stream。

——————————————————————————
2. stream添加属性
2.1 “为stream添加属性”的作用
运用上面介绍的Java中操作IO的API，我们就可完成我们想完成的任何操作了。但通过FilterInputStream和FilterOutStream的子类，我们可以为stream添加属性。下面以一个例子来说明这种功能的作用。
如果我们要往一个文件中写入数据，我们可以这样操作：
FileOutStream fs = new FileOutStream(“test.txt”);
然后就可以通过产生的fs对象调用write()函数来往test.txt文件中写入数据了。但是，如果我们想实现“先把要写入文件的数据先缓存到内存中，再把缓存中的数据写入文件中”的功能时，上面的API就没有一个能满足我们的需求了。但是通过FilterInputStream和 FilterOutStream的子类，为FileOutStream添加我们所需要的功能。

2.2 FilterInputStream的各种类型
2.2.1 用于封装以字节为导向的InputStream
1) DataInputStream：从stream中读取基本类型（int、char等）数据。
2) BufferedInputStream：使用缓冲区
3) LineNumberInputStream：会记录input stream内的行数，然后可以调用getLineNumber()和setLineNumber(int)
4) PushbackInputStream：很少用到，一般用于编译器开发

2.2.2 用于封装以字符为导向的InputStream
1) 没有与DataInputStream对应的类。除非在要使用readLine()时改用BufferedReader，否则使用DataInputStream
2) BufferedReader：与BufferedInputStream对应
3) LineNumberReader：与LineNumberInputStream对应
4) PushBackReader：与PushbackInputStream对应

2.3 FilterOutStream的各种类型
2.2.3 用于封装以字节为导向的OutputStream
1) DataIOutStream：往stream中输出基本类型（int、char等）数据。
2) BufferedOutStream：使用缓冲区
3) PrintStream：产生格式化输出

2.2.4 用于封装以字符为导向的OutputStream
1) BufferedWrite：与对应
2) PrintWrite：与对应

3. RandomAccessFile
1) 可通过RandomAccessFile对象完成对文件的读写操作
2) 在产生一个对象时，可指明要打开的文件的性质：r，只读；w，只写；rw可读写
3) 可以直接跳到文件中指定的位置
————————————————————————

Java IO的一般使用原则：
一、按数据来源（去向）分类：
1、是文件： FileInputStream, FileOutputStream, FileReader, FileWriter
2、是byte[]：ByteArrayInputStream, ByteArrayOutputStream
3、是Char[]: CharArrayReader, CharArrayWriter
4、是String: StringBufferInputStream, StringReader, StringWriter
5、网络数据流：InputStream, OutputStream, Reader, Writer

二、按是否格式化输出分：
1、要格式化输出：PrintStream, PrintWriter

三、按是否要缓冲分：
1、要缓冲：BufferedInputStream, BufferedOutputStream, BufferedReader, BufferedWriter

四、按数据格式分：
1、二进制格式（只要不能确定是纯文本的）: InputStream, OutputStream及其所有带Stream结束的子类
2、纯文本格式（含纯英文与汉字或其他编码方式）；Reader, Writer及其所有带Reader, Writer的子类

五、按输入输出分：
1、输入：Reader, InputStream类型的子类
2、输出：Writer, OutputStream类型的子类

六、特殊需要：
1、从Stream到Reader,Writer的转换类：InputStreamReader, OutputStreamWriter
2、对象输入输出：ObjectInputStream, ObjectOutputStream
3、进程间通信：PipeInputStream, PipeOutputStream, PipeReader, PipeWriter
4、合并输入：SequenceInputStream
5、更特殊的需要：PushbackInputStream, PushbackReader, LineNumberInputStream, LineNumberReader

决定使用哪个类以及它的构造进程的一般准则如下（不考虑特殊需要）：
首先，考虑最原始的数据格式是什么： 原则四
第二，是输入还是输出：原则五
第三，是否需要转换流：原则六第1点
第四，数据来源（去向）是什么：原则一
第五，是否要缓冲：原则三 （特别注明：一定要注意的是readLine()是否有定义，有什么比read, write更特殊的输入或输出方法）
第六，是否要格式化输出：原则二
——————————————————————–

关于代码的解释（以区为单位）：
1区中，当读取文件时，先把文件内容读到缓存中，当调用in.readLine()时，再从缓存中以字符的方式读取数据（以下简称“缓存字节读取方式”）。
1b区中，由于想以缓存字节读取方式从标准IO（键盘）中读取数据，所以要先把标准IO（System.in）转换成字符导向的stream，再进行BufferedReader封装。
2区中，要以字符的形式从一个String对象中读取数据，所以要产生一个StringReader类型的stream。
4区中，对String对象s2读取数据时，先把对象中的数据存入缓存中，再从缓冲中进行读取；对TestIO.out文件进行操作时，先把格式化后的信息输出到缓存中，再把缓存中的信息输出到文件中。
5 区中，对Data.txt文件进行输出时，是先把基本类型的数据输出屋缓存中，再把缓存中的数据输出到文件中；对文件进行读取操作时，先把文件中的数据读取到缓存中，再从缓存中以基本类型的形式进行读取。注意in5.readDouble()这一行。因为写入第一个writeDouble()，所以为了正确显示。也要以基本类型的形式进行读取。
6区是通过RandomAccessFile类对文件进行操作。