妙用Commons良药

妙用commons良药<一> 
这一篇文章主要是讲Commons IO的一些内容. 
Commons IO提供了org.apache.commons.io.CopyUtils类来将某个InputStream,Reader,byte[]数据或字符串的内容拷贝到OutputStream或Writer. 

Writer writer = new FileWriter( "test.dat" );
InputStream inputStream =
    getClass( ).getResourceAsStream("./test.resource");
CopyUtils.copy( inputStream, writer );
writer.close( );
inputStream.close( );

如果需要把信息从Reader或InputStream拷贝到字符串中,请使用IOUtils.toString()方法. 

InputStream inStream = url.openStream( );
String contents = IOUtils.toString( inStream );

通过org.apache.commons.io.IOUtils,你可以很好地关闭某个InputStream,OutputStream,Reader或Writer,而不必担心null或IOException. 

try {
    File file = new File( "test.dat" );
    reader = new FileReader( file );
    result = CopyUtils.toString( reader );
} catch( IOException ioe ) {
    System.out.println( "Unable to copy file test.dat to a String." );
} finally {
    IOUtils.closeQuietly( reader );
}

使用FileUtils.byteCountToDisplaySize()生成一个字符串,该字符串含有有一个近似的比较好理解的文件的相对大小的值. 

File file = new File("project.xml");
long bytes = file.length( );
String display = FileUtils.byteCountToDisplaySize( bytes );

如果需要将一个文件拷贝为另一个文件,或者需要将某个文件拷贝到某一个目录中,可以使用如下的代码: 
拷贝为另一个文件: 

File src = new File( "test.dat" );
file dest = new File( "test.dat.bak" );
FileUtils.copyFile( src, dest );

拷贝到某一个目录: 

File src = new File( "test.dat" );
File dir = new File( "./temp" );
FileUtils.copyFileToDirectory( src, dir );

使用Commons IO,你也可以很方便把字符串的内容写入文件中去,具体的过程不用怎么理会: 

String string = "Blah blah blah";
File dest = new File( "test.tmp" );
FileUtils.writeStringToFile( dest, string);

当然,有另外的一个功能,可以将URL的内容存入文件中去: 

URL src = new URL( "http://www." );
File dest = new File( "times.html" );
FileUtils.copyURLToFile( src, dest );

如果你需要删除一个目录下的所有内容(包括其目录),可以这样做: 

File dir = new File( "temp" );
FileUtils.deleteDirectory( dir );

如果只想清空目录下所有内容,并不删除该目录,可以这样写:FileUtils.cleanDirectory( dir ); 


很简单地,可以得到一个目录的大小: 

File dir = new File( "temp" );
long dirSize = FileUtils.sizeOfDirectory( );

如果你想得到某个目录下所有以.txt结尾的文件,可以如下这样做: 

import java.io.FilenameFilter;
import org.apache.commons.io.filefilter.SuffixFileFilter;
import org.apache.commons.lang.ArrayUtils;

File rootDir = new File(".");
FilenameFilter fileFilter = new SuffixFileFilter(".txt");
String[] txtFiles = rootDir.list( fileFilter );
System.out.println( ArrayUtils.toString( txtFiles ) );

举另一个例子,怎样列出目录中以.htm和.html结尾的文件 

import org.apache.commons.io.filefilter.AndFileFilter;
import org.apache.commons.io.filefilter.DirectoryFileFilter;
import org.apache.commons.io.filefilter.IOFileFilter;
import org.apache.commons.io.filefilter.NotFileFilter;
import org.apache.commons.io.filefilter.OrFileFilter;
import org.apache.commons.io.filefilter.SuffixFileFilter;
import org.apache.commons.lang.ArrayUtils;

IOFileFilter htmlFilter =
    new OrFileFilter( new SuffixFileFilter("htm"),new SuffixFileFilter("html") ); //复合两个SuffixFileFilter
IOFileFilter notDirectory = new NotFileFilter( DirectoryFileFilter.INSTANCE );    //拒绝选择目录
FilenameFilter fileFilter = new AndFileFilter( htmlFilter, notDirectory );
String[] htmlFiles = rootDir.list(fileFilter);
System.out.println( ArrayUtils.toString( htmlFiles ));

注:文中代码来之<<Jakarta Commons Cookbook>>一书第十章 
文章待续,会写一些关于commons的笔录下来 

 

妙用Commons良药<二> 

谈谈怎么用org.apache.commons.lang.StringUtils这一个类,讲一下具体的几个常用的方法 
使用StringUtils.isBlank(),该方法在收到空字符串,零长度字符串或全为空格的字符串时将返回true.它能通过返回true的方式优雅地处理null． 

String test = "";
String test2 = "\n\n\t";
String test3 = null;
String test4 = "Test";
System.out.println( "test blank? " + StringUtils.isBlank( test ) );
System.out.println( "test2 blank? " + StringUtils.isBlank( test2 ) );
System.out.println( "test3 blank? " + StringUtils.isBlank( test3 ) );
System.out.println( "test4 blank? " + StringUtils.isBlank( test4 ) );

前面三个返回true,返回一个返回false 


同样，有一个StringUtils.isNotBlank（）方法，当一个字符串里面为空，或只包含空格，或是null时，该方法将返回false,该方法的作用相当于： 

if( variable != null &&  variable.length( ) > 0 && !variable.trim( ).equals("") ) {
        // Do something
}

接下来，介绍一个非常有用的方法StringUtils.abbreviate(),该方法接受一个字符串，如果可以的话就缩减它，如果要把一个字符串缩减为20个字符长，而原字符串长度小于２０个字符长，则该方法将返回原文本．若原字符串长度大于20个字符，则显示17个字符和3个省略号. 

String test = "This is a test of the abbreviation."
String test2 = "Test"
System.out.println( StringUtils.abbreviate( test, 10 ) );
System.out.println( StringUtils.abbreviate( test2, 10 ) );

结果如下： 
This is... 
Test 
另外一点，可以使用StringUtils.split(),并提供一系列字符作为分隔符,StringUtils.chomp()去除字符串的末行终止序列． 



接下来，看一下StringUtils.substringBetween（）方法，看下面一个例子： 

String variables = "{45}, {35}, {120}" ;
List numbers = new ArrayList( );

String variablesTemp = variables;
while( StringUtils.substringBetween( variablesTemp, "{", "}" ) != null ) {
    String numberStr = StringUtils.substringBetween( variables, "{", "}" );
    Double number = new Double( numberStr );
    numbers.add( number );
    variablesTemp = variablesTemp.substring( variablesTemp.indexOf(",") );
}
double sum = StatUtil.sum( ArrayUtils.toPrimitive( numbers.toArray( ) ) );
System.out.println( "Variables: " + variables + ", Sum: " + sum );

其结果如下： 
Variable: {45}, {35}, {120}, Sum: 200 


如果字符串的首尾含有需要清除的字符，可使用StringUtils.strip()清除它们．看下面例子： 

String original = "-------***---SHAZAM!---***-------";
String stripped = StringUtils.strip( original, "-*" );
System.out.println( "Stripped: " + stripped )

结果如下： 
Stripped: SHAZAM! 



增加一点，StringUtils.reverse()可以实现字符串的反转，StringUtils.reverseDelimited()能够分隔符反向排列字符串中的标记．举例： 

public Sentence reverseSentence(String sentence) {
    String reversed = StringUtils.chomp( sentence, "." );
    reversed = StringUtils.reverseDelimited( reversed, ' ' );
    reversed = reversed + ".";
    return reversed;
}
String sentence = "I am Susan."
String reversed = reverseSentence( sentence ) );
System.out.println( sentence );
System.out.println( reversed );

结果如下: 
I am Susan. 
Susan am I.： 


当然，还可以检测字符串内容，isNumeric( ),isAlpha(),isAlphanumeric(),and isAlphaSpace()这几个方法用来验证用户输入的正确性，验证字符串的内容是否为数字，是否字符，是否为数字＋字符，是否为字符＋空格． 


如果你需要检查一个大文件里面一个字符串出现的次数，可以为StringUtils.countMatches()这一个方法，下面举一个比较好的例子，不能将整个文件放入内存中，相对比较合理的做法是一次一行地统计,其方法如下： 

public  int testNumber() throws Exception{
       File manuscriptFile = new File("c:\\test.txt");
       Reader reader = new FileReader(manuscriptFile);
       LineNumberReader lineReader = new LineNumberReader(reader);
       int number = 0;
       while(lineReader.ready()){
           String line = StringUtils.lowerCase(lineReader.readLine());
           number += StringUtils.countMatches(line, "test");
       }
       return number;

   }

 

这一篇文章主要是介绍怎样用Commons处理XMl文件 
1、将XML文档转化为你想要的对象 
   可以使用org.apache.commons.digester.Digester来实现你想要的功能，其步骤如下：定义待匹配的模式，以及遇到之些模式时将执行的动作，通过Digester可以很容易地实现你自己的SAX解析器，并让你无须处理复杂的SAX API，即可完成你想要的功能。Digester只是SAX外面的一个轻量级外壳，其解析的速度差不多和SAX一样快的。 
   看一个XML文件: 

<?xml version="1.0"?>
<plays>
  <play genre="tragedy" year="1603" language="english">
    <name>Hamlet</name>
    <author>William Shakespeare</author>
    <summary>
      Prince of Denmark freaks out, talks to ghost, gets into a
      crazy nihilistic funk, and dies in a duel.
    </summary>
    <characters>
      <character protagonist="false">
        <name>Claudius</name>
        <description>King of Denmark</description>
      </character>
      <character protagonist="true">
        <name>Hamlet</name>
        <descr> Son to the late, and nephew of the present king </descr>
      </character>
      <character protagonist="false">
        <name>Horatio</name>
        <descr>friend to Hamlet </descr>
      </character>
    </characters>
  </play>
</plays>

为了解析这一个配置文件的内容，相对应地我们写出下面的类： 

public class Play {
    private String genre;
    private String year;
    private String language;
    private String name;
    private String author;
    private String summary;
    private List characters = new ArrayList( );
    // accessors omitted for brevity
    // Add method to support adding elements to characters.
    public void addCharacter(Character character) {
        characters.add( character );
    }
}
public class Character {
    private String name;
    private String description;
    private boolean protagonist;
    // accessors omitted for brevity
}

下一步，写出Digester的配置文件: 

<?xml version="1.0"?>
<digester-rules>
  <pattern value="plays/play">
    <object-create-rule classname="xml.digester.Play"/>
    <set-next-rule methodname="add" paramtype="java.lang.Object"/>
    <set-properties-rule/>
    <bean-property-setter-rule pattern="name"/>
    <bean-property-setter-rule pattern="summary"/>
    <bean-property-setter-rule pattern="author"/>
    <pattern value="characters/character">
      <object-create-rule classname="xml.digester.Character"/>
      <set-next-rule methodname="addCharacter"
                     paramtype="xml.digester.Character"/>
      <set-properties-rule/>
      <bean-property-setter-rule pattern="name"/>
      <bean-property-setter-rule pattern="descr"
                                 propertyname="description"/>
    </pattern>
  </pattern>
</digester-rules>

下面是其解析的过程,是不是相对于SAX来说简单多了啊,呵呵: 

import org.apache.commons.digester.Digester;
import org.apache.commons.digester.xmlrules.DigesterLoader;

List plays = new ArrayList( );
// Create an instance of the Digester from the XML rule set
URL rules = getClass( ).getResource("./play-rules.xml");
Digester digester = DigesterLoader.createDigester(rules);
// Push a reference to the plays List on to the Stack
digester.push(plays);

// Parse the XML document
InputStream input = getClass( ).getResourceAsStream("./plays.xml");
Object root = digester.parse(input);

// The XML document contained one play "Hamlet"
Play hamlet = (Play) plays.get(0);
List characters = (List) hamlet.getCharacters( );

2、将Beans转化为XML文档 
使用Commons Betwixt里面的org.apache.commons.betwixt.io.BeanWriter类可以把某个bean转换为一个xml文档,看下面的例子： 

Play play = new Play( );
// populatePlay populates all properties and nested Character objects
populatePlay( play );
// Write XML document
BeanWriter beanWriter = new BeanWriter( );
beanWriter.enablePrettyPrint( );
beanWriter.write( play );
System.out.println( beanWriter.toString( ) );

短短的几行代码就可以实现这一个功能了，简单吧;注意一下，beanWriter.enablePrettyPrint( )是启用缩进格式. 

BeanWriter 类还用于向某个OutputStream或Writer写入XML文档，只要向其构造函数传一个Writer或OutputStream实例即可. 

import org.apache.commons.betwixt.io.BeanWriter

Play play = new Play( );
populatePlay( play );

Writer outputWriter = new FileWriter("test.dat");
BeanWriter beanWriter = new BeanWriter( outputWriter );
beanWriter.setEndOfLine( "\r\n" );
beanWriter.setIndent( "\t" );
beanWriter.enablePrettyPrint( );
beanWriter.write( play );
outputWriter.close( );

另外提示一下，beanWriter.setEndOfLine()方法可接受一个String作为行结束序列。beanWriter.setIndent()方法接受一个String参数，该String将在BeanWriter中enablePrettyPrint()开启缩进时用作缩进字符串。 

3、转换ＸＭＬ文档为Beans 
其实这一部分的内容和第一部分的内容差不多有点类似的，有兴趣的朋友可以对比一下. 
Commons Betwixt使用Commons Digester解析XML，而BeanReader即为Digester的一个子类。BeanReader使用自省机制以及类路径中的Betwixt映射文件来创建了一组Digester规则. 
举例，有一个XMl文件就为前面第一个ＸＭＬ文件 

import org.apache.commons.betwixt.io.BeanReader;

InputStream customPlay =
    getClass( ).getResourceAsStream("./customized-play.xml");
BeanReader beanReader = new BeanReader( );
beanReader.getXMLIntrospector( ).setWrapCollectionsInElement(false);
beanReader.registerBeanClass(Play.class);
Play play = (Play) beanReader.parse( customPlay );

注：些文章中的代码来自<<Jakarta Commons Cookbook>>第六章内容

 

妙用Commons良药<四> 

谈一谈Math包的一点内容，和怎样对属性文件,xml文件进行访问 
1、关于org.apache.commons.lang.math的应用 
可使用Commons Lang的NumberUtils.max()和NumberUtils.min()方法来从基本类型数组(如

double[],float[],long[],int[],short[],byte[])中检索出最小或最大值.举例:
import org.apache.commons.lang.math.NumberUtils;

double[] array = {0.2, 0.4, 0.5, -3.0, 4.223, 4.226};
double max = NumberUtils.max( array ); // returns 4.226
double min = NumberUtils.min( array ); // returns -3.0

当然,你可以处理数学的范围,需要为某个变量定义一组可接受的值,并检测该变量值是否落在指定的范围内.Range是一个接口，定义了一个简单的数值范围，它有几个不同的实现，如NumberRange,DoubleRange,FloatRange,IntRange以及LongRange等等. 

import org.apache.commons.lang.math.DoubleRange;
import org.apache.commons.lang.math.Range;

Range safeSpeed = new DoubleRange( 0.0, 65.0 );
double currentSpeed = getCurrentSpeed( );
if( !safeSpeed.containsDouble( currentSpeed ) ) {
    System.out.println( "Warning, current speed is unsafe." );
}

如果你想生成一个随机数，可以这样写： 

import org.apache.commons.lang.math.RandomUtils;

// Create a random integer between 0 and 30
int maxVal = 30;
int randomInt = RandomUtils.nextInt( maxVal );

其作用相当于：int randomInt = (int) Math.floor( (Math.random( ) * (double) maxVal) ); 
此外提示一点，RandomUtils.nextBoolean()可以返回一个随机的boolean变量 


2、关于Jakarta Commons Math包一点应用 
举一个例子，如下： 

import org.apache.commons.math.stat.StatUtils;

double[] values = new double[] { 2.3, 5.4, 6.2, 7.3, 23.3 };
System.out.println( "min: " + StatUtils.min( values ) );
System.out.println( "max: " + StatUtils.max( values ) );
System.out.println( "平均值: " + StatUtils.mean( values ) );
System.out.println( "积: " + StatUtils.product( values ) );
System.out.println( "和: " + StatUtils.sum( values ) );
System.out.println( "方差: " + StatUtils.variance( values ) );

当然，这一个包也可以处理复数，矩阵，统计以及线性方程，具体的用法参考官方的文档 


3、使用Commons Configuration包配置应用程序 
如果想访问属性文件的话，可以运用PropertiesConfiguration这一个类： 
属性文件如下： 
speed=23.332 
names=Bob,Gautam,Jarret,Stefan 
correct=false 

其代码如下：
import org.apache.commons.configuration.Configuration;
import org.apache.commons.configuration.PropertiesConfiguration;

Configuration config = new PropertiesConfiguration( "test.properties" );
float speed = config.getFloat("speed"));
List names = config.getList("names"));
boolean correct = config.getBoolean("correct");

如果想访问一个xml文件里面具体的属性，可以使用XMLConfiguration的一个实现从某个文档中加载配置参数。举例如下： 
其配置文件： 

<?xml version="1.0" encoding="ISO-8859-1" ?>
<engine-config>
    <start-criteria>
        <criteria type="critical">
            Temperature Above -10 Celsius
        </criteria>
        <criteria> Fuel tank is not empty </criteria>
    </start-criteria>
    <name>
        <first>Tom</first>
        <last>Payne</last>
    </name>
    <horsepower>42</horsepower>
</engine-config>

具体访问的代码如下： 

import org.apache.commons.configuration.Configuration;
import org.apache.commons.configuration.DOMConfiguration;

String resource = "com/discursive/jccook/configuration/global.xml";
Configuration config = new DOMConfiguration(resource);
// Retrieve a list of all Criteria elements
List startCriteria = config.getList("start-criteria.criteria");
// Retrieve the value of the first criteria element
String firstCriteria = config.getString("start-criteria.criteria(0)");
// Retrieve the type attribute of the first criteria element
String firstCriteriaType = config.getString("start-criteria.criteria(0)[@type]");
// Retrieve the horsepower as an int
int horsepower = config.getInt("horsepower");

 

这一篇文章主要是讲一下关于Commons开源项目中其Commons BeanUtils的一些相关的用法. 

1、复制Bean属性 
如果你有两个相同的Bean的实例，并需要将其中的一个bean属性复制到另一个中去,调用PropertyUtils.copyProperties（）即可，这一个方法经常在使用struts,hibernate等框架的时候常常用到.举例： 

import org.apache.commons.beanutils.PropertyUtils;

Book book = new Book( );
book.setName( "Prelude to Foundation" );
book.setAuthorName( "Asimov" );
Book destinationBook = new Book( );
PropertyUtils.copyProperties( destinationBook, book );

请注意，该方法是将相同的引用对象赋给目的的bean,并没有克隆bean属性的值. 


2、怎样使用Map来封装Bean 
假如你需要将bean的属性传入Map 
可使用BeanMap类封装任何Bean。该Map通过内省机制提供了对bean属性的访问，使得其看上去像是Map中成对的键与值.举例： 

import java.util.*;
import org.apache.commons.beanutils.PropertyUtils;

// Create a Person and a Book bean instance
Person person = new Person( );
person.setName( "Some Dude" );

Book book = new Book( );
book.setName( "Some Silly Computer Book" );
book.setAuthor( person );

// Describe both beans with a Map
Map bookMap = PropertyUtils.describe( book );
Map authorMap = PropertyUtils.describe( bookMap.get("book") );
System.out.println( "Book Name: " + bookMap.get( "name" ) );
System.out.println( "Author Name: " + authorMap.get( "name" ) );

注意一点，如果你修改了BeanMap的时候，你也就修改了其内部的Bean. 
还有常用的clear(),setBean(Object bean)等方法 


3、可以根据Bean的属性来比较Beans 
使用BeanComparator可根据bean属性来比较两个Bean.兴例如下： 

import java.util.*;
import org.apache.commons.beanutils.BeanComparator;

Country country1 = new Country( );
country1.setName( "India" );
Country country2 = new Country( );
country2.setName( "Pakistan" );
Country country3 = new Country( );
country3.setName( "Afghanistan" );

// Create a List of Country objects
Country[] countryArray = new Country[] { country1, country2, country3 };
List countryList = Arrays.asList( countryArray );

// Sort countries by name
Comparator nameCompare = new BeanComparator( "name" );
Collections.sort( countryList, nameCompare );

System.out.println( "Sorted Countries:" );
Iterator countryIterator = countryList.iterator( );
while( countryIterator.hasNext( ) ) {
    Country country = (Country) countryIterator.next( );
    System.out.println( "\tCountry: " + country.getName( ) );
}

结果显示如下： 

引用

Sorted Countries: 
    Country: Afghanistan 
    Country: India 
    Country: Pakistan 

注：文章中的代码均来之<<Jakarta  Commons Cookbook>>一书第三章

 

妙用Commons良药 <六> 
1、定义toString(),hashCode(),equals()等内容 
toString()方法举例： 

import org.apache.commons.lang.builder.ToStringBuilder;
import org.apache.commons.lang.builder.ToStringStyle;

public String toString( ) {
    return new ToStringBuilder(this, ToStringStyle.MULTI_LINE_STYLE)
                   .append("lastName", lastName)
                   .append("firstName", firstName)
                   .toString( );
}

提示一点，ToStringBuilder(this, ToStringStyle.MULTI_LINE_STYLE)，第二个参数当然也可以为ToStringStyle.DEFAULT_STYLE,ToStringStyle.NO_FIELD_NAMES_STYLE和ToStringStyle.SIMPLE_STYLE 


hashCode()与equals()方法举例: 

import org.apache.commons.lang.builder.HashCodeBuilder;
import org.apache.commons.lang.builder.EqualsBuilder;

public class PoliticalCandidate {
    public int hashCode( ) {
        return new HashCodeBuilder(17, 37) //两个不为0且非偶的质数
                       .append(firstName)
                       .append(lastName).toHashCode( );
    }

    public boolean equals(Object o) {
        boolean equals = false;
        if ( o != null &&
            PoliticalCandidate.class.isAssignableFrom(o) ) {
            PoliticalCandidate pc = (PoliticalCandidate) o;
            equals = (new EqualsBuilder( )
                       .append(firstName, ps.firstName)
                       .append(lastName, ps.lastName)).isEquals( );
        }
        return equals;
    }
}

2、操作数组内容 
ArrayUtils.toString()方法可以输入数组内容，此方法接受任意一个数组作为参数并输出其内容，输出时所有元素位于大括号，中间逗号隔开.举例： 

int[] intArray = new int[] { 2, 3, 4, 5, 6 };
int[] multiDimension = new int[][] { { 1, 2, 3 }, { 2, 3 }, {5, 6, 7} };
System.out.println( "intArray: " + ArrayUtils.toString( intArray ) );
System.out.println( "multiDimension: " + ArrayUtils.toString( multiDimension ) );

使用ArrayUtils.reverse()方法可以反转一个数组. 
使用ArrayUtils.toObject()和ArrayUtils.toPrimitive()两个方法，即可互相转换基本类型数组和对象数组。 


当然，Commons也提供了方便的方法，可以在数组中搜索特定项. 
使用ArrayUtils.contains()方法可以判定数组是否存在指完元素.当然有两个比较实用的方法ArrayUtils.lastIndexOf()和ArrayUtils.indexOf(),举例如下： 

import org.apache.commons.lang.ArrayUtils;

String[] stringArray = { "Red", "Orange", "Blue", "Brown", "Red" };
boolean containsBlue = ArrayUtils.contains( stringArray, "Blue" );
int indexOfRed = ArrayUtils.indexOf( stringArray, "Red");
int lastIndexOfRed = ArrayUtils.lastIndexOf( string, "Red" );

System.out.println( "Array contains 'Blue'? " + containsBlue );
System.out.println( "Index of 'Red'? " + indexOfRed );
System.out.println( "Last Index of 'Red'? " + lastIndexOfRed );

结果如下： 

引用

Array contains 'Blue'? true 
Index of 'Red'? 0 
Last Index of 'Red'? 4

另外一个功能，你可以很容易将一个二维对象数组成一个Map对象，只需要ArrayUtils.toMap()这一个方法即可.举例如下： 

import org.apache.commons.lang.ArrayUtils;

Object[] weightArray =
    new Object[][] { {"H" , new Double( 1.007)},
                     {"He", new Double( 4.002)},
                     {"Li", new Double( 6.941)},
                     {"Be", new Double( 9.012)},
                     {"B",  new Double(10.811)},
                     {"Ne", new Double(20.180)} };
Map weights = ArrayUtils.toMap( weightArray );
Double hydrogenWeight = map.get( "H" );

3、怎样格式化日期 
如果你想格式化一个的时候，需要注意一下JDK中自带的SimpleDatFormat类不是线程安全的。你可以用FastDateFormat或DateFormatUtils来实现你想要的功能。如果在你的系统中有多个线程共享一个SimpleDatFormat实例，建议你马上改为SimpleDatFormat类. 
举例： 

Date now = new Date( );
String isoDT = DateFormatUtils.ISO_DATETIME_TIME_ZONE_FORMAT.format( now );
System.out.println( "It is currently: " + isoDT );

结果是： 

引用

It is currently: 2004-03-26T16:20:00-07:00

又举一个例子，如下： 

FastDateFormat formatter =
new FastDateFormat( "yyyy-mm", TimeZone.getDefault( ), Locale.getDefault( ));
String output = formatter.format( new Date( ) );
// output equals "2003-10"

DateFormatUtils的时间格式如下： 

ISO_DATE_FORMAT
 yyyy-MM-dd"2004-01-02"

ISO_DATE_TIME_ZONE_FORMAT
 yyyy-MM-ddZZ"2004-01-02-07:00"

ISO_DATETIME_FORMAT
 yyyy-MM-dd'T'HH:mm:ss"2004-01-02T23:22:12"

ISO_DATETIME_TIME_ZONE_FORMAT
 yyyy-MM-dd'T'HH:mm:ssZZ"2004-01-02T21:13:45-07:00"

ISO_TIME_FORMAT
 'T'HH:mm:ss"T04:23:22"

ISO_TIME_NO_T_FORMAT
 HH:mm:ss"05:12:34"

ISO_TIME_NO_T_TIME_ZONE_FORMAT
 HH:mm:ssZZ"12:32:22-07:00"

ISO_TIME_TIME_ZONE_FORMAT
 'T'HH:mm:ssZZ"T18:23:22-07:00"

SMTP_DATETIME_FORMAT
 EEE, dd MMM yyyy HH:mm:ss Z"Wed, 01 Feb 2004 20:03:01 CST"

注：本文章代码均来自<<Jarkata Commonss Cookbook>>一书第一章的内容,下一讲主要说一下Functors方面的内容