JDT实际上是将Java代码构建成一个基于DOM结构的抽象语法树AST（Abstract Syntax Tree ）。代码中的每个部分都对应一个ASTNode，许多的ASTNode就构成了这个抽象的语法树。Java Class一般对应Compilation Unit node，该节点也是AST树上的顶点。创建一个AST如下：

其中createAST，当parse需要较长时间时，可以采用createAST(new NullProgressMonitor())，否则直接传null即可。

recordModifications()用于记录节点的变动，比如修改、删除等，当需要对AST树进行变动操作时，必须要预先调用这个方法。

// package astexplorer;
java 代码

 

    
PackageDeclaration packageDeclaration = ast.newPackageDeclaration();  
    
unit.setPackage(packageDeclaration);  
    
packageDeclaration.setName(ast.newSimpleName("astexplorer")); 

    

// import org.eclipse.swt.SWT;

// import org.eclipse.swt.events.*;

// import org.eclipse.swt.graphics.*;

// import org.eclipse.swt.layout.*;

// import org.eclipse.swt.widgets.*;
java 代码

 

    
for (int i = 0; i < IMPORTS.length; ++i) {  
    
ImportDeclaration importDeclaration = ast.newImportDeclaration();  
    
importDeclaration.setName(ast.newName(getSimpleNames(IMPORTS[i])));  
    
if (IMPORTS[i].indexOf("*") > 0)  
    
importDeclaration.setOnDemand(true);  
    
else  
    
importDeclaration.setOnDemand(false);  
    
  
    
unit.imports().add(importDeclaration);  
    
}  

// public class SampleComposite extends Composite 

java 代码

 

    
TypeDeclaration classType = ast.newTypeDeclaration();  
    
classType.setInterface(false);  
    
classType.setModifiers(Modifier.PUBLIC);  
    
classType.setName(ast.newSimpleName("SampleComposite"));  
    
classType.setSuperclass(ast.newSimpleName("Composite"));  
    
unit.types().add(classType);  

List 4 生成Constructor Declaration



// public SampleComposite(Composite parent,int style){}

java 代码

 

    
MethodDeclaration methodConstructor = ast.newMethodDeclaration();  
    
methodConstructor.setConstructor(true);  
    
methodConstructor.setModifiers(Modifier.PUBLIC);  
    
methodConstructor.setName(ast.newSimpleName("SampleComposite"));  
    
classType.bodyDeclarations().add(methodConstructor);  
    
  
    
// constructor parameters  
    
  
    
SingleVariableDeclaration variableDeclaration = ast.newSingleVariableDeclaration();  
    
variableDeclaration.setModifiers(Modifier.NONE);  
    
variableDeclaration.setType(ast.newSimpleType(ast.newSimpleName("Composite")));  
    
variableDeclaration.setName(ast.newSimpleName("parent"));  
    
methodConstructor.parameters().add(variableDeclaration);  
    
  
    
variableDeclaration = ast.newSingleVariableDeclaration();  
    
variableDeclaration.setModifiers(Modifier.NONE);  
    
variableDeclaration.setType(ast.newPrimitiveType(PrimitiveType.INT));  
    
variableDeclaration.setName(ast.newSimpleName("style"));  
    
methodConstructor.parameters().add(variableDeclaration);  
    

    
Block constructorBlock = ast.newBlock();  
    
methodConstructor.setBody(constructorBlock);

    

 List 5 生成Spuer Invocation



// super(parent,style)

java 代码

 

    
SuperConstructorInvocation superConstructorInvocation = ast.newSuperConstructorInvocation();  
    
constructorBlock.statements().add(superConstructorInvocation);  
    
Expression exp = ast.newSimpleName("parent");  
    
superConstructorInvocation.arguments().add(exp);  
    
superConstructorInvocation.arguments().add(ast.newSimpleName("style"));  

List 6 生成ClassInstanceCreation



// GridLayout gridLayout = new GridLayout();

java 代码

 

    
VariableDeclarationFragment vdf = ast.newVariableDeclarationFragment();  
    
vdf.setName(ast.newSimpleName("gridLayout"));  
    
ClassInstanceCreation cc = ast.newClassInstanceCreation();  
    
cc.setName(ast.newSimpleName("GridLayout"));  
    
vdf.setInitializer(cc);  
    
VariableDeclarationStatement vds = ast.newVariableDeclarationStatement(vdf);  
    
vds.setType(ast.newSimpleType(ast.newSimpleName("GridLayout"))); 
    
constructBlock.statements().add(vds);

// Label label = new Label(this,SWT.NONE);

java 代码

 

    
VariableDeclarationFragment vdf = ast.newVariableDeclarationFragment();  
    
vdf.setName(ast.newSimpleName("label"));  
    
cc = ast.newClassInstanceCreation();  
    
cc.setName(ast.newSimpleName("Label"));  
    
cc.arguments().add(ast.newThisExpression());  
    
cc.arguments().add(ast.newName(getSimpleNames("SWT.NONE")));  
    
vdf.setInitializer(cc);  

    
    
VariableDeclarationStatement vds = ast.newVariableDeclarationStatement(vdf);  
    
vds.setType(ast.newSimpleType(ast.newSimpleName("Label")));  
    
constructBlock.statements().add(vds);

List 7生成MethodInvocation



// setLayout(gridLayout);

java 代码

 

    
MethodInvocation mi = ast.newMethodInvocation();  
    
mi.setName(ast.newSimpleName("setLayout"));  
    
mi.arguments().add(ast.newSimpleName("gridLayout")); 
    
constructorBlock.statements().add(ast.newExpressionStatement(mi));

// label.setText("Press the button to close:");

         java 代码

    
mi = ast.newMethodInvocation();   
    
mi.setExpression(ast.newSimpleName("label"));   
    
mi.setName(ast.newSimpleName("setText"));   
    
StringLiteral sl = ast.newStringLiteral();   
    
sl.setLiteralValue("Press the button to close:");   
    
mi.arguments().add(sl);   
    
constructorBlock.statements().add(ast.newExpressionStatement(mi));  

// label.setLayoutData(new GridData(GridData.HORIZONTAL_ALIGN_CENTER));

           java 代码



    
mi = ast.newMethodInvocation();   
    
mi.setExpression(ast.newSimpleName("label"));   
    
mi.setName(ast.newSimpleName("setLayoutData"));   
    
  
    
cc = ast.newClassInstanceCreation();   
    
cc.setName(ast.newSimpleName("GridData"));   
    
cc.arguments().add(ast.newName(getSimpleNames("GridData.HORIZONTAL_ALIGN_CENTER")));   
    
mi.arguments().add(cc);   
    
constructorBlock.statements().add(ast.newExpressionStatement(mi));  




 // Button button = new Button(this,SWT.PUSH);
java 代码



    
vdf = ast.newVariableDeclarationFragment();   
    
vdf.setName(ast.newSimpleName("button"));   
    
vds = ast.newVariableDeclarationStatement(vdf);   
    
vds.setType(ast.newSimpleType(ast.newSimpleName("Button")));   
    
constructorBlock.statements().add(vds);   
    
  
    
cc = ast.newClassInstanceCreation();   
    
cc.setName(ast.newSimpleName("Button"));   
    
vdf.setInitializer(cc);   
    
cc.arguments().add(ast.newThisExpression());   
    
cc.arguments().add(ast.newName(getSimpleNames("SWT.PUSH")));   



// button.addSelectionListener(new SelectionAdapter() {}); 
    java 代码



    
mi = ast.newMethodInvocation();   
    
constructorBlock.statements().add(ast.newExpressionStatement(mi));   
    
mi.setExpression(ast.newSimpleName("button"));   
    
mi.setName(ast.newSimpleName("addSelectionListener"));   
    
  
    
ClassInstanceCreation ci = ast.newClassInstanceCreation();   
    
ci.setName(ast.newSimpleName("SelectionAdapter"));   
    
mi.arguments().add(ci);   
    
AnonymousClassDeclaration cd = ast.newAnonymousClassDeclaration();   
    
ci.setAnonymousClassDeclaration(cd);  

◆一般情况下,我们都使用相对路径来获取资源,这样的灵活性比较大.

比如当前类为com/bbebfe/Test.class

而图像资源比如sample.gif应该放置在com/bbebfe/sample.gif

而如果这些图像资源放置在icons目录下,则应该是com/bbebfe/icons/sample.gif

通过当前类文件的路径获取资源主要有如下几种方式:

· 假设当前类为com.bbebfe.Test

· 包所在的文件夹为bin

String imageName = "icons/sample.gif"

1, 通过Class.getResource()定位类路径下的资源(bin/com/bbebfe/icons/sample.gif)

Class clazz = this.getClass();

URL url = clazz.getResource(imageName);

2,通过ClassLoader.getResource()定位包的根目录下的资源(bin/icons/sample.gif)

Class clazz = this.getClass();

URLClassLoader loader = (URLClassLoader)clazz.getClassLoader();

URL url = loader.getResource(imageName);

3, 通过ClassLoader.findResource()提供自己定制的方式定位资源

URL url = loader.findResource(imageName);

◆那么这三种方法有那些区别, 我们应该在何时使用哪种方法呢?

· Class.getResource() 方法

该方法实际通过该Class的Class Loader的getResource()方法来获得资源, 在调用ClassLoader的getResource()方法之前, Class.getResource()方法会对资源名称做一定的处理,构建一个该资源的绝对名称(absolute name, 大意是:

       ＋如果资源名称以'/'('"u002f') 开始, 则资源的绝对名称是'/'以后的部分.

              如果imageName是"/icons/sample.gif", 则在这里会变成"icons/sample.gif"

       ＋否则对于其他情况, 绝对名称将是如下形式(给资源名称的前面加上modified_package_name/):
              modified_package_name/resource_name (修正的包名称/资源名称)

其中修正的包名称含义是将当前对象所在的包名称中的'.'('"u002e')替换为'/'

如果ClassLoader.getResource()方法返回一个值为null的URL, 则Class.getResource()方法最终会将资源请求交给ClassLoader.getSystemResource(java.lang.String).

· ClassLoader.getResource() 方法

该对资源进行查找, 资源的名称是以'/'分隔的路径, 这个方法首先查找自己的父亲ClassLoader, 由自己的父ClassLoader来查找资源(实际上, 如果父亲的父亲不是空, 则父亲仍会向上提交查找请求). 如果自己的父ClassLoader是null, 则查找Java虚拟机中内建的class loader, 并将资源请求提交给它们, 如果这些操作都失败了, 则ClassLoader会调用自己的findResource()方法来查找资源.

· ClassLoader.findResource() 方法

该方法在内部查找指定的资源, 如果你实现了自己的Class Loader,则应该重载这个方法以自己特定的方式来查找类文件和资源.

◆通过以上的总结, 我们可以看到三点.

1, 无论是getResource(), 还是findResource(), 这些方法都只是资源的定位方法, 最终都只是返回一个URL, 只是对资源的定位而已, 我们随后应通过自己的方法来读取这些资源. 而在Class和ClassLoader中还定义的有getResourceAsStream方法, 该方法是getResource的增强版, 这里就不介绍了.

2,如果需要以类为相对路径查找资源, 则应该调用Class.getResource()方法, 不要直接调用ClassLoader.getResource()方法. 另外, 除非是你自己定义了ClassLoader并重载了findResource方法,否则也不要直接调用ClassLoader.findResource方法, 因为在Class.getResource()方法中会对资源名称作一定的处理, 这在上面介绍了, 下面举个实例:

       假设我的当前类在Eclipse工程Database下, 类所在的包是com.bbebfe.test, 而icons目录放在bin/com/bbebfe/test/目录下, 我需要得到icons/sample.gif文件的URL, 则调用this.getClass().getResource()得到的URL是:

       file:/E:/MyLife/MyProjects/Eclipse3.2/Database/bin/com/bbebfe/test/icons/disremove.gif

3, 有时候我们希望某个jar库的图像资源在同一个icons下统一管理, 而不是为每个包下面的Class建一个icons, 也就是说需要以库为相对路径来查找资源, 此时则应该调用ClassLoader.getResource()方法, 举个例子:

·某个工程有如下的包结构:

       com.bbebfe.ui

       com.bbebfe.test

       com.bbebfe.database

·如果以类为相对路径, 则在每个包下都必须建立一个icons目录, 并放置相应的资源文件. 如下:

       com.bbebfe.ui/icons/...

       com.bbebfe.test/icons/...

       com.bbebfe.database/icons/...

·而我们可能希望在根目录下放置一个icons目录, 把所有资源放置在这里管理, 这样还可以防止资源的重复. 就是如下形式

       com.bbebfe.ui

       com.bbebfe.test

       com.bbebfe.database

       icons/sample.gif ...

       则此时我们应该调用ClassLoader.getResource方法, 由于它没有对资源名称作处理, 也就是说没有将修正的包名添加到资源名称前, 所以它会在类所在的包的根下去查找资源.(运行java程序的语法是java com.bbebfe.ui.Test, 所以根目录是com目录的上级目录).

◆最后, 在Java中对资源进行定位的方法有很多种, 在Eclipse源代码中还有如下一段定位文件资源的代码, 还没有时间研究, 以后再谈:

ProtectionDomain domain = Main.class.getProtectionDomain();

CodeSource source = null;

URL result = null;

if (domain != null)

source = domain.getCodeSource();//获得code source

if (source != null)

      result = source.getLocation();//获得URL

String path = decode(result.getFile());//

// normalize to not have leading / so we can check the form

File file = new File(path);

path = file.toString().replace('""', '/');

// create a file URL (via File) to normalize the form (e.g., put

// the leading / on if necessary)

path = new File(path).toURL().getFile();

      1. 问题分析

      在JAVA环境中，一个任务一般是由一个独立线程来引导实现的，独立线程可能调用一系列子线程。如果在执行过程中，某一个线程发生异常（产生的原因很多，比如软件升级、运行环境改变、系统资抢占等），那么该线程就会停止运行，直到下次任务重新被提交。对于实时环境来说当前任务是失败的。我们无法预测和完全避免异常的发生，但是可以通过一些技术手段来跟踪任务的状态，从而及时发现问题并恢复正常，减少损失。

　 2. 设计原理

      对于一个实时任务而言，执行效率是非常关键的，这意味着不可能考虑用非常复杂的方式来实现任务监控，即使这样可以做的比较完善，同时监控代码本身也会引入一些异常，这就要求监控程序必须简单可靠，能够发现大多数问题，并能及时处理。

一个可能的简单实现。

      我们对每个任务加上一个监控的"壳"，调度程序调用这个"壳"来完成对具体任务的引导和监控，相当于每个任务具有自治能力。这样做的好处有：

1. 分散控制。不需要修改调度主体程序，不增加调度过程的复杂度；
2. 控制灵活，安全性高。对于不同任务可定义不同控制方式和控制参数，封装在任务内部，灵活性好，对个别任务控制代码的修改不会影响其他任务，即任务控制实现松藕合，避免错误扩散。适合团队开发；
3. 维护简单，升级方便。对于新的任务加入也无需改变原来调度程序的结构，只需修改任务表及相关参数，这样在性能提高的同时也简化了软件升级过程中的代码维护量。

       3. 设计实现

       每个线程理论上有四种状态：

在实际操作中，为了便于描述，我们重新规定了线程的状态：

根据上述理论，我们只需要对Actived状态的线程进行监控，也只有对Actived状态监控才有意义，这是对监控模块做出逻辑简化。那么如何实现监控模块对具体任务的监控呢？

对具体任务的监控方式有多种，根据任务的不同，需要采用不同的监控代码，但是在结构上基本相同。这和类的重载概念有点相似。本文附有一个简单的例子。

A任务每秒执行一个简单的代数运算 j = 1/ i，并打印结果。我们故意在其中设置了一个异常陷阱，使得执行过程中出现一次被0除的算术异常，下面结合这个例子讲述监控原理。

为了监控A，我们设计了一个监控线程M。M中定义了一些关键逻辑变量：

为了适应监控，在A任务中相应增加一些可以被监控的状态和行为：

      如果是因为系统偶然因素导致A死亡，那么在随后的新的任务启动过程中一般可以顺利完成。但是万一由于环境参数改变或软件升级存在版本缺陷，A可能始终会产生异常，那么M是否需要耐心地监控下去呢？一个形象的例子是：如果你连续3次开机都失败，你是否会怀疑机器有问题？当然，你会，那么M也应该会。

      为了对A任务重复多次死亡有一个统计，M中又引入了另外对计数器和边界值（deadtimes和deadtimeout），和你开计算机的过程一样，如果连续n次都发现A有问题，可以基本肯定不是由于偶然因素引起的，需要对A的代码或系统的环境进行检查。M会发出告警，通知必须要对A进行审查了，然后清空A，自己自动安全退出。如果在核心调度程序中设置一个标志接受M们的告警，就可以有足够理由终止其他任务的执行。可以看见，在A任务发生异常期间，M承担了核心调度程序的维护功能。特别是当任务数量比较多的情况，核心调度程序只能采用排队方式处理任务异常，而且由于处理异常的复杂程度不同，无法保证对多任务异常的实时处理。

      还要考虑正常情况下A和M的关系。核心调度程序通过M启动A任务后，M处于持续监控状态，当A正常结束任务后，A需要通知M结束监控，这样，当A进入休眠状态后，M也不会占用内存空间，提高了系统资源的利用率。

      通过以上描述，可以看到，上述监控思想具有清晰的概念和可操作性，占用资源少，为保证系统连续稳定运行创造了条件。

具体代码实现附后。

运行结果如下：

异常情况 正常情况 i=-3: status=true M read A status = true i=-2: status=false M read A status = false i=-1: status=true M read A status = true A become Exception! M read A status = true M read A status = true M read A status = true A is deaded! M is restarting A! ____________________________ i=-3: status=false M read A status = false i=-2: status=true M read A status = true i=-1: status=false M read A status = false A become Exception! M read A status = false M read A status = false M read A status = false A is deaded! M is restarting A! ____________________________ i=-3: status=true M read A status = true i=-2: status=false M read A status = false i=-1: status=true M read A status = true A become Exception! M read A status = true M read A status = true M read A status = true Alert! A is unstable, M will stop it （结束） i=1: status=true M read A status = true i=2: status=false M read A status = false i=3: status=true M read A status = true i=4: status=false M read A status = false i=5: status=true M read A status = true A is Ending M M read A status = true （结束）

      4. 结束语

      通过给制定任务线程增加监控线程，可以很好地解决实时多任务环境下的安全监控问题，同时避免了核心调度线程事务过分复杂的问题。实践证明，该方法复杂度小，占用资源少，运行可靠，适合复杂条件下的多任务环境。

      5. 源代码：

// 核心调度程序
public class mythread {
public mythread() {  }
public static void main(String[] args) {
M m = new M();
}
}
// A 任务线程
class A extends Thread {
public static boolean dead = false;
M m;
A(M m){
m = m;
start();
}
public void run(){
try{
for(int i=-3;i<= 5;i++){
int j=1/i;   // 人为设置过程中陷阱
dead = !dead;  // 活动状态
System.out.println("i=" + i + ": status=" + dead);
try{
sleep(2000);
}
catch(InterruptedException ie){
System.out.println("A is Interrupted!");
}
}
m.Keepchecking = false;  //A 正常结束后关闭监控线程
System.out.println("A is Ending M");
}
catch(Exception e){
System.out.println("A become Exception!");
}
}
}
// 监控线程
class M extends Thread{
public static boolean Keepchecking = true;  // 持续监控标志
boolean laststatus;     //保存上次监控状态
int maydeadtimes = 0;  //监控线程可能死亡的计数器
int maydeadtimeout = 3;//定义判断线程死亡的边界条件
int deadtimes = 0;     //监控线程死亡次数的计数器
int deadtimeout = 3;   //定义判断线程不正常的边界条件
A a;
M(){start();}
public void run(){
schedule();
while(Keepchecking){
laststatus = a.dead;
try{
sleep(2000);
}
catch(InterruptedException e){
System.out.println("M is Interrupted!");
}
System.out.println("M read A status = " + a.dead);
if(laststatus == a.dead ){
if(++maydeadtimes >= maydeadtimeout){
if(++deadtimes >= deadtimeout){
System.out.println("Alert! A is unstable, M will stop it");
a = null;
break;
}
else{
System.out.println( "A is deaded!");
schedule();
System.out.println("M is restarting A!\n____________________________\n");
}
}
}
else{
maydeadtimes = 0;
}
}
}
private void schedule(){
A a = new A(this);
}
}

http://lavasoft.blog.51cto.com/

一、Java中的日期概述

日期在Java中是一块非常复杂的内容，对于一个日期在不同的语言国别环境中，日期的国际化，日期和时间之间的转换，日期的加减运算，日期的展示格式都是非常复杂的问题。

在Java中，操作日期主要涉及到一下几个类：

1、java.util.Date
类 Date 表示特定的瞬间，精确到毫秒。从 JDK 1.1 开始，应该使用 Calendar 类实现日期和时间字段之间转换，使用 DateFormat 类来格式化和分析日期字符串。Date 中的把日期解释为年、月、日、小时、分钟和秒值的方法已废弃。

2、java.text.DateFormat（抽象类）
DateFormat 是日期/时间格式化子类的抽象类，它以与语言无关的方式格式化并分析日期或时间。日期/时间格式化子类（如 SimpleDateFormat）允许进行格式化（也就是日期 -> 文本）、分析（文本-> 日期）和标准化。将日期表示为 Date 对象，或者表示为从 GMT（格林尼治标准时间）1970 年，1 月 1 日 00:00:00 这一刻开始的毫秒数。

3、java.text.SimpleDateFormat（DateFormat的直接子类）
SimpleDateFormat 是一个以与语言环境相关的方式来格式化和分析日期的具体类。它允许进行格式化（日期 -> 文本）、分析（文本 -> 日期）和规范化。
SimpleDateFormat 使得可以选择任何用户定义的日期-时间格式的模式。但是，仍然建议通过 DateFormat 中的 getTimeInstance、getDateInstance 或 getDateTimeInstance 来新的创建日期-时间格式化程序。

4、java.util.Calendar（抽象类）
Calendar 类是一个抽象类，它为特定瞬间与一组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR 等 日历字段之间的转换提供了一些方法，并为操作日历字段（例如获得下星期的日期）提供了一些方法。瞬间可用毫秒值来表示，它是距历元（即格林威治标准时间 1970 年 1 月 1 日的 00:00:00.000，格里高利历）的偏移量。
与其他语言环境敏感类一样，Calendar 提供了一个类方法 getInstance，以获得此类型的一个通用的对象。Calendar 的 getInstance 方法返回一个 Calendar 对象，其日历字段已由当前日期和时间初始化。

5、java.util.GregorianCalendar（Calendar的直接子类）
GregorianCalendar 是 Calendar 的一个具体子类，提供了世界上大多数国家使用的标准日历系统。
GregorianCalendar 是一种混合日历，在单一间断性的支持下同时支持儒略历和格里高利历系统，在默认情况下，它对应格里高利日历创立时的格里高利历日期（某些国家是在 1582 年 10 月 15 日创立，在其他国家要晚一些）。可由调用方通过调用 setGregorianChange() 来更改起始日期。


二、java.util.Date的使用

1、java.util.Date的API简介

类 java.util.Date 表示特定的瞬间，精确到毫秒。提供了很多的方法，但是很多已经过时，不推荐使用，下面仅仅列出没有过时的方法：

构造方法摘要
-------------
Date()
分配 Date 对象并用当前时间初始化此对象，以表示分配它的时间（精确到毫秒）。
Date(long date)
分配 Date 对象并初始化此对象，以表示自从标准基准时间（称为“历元（epoch）”，即 1970 年 1 月 1 日 00:00:00 GMT）以来的指定毫秒数。

方法摘要
-------------
boolean after(Date when)
测试此日期是否在指定日期之后。

boolean before(Date when)
测试此日期是否在指定日期之前。

Object clone()
返回此对象的副本。

int compareTo(Date anotherDate)
比较两个日期的顺序。

boolean equals(Object obj)
比较两个日期的相等性。

long getTime()
返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数。

int hashCode()
返回此对象的哈希码值。

void setTime(long time)
设置此 Date 对象，以表示 1970 年 1 月 1 日 00:00:00 GMT 以后 time 毫秒的时间点。

String toString()
把此 Date 对象转换为以下形式的 String： dow mon dd hh:mm:ss zzz yyyy 其中：
dow 是一周中的某一天 (Sun, Mon, Tue, Wed, Thu, Fri, Sat)。
mon 是月份 (Jan, Feb, Mar, Apr, May, Jun, Jul, Aug, Sep, Oct, Nov, Dec)。
dd 是一月中的某一天（01 至 31），显示为两位十进制数。
hh 是一天中的小时（00 至 23），显示为两位十进制数。
mm 是小时中的分钟（00 至 59），显示为两位十进制数。
ss 是分钟中的秒数（00 至 61），显示为两位十进制数。
zzz 是时区（并可以反映夏令时）。标准时区缩写包括方法 parse 识别的时区缩写。如果不提供时区信息，则 zzz 为空，即根本不包括任何字符。
yyyy 是年份，显示为 4 位十进制数。

下面是一个Date类的综合实例:
import java.util.Date;

/**
* Created by IntelliJ IDEA.
* User: leizhimin
* Date: 2007-11-30
* Time: 8:45:44
* 日期测试
*/
public class TestDate {
public static void main(String args[]) {
TestDate nowDate = new TestDate();
nowDate.getSystemCurrentTime();
nowDate.getCurrentDate();
}

/**
* 获取系统当前时间
* System.currentTimeMillis()返回系统当前时间，结果为1970年1月1日0时0分0秒开始，到程序执行取得系统时间为止所经过的毫秒数
* 1秒＝1000毫秒
*/
public void getSystemCurrentTime() {
System.out.println("----获取系统当前时间----");
System.out.println("系统当前时间 = " + System.currentTimeMillis());
}

/**
* 通过Date类获取当前日期和当前时间
* date.toString()把日期转换为dow mon dd hh:mm:ss zzz yyyy
*/
public void getCurrentDate() {
System.out.println("----获取系统当前日期----");
//创建并初始化一个日期（初始值为当前日期）
Date date = new Date();
System.out.println("现在的日期是 = " + date.toString());
System.out.println("自1970年1月1日0时0分0秒开始至今所经历的毫秒数 = " + date.getTime());
}
}

运行结果:
----获取系统当前时间----
系统当前时间 = 1196413077278
----获取系统当前日期----
现在的日期是 = Fri Nov 30 16:57:57 CST 2007
自1970年1月1日0时0分0秒开始至今所经历的毫秒数 = 1196413077278

Process finished with exit code 0


2、java.text.DateFormat抽象类的使用

DateFormat 是日期/时间格式化子类的抽象类，它以与语言无关的方式格式化并分析日期或时间。日期/时间格式化子类（如 SimpleDateFormat）允许进行格式化（也就是日期 -> 文本）、分析（文本-> 日期）和标准化。将日期表示为 Date 对象，或者表示为从 GMT（格林尼治标准时间）1970 年，1 月 1 日 00:00:00 这一刻开始的毫秒数。

DateFormat 提供了很多类方法，以获得基于默认或给定语言环境和多种格式化风格的默认日期/时间 Formatter。格式化风格包括 FULL、LONG、MEDIUM 和 SHORT。方法描述中提供了使用这些风格的更多细节和示例。

DateFormat 可帮助进行格式化并分析任何语言环境的日期。对于月、星期，甚至日历格式（阴历和阳历），其代码可完全与语言环境的约定无关。

要格式化一个当前语言环境下的日期，可使用某个静态工厂方法：
myString = DateFormat.getDateInstance().format(myDate);



如果格式化多个日期，那么获得该格式并多次使用它是更为高效的做法，这样系统就不必多次获取有关环境语言和国家约定的信息了。
DateFormat df = DateFormat.getDateInstance();
for (int i = 0; i < myDate.length; ++i) {
output.println(df.format(myDate[i]) + "; ");
}

要格式化不同语言环境的日期，可在 getDateInstance() 的调用中指定它。
DateFormat df = DateFormat.getDateInstance(DateFormat.LONG, Locale.FRANCE);

还可使用 DateFormat 进行分析。
myDate = df.parse(myString);

使用 getDateInstance 来获得该国家的标准日期格式。另外还提供了一些其他静态工厂方法。使用 getTimeInstance 可获得该国家的时间格式。使用 getDateTimeInstance 可获得日期和时间格式。可以将不同选项传入这些工厂方法，以控制结果的长度（从 SHORT 到 MEDIUM 到 LONG 再到 FULL）。确切的结果取决于语言环境，但是通常：
SHORT 完全为数字，如 12.13.52 或 3:30pm
MEDIUM 较长，如 Jan 12, 1952
LONG 更长，如 January 12, 1952 或 3:30:32pm
FULL 是完全指定，如 Tuesday, April 12, 1952 AD 或 3:30:42pm PST。

如果愿意，还可以在格式上设置时区。如果想对格式化或分析施加更多的控制（或者给予用户更多的控制），可以尝试将从工厂方法所获得的 DateFormat 强制转换为 SimpleDateFormat。这适用于大多数国家；只是要记住将其放入一个 try 代码块中，以防遇到特殊的格式。

还可以使用借助 ParsePosition 和 FieldPosition 的分析和格式化方法形式来：逐步地分析字符串的各部分。 对齐任意特定的字段，或者找出字符串在屏幕上的选择位置。

DateFormat 不是同步的。建议为每个线程创建独立的格式实例。如果多个线程同时访问一个格式，则它必须保持外部同步。

3、java.text.SimpleDateFormat（DateFormat的直接子类）的使用

SimpleDateFormat 是一个以与语言环境相关的方式来格式化和分析日期的具体类。它允许进行格式化（日期 -> 文本）、分析（文本 -> 日期）和规范化。

SimpleDateFormat 使得可以选择任何用户定义的日期-时间格式的模式。但是，仍然建议通过 DateFormat 中的 getTimeInstance、getDateInstance 或 getDateTimeInstance 来新的创建日期-时间格式化程序。每一个这样的类方法都能够返回一个以默认格式模式初始化的日期/时间格式化程序。可以根据需要使用 applyPattern 方法来修改格式模式。有关使用这些方法的更多信息，请参阅 DateFormat。

日期和时间模式
日期和时间格式由日期和时间模式 字符串指定。在日期和时间模式字符串中，未加引号的字母 'A' 到 'Z' 和 'a' 到 'z' 被解释为模式字母，用来表示日期或时间字符串元素。文本可以使用单引号 (') 引起来，以免进行解释。"''" 表示单引号。所有其他字符均不解释；只是在格式化时将它们简单复制到输出字符串，或者在分析时与输入字符串进行匹配。

定义了以下模式字母（所有其他字符 'A' 到 'Z' 和 'a' 到 'z' 都被保留）：
字母 日期或时间元素 表示 示例
G Era 标志符 Text AD
y 年 Year 1996; 96
M 年中的月份 Month July; Jul; 07
w 年中的周数 Number 27
W 月份中的周数 Number 2
D 年中的天数 Number 189
d 月份中的天数 Number 10
F 月份中的星期 Number 2
E 星期中的天数 Text Tuesday; Tue
a Am/pm 标记 Text PM
H 一天中的小时数（0-23） Number 0
k 一天中的小时数（1-24） Number 24
K am/pm 中的小时数（0-11） Number 0
h am/pm 中的小时数（1-12） Number 12
m 小时中的分钟数 Number 30
s 分钟中的秒数 Number 55
S 毫秒数 Number 978
z 时区 General time zone Pacific Standard Time; PST; GMT-08:00
Z 时区 RFC 822 time zone -0800

更多的参考信息可以查看JDK API文档,下面给出一个综合实例:

import java.util.Date;
import java.util.Locale;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;

/**
* Created by IntelliJ IDEA.
* User: leizhimin
* Date: 2007-11-30
* Time: 11:20:58
* To change this template use File | Settings | File Templates.
*/
public class TestSimpleDateFormat {
public static void main(String args[]) throws ParseException {
TestSimpleDateFormat test = new TestSimpleDateFormat();
test.testDateFormat();

}

public void testDateFormat() throws ParseException {
//创建日期
Date date = new Date();

//创建不同的日期格式
DateFormat df1 = DateFormat.getInstance();
DateFormat df2 = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss EE");
DateFormat df3 = DateFormat.getDateInstance(DateFormat.FULL, Locale.CHINA); //产生一个指定国家指定长度的日期格式，长度不同，显示的日期完整性也不同
DateFormat df4 = new SimpleDateFormat("yyyy年MM月dd日 hh时mm分ss秒 EE", Locale.CHINA);
DateFormat df5 = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss EEEEEE", Locale.US);
DateFormat df6 = new SimpleDateFormat("yyyy-MM-dd");
DateFormat df7 = new SimpleDateFormat("yyyy年MM月dd日");

//将日期按照不同格式进行输出
System.out.println("-------将日期按照不同格式进行输出------");
System.out.println("按照Java默认的日期格式，默认的区域 : " + df1.format(date));
System.out.println("按照指定格式 yyyy-MM-dd hh:mm:ss EE ，系统默认区域 :" + df2.format(date));
System.out.println("按照日期的FULL模式，区域设置为中文 : " + df3.format(date));
System.out.println("按照指定格式 yyyy年MM月dd日 hh时mm分ss秒 EE ，区域为中文 : " + df4.format(date));
System.out.println("按照指定格式 yyyy-MM-dd hh:mm:ss EE ，区域为美国 : " + df5.format(date));
System.out.println("按照指定格式 yyyy-MM-dd ，系统默认区域 : " + df6.format(date));

//将符合该格式的字符串转换为日期，若格式不相配，则会出错
Date date1 = df1.parse("07-11-30 下午2:32");
Date date2 = df2.parse("2007-11-30 02:51:07 星期五");
Date date3 = df3.parse("2007年11月30日 星期五");
Date date4 = df4.parse("2007年11月30日 02时51分18秒 星期五");
Date date5 = df5.parse("2007-11-30 02:51:18 Friday");
Date date6 = df6.parse("2007-11-30");

System.out.println("-------输出将字符串转换为日期的结果------");
System.out.println(date1);
System.out.println(date2);
System.out.println(date3);
System.out.println(date4);
System.out.println(date5);
System.out.println(date6);
}
}

运行结果:
-------将日期按照不同格式进行输出------
按照Java默认的日期格式，默认的区域 : 07-11-30 下午5:04
按照指定格式 yyyy-MM-dd hh:mm:ss EE ，系统默认区域 :2007-11-30 05:04:10 星期五
按照日期的FULL模式，区域设置为中文 : 2007年11月30日 星期五
按照指定格式 yyyy年MM月dd日 hh时mm分ss秒 EE ，区域为中文 : 2007年11月30日 05时04分10秒 星期五
按照指定格式 yyyy-MM-dd hh:mm:ss EE ，区域为美国 : 2007-11-30 05:04:10 Friday
按照指定格式 yyyy-MM-dd ，系统默认区域 : 2007-11-30
-------输出将字符串转换为日期的结果------
Fri Nov 30 14:32:00 CST 2007
Fri Nov 30 02:51:07 CST 2007
Fri Nov 30 00:00:00 CST 2007
Fri Nov 30 02:51:18 CST 2007
Fri Nov 30 02:51:18 CST 2007
Fri Nov 30 00:00:00 CST 2007

Process finished with exit code 0

4、java.util.Calendar（抽象类）

java.util.Calendar是个抽象类，是系统时间的抽象表示，它为特定瞬间与一组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR 等 日历字段之间的转换提供了一些方法，并为操作日历字段（例如获得下星期的日期）提供了一些方法。瞬间可用毫秒值来表示，它是距历元（即格林威治标准时间 1970 年 1 月 1 日的 00:00:00.000，格里高利历）的偏移量。

与其他语言环境敏感类一样，Calendar 提供了一个类方法 getInstance，以获得此类型的一个通用的对象。Calendar 的 getInstance 方法返回一个 Calendar 对象，其日历字段已由当前日期和时间初始化。

一个Calendar的实例是系统时间的抽象表示，从Calendar的实例可以知道年月日星期月份时区等信息。Calendar类中有一个静态方法get(int x),通过这个方法可以获取到相关实例的一些值（年月日星期月份等）信息。参数x是一个产量值，在Calendar中有定义。

Calendar中些陷阱，很容易掉下去：
1、Calendar的星期是从周日开始的，常量值为0。
2、Calendar的月份是从一月开始的，常量值为0。
3、Calendar的每个月的第一天值为1。

5、java.util.GregorianCalendar（Calendar的直接子类）

GregorianCalendar 是 Calendar 的一个具体子类，提供了世界上大多数国家使用的标准日历系统。结合Calendar抽象类使用。

下面给出一个综合实例看看Calendar类的用法：

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

/**
* Created by IntelliJ IDEA.
* User: leizhimin
* Date: 2007-11-30
* Time: 15:06:57
* Calendar的使用测试
*/
public class TestCalendar {
public static void main(String args[]) {
TestCalendar testCalendar = new TestCalendar();
testCalendar.testCalendar();

}

public void testCalendar() {
//创建Calendar的方式
Calendar now1 = Calendar.getInstance();
Calendar now2 = new GregorianCalendar();
Calendar now3 = new GregorianCalendar(2007, 10, 30);
Calendar now4 = new GregorianCalendar(2007, 10, 30, 15, 55); //陷阱:Calendar的月份是0~11
Calendar now5 = new GregorianCalendar(2007, 10, 30, 15, 55, 44);
Calendar now6 = new GregorianCalendar(Locale.US);
Calendar now7 = new GregorianCalendar(TimeZone.getTimeZone("GMT-8:00"));

//通过日期和毫秒数设置Calendar
now2.setTime(new Date());
System.out.println(now2);

now2.setTimeInMillis(new Date().getTime());
System.out.println(now2);

//定义日期的中文输出格式,并输出日期
SimpleDateFormat df = new SimpleDateFormat("yyyy年MM月dd日 hh时mm分ss秒 E", Locale.CHINA);
System.out.println("获取日期中文格式化化输出：" + df.format(now5.getTime()));
System.out.println();

System.out.println("--------通过Calendar获取日期中年月日等相关信息--------");
System.out.println("获取年：" + now5.get(Calendar.YEAR));
System.out.println("获取月(月份是从0开始的)：" + now5.get(Calendar.MONTH));
System.out.println("获取日：" + now5.get(Calendar.DAY_OF_MONTH));
System.out.println("获取时：" + now5.get(Calendar.HOUR));
System.out.println("获取分：" + now5.get(Calendar.MINUTE));
System.out.println("获取秒：" + now5.get(Calendar.SECOND));
System.out.println("获取上午、下午：" + now5.get(Calendar.AM_PM));
System.out.println("获取星期数值(星期是从周日开始的)：" + now5.get(Calendar.DAY_OF_WEEK));
System.out.println();

System.out.println("---------通用星期中文化转换---------");
String dayOfWeek[] = {"", "日", "一", "二", "三", "四", "五", "六"};
System.out.println("now5对象的星期是:" + dayOfWeek[now5.get(Calendar.DAY_OF_WEEK)]);
System.out.println();

System.out.println("---------通用月份中文化转换---------");
String months[] = {"一月", "二月", "三月", "四月", "五月", "六月", "七月", "八月", "九月", "十月", "十一月", "十二月"};
System.out.println("now5对象的月份是: " + months[now5.get(Calendar.MONTH)]);
}
}

运行结果：
java.util.GregorianCalendar[time=1196414388324,areFieldsSet=true,areAllFieldsSet=true,lenient=true,zone=sun.util.calendar.ZoneInfo[id="Asia/Shanghai",offset=28800000,dstSavings=0,useDaylight=false,transitions=19,lastRule=null],firstDayOfWeek=1,minimalDaysInFirstWeek=1,ERA=1,YEAR=2007,MONTH=10,WEEK_OF_YEAR=48,WEEK_OF_MONTH=5,DAY_OF_MONTH=30,DAY_OF_YEAR=334,DAY_OF_WEEK=6,DAY_OF_WEEK_IN_MONTH=5,AM_PM=1,HOUR=5,HOUR_OF_DAY=17,MINUTE=19,SECOND=48,MILLISECOND=324,ZONE_OFFSET=28800000,DST_OFFSET=0]
java.util.GregorianCalendar[time=1196414388324,areFieldsSet=true,areAllFieldsSet=true,lenient=true,zone=sun.util.calendar.ZoneInfo[id="Asia/Shanghai",offset=28800000,dstSavings=0,useDaylight=false,transitions=19,lastRule=null],firstDayOfWeek=1,minimalDaysInFirstWeek=1,ERA=1,YEAR=2007,MONTH=10,WEEK_OF_YEAR=48,WEEK_OF_MONTH=5,DAY_OF_MONTH=30,DAY_OF_YEAR=334,DAY_OF_WEEK=6,DAY_OF_WEEK_IN_MONTH=5,AM_PM=1,HOUR=5,HOUR_OF_DAY=17,MINUTE=19,SECOND=48,MILLISECOND=324,ZONE_OFFSET=28800000,DST_OFFSET=0]
获取日期中文格式化化输出：2007年11月30日 03时55分44秒 星期五

--------通过Calendar获取日期中年月日等相关信息--------
获取年：2007
获取月(月份是从0开始的)：10
获取日：30
获取时：3
获取分：55
获取秒：44
获取上午、下午：1
获取星期数值(星期是从周日开始的)：6

---------通用星期中文化转换---------
now5对象的星期是:五

---------通用月份中文化转换---------
now5对象的月份是: 十一月

Process finished with exit code 0

三、总结
Java中日期的经常有一下五个方面：
1、创建日期
2、日期格式化显示
3、日期的转换（主要是和字符串之间的相互转换）
4、日期中年、月、日、时、分、秒、星期、月份等获取。
5、日期的大小比较、日期的加减。
这也是学习java日期操作的难点和关键，掌握了这些，日期问题一般难不倒你。

关于日期的大小比较和加减在API文档中都有详尽的描述。

做项目的时候，用到了JfreeChart。但是在时间轴刻度的显示上出现了问题。在设置dateAxis.setAutoTickUnitSelection(true)后，当时间间隔比较小的时候，同一时间段会显示多个相同的时间。我一直没有查出原因，在网上也没有搜到相关的问题和解决办法，感觉是JfreeChart的问题。一直想了解JfreeChart是如何自动设置时间刻度，但没有头绪。于是，增加了判断当时间间隔 >10天的时候，自动设置时间刻度；反之，以1天为间隔设置。这样问题解决了，经过测试，也没有发现相同时间刻度的情况的出现。
long maximumDate = dateAxis.getMaximumDate().getTime();
long minimumDate = dateAxis.getMinimumDate().getTime();
long times = (maximumDate - minimumDate)/(3600*24*1000);

if(times<10){
dateAxis.setTickUnit(new DateTickUnit(DateTickUnit.DAY, 1, dateFormat));
}
else{
dateAxis.setAutoTickUnitSelection(true);
}
尽管这样还是感觉这样解决问题不是很好。

在解决问题过程中，遇到了关于对日期的处理问题。在网上找了资料，发现上面那篇不错还，就拿过来了，以后遇到日期问题也好有个参考，不用再东找西找了。