apache 常用类和方法

常用组件和类

org.apache.commons

org.apache.commons.beanutils.BeanUtils

//将相同名称属性值从源orig复制到目标dest（支持bean和map，支持部分类型自动转换）
static void copyProperties(Object dest, Object orig)

//将源orig的name属性值复制到目标dest
static void copyProperty(Object dest, String name, Object orig)

//将Map orig的属性值复制到目标dest
static void populate(Object dest, Map<String,? extends Object> orig)

//将value值根据需要执行类型转换再设置到dest的name属性中
static void setProperty(Object dest, String name, Object value)

BeanUtils.copyProperties 性能非常低，可以用以下方式替换：

1. springframework的BeanUtils
2. cglib的BeanCopier
3. Apache BeanUtils包的PropertyUtils

1. org.springframework.beans.BeanUtils

//将相同名称属性值从source复制到target（不支持map，不支持类型转换）
static void copyProperties(Object source, Object target)

2. org.springframework.cglib.beans.BeanCopier

//指定拷贝的source类和target类以及是否使用类型转换
static BeanCopier create(Class source, Class target, boolean useConverter)

//结合上一个方法使用，将相同名称属性值从source复制到target（不支持map，选择使用类型转换）
abstract void copy(Object source, Object target, Converter var1)

//补充 org.springframework.cglib.beans
//目标bean转BeanMap
static BeanMap create(Object bean)

举例：字符串转Date

        BeanCopier copier = BeanCopier.create(User.class, User2.class, true);
        copier.copy(origUser, targetUser, new Converter() {
            @Override
            public Object convert(Object sourceValue, Class targetClass, Object o1) {
                if (sourceValue instanceof Date) {
                    Date sourceDate = (Date) sourceValue;
                    return DateFormatUtils.format(sourceDate, "yyyy-MM-dd HH:mm:ss");
                }
                return sourceValue;
            }
        });

3. org.apache.commons.beanutils.PropertyUtils

//将相同名称属性值从source复制到target（支持map，不支持类型转换）
static void copyProperties(final Object dest, final Object orig)

org.apache.commons.beanutils.ConvertUtils

//注册转换器针对目标类clazz
static void register(final Converter converter, final Class<?> clazz)

举例：字符串转Date

 ConvertUtils.register(new Converter() {
            @Override
            public Object convert(Class type, Object sourceValue) {
                try {
                    return  DateUtils.parseDate(sourceValue.toString(),"yyyy-MM-dd HH:mm:ss");
                } catch (ParseException e) {
                    e.printStackTrace();
                }
                return null;
            }
        }, Date.class);
//后调用拷贝方法
BeanUtils.copyProperties(destUser, sourceUser);

org.apache.commons.collections4.CollectionUtils

//将数组中的所有元素添加到给定集合
static <C> boolean addAll(Collection<C> collection, C... elements)

//如果coll2中元素都包含在coll1中就返回true
static boolean containsAll(Collection<?> coll1, Collection<?> coll2)

//检查集合是否为空，coll==null或者coll.size==0返回true
static boolean isEmpty(Collection<?> coll)

//检查集合是否为空，coll!=null并且coll.size>0返回true
static boolean isNotEmpty(Collection<?> coll)

//从集合中移除掉remove集合中包含的元素
static <E> Collection<E> removeAll(Collection<E> collection, Collection<?> remove)

//返回两个集合都包含的元素集合
static <C> Collection<C> retainAll(Collection<C> collection, Collection<?> retain)

org.apache.commons.collections4.MapUtils

更多参考：https://blog.csdn.net/u012894692/article/details/82557843

//如果map为null，返回null,否则返回map中k对应值
static <K> String getString(Map<? super K,?> map, K key)

//如果map==null返回0，否则返回map.size()
static int size(Map<?,?> map)

//返回一个同步map
static <K,V> Map<K,V> synchronizedMap(Map<K,V> map)

org.apache.commons.collections4.ListUtils

//判断两个集合是否包含相同的元素
static boolean isEqualList(Collection<?> list1, Collection<?> list2)

//从第一个列表中减去第二个列表中的所有元素，将结果放入一个新列表。
static <E> List<E>	subtract(List<E> list1, List<? extends E> list2)

//返回一个同步list
static <E> List<E>	synchronizedList(List<E> list)

//返回一个新集合，是两个集合的并集
static <E> List<E>	union(List<? extends E> list1, List<? extends E> list2)

org.apache.commons.collections4.SetUtils

//返回一个hashSet
static <E> HashSet<E>	hashSet(E... items)

//返回一个同步set
static <E> Set<E>	synchronizedSet(Set<E> set)

//返回一个排序后的Set
static <E> Set<E>	orderedSet(Set<E> set)

org.apache.commons.io.FilenameUtils

Linux 下的分隔符：/
Windows 下的分隔符：\

//将文件名连接到基础路径
static String concat(String basePath, String fullFilenameToAdd)

//获取文件的全路径
static String	getFullPath(String filename)

//获取文件的全路径去掉最后的分隔符
static String	getFullPathNoEndSeparator(String filename)

//获取文件路径
static String	getPath(String filename)

//获取文件路径去掉最后的分隔符
static String	getPathNoEndSeparator(String filename)

//获取文件名
static String	getName(String filename)

//完整文件名去除路径和后缀后的文件名
static String	getBaseName(String filename)

//获取文件路径前缀
static String	getPrefix(String filename)

//获取文件的后缀
static String	getExtension(String filename)

//是否是指定的后缀
static boolean	isExtension(String filename, String extension)

//后缀是否在指定的后缀数组中
static boolean	isExtension(String filename, String[] extensions)

//后缀是否在指定的后缀集合中
static boolean	isExtension(String filename, Collection<String> extensions)

//文件的全路径去除后缀
static String	removeExtension(String filename)

//获取当前系统格式化路径(windowns:"\\",linux:"/")
static String	normalize(String filename)

//转换分隔符为当前系统分隔符(windowns:"\\",linux:"/")
static String	separatorsToSystem(String path)

FilenameUtils.concat("D:\\a\\b", "xx.txt");// D:\a\b\xx.txt

FilenameUtils.getFullPath("D:\\a\\b\\xx.txt");// D:\a\b\
FilenameUtils.getFullPathNoEndSeparator("D:\\a\\b\\xx.txt");// D:\a\b
FilenameUtils.getPath("D:\\a\\b\\xx.txt");// a\b\
FilenameUtils.getPathNoEndSeparator("D:\\a\\b\\xx.txt");// a\b

FilenameUtils.getName("D:\\a\\b\\xx.txt");// xx.txt
FilenameUtils.getBaseName("D:\\a\\b\\xx.txt");// xx

FilenameUtils.getPrefix("D:\\a\\b\\xx.txt");// D:\
FilenameUtils.getExtension("D:\\a\\b\\xx.txt");// txt

FilenameUtils.isExtension("D:\\a\\b\\xx.txt","txt");// true
FilenameUtils.isExtension("D:\\a\\b\\xx.txt",new String[]{"exe","txt","sql"});//true
FilenameUtils.isExtension("D:\\a\\b\\xx.txt",Arrays.asList(new String[]{"exe","txt","sql"}));// true
FilenameUtils.removeExtension("D:\\a\\b\\xx.txt");// D:\a\b\xx

FilenameUtils.normalize("D:\\a\\b\\xx.txt");// D:\a\b\xx.txt
FilenameUtils.separatorsToSystem("D:\\a\\b");// D:\a\b

org.apache.commons.io.FileUtils

//删除目录下的所有文件和文件夹
static void	cleanDirectory(File directory)

//将srcDir目录下的文件和文件夹拷贝到destDir目录，保留文件日期
static void	copyDirectory(File srcDir, File destDir)

//将srcDir目录下的文件和文件夹拷贝到destDir目录，控制是否保留文件日期
static void	copyDirectory(File srcDir, File destDir, boolean preserveFileDate)

//将srcDir目录下的文件和文件夹过滤后拷贝到destDir目录，保留文件日期
static void	copyDirectory(File srcDir, File destDir, FileFilter filter)

//将srcDir目录下的文件和文件夹过滤后拷贝到destDir目录，控制是否保留文件日期
static void	copyDirectory(File srcDir, File destDir, FileFilter filter, boolean preserveFileDate)

//将srcDir目录最后一个文件夹及下的文件和文件夹过滤后拷贝到destDir目录
static void	copyDirectoryToDirectory(File srcDir, File destDir)

//拷贝srcFile文件到destFile文件，保留文件日期
static void	copyFile(File srcFile, File destFile)

//拷贝srcFile文件到destFile文件，控制是否保留文件日期
static void	copyFile(File srcFile, File destFile, boolean preserveFileDate)

//拷贝input文件到output输出流，返回拷贝字节大小
static long	copyFile(File input, OutputStream output)

//拷贝srcFile文件到destDir目录下，保留文件日期
static void	copyFileToDirectory(File srcFile, File destDir)

//拷贝srcFile文件到destDir目录下，控制是否保留文件日期
static void	copyFileToDirectory(File srcFile, File destDir, boolean preserveFileDate)

//将source输入流拷贝到destination文件
static void	copyInputStreamToFile(InputStream source, File destination)

//拷贝src文件或者目录到destDir目录，保留文件日期
static void	copyToDirectory(File src, File destDir)

//拷贝多个文件到destDir目录，保留每个文件的日期
static void	copyToDirectory(Iterable<File> srcs, File destDir)

//将source输入流拷贝到destination文件
static void	copyToFile(InputStream source, File destination)

//删除directory目录
static void	deleteDirectory(File directory)

//删除一个文件，不会抛出异常
static boolean	deleteQuietly(File file)

//directory目录拼接上child目录或者文件
static boolean	directoryContains(File directory, File child)

//强制删除文件或者目录
static void	forceDelete(File file)

//将srcDir目录移到destDir目录下
static void	moveDirectory(File srcDir, File destDir)

//移动文件,并重新命名
static void	moveFile(File srcFile, File destFile)

//移送srcFile文件到destDir目录
static void	moveFileToDirectory(File srcFile, File destDir, boolean createDestDir)

//移送srcFile文件或目录到destDir目录
static void	moveToDirectory(File src, File destDir, boolean createDestDir)

//获取文件输入流，file有问题时会抛出更详细日志
static FileInputStream	openInputStream(File file)

//获取文件输出流，file有问题时会抛出更详细日志
static FileOutputStream	openOutputStream(File file)

//把文件读到字节数组中
static byte[]	readFileToByteArray(File file)

//逐行将文件内容读取到字符串列表中。
static List<String>	readLines(File file, String encoding)

//返回文件或者目录的大小(递归地计算一个目录的所有文件的长度的总和)，单位:KB
static long	sizeOf(File file)

//获取指定文件或目录大小(递归地计算一个目录的所有文件的长度的总和)，单位:KB
static BigInteger	sizeOfAsBigInteger(File file)

有疑问的方法示例：

File directory = new File("D:\\a\\b");
File file = new File("D:\\a\\b\\xx.txt");
File file1 = new File("D:\\a\\b\\xx1.txt");

FileUtils.cleanDirectory(directory);//D:\a\b\xx.txt目录下 xx.txt被删除
FileUtils.copyDirectory(directory,new File("D:\\a1"));//将D:\a\b下的xx.txt复制到了D:\a1
FileUtils.copyDirectoryToDirectory(directory,new File("D:\\a1"));//将b文件夹及xx.txt复制到了D:\a1
FileUtils.copyFile(file,file1);//xx.txt文件拷贝到了xx1.txt

org.apache.commons.io.IOUtils

//创建一个缓存输入流
static BufferedInputStream	buffer(InputStream inputStream)

//创建一个缓存输出流
static BufferedOutputStream	buffer(OutputStream outputStream)

//创建一个缓存输入流
static BufferedReader	buffer(Reader reader)

//创建一个缓存输出流
static BufferedWriter	buffer(Writer writer)

//关闭URL连接
static void	close(URLConnection conn)

//关闭流，会做非空判断（类似流关闭都已过时，用try-with-resources语句）
static void	closeQuietly(InputStream input)

//拷贝InputStream 到OutputStream，返回拷贝字节数量
static int	copy(InputStream input, OutputStream output)

//指定输入编码拷贝input到output
static void	copy(InputStream input, Writer output, String inputEncoding)

//指定输出编码拷贝input到output
static void	copy(Reader input, OutputStream output, String outputEncoding)

//拷贝input到output
static int	copy(Reader input, Writer output)

//拷贝超过2GB的流文件input到output
static long	copyLarge(InputStream input, OutputStream output)

//拷贝超过2GB的流文件input到output
static long	copyLarge(Reader input, Writer output)

org.apache.commons.lang3.ArrayUtils

//在原数组中添加一个元素，返回一个新数组，xxx为boolean、int、long等基础类型
static xxx[]	add(boolean[] array, xxx element)

//在原数组中添加一个元素，返回一个新数组
static <T> T[]	add(T[] array, T element)

//在原数组中添加多个元素，返回一个新数组，xxx为boolean、int、long等基础类型
static xxx[]	addAll(xxx[] array1, xxx... array2)

//在原数组中添加多个元素，返回一个新数组
static <T> T[]	addAll(T[] array1, T... array2)

//克隆返回类型转换结果并处理空值的数组。xxx为boolean、int、long等基础类型(深拷贝)
static xxx[]	clone(xxx[] array)

//克隆返回类型转换结果并处理空值的数组。(深拷贝)
static <T> T[]	clone(T[] array)

//检查objectToFind是否在数组中
static boolean	contains(Object[] array, Object objectToFind)

//array为null返回0，否则返回array长度
static int	getLength(Object array)

//查找valueToFind在数组中第一次出现的索引，xxx为boolean、int、long等基础类型
static int	indexOf(xxx[] array, xxx valueToFind)

//从索引startIndex开始查找valueToFind在数组中第一次出现的索引，xxx为boolean、int、long等基础类型
static int	indexOf(xxx[] array, xxx valueToFind, int startIndex)

//查找valueToFind在数组中第一次出现的索引
static int	indexOf(Object[] array, Object objectToFind)

//从索引startIndex开始查找valueToFind在数组中第一次出现的索引
static int	indexOf(Object[] array, Object objectToFind, int startIndex)

//在数组指定索引位置添加多个元素，返回一个新数组，xxx为boolean、int、long等基础类型
static xxx[]	insert(int index, xxx[] array, xxx... values)

//在数组指定索引位置添加多个元素，返回一个新数组
static <T> T[]	insert(int index, T[] array, T... values)

//检查数组是否是空的，null返回true,xxx为boolean、int、long等基础类型
static boolean	isEmpty(xxx[] array)

//检查数组是否不是空的，null返回false,xxx为boolean、int、long等基础类型
static boolean	isNotEmpty(xxx[] array)

//检查数组是否不是空的，null返回false
static <T> boolean	isNotEmpty(T[] array)

//判断两个数组长度是相同，null长度为0
static boolean	isSameLength(boolean[] array1, boolean[] array2)

//判断两个数组类型是相同
static boolean	isSameType(Object array1, Object array2)

//此方法检查提供的数组是否按自然顺序排序（true之前为false)
static boolean	isSorted(xxx[] array)

//valueToFind在数组中最后出现的索引
static int	lastIndexOf(xxx[] array, xxx valueToFind)

//valueToFind在数组中最后出现的索引
static int	lastIndexOf(Object[] array, Object objectToFind)

//从索引startIndex开始valueToFind在数组中最后出现的索引
static int	lastIndexOf(Object[] array, Object objectToFind, int startIndex)

//array为null就返回一个空数组，否则返回array
static xxx[]	nullToEmpty(xxx[] array)

//array为null就返回一个空数组，否则返回array
static Object[]	nullToEmpty(Object[] array)

//array为null就返回一个空type类型数组，否则返回array
static <T> T[]	nullToEmpty(T[] array, Class<T[]> type)

//数组移除指定索引元素，返回一个新数组
static xxx[]	remove(xxx[] array, int index)

//数组移除指定索引元素，返回一个新数组
static <T> T[]	remove(T[] array, int index)

//数组移除多个指定索引元素，返回一个新数组
static xxx[]	removeAll(xxx[] array, int... indices)

//数组移除多个指定索引元素，返回一个新数组
static <T> T[]	removeAll(T[] array, int... indices)

//数组移除所有的element元素，返回一个新数组
static xxx[]	removeAllOccurences(xxx[] array, xxx element)

//数组移除所有的element元素，返回一个新数组
static <T> T[]	removeAllOccurences(T[] array, T element)

//数组移除第一个element元素，返回一个新数组
static xxx[]	removeElement(xxx[] array, xxx element)

//数组移除第一个element元素，返回一个新数组
static <T> T[]	removeElement(T[] array, Object element)

//数组移除多个element元素，返回一个新数组
static boolean[]	removeElements(boolean[] array, boolean... values)

//数组移除多个element元素，返回一个新数组
static <T> T[]	removeElements(T[] array, T... values)

//反转给定数组的顺序
static void	reverse(xxx[] array)

//反转给定数组指定索引范围内元素的顺序
static void	reverse(xxx[] array, int startIndexInclusive, int endIndexExclusive)

//反转给定数组的顺序
static void	reverse(Object[] array)

//反转给定数组指定索引范围内元素的顺序
static void	reverse(Object[] array, int startIndexInclusive, int endIndexExclusive)

//将数组按照指定索引范围截取出一个新数组
static xxx[]	subarray(xxx[] array, int startIndexInclusive, int endIndexExclusive)

//将数组按照指定索引范围截取出一个新数组
static <T> T[]	subarray(T[] array, int startIndexInclusive, int endIndexExclusive)

//交换指定索引的两个元素
static void	swap(xxx[] array, int offset1, int offset2)

//交换指定索引的两个元素
static void	swap(Object[] array, int offset1, int offset2)

//转换成map
static Map<Object,Object>	toMap(Object[] array)

//转换成包装类型
static Xxx[]	toObject(xxx[] array)

//转换成基础类型
static xxx[]	toPrimitive(Xxx[] array)

//转换成基础类型,null指用默认值valueForNull替换
static xxx[]	toPrimitive(Xxx[] array, xxx valueForNull)

//从包装类型数组创建基础类型数组。
static Object	toPrimitive(Object array)

//将数组输出为字符串，将null视为空数组。
static String	toString(Object array)

//返回一个数组，该数组包含参数数组中每个元素的字符串表示形式
static String[]	toStringArray(Object[] array)

//返回一个数组，该数组包含处理空元素的参数数组中每个元素的字符串表示形式,null值用valueForNullElements替换
static String[]	toStringArray(Object[] array, String valueForNullElements)

org.apache.commons.lang3.StringUtils

//检查seq是否包含searchSeq，处理空值
static boolean	contains(CharSequence seq, CharSequence searchSeq)

//检查cs是否包含给定数组searchCharSequences中的任何y元素。
static boolean	containsAny(CharSequence cs, CharSequence... searchCharSequences)

//检查seq是否包含searchSeq，忽略大小写，处理空值
static boolean	containsIgnoreCase(CharSequence str, CharSequence searchStr)

//返回传入字符串，如果字符串为null，则返回空字符串（“”）
static String	defaultString(String str)

//返回传入字符串，如果字符串为null，则返回defaultStr
static String	defaultString(String str, String defaultStr)

//检查字符序列是否以指定的后缀结尾。
static boolean	endsWith(CharSequence str, CharSequence suffix)

//检查字符序列是否以提供的数组中任何后缀结尾，区分大小写
static boolean	endsWithAny(CharSequence sequence, CharSequence... searchStrings)

//检查字符序列是否以指定的后缀结尾，忽略大小写
static boolean	endsWithIgnoreCase(CharSequence str, CharSequence suffix)

//比较两个字符序列，如果它们表示相等的字符序列，则返回true。
static boolean	equals(CharSequence cs1, CharSequence cs2)

//查找数组中是否有和指定字符序列相等的字符序列
static boolean	equalsAny(CharSequence string, CharSequence... searchStrings)

//比较两个字符序列，如果它们表示相等的字符序列，则返回true，忽略大小写
static boolean	equalsIgnoreCase(CharSequence cs1, CharSequence cs2)

//查找数组中是否有和指定字符序列相等的字符序列，忽略大小写
static boolean	equalsAnyIgnoreCase(CharSequence string, CharSequence... searchStrings)

//查找seq中的第一个索引，处理空值。
static int	indexOf(CharSequence seq, CharSequence searchSeq)

//从startPos开始查找seq中的第一个索引，处理空值。
static int	indexOf(CharSequence seq, CharSequence searchSeq, int startPos)

//查找seq中的第一个索引，处理空值。忽略大小写
static int	indexOfIgnoreCase(CharSequence str, CharSequence searchStr)

//从startPos开始查找seq中的第一个索引，处理空值。忽略大小写
indexOfIgnoreCase(CharSequence str, CharSequence searchStr, int startPos)

//检查字符序列是否为空（“”）、null或者空格
static boolean	isBlank(CharSequence cs)

//检查字符序列是否为空（“”）、null
static boolean	isEmpty(CharSequence cs)

//检查字符序列数组中是否没有为空（“”）、null或者空格
static boolean	isNoneBlank(CharSequence... css)

//检查字符序列数组中是否没有为空（“”）、null
static boolean	isNoneEmpty(CharSequence... css)

//检查字符序列是否不为空（“”）、null或者空格
static boolean	isNotBlank(CharSequence cs)

//检查字符序列是否不为空（“”）、null
static boolean	isNotEmpty(CharSequence cs)

//将separator拼接在数组元素之间
static String	join(xxx[] array, char separator)

//将separator拼接在数组元素之间
static String	join(Object[] array, String separator)

//将separator拼接在数组元素之间
static String	joinWith(String separator, Object... objects)

//返回指定字符最后一次出现的序列内的索引。
static int	lastIndexOf(CharSequence seq, CharSequence searchSeq)

//返回指定字符最后一次出现的序列内的索引。忽略大小写
static int	lastIndexOfIgnoreCase(CharSequence str, CharSequence searchStr)

//获取cs长度，如果cs为空，则为0。
static int	length(CharSequence cs)

//转换为小写
static String	lowerCase(String str)

//从源字符串中删除子字符串的所有出现项。
static String	remove(String str, String remove)

//从源字符串中删除子字符串的所有出现项。忽略大小写
static String	removeIgnoreCase(String str, String remove)

//替换searchString中所有text为replacement
static String	replace(String text, String searchString, String replacement)

//替换searchString中所有text为replacement，忽略大小写
static String	replaceIgnoreCase(String text, String searchString, String replacement)

//按照separatorChars分隔符将文本拆分为一个数组
static String[]	split(String str, String separatorChars)

//检查字符序列是否以指定的前缀开头。
static boolean	startsWith(CharSequence str, CharSequence prefix)

//从字符串的开始和结束处删除空隔
static String	strip(String str)

//从字符串的开始和结束处删除stripChars
static String	strip(String str, String stripChars)

//从字符串的结束处删除stripChars
static String	stripEnd(String str, String stripChars)

//从字符串的开始处删除stripChars
static String	stripStart(String str, String stripChars)

//从指定的字符串中获取避免异常的子字符串。
static String	substring(String str, int start)

//从指定的字符串中获取避免异常的子字符串。
static String	substring(String str, int start, int end)

//获取第一次出现分隔符后的子字符串。
static String	substringAfter(String str, String separator)

//获取嵌套在两个字符串之间的字符串
static String	substringBetween(String str, String open, String close)

//交换字符串的大小写，将大写更改为小写，小写更改为大写。
static String	swapCase(String str)

//从该字符串的两端删除控制字符（char<=32），str为null则返回null
static String	trim(String str)

//将字符串转换为大写。
static String	upperCase(String str)

//返回char数组的字符串表示形式或为null
static String	valueOf(char[] value)

org.apache.commons.lang3.BooleanUtils

//检查一个Boolean 值是否是false，null也返回false
static boolean	isFalse(Boolean bool)

//检查一个Boolean 值是否是true，null也返回true
static boolean	isTrue(Boolean bool)

//Boolean转boolean,null返回false
static boolean	toBoolean(Boolean bool)

//将字符串转换为布尔值（优化性能）
static boolean	toBoolean(String str)

//将字符串转换为布尔值
static Boolean	toBooleanObject(String str)

org.apache.commons.lang3.time.DateFormatUtils

//将日历格式化为特定模式
static String	format(Calendar calendar, String pattern)

//将date或者time格式化为特定模式
static String	format(Date date, String pattern)

//将时间戳格式化为特定模式
static String	format(long millis, String pattern)

org.apache.commons.lang3.time.DateUtils

//一天换算成毫秒：86400000L
static long	MILLIS_PER_DAY

//一个小时换算成毫秒：3600000L
static long	MILLIS_PER_HOUR

//一分钟换算成毫秒：60000
static long	MILLIS_PER_MINUTE

//一秒钟换算成毫秒：1000
static long	MILLIS_PER_SECOND

static Date	addYears(Date date, int amount)
static Date	addMonths(Date date, int amount)
static Date	addDays(Date date, int amount)
static Date	addHours(Date date, int amount)
static Date	addMinutes(Date date, int amount)
static Date	addSeconds(Date date, int amount)
static Date	addWeeks(Date date, int amount)

//从给定字段开始“向上”格式化日期
static Calendar	ceiling(Calendar date, int field)

//从给定字段开始“向上”格式化日期
static Date	ceiling(Date date, int field)

//fragment是Calendar时间常量字段，Xxx是Days、Hours、Minutes等，返回结果如：Days 返回今天是对应的本年或者本月第几天
static long	getFragmentInXxx(Calendar calendar, int fragment)

//fragment是Calendar时间常量字段，Xxx是Days、Hours、Minutes等，返回结果如：Days 返回今天是对应的本年或者本月第几天
static long	getFragmentInXxx(Date date, int fragment)

//对时间设置对应字段，Xxx是Days、Hours、Minutes等
static Date	setXxx(Date date, int amount)

//判断两个日历是否是同一天。忽略time
static boolean	isSameDay(Calendar cal1, Calendar cal2)

//判断两个日期是否是同一天。忽略time
static boolean	isSameDay(Date date1, Date date2)

//解析器数组中依次尝试解析表示日期的字符串
static Date	parseDate(String str, String... parsePatterns)

//对日期时间进行四舍五入。filed指定取整的字段
static Calendar	round(Calendar date, int field)

//对日期时间进行四舍五入。filed指定取整的字段
static Date	round(Date date, int field)

//date转Calendar	
static Calendar	toCalendar(Date date)

//从给定字段开始格式化截取日期
static Calendar	truncate(Calendar date, int field)

//从给定字段开始格式化截取日期
static Date	truncate(Date date, int field)

//从给定字段开始格式化截取日期,然后比较
static int	truncatedCompareTo(Calendar cal1, Calendar cal2, int field)

//从给定字段开始格式化截取日期,然后比较
static int	truncatedCompareTo(Date date1, Date date2, int field)

//从给定字段开始格式化截取日期,然后比较是否相等
static boolean	truncatedEquals(Calendar cal1, Calendar cal2, int field)

//从给定字段开始格式化截取日期,然后比较是否相等
static boolean	truncatedEquals(Date date1, Date date2, int field)

疑问示范：

static Date ceiling(Date date, int field)
从给定字段开始“向上”格式化日期

// 当前时间为'2017-06-04 01:02:31'，则执行以下代码
DateUtils.ceiling(new Date(), Calendar.YEAR); // 2018-01-01 00:00:00
DateUtils.ceiling(new Date(), Calendar.MONTH); // 2017-07-01 00:00:00
DateUtils.ceiling(new Date(), Calendar.HOUR_OF_DAY); // 2017-06-04 02:00:00
DateUtils.ceiling(new Date(), Calendar.DAY_OF_MONTH); // 2017-06-05 00:00:00
DateUtils.ceiling(new Date(), Calendar.HOUR); // 2017-06-04 02:00:00
DateUtils.ceiling(new Date(), Calendar.MINUTE); // 2017-06-04 01:03:00
DateUtils.ceiling(new Date(), Calendar.SECOND); // 2017-06-04 01:02:32

long getFragmentInDays(Date date, int fragment)
fragment是Calendar时间常量字段，返回今天是对应的本年或者本月第几天

注意：小时必须用24小时制的，即Calendar.HOUR_OF_DAY，而不能用Calendar.HOUR字段。

// 当前时间为'2017-02-04 01:12:31'，则执行以下代码
DateUtils.getFragmentInDays(new Date(), Calendar.YEAR); // 35
DateUtils.getFragmentInDays(new Date(), Calendar.MONTH); // 4

static Date round(Date date, int field)
对日期时间进行四舍五入。filed指定取整的字段，可以取的值为

• Calendar.SECOND
• Calendar.MINUTE
• Calendar.HOUR_OF_DAY
• Calendar.DAY_OF_MONTH
• Calendar.MONTH
• Calendar.YEAR

// 当前时间为'2017-06-04 00:44:41'，则执行以下代码
DateUtils.round(new Date(), Calendar.YEAR); // 2017-01-01 00:00:00
DateUtils.round(new Date(), Calendar.MONTH); // 2017-06-01 00:00:00
DateUtils.round(new Date(), Calendar.HOUR_OF_DAY); // 2017-06-04 01:00:00
DateUtils.round(new Date(), Calendar.DAY_OF_MONTH); // 2017-06-04 00:00:00
DateUtils.round(new Date(), Calendar.HOUR); // 2017-06-04 01:00:00
DateUtils.round(new Date(), Calendar.MINUTE); // 2017-06-04 00:45:00
DateUtils.round(new Date(), Calendar.SECOND); // 2017-06-04 00:44:43

static Date truncate(Date date, int field)
从给定字段开始格式化截取日期。对一个时间对象的某个字段进行截断。

// 当前时间为'2017-06-04 00:56:05'，则执行以下代码
DateUtils.truncate(new Date(), Calendar.YEAR); // 2017-01-01 00:00:00
DateUtils.truncate(new Date(), Calendar.MONTH); // 2017-06-01 00:00:00
DateUtils.truncate(new Date(), Calendar.HOUR_OF_DAY); // 2017-06-04 00:00:00
DateUtils.truncate(new Date(), Calendar.DAY_OF_MONTH); // 2017-06-04 00:00:00
DateUtils.truncate(new Date(), Calendar.HOUR); // 2017-06-04 00:00:00
DateUtils.truncate(new Date(), Calendar.MINUTE); // 2017-06-04 00:56:00
DateUtils.truncate(new Date(), Calendar.SECOND); // 2017-06-04 00:56:05

org.apache.commons.lang3.time.FastDateFormat

FastDateFormat是一个快速且线程安全的时间操作类，它完全可以替代SimpleDateFromat。因为是线程安全的，所以你可以把它作为一个类的静态字段使用。构造方法为protected，不允许直接构造它的对象，可以通过工厂方法获取。FastDateFormat之所以是线程安全的，是因为这个类是无状态的：内部的成员在构造时就完成了初始化，并在对象存活期，不提供任何API供外界修改他们。

常用方式：

private static final FastDateFormat DATE_FORMATTER = FastDateFormat.getInstance("yyyy-MM-dd HH:mm:ss");

//格式化calendar对象
String	format(Calendar calendar)

//格式化date对象
String	format(Date date)

//格式化时间戳
String	format(long millis)

//获取在默认时区和区域设置中使用指定样式的日期格式化程序实例
static FastDateFormat	getDateInstance(int style)

//获取在默认时区和区域设置中使用指定样式的日期和时刻格式化程序实例
static FastDateFormat	getDateTimeInstance(int dateStyle, int timeStyle)

//获取在默认区域设置中使用默认模式的格式化程序实例。
static FastDateFormat	getInstance()

//根据格式获取在默认区域设置中使用默认模式的格式化程序实例。
static FastDateFormat	getInstance(String pattern)

//获取在默认时区和区域设置中使用指定样式的时刻格式化程序实例。
static FastDateFormat	getTimeInstance(int style)

//字符串解析为date
Date	parse(String source)

org.apache.commons.lang3.time.StopWatch

StopWatch是一个方便的计时器。

//提供一个秒表并启动
static StopWatch	createStarted()

//开始计时
void	start()

//停止计时
void	stop()

//重置计时
void	reset()

//暂停计时
void	suspend()

//继续计时
void	resume()

//获取消耗的纳秒数
long	getNanoTime()

//获取消耗的毫秒数
long	getTime()

//获取开始的毫秒数
long	getStartTime()

//是否开始
boolean	isStarted()

//是否暂停
boolean	isSuspended()

//是否停止
boolean	isStopped()

使用示例

StopWatch stopWatch = new StopWatch();
stopWatch.start();
...
stopWatch.stop();
System.out.println(stopWatch.getTime());