Closure

ChainedClosure

IfClosure

WhileClosure

ClosureUtils

Closure这一组接口和类提供一个操作对象的execute方法，为我们在处理一系列对象时可以将处理逻辑分离出来。理论上讲，使用Transformer也可以达到类似的效果，只要输出对象和输入对象是同一个对象就好，但是Closure接口定义的execute方法返回void，并且从效果和功能区分上，Closure可以更好的诠释对象处理或执行的意思。而事实上，ClosureUtils中也提供了一个asClosure方法包装一个现成的Transformer。

沿用前面的Emploee类，我们来给一组员工涨工资：

package sean.study.commons.collections;

import java.util.Arrays;

import java.util.Collection;

import java.util.Date;

import java.util.Iterator;

import org.apache.commons.collections.Closure;

import org.apache.commons.collections.CollectionUtils;

import org.apache.commons.lang.StringUtils;

public class ClosureUsage {

    public static void main(String[] args) {

        demoClosureUsage();

    }

    public static void demoClosureUsage() {

        System.out.println(StringUtils.center(" demoClosureUsage ", 40, "="));

        // data setup

        Employee[] employees = new Employee[] {

            new Employee("Tony", 26, new Date(), "E4", 2000),

            new Employee("Michelle", 24, new Date(), "E4", 2000),

            new Employee("Jack", 28, new Date(), "E5", 3000)

        };

        Collection empColl = Arrays.asList(employees);

        printColl("Before salary increase:", empColl);

        // closure setup

        Closure salaryIncreaseClosure = new Closure() {

            public void execute(Object obj) {

                Employee emp = (Employee) obj;

                emp.setSalary(emp.getSalary() * 1.20);

            }

        };

        // salary increase

        CollectionUtils.forAllDo(empColl, salaryIncreaseClosure);

        printColl("After salary increase:", empColl);

        System.out.println(StringUtils.repeat("=", 40));

    }

    public static void printColl(String label, Collection c) {

        if (StringUtils.isNotBlank(label)) {

            System.out.println(label);

        }

        Iterator iter = c.iterator();

        while (iter.hasNext()) {

            System.out.println(iter.next());

        }

    }

}

以下是运行结果：

=========== demoClosureUsage ===========

Before salary increase:

Employee[name=Tony,age=26,dateJoined=2005-08-05,grade=E4,salary=2000.0]

Employee[name=Michelle,age=24,dateJoined=2005-08-05,grade=E4,salary=2000.0]

Employee[name=Jack,age=28,dateJoined=2005-08-05,grade=E5,salary=3000.0]

After salary increase:

Employee[name=Tony,age=26,dateJoined=2005-08-05,grade=E4,salary=2400.0]

Employee[name=Michelle,age=24,dateJoined=2005-08-05,grade=E4,salary=2400.0]

Employee[name=Jack,age=28,dateJoined=2005-08-05,grade=E5,salary=3600.0]

========================================

我这里举的是一个相对简单的例子，在Closure这一组还有一些很方便的类，如ChainedClosure可以包装一组Closure作为整体执行；IfClosure在创建时需要提供给它一个Predicate和两个Closure，执行时先做Predicate判定再决定执行哪一个Closure；SwitchClosure跟SwitchTransformer类似，根据创建时传入的Predicate组和Closure组对应执行；WhileClosure则根据创建时传入的Predicate做判断，如果为true则执行Closure，直到Predicate返回false；等等。

Predicate

AndPredicate

OrPredicate

AllPredicate

OnePredicate

NonePredicate

PredicateUtils

Predicate是Commons Collections中定义的一个接口，可以在org.apache.commons.collections包中找到。其中定义的方法签名如下：

public boolean evaluate(Object object)

它以一个Object对象为参数，处理后返回一个boolean值，检验某个对象是否满足某个条件。其实这个Predicate以及上一篇笔记提到的Comparator还有我们即将看到的Transformer和Closure等都有些类似C/C++中的函数指针，它们都只是提供简单而明确定义的函数功能而已。

跟其他组类似，Commons Collections也提供了一组定义好的Predicate类供我们使用，这些类都放在org.apache.commons.collections.functors包中。当然，我们也可以自定义Predicate，只要实现这个Predicate接口即可。在Commons Collections中我们也可以很方便使用的一组预定义复合Predicate，我们提供2个或不定数量个Predicate，然后交给它，它可以帮我们处理额外的逻辑，如AndPredicate处理两个Predicate，只有当两者都返回true它才返回true；AnyPredicate处理多个Predicate，当其中一个满足就返回true，等等。

看看具体的代码中如何使用这些Predicate吧：

package sean.study.commons.collections;

import org.apache.commons.collections.Predicate;

import org.apache.commons.collections.PredicateUtils;

import org.apache.commons.collections.functors.InstanceofPredicate;

import org.apache.commons.collections.functors.NotNullPredicate;

import org.apache.commons.lang.BooleanUtils;

import org.apache.commons.lang.StringUtils;

public class PredicateUsage {

    public static void main(String[] args) {

        demoPredicates();

    }

    public static void demoPredicates() {

        System.out.println(StringUtils.center(" demoPredicates ", 40, "="));

        Predicate p1 = new InstanceofPredicate(String.class);

        Predicate p2 = NotNullPredicate.getInstance();

        Predicate p3 = new Predicate() {

            public boolean evaluate(Object obj) {

                String str = (String) obj;

                return StringUtils.isAlphanumeric(str)

                    && str.length() >= 6

                    && str.length() <= 10;

            }

        };

        Predicate p4 = PredicateUtils.allPredicate(new Predicate[]{p1, p2, p3});                String input = "ABCD1234";

        Object[] raw = new Object[] {

            "Is '",

            input,

            "' a valid input? ",

            BooleanUtils.toStringYesNo(p4.evaluate(input)),

            "."

        };

        System.out.println(StringUtils.join(raw));

        System.out.println(StringUtils.repeat("=", 40));

    }

}

输出结果如下：

============ demoPredicates ============

Is 'ABCD1234' a valid input? yes.

========================================

TypedCollection

CollectionUtils

首先就是这个TypedCollection，它实际上的作用就是提供一个decorate方法，我们传进去一个Collection和需要的类型甄别信息java.lang.Class，它给我们创建一个全新的强类型的Collection。我们其实在bag、buffer、list、map、set这些子包中都可以找到分别对应Bag、Buffer、List、Map、Set接口的TypedXxxx版本。

方法签名：

public static Collection decorate(Collection coll, Class type)

当它执行时，它会判断coll是否为null，同时如果coll包含数据，它会对数据进行验证，看是否满足指定的type条件。最后它返回一个强类型的Collection，当我们对这个强类型的Collection进行add操作时，它会帮我们确保添加的是正确的类型。

而这个CollectionUtils可能大家都已经想到了，就是提供一组针对Collection操作的工具/静态方法。比较有意思的是对Collection的转型、合并、减等操作。

ReverseComparator

ComparatorChain

NullComparator

FixedOrderComparator

ComparatorUtils

其实Comparator这个概念并不是Commons Collections引入的，在标准的Java Collections API中，已经明确定了一个java.util.Comparator接口，只是有很多人并不了解，Commons Collections也只是扩展了这个接口而已。这个java.util.Comparator定义如下核心方法：

public int compare(Object arg0, Object arg1)

传给它两个对象，它要告诉我们这两个对象哪一个在特定的语义下更“大”，或者两者相等。如果arg0 > arg1，返回大于0的整数；如果arg0 = arg1，返回0；如果arg0 < arg2，返回小于0的整数。

我们看看Commons Collections给我们提供了哪些Comparator的实现类（都在org.apache.commons.collections.comparators包下面）：

BooleanComparator – 用于排序一组Boolean对象，指明先true还是先false；

ComparableComparator – 用于排序实现了java.lang.Comparable接口的对象（我们常用的Java类如String、Integer、Date、Double、File、Character等等都实现了Comparable接口）；

ComparatorChain – 定义一组Comparator链，链中的Comparator对象会被依次执行；

FixedOrderComparator – 用于定义一个特殊的顺序，对一组对象按照这样的自定义顺序进行排序；

NullComparator – 让null值也可参与比较，可以设定为先null或者后null；

ReverseComparator – 将原有的Comparator效果反转；

TransformingComparator – 将一个Comparator装饰为具有Transformer效果的Comparator。

// 有关Transformer的内容会在以后的笔记中讲到。

以上除了ComparatorChain之外，似乎都是实现一些很基本的比较方法，但是当我们用ComparatorChain将一组Comparator串起来之后，就可以实现非常灵活的比较操作。那么这些Comparator在实际代码中如何使用呢？看例子：

/** Issue.java */

package sean.study.commons.collections;

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

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

public class Issue {

    private long id;

    private String severity;

    private String owner;

    public Issue() {

    }

    public Issue(long id, String severity, String owner) {

        this.id = id;

        this.severity = severity;

        this.owner = owner;

    }

    public String toString() {

        return new ToStringBuilder(this, ToStringStyle.SHORT_PREFIX_STYLE)

                .append("id", id)

                .append("severity", severity)

                .append("owner", owner)

                .toString();

    }

    public long getId() {

        return id;

    }

    public void setId(long id) {

        this.id = id;

    }

    public String getOwner() {

        return owner;

    }

    public void setOwner(String owner) {

        this.owner = owner;

    }

    public String getSeverity() {

        return severity;

    }

    public void setSeverity(String severity) {

        this.severity = severity;

    }

}

/** ComparatorUsage.java */

package sean.study.commons.collections;

import java.util.Arrays;

import java.util.Comparator;

import org.apache.commons.beanutils.BeanComparator;

import org.apache.commons.collections.comparators.ComparatorChain;

import org.apache.commons.collections.comparators.FixedOrderComparator;

import org.apache.commons.lang.StringUtils;

public class ComparatorUsage {

    public static void main(String[] args) {

        demoComparator();

    }

    public static void demoComparator() {

        System.out.println(StringUtils.center(" demoComparator ", 40, "="));

        // data setup

        Issue[] issues = new Issue[] {

                new Issue(15102, "Major", "John"),

                new Issue(15103, "Minor", "Agnes"),

                new Issue(15104, "Critical", "Bill"),

                new Issue(15105, "Major", "John"),

                new Issue(15106, "Major", "John"),

                new Issue(15107, "Critical", "John"),

                new Issue(15108, "Major", "Agnes"),

                new Issue(15109, "Minor", "Julie"),

                new Issue(15110, "Major", "Mary"),

                new Issue(15111, "Enhancement", "Bill"),

                new Issue(15112, "Minor", "Julie"),

                new Issue(15113, "Major", "Julie")

        };

        // comparators setup

        String[] severityOrder = {"Critical", "Major", "Minor", "Enhancement"};

        Comparator severityComparator = new FixedOrderComparator(severityOrder);

        ComparatorChain compChain = new ComparatorChain();

        compChain.addComparator(new BeanComparator("owner"));

        compChain.addComparator(new BeanComparator("severity", severityComparator));

        compChain.addComparator(new BeanComparator("id"));

        // sort and display

        Arrays.sort(issues, compChain);

        for (int i = 0; i < issues.length; i++) {

            System.out.println(issues[i]);

        }

        System.out.println(StringUtils.repeat("=", 40));

    }

}

输出结果为：

============ demoComparator ============

Issue[id=15108,severity=Major,owner=Agnes]

Issue[id=15103,severity=Minor,owner=Agnes]

Issue[id=15104,severity=Critical,owner=Bill]

Issue[id=15111,severity=Enhancement,owner=Bill]

Issue[id=15107,severity=Critical,owner=John]

Issue[id=15102,severity=Major,owner=John]

Issue[id=15105,severity=Major,owner=John]

Issue[id=15106,severity=Major,owner=John]

Issue[id=15113,severity=Major,owner=Julie]

Issue[id=15109,severity=Minor,owner=Julie]

Issue[id=15112,severity=Minor,owner=Julie]

Issue[id=15110,severity=Major,owner=Mary]

========================================

Buffer

BlockingBuffer

BoundedFifoBuffer

PriorityBuffer

UnboundedFifoBuffer

BufferUtils

Buffer是定义在org.apache.commons.collections包下面的接口，用于表示按一定顺序除去成员对象的collection如队列等。具体的实现类在org.apache.commons.collections.buffer包下可以找到。

BufferUtils提供很多静态/工具方法装饰现有的Buffer实例，如将其装饰成BlockingBuffer、执行类型检查的TypedBuffer、或者不可改变的UnmodifiableBuffer等等。

最简单直接的Buffer实现类是UnboundedFifoBuffer，提供先进先出的大小可变的队列。而BoundedFifoBuffer则是对其大小进行了限制，是固定大小的先进先出队列。BlockingBuffer要在多线程的环境中才能体现出它的价值，尤其是当我们需要实现某种流水线时这个BlockingBuffer很有用：每个流水线上的组件从上游的BlockingBuffer获取数据，处理后放到下一个BlockingBuffer中依次传递。BlockingBuffer的核心特色通俗点说就是如果你向它要东西，而它暂时还没有的话，你可以一直等待直至拿到为止。PriorityBuffer则提供比一般的先进先出Buffer更强的控制力：我们可以自定义Comparator给它，告诉它怎么判定它的成员的先后顺序，优先级最高的最先走。

为了方便和清晰的需要，我在这里只举一个BoundedFifoBuffer，包装成TypedBuffer，看看在具体的代码中通常如何使用Buffer：（还是沿用上次的Book类）

package sean.study.commons.collections;

import java.util.Iterator;

import org.apache.commons.collections.Buffer;

import org.apache.commons.collections.BufferUtils;

import org.apache.commons.collections.buffer.BoundedFifoBuffer;

import org.apache.commons.lang.StringUtils;

public class BufferUsage {

    public static void main(String[] args) {

        demoBufferUsage();

    }

    public static void demoBufferUsage() {

        System.out.println(StringUtils.center(" demoBagUsage ", 40, "="));

        // data setup

        Book book1 = new Book("Refactoring Workbook", "7-5083-2208-8", 29.8);

        Book book2 = new Book("J2EE Design Patterns", "7-5083-3099-4", 45);

        Book book3 = new Book("Agile Software Development", "7-5083-1503-0", 59);

        Book book4 = new Book("Professional JSP", "7-5053-8005-2", 100);

        // create a Buffer

        Buffer buffer =

            BufferUtils.typedBuffer(new BoundedFifoBuffer(3), Book.class);

        buffer.add(book1);

        buffer.add(book2);

        buffer.add(book3);

        Book removed = (Book) buffer.remove();

        System.out.println("Removed:");

        System.out.println(removed);

        buffer.add(book4);

        // get items in buffer

        for (int i = 0; i < 3; i++) {

            System.out.println(buffer.get());

            buffer.remove();

        }

        System.out.println(StringUtils.repeat("=", 40));

    }

}

以下是运行结果：

============= demoBagUsage =============

Removed:

sean.study.commons.collections.Book@e09713[

  name=Refactoring Workbook

  ISBN=7-5083-2208-8

  retailPrice=29.8

]

Remaining:

sean.study.commons.collections.Book@e09713[

  name=J2EE Design Patterns

  ISBN=7-5083-3099-4

  retailPrice=45.0

]

sean.study.commons.collections.Book@47b480[

  name=Agile Software Development

  ISBN=7-5083-1503-0

  retailPrice=59.0

]

sean.study.commons.collections.Book@19b49e6[

  name=Professional JSP

  ISBN=7-5053-8005-2

  retailPrice=100.0

]

========================================

BidiMap

MultiMap

LazyMap

MapUtils

Commons Collections在java.util.Map的基础上扩展了很多接口和类，比较有代表性的是BidiMap、MultiMap和LazyMap。跟Bag和Buffer类似，Commons Collections也提供了一个MapUtils。

所谓BidiMap，直译就是双向Map，可以通过key找到value，也可以通过value找到key，这在我们日常的代码-名称匹配的时候很方便：因为我们除了需要通过代码找到名称之外，往往也需要处理用户输入的名称，然后获取其代码。需要注意的是BidiMap当中不光key不能重复，value也不可以。

所谓MultiMap，就是说一个key不在是简单的指向一个对象，而是一组对象，add()和remove()的时候跟普通的Map无异，只是在get()时返回一个Collection，利用MultiMap，我们就可以很方便的往一个key上放数量不定的对象，也就实现了一对多。

所谓LazyMap，意思就是这个Map中的键/值对一开始并不存在，当被调用到时才创建，这样的解释初听上去是不是有点不可思议？这样的LazyMap有用吗？我们这样来理解：我们需要一个Map，但是由于创建成员的方法很“重”（比如数据库访问），或者我们只有在调用get()时才知道如何创建，或者Map中出现的可能性很多很多，我们无法在get()之前添加所有可能出现的键/值对，或者任何其它解释得通的原因，我们觉得没有必要去初始化一个Map而又希望它可以在必要时自动处理数据生成的话，LazyMap就变得很有用了。

我们还是通过一个具体的例子来说明：

package sean.study.commons.collections;

import java.util.Date;

import java.util.HashMap;

import java.util.Map;

import org.apache.commons.collections.BidiMap;

import org.apache.commons.collections.Factory;

import org.apache.commons.collections.MultiHashMap;

import org.apache.commons.collections.MultiMap;

import org.apache.commons.collections.bidimap.DualHashBidiMap;

import org.apache.commons.collections.map.LazyMap;

import org.apache.commons.lang.StringUtils;

public class MapUsage {

    public static void main(String[] args) {

        demoBidiMap();

        demoMultiMap();

        demoLazyMap();

    }

    public static void demoBidiMap() {

        System.out.println(StringUtils.center(" demoBidiMap ", 40, "="));

        BidiMap bidiMap = new DualHashBidiMap();

        bidiMap.put("BJ", "Beijing");

        bidiMap.put("SH", "Shanghai");

        bidiMap.put("GZ", "Guangzhou");

        bidiMap.put("CD", "Chengdu");

        System.out.println("Key-Value: BJ = " + bidiMap.get("BJ"));

        System.out.println("Value-Key: Chengdu = " + bidiMap.getKey("Chengdu"));

        System.out.println(StringUtils.repeat("=", 40));

    }

    public static void demoMultiMap() {

        System.out.println(StringUtils.center(" demoMultiMap ", 40, "="));

        MultiMap multiMap = new MultiHashMap();

        multiMap.put("Sean", "C/C++");

        multiMap.put("Sean", "OO");

        multiMap.put("Sean", "Java");

        multiMap.put("Sean", ".NET");

        multiMap.remove("Sean", "C/C++");

        System.out.println("Sean's skill set: " + multiMap.get("Sean"));

        System.out.println(StringUtils.repeat("=", 40));

    }

    public static void demoLazyMap() {

        System.out.println(StringUtils.center(" demoLazyMap ", 40, "="));

        // borrowed from Commons Collection's Javadoc

        Factory factory = new Factory() {

            public Object create() {

                return new Date();

            }

        };

        Map lazy = LazyMap.decorate(new HashMap(), factory);

        System.out.println(lazy.get("NOW"));

        System.out.println(StringUtils.repeat("=", 40));

    }

}

以下是运行结果：

============= demoBidiMap ==============

Key-Value: BJ = Beijing

Value-Key: Chengdu = CD

========================================

============= demoMultiMap =============

Sean's skill set: [OO, Java, .NET]

========================================

============= demoLazyMap ==============

Wed Aug 03 12:44:56 CST 2005

========================================

在这里可以找到下载链接：（binary和src都有）

http://jakarta.apache.org/site/downloads/downloads_commons-collections.cgi

目前Commons Collection发布的最新版本是3.1。建议下载这个3.1版本，页面上出现的2.1.1是针对2.1不兼容3.0而发布的升级维护版。

我们先来浏览一下它的包结构。一共是12个：

org.apache.commons.collections – Commons Collections自定义的一组公用的接口和工具类

org.apache.commons.collections.bag – 实现Bag接口的一组类

org.apache.commons.collections.bidimap – 实现BidiMap系列接口的一组类

org.apache.commons.collections.buffer – 实现Buffer接口的一组类

org.apache.commons.collections.collection – 实现java.util.Collection接口的一组类

org.apache.commons.collections.comparators – 实现java.util.Comparator接口的一组类

org.apache.commons.collections.functors – Commons Collections自定义的一组功能类

org.apache.commons.collections.iterators – 实现java.util.Iterator接口的一组类

org.apache.commons.collections.keyvalue – 实现集合和键/值映射相关的一组类

org.apache.commons.collections.list – 实现java.util.List接口的一组类

org.apache.commons.collections.map – 实现Map系列接口的一组类

org.apache.commons.collections.set – 实现Set系列接口的一组类

用过Java Collections API的朋友大概或多或少会同意我如下的划分：在Java的Collections API中，不狭义的区分语法上的接口和类，把它们都看作是类的话，大致我们可以发现三种主要的类别：

1- 容器类：如Collection、List、Map等，用于存放对象和进行简单操作的；

2- 操作类：如Collections、Arrays等，用于对容器类的实例进行相对复杂操作如排序等；

3- 辅助类：如Iterator、Comparator等，用于辅助操作类以及外部调用代码实现对容器类的操作，所谓辅助，概括而通俗的来讲，就是这些类提供一种算法，你给它一个对象或者一组对象，或者仅仅是按一定的规则调用它，它给你一个运算后的答案，帮助你正确处理容器对象。比如Iterator会告诉你容器中下一个对象有没有、是什么，而Comparator将对象大小/先后次序的算法逻辑独立出来。

同样，Jakarta Commons Collections我们细细看来，也能够找出类似的划分：

1- 作为容器类的补充，我们可以找到Bag、Buffer、BidiMap、OrderedMap等等；

2- 作为操作类的补充，我们可以找到CollectionUtils、IteratorUtils、ListUtils、SetUtils等等；

3- 作为辅助类的补充，我们可以找到MapIterator、Closure、Predicate、Transformer等等；

对于这样的一个大包，当然不可能一个类一个类的讲了，找一些常用的和有用的当做接下来讨论的话题吧。大概列个清单：

Bag

HashBag

BagUtils

Buffer

BlockingBuffer

BoundedFifoBuffer

PriorityBuffer

BufferUtils

MultiMap

BidiMap

CaseInsensitiveMap

LazyMap

MapUtils

TypedCollection

CollectionUtils

ReverseComparator

ComparatorChain

NullComparator

FixedOrderComparator

ComparatorUtils

Predicate

AndPredicate

OrPredicate

AllPredicate

OnePredicate

NonePredicate

PredicateUtils

Transformer

ChainedTransformer

SwitchTransformer

TransformerUtils

Closure

ChainedClosure

IfClosure

WhileClosure

ClosureUtils

LoopingIterator

ArrayListIterator

FilterIterator

UniqueFilterIterator

IteratorUtils

Bag

HashBag

BagUtils

Bag是在org.apache.commons.collections包中定义的接口，它extends java.util.Collection，而它的实现类都被放在下面的bag包中。之所以有这样一组类型，是因为我们有时候需要在Collection中存放多个相同对象的拷贝，并且需要很方便的取得该对象拷贝的个数。需要注意的一点是它虽然extends Collection，但是如果真把它完全当作java.util.Collection来用会遇到语义上的问题，详细信息参考Javadoc。

HashBag是Bag接口的一个标准实现。而BagUtils提供一组static的方法让调用者获取经过不同装饰后的Bag实例。

还是举例子来看：

/** Book.java */

package sean.study.commons.collections;

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

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

public class Book {

    private String name;

    private String isbn;

    private double retailPrice;

    public Book() {

    }

    public Book(String name, String isbn, double retailPrice) {

        this.name = name;

        this.isbn = isbn;

        this.retailPrice = retailPrice;

    }

    public String toString() {

        return new ToStringBuilder(this, ToStringStyle.MULTI_LINE_STYLE)

        .append("name", name)

        .append("ISBN", isbn)

        .append("retailPrice", retailPrice)

        .toString();

    }

    public String getIsbn() {

        return isbn;

    }

    public void setIsbn(String isbn) {

        this.isbn = isbn;

    }

    public String getName() {

        return name;

    }

    public void setName(String name) {

        this.name = name;

    }

    public double getRetailPrice() {

        return retailPrice;

    }

    public void setRetailPrice(double retailPrice) {

        this.retailPrice = retailPrice;

    }

}

/** BagUsage.java */

package sean.study.commons.collections;

import org.apache.commons.collections.Bag;

import org.apache.commons.collections.BagUtils;

import org.apache.commons.collections.bag.HashBag;

import org.apache.commons.lang.StringUtils;

public class BagUsage {

    public static void main(String[] args) {

        demoBagUsage();

    }

    public static void demoBagUsage() {

        System.out.println(StringUtils.center(" demoBagUsage ", 40, "="));

        // data setup

        Book book1 = new Book("Refactoring Workbook", "7-5083-2208-8", 29.8);

        Book book2 = new Book("J2EE Design Patterns", "7-5083-3099-4", 45);

        Book book3 = new Book("Agile Software Development", "7-5083-1503-0", 59);

        // create a bag

        Bag myBag = BagUtils.typedBag(new HashBag(), Book.class);

        myBag.add(book1, 360);

        myBag.add(book2, 500);

        myBag.add(book3, 170);

        // calculations for a bag

        double price1 = book1.getRetailPrice();

        double price2 = book2.getRetailPrice();

        double price3 = book3.getRetailPrice();

        int book1Count = myBag.getCount(book1);

        int book2Count = myBag.getCount(book2);

        int book3Count = myBag.getCount(book3);

        double totalValue = (price1 * book1Count) + (price2 * book2Count)

                + (price3 * book3Count);

        // dispaly results

        System.out.println("There are " + book1Count + " copies of "

                + book1.getName() + ".");

        System.out.println("There are " + book2Count + " copies of "

                + book2.getName() + ".");

        System.out.println("There are " + book3Count + " copies of "

                + book3.getName() + ".");

        System.out.println("The total value of these books is: " + totalValue);

        System.out.println();

    }

}

以下是运行结果：

============= demoBagUsage =============

There are 360 copies of Refactoring Workbook.

There are 500 copies of J2EE Design Patterns.

There are 170 copies of Agile Software Development.

The total value of these books is: 43258.0

BeanUtils最核心的好处在于：我们在编码时，并不需要知道我们处理的JavaBeans具体是什么类型，有哪些属性，这些信息是可以动态获取的，甚至我们都可以不必去关心事实上是否存在这样一个具体的JavaBean类。我们只需要知道有一个JavaBean的实例，我们需要从中取得某个属性，设定某个属性的值，或者仅仅是需要一个属性表。要做到这些，依靠Sun提供的JavaBean规范似乎找不到一个很直接的方式，除非硬编码，将getXxxx()和setXxxx()直接写进我们的程序。但是这样就大大增加了代码的复杂度、耦合性和维护成本。还好Commons BeanUtils对这个问题提供了一种优雅的解决方案。

我们有两种途径获取Commons BeanUtils的binary：

1- 从Struts、Spring或者任何依赖BeanUtils的开源产品的发行包中找到相应的jar文件；

2- 从http://www.apache.org/dist/jakarta/commons/beanutils/binaries/下载。

Commons BeanUtils的源码下载地址：

http://www.apache.org/dist/jakarta/commons/beanutils/source/

Commons BeanUtils一共包括如下5个包：

org.apache.commons.beanutils – 核心包，定义一组Utils类和需要用到的接口规范

org.apache.commons.beanutils.converters – 转换String到需要类型的类，实现Converter接口

org.apache.commons.beanutils.locale – beanutils的locale敏感版本

org.apache.commons.beanutils.locale.converters – converters的locale敏感版本

org.apache.commons.collections – beanutils使用到的Collection类

其中需要我们特别关注的是这个org.apache.commons.beanutils包，其他包都是起辅助作用的。接下来我们就仔细看一看这个包都有些什么东东：

[4个接口]

Converter

该接口定义了如下方法：

public java.lang.Object convert(java.lang.Class type, java.lang.Object value);

只要实现了这个Converter接口并注册到ConvertUtils类即可被我们的BeanUtils包所使用，它的主要目的是提供将给定的Object实例转换为目标类型的算法。我们可以在beanutils.converters包中找到相当多的已经实现的转换器。

DynaBean

该接口定义的是一个动态的JavaBean，它的属性类型、名称和值都是可以动态改变的。

DynaClass

该接口定义的是针对实现了DynaBean接口的类的java.lang.Class对象，提供如getName()、newInstance()等方法。

MutableDynaClass

该接口是对DynaClass的扩展，使得动态bean的属性可以动态增加或删除。

[24个类]

BasicDynaBean

DynaBean接口的最精简实现

BasicDynaClass

DynaClass接口的最精简实现

BeanUtils

提供通过反射机制填写JavaBeans属性的工具/静态方法

BeanUtilsBean

BeanUtils类的实例化实现，区别于BeanUtils的静态方法方式，使得自定义的配置得以保持

ConstructorUtils

同MethodUtils类似，不过专注于构造方法

ContextClassLoaderLocal

针对每个classloader的唯一标识

ConvertingWrapDynaBean

包含了标准JavaBean实例的DynaBean实现，使得我们可以使用DynaBean的API来访问起属性，同时提供设定属性时的类型转换，继承自并区别于WrapDynaBean

ConvertUtils

提供工具/静态方法，用于将String对象及其数组转换为指定的类型的对象及其数组。

ConvertUtilsBean

ConvertUtils类的实例化实现，区别于ConvertUtils的静态方法方式，使得自定义的配置得以保持

DynaProperty

用于描述DynaBean的属性

JDBCDynaClass

为DynaClass的JDBC实现提供公用的逻辑

LazyDynaBean

懒载入DynaBean，自动往DynaClass添加属性并提供懒载入List和懒载入Map的功能

LazyDynaClass

实现MutableDynaClass接口的类

LazyDynaMap

为Map实例提供一个轻量级的DynaBean包装

MappedPropertyDescriptor

用于描述映射的属性

MethodUtils

包含了针对一般意义上的方法而非特定属性的反射工具/静态方法

MethodUtils.MethodDescriptor

描述通过反射查找某个方法所使用的键值

PropertyUtils

提供利用Java反射API调用具体对象的getter和setter的工具/静态方法

PropertyUtilsBean

PropertyUtils类的实例化实现，区别于PropertyUtils的静态方法方式，使得自定义的配置得以保持

ResultSetDynaClass

包装java.sql.ResultSet中的java.sql.Row实例的DynaBean所对应的DynaClass实现

ResultSetIterator

针对ResultSetDynaClass的java.util.Iterator实现

RowSetDynaClass

DynaClass的一种实现，用于在内存中创建一组表示SQL查询结果的DynaBeans，区别于ResultSetDynaClass，它不需要保持ResultSet打开

WrapDynaBean

DynaBean的一种实现，包含一个标准的JavaBean实例，以便我们可以使用DynaBean的API去访问它的属性，区别于ConvertingWrapDynaBean，它不做专门的类型转换

WrapDynaClass

DynaClass的一种实现，针对那些包装标准JavaBean实例的DynaBeans

[3个Exception]

（略）

看到这么多东西是不是有点头晕？不要慌，看几个例子就明白了。只要把握好BeanUtils本身要完成的事，就不难理解这些类存在的道理。我们不妨把BeanUtils的基础应用分解成：访问JavaBean的属性、设定JavaBean的属性、以及创建和使用DynaBeans。这样来看BeanUtils，你就会觉得简单清晰得多。

/** Address.java */

package sean.study.commons.beanutils;

public class Address {

    private String zipCode;

    private String addr;

    private String city;

    private String country;

    public Address() {

    }

    public Address(String zipCode, String addr, String city, String country) {

        this.zipCode = zipCode;

        this.addr = addr;

        this.city = city;

        this.country = country;

    }

    public String getAddr() {

        return addr;

    }

    public void setAddr(String addr) {

        this.addr = addr;

    }

    public String getCity() {

        return city;

    }

    public void setCity(String city) {

        this.city = city;

    }

    public String getCountry() {

        return country;

    }

    public void setCountry(String country) {

        this.country = country;

    }

    public String getZipCode() {

        return zipCode;

    }

    public void setZipCode(String zipCode) {

        this.zipCode = zipCode;

    }

}

/** Customer.java */

package sean.study.commons.beanutils;

public class Customer {

    private long id;

    private String name;

    private Address[] addresses;

    public Customer() {

    }

    public Customer(long id, String name, Address[] addresses) {

        this.id = id;

        this.name = name;

        this.addresses = addresses;

    }

    public Address[] getAddresses() {

        return addresses;

    }

    public void setAddresses(Address[] addresses) {

        this.addresses = addresses;

    }

    public long getId() {

        return id;

    }

    public void setId(long id) {

        this.id = id;

    }

    public String getName() {

        return name;

    }

    public void setName(String name) {

        this.name = name;

    }

}

我们来看看通常我们是怎样利用Commons BeanUtils来完成一些基本的JavaBean和DynaBean操作：

package sean.study.commons.beanutils;

import org.apache.commons.beanutils.BasicDynaBean;

import org.apache.commons.beanutils.BasicDynaClass;

import org.apache.commons.beanutils.DynaBean;

import org.apache.commons.beanutils.DynaProperty;

import org.apache.commons.beanutils.PropertyUtils;

import org.apache.commons.lang.StringUtils;

public class BeanUtilsUsage {

    public static void main(String[] args) throws Exception {

        demoNormalJavaBeans();

        demoDynaBeans();

    }

    public static void demoNormalJavaBeans() throws Exception {

        System.out.println(StringUtils.center(" demoNormalJavaBeans ", 40, "="));

        // data setup

        Address addr1 = new Address("CA1234", "xxx", "Los Angeles", "USA");

        Address addr2 = new Address("100000", "xxx", "Beijing", "China");

        Address[] addrs = new Address[2];

        addrs[0] = addr1;

        addrs[1] = addr2;

        Customer cust = new Customer(123, "John Smith", addrs);

        // accessing the city of first address

        String cityPattern = "addresses[0].city";

        String name = (String) PropertyUtils.getSimpleProperty(cust, "name");

        String city = (String) PropertyUtils.getProperty(cust, cityPattern);

        Object[] rawOutput1 = new Object[] { "The city of customer ", name,

                "'s first address is ", city, "." };

        System.out.println(StringUtils.join(rawOutput1));

        // setting the zipcode of customer's second address

        String zipPattern = "addresses[1].zipCode";

        if (PropertyUtils.isWriteable(cust, zipPattern)) {

            System.out.println("Setting zipcode ...");

            PropertyUtils.setProperty(cust, zipPattern, "200000");

        }

        String zip = (String) PropertyUtils.getProperty(cust, zipPattern);

        Object[] rawOutput2 = new Object[] { "The zipcode of customer ", name,

                "'s second address is now ", zip, "." };

        System.out.println(StringUtils.join(rawOutput2));

        System.out.println();

    }

    public static void demoDynaBeans() throws Exception {

        System.out.println(StringUtils.center(" demoDynaBeans ", 40, "="));

        // creating a DynaBean

        DynaProperty[] dynaBeanProperties = new DynaProperty[] {

                new DynaProperty("name", String.class),

                new DynaProperty("inPrice", Double.class), 

                new DynaProperty("outPrice", Double.class),

        };

        BasicDynaClass cargoClass = new BasicDynaClass("Cargo", BasicDynaBean.class, dynaBeanProperties);

        DynaBean cargo = cargoClass.newInstance();

        // accessing a DynaBean

        cargo.set("name", "Instant Noodles");

        cargo.set("inPrice", new Double(21.3));

        cargo.set("outPrice", new Double(23.8));

        System.out.println("name: " + cargo.get("name"));

        System.out.println("inPrice: " + cargo.get("inPrice"));

        System.out.println("outPrice: " + cargo.get("outPrice"));

        System.out.println();

    }

}

上述代码运行结果如下：

========= demoNormalJavaBeans ==========

The city of customer John Smith's first address is Los Angeles.

Setting zipcode ...

The zipcode of customer John Smith's second address is now 200000.

============ demoDynaBeans =============

name: Instant Noodles

inPrice: 21.3

outPrice: 23.8

http://jakarta.apache.org/commons/math/

org.apache.commons.lang.math包中共有10个类，这些类可以归纳成四组：

1- 处理分数的Fraction类；

2- 处理数值的NumberUtils类；

3- 处理数值范围的Range、NumberRange、IntRange、LongRange、FloatRange、DoubleRange类；

4- 处理随机数的JVMRandom和RandomUtils类。

下面我举个例子分别说明上述四组的使用方法：

package sean.study.jakarta.commons.lang;

import org.apache.commons.lang.ArrayUtils;

import org.apache.commons.lang.BooleanUtils;

import org.apache.commons.lang.StringUtils;

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

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

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

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

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

public class LangMathUsage {

    public static void main(String[] args) {

        demoFraction();

        demoNumberUtils();

        demoNumberRange();

        demoRandomUtils();

    }

    public static void demoFraction() {

        System.out.println(StringUtils.center(" demoFraction ", 30, "="));

        Fraction myFraction = Fraction.getFraction(144, 90);

        // Fraction myFraction = Fraction.getFraction("1 54/90");

        System.out.println("144/90 as fraction: " + myFraction);

        System.out.println("144/90 to proper: " + myFraction.toProperString());

        System.out.println("144/90 as double: " + myFraction.doubleValue());

        System.out.println("144/90 reduced: " + myFraction.reduce());

        System.out.println("144/90 reduced proper: "

                + myFraction.reduce().toProperString());

        System.out.println();

    }

    public static void demoNumberUtils() {

        System.out.println(StringUtils.center(" demoNumberUtils ", 30, "="));

        System.out.println("Is 0x3F a number? "

                + StringUtils.capitalize(BooleanUtils.toStringYesNo(NumberUtils

                        .isNumber("0x3F"))) + ".");

        double[] array = { 1.0, 3.4, 0.8, 7.1, 4.6 };

        double max = NumberUtils.max(array);

        double min = NumberUtils.min(array);

        String arrayStr = ArrayUtils.toString(array);

        System.out.println("Max of " + arrayStr + " is: " + max);

        System.out.println("Min of " + arrayStr + " is: " + min);

        System.out.println();

    }

    public static void demoNumberRange() {

        System.out.println(StringUtils.center(" demoNumberRange ", 30, "="));

        Range normalScoreRange = new DoubleRange(90, 120);

        double score1 = 102.5;

        double score2 = 79.9;

        System.out.println("Normal score range is: " + normalScoreRange);

        System.out.println("Is "

                + score1

                + " a normal score? "

                + StringUtils

                        .capitalize(BooleanUtils.toStringYesNo(normalScoreRange

                                .containsDouble(score1))) + ".");

        System.out.println("Is "

                + score2

                + " a normal score? "

                + StringUtils

                        .capitalize(BooleanUtils.toStringYesNo(normalScoreRange

                                .containsDouble(score2))) + ".");

        System.out.println();

    }

    public static void demoRandomUtils() {

        System.out.println(StringUtils.center(" demoRandomUtils ", 30, "="));

        for (int i = 0; i < 5; i++) {

            System.out.println(RandomUtils.nextInt(100));

        }

        System.out.println();

    }

}

以下是运行结果：

======== demoFraction ========

144/90 as fraction: 144/90

144/90 to proper: 1 54/90

144/90 as double: 1.6

144/90 reduced: 8/5

144/90 reduced proper: 1 3/5

====== demoNumberUtils =======

Is 0x3F a number? Yes.

Max of {1.0,3.4,0.8,7.1,4.6} is: 7.1

Min of {1.0,3.4,0.8,7.1,4.6} is: 0.8

====== demoNumberRange =======

Normal score range is: Range[90.0,120.0]

Is 102.5 a normal score? Yes.

Is 79.9 a normal score? No.

====== demoRandomUtils =======

75

63

40

21

92

DateFormatUtils – 提供格式化日期和时间的功能及相关常量；

DateUtils – 在Calendar和Date的基础上提供更方便的访问；

DurationFormatUtils – 提供格式化时间跨度的功能及相关常量；

FastDateFormat – 为java.text.SimpleDateFormat提供一个的线程安全的替代类；

StopWatch – 是一个方便的计时器。

我们还是在一个例子中来看上述各个类的用法吧：

package sean.study.jakarta.commons.lang;

import java.util.Calendar;

import java.util.Date;

import org.apache.commons.lang.StringUtils;

import org.apache.commons.lang.time.DateFormatUtils;

import org.apache.commons.lang.time.DateUtils;

import org.apache.commons.lang.time.FastDateFormat;

import org.apache.commons.lang.time.StopWatch;

public class DateTimeUsage {

    public static void main(String[] args) {

        demoDateUtils();

        demoStopWatch();

    }

    public static void demoDateUtils() {

        System.out.println(StringUtils.center(" demoDateUtils ", 30, "="));

        Date date = new Date();

        String isoDateTime = DateFormatUtils.ISO_DATETIME_FORMAT.format(date);

        String isoTime = DateFormatUtils.ISO_TIME_NO_T_FORMAT.format(date);

        FastDateFormat fdf = FastDateFormat.getInstance("yyyy-MM");

        String customDateTime = fdf.format(date);

        System.out.println("ISO_DATETIME_FORMAT: " + isoDateTime);

        System.out.println("ISO_TIME_NO_T_FORMAT: " + isoTime);

        System.out.println("Custom FastDateFormat: " + customDateTime);

        System.out.println("Default format: " + date);

        System.out.println("Round HOUR: " + DateUtils.round(date, Calendar.HOUR));

        System.out.println("Truncate HOUR: " + DateUtils.truncate(date, Calendar.HOUR));

        System.out.println();

    }

    public static void demoStopWatch() {

        System.out.println(StringUtils.center(" demoStopWatch ", 30, "="));

        StopWatch sw = new StopWatch();

        sw.start();

        operationA();

        sw.stop();

        System.out.println("operationA used " + sw.getTime() + " milliseconds.");

        System.out.println();

    }

    public static void operationA() {

        try {

            Thread.sleep(999);

        }

        catch (InterruptedException e) {

            // do nothing

        }

    }

}

以下是运行结果：

======= demoDateUtils ========

ISO_DATETIME_FORMAT: 2005-08-01T12:41:51

ISO_TIME_NO_T_FORMAT: 12:41:51

Custom FastDateFormat: 2005-08

Default format: Mon Aug 01 12:41:51 CST 2005

Round HOUR: Mon Aug 01 13:00:00 CST 2005

Truncate HOUR: Mon Aug 01 12:00:00 CST 2005

======= demoStopWatch ========

operationA used 1000 milliseconds.

package sean.study.jakarta.commons.lang;

import org.apache.commons.lang.StringUtils;

public class StringUtilsAndWordUtilsUsage {

    public static void main(String[] args) {

        // data setup

        String str1 = "";

        String str2 = " ";

        String str3 = "\t";

        String str4 = null;

        String str5 = "123";

        String str6 = "ABCDEFG";

        String str7 = "It feels good to use Jakarta Commons.\r\n";

        // check for empty strings

        System.out.println("==============================");

        System.out.println("Is str1 blank? " + StringUtils.isBlank(str1));

        System.out.println("Is str2 blank? " + StringUtils.isBlank(str2));

        System.out.println("Is str3 blank? " + StringUtils.isBlank(str3));

        System.out.println("Is str4 blank? " + StringUtils.isBlank(str4));

        // check for numerics

        System.out.println("==============================");

        System.out.println("Is str5 numeric? " + StringUtils.isNumeric(str5));

        System.out.println("Is str6 numeric? " + StringUtils.isNumeric(str6));

        // reverse strings / whole words

        System.out.println("==============================");

        System.out.println("str6: " + str6);

        System.out.println("str6 reversed: " + StringUtils.reverse(str6));

        System.out.println("str7: " + str7);

        String str8 = StringUtils.chomp(str7);

        str8 = StringUtils.reverseDelimited(str8, ' ');

        System.out.println("str7 reversed whole words : \r\n" + str8);

        // build header (useful to print log messages that are easy to locate)

        System.out.println("==============================");

        System.out.println("print header:");

        String padding = StringUtils.repeat("=", 50);

        String msg = StringUtils.center(" Customised Header ", 50, "%");

        Object[] raw = new Object[]{padding, msg, padding};

        String header = StringUtils.join(raw, "\r\n");

        System.out.println(header);

    }

}

输出的结果如下：

==============================

Is str1 blank? true

Is str2 blank? true

Is str3 blank? true

Is str4 blank? true

==============================

Is str5 numeric? true

Is str6 numeric? false

==============================

str6: ABCDEFG

str6 reversed: GFEDCBA

str7: It feels good to use Jakarta Commons.

str7 reversed whole words :

Commons. Jakarta use to good feels It

==============================

print header:

==================================================

%%%%%%%%%%%%%%% Customised Header %%%%%%%%%%%%%%%%

==================================================

CompareToBuilder – 用于辅助实现Comparable.compareTo(Object)方法；

EqualsBuilder – 用于辅助实现Object.equals()方法；

HashCodeBuilder – 用于辅助实现Object.hashCode()方法；

ToStringBuilder – 用于辅助实现Object.toString()方法；

ReflectionToStringBuilder – 使用反射机制辅助实现Object.toString()方法；

ToStringStyle – 辅助ToStringBuilder控制输出格式；

StandardToStringStyle – 辅助ToStringBuilder控制标准格式。

我们知道，在实际应用中，其实经常需要在运行过程中判定对象的知否相等、比较、取hash、和获取对象基本信息（一般是产生log日志）。然而实现这些compareTo、equals、hashCode、toString其实并非那么直截了当，甚至稍有不注意就可能造成难以追踪的bug，而且这些方法手工维护的话，比较繁琐，也容易出错。于是Commons Lang在builder这个包中提供了上述辅助类，为我们简化这些方法的实现和维护。

来看一个例子：

package sean.study.jakarta.commons.lang;

import java.util.Date;

import org.apache.commons.lang.builder.CompareToBuilder;

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

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

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

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

public class BuilderUsage {

    public static void main(String[] args) {

        Staff staff1 = new Staff(123, "John Smith", new Date());

        Staff staff2 = new Staff(456, "Jane Smith", new Date());

        System.out.println("staff1's info: " + staff1);

        System.out.println("staff2's info: " + staff2);

        System.out.println("staff1's hash code: " + staff1.hashCode());

        System.out.println("staff2's hash code: " + staff2.hashCode());

        System.out.println("staff1 equals staff2? " + staff1.equals(staff2));

    }

}

class Staff implements Comparable {

    private long staffId;

    private String staffName;

    private Date dateJoined;

    public Staff() {

    }

    public Staff(long staffId, String staffName, Date dateJoined) {

        this.staffId = staffId;

        this.staffName = staffName;

        this.dateJoined = dateJoined;

    }

    public int compareTo(Object o) {

        int res = -1;

        if (o != null && Staff.class.isAssignableFrom(o.getClass())) {

            Staff s = (Staff) o;

            res = new CompareToBuilder()

                    .append(dateJoined, s.getDateJoined())

                    .append(staffName, s.getStaffName()).toComparison();

        }

        return res;

    }

    public boolean equals(Object o) {

        boolean res = false;

        if (o != null && Staff.class.isAssignableFrom(o.getClass())) {

            Staff s = (Staff) o;

            res = new EqualsBuilder()

                    .append(staffId, s.getStaffId())

                    .isEquals();

        }

        return res;

    }

    public int hashCode() {

        return new HashCodeBuilder(11, 23).append(staffId).toHashCode();

    }

    public String toString() {

        return new ToStringBuilder(this, ToStringStyle.MULTI_LINE_STYLE)

                .append("staffId", staffId)

                .append("staffName", staffName)

                .append("dateJoined", dateJoined)

                .toString();

    }

    public Date getDateJoined() {

        return dateJoined;

    }

    public void setDateJoined(Date dateJoined) {

        this.dateJoined = dateJoined;

    }

    public long getStaffId() {

        return staffId;

    }

    public void setStaffId(long staffId) {

        this.staffId = staffId;

    }

    public String getStaffName() {

        return staffName;

    }

    public void setStaffName(String staffName) {

        this.staffName = staffName;

    }

}

以下是运行结果：

staff1's info: sean.study.jakarta.commons.lang.Staff@190d11[

  staffId=123

  staffName=John Smith

  dateJoined=Sat Jul 30 13:18:45 CST 2005

]

staff2's info: sean.study.jakarta.commons.lang.Staff@1fb8ee3[

  staffId=456

  staffName=Jane Smith

  dateJoined=Sat Jul 30 13:18:45 CST 2005

]

staff1's hash code: 376

staff2's hash code: 709

staff1 equals staff2? false

这些builder使用起来都很简单，new一个实例，append需要参与的信息，最后加上toComparison、isEquals、toHashCode、toString这样的结尾即可。相应的，如果你不需要这样级别的控制，也可以使用利用反射机制的版本自动化实现需要的功能，如：

    public int compareTo(Object o) {

        return CompareToBuilder.reflectionCompare(this, o);

    }

    public boolean equals(Object o) {

        return EqualsBuilder.reflectionEquals(this, o);

    }

    public int hashCode() {

        return HashCodeBuilder.reflectionHashCode(this);

    }

    public String toString() {

        return ReflectionToStringBuilder.toString(this);

    }

ArrayUtils – 用于对数组的操作，如添加、查找、删除、子数组、倒序、元素类型转换等；

BitField – 用于操作位元，提供了一些方便而安全的方法；

BooleanUtils – 用于操作和转换boolean或者Boolean及相应的数组；

CharEncoding – 包含了Java环境支持的字符编码，提供是否支持某种编码的判断；

CharRange – 用于设定字符范围并做相应检查；

CharSet – 用于设定一组字符作为范围并做相应检查；

CharSetUtils – 用于操作CharSet；

CharUtils – 用于操作char值和Character对象；

ClassUtils – 用于对Java类的操作，不使用反射；