开发Commons实用工具

一、介绍

1.commons-codec

在实际的应用中，我们经常需要对字符串进行编解码，​​Apache Commons​​​家族中的​​Commons Codec​​​就提供了一些公共的编解码实现，比如​​Base64​​​, ​​Hex​​​, ​​MD5​​​,​​​Phonetic​​ 和​​URLs​​​等等。

​​http://commons.apache.org/codec/​​

2.commons-lang3

字符串处理

​​https://commons.apache.org/proper/commons-lang/​​

3.commons-io

java io操作是开发中比较常用的技术,但是如果每次都使用原生的IO流来操作会显得比较繁琐。

4.结构

​​Common IO​​ 是一个工具库，用来帮助开发IO功能， 它包括6个主要部分

• ​​Utility classes​​ – 工具类，包括一些静态方法来执行常用任务
• ​​Input ​​– 输入，​​InputStream​​ 和 ​​Reader ​​实现
• ​​Output​​ – 输出，​​OutputStream ​​和 ​​Writer ​​实现
• ​​Filters ​​– 过滤器，多种文件过滤器实现(定义了 ​​IOFileFilter​​​接口,同时继承了 ​​FileFilter ​​​和 ​​FilenameFilter ​​接口)
• ​​Comparators ​​– 比较器，用于文件比较的多种​​java.util.Comparato​​实现
• ​​File Monitor​​–文件监控

二、开发

1.commons-codec

maven包

<dependency>
<groupId>commons-codec</groupId>
<artifactId>commons-codec</artifactId>
<version>1.15</version>
</dependency>

1、 Base64编解码

private static String encodeTest(String str){

Base64 base64 = new Base64();
try {
str = base64.encodeToString(str.getBytes(“UTF-8”));
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
System.out.println(“Base64 编码后：”+str);
return str;
}

private static void decodeTest(String str){
Base64 base64 = new Base64();
//str = Arrays.toString(Base64.decodeBase64(str));
str = new String(Base64.decodeBase64(str));
System.out.println(“Base64 解码后：”+str);
}

2、 Hex编解码

private static String encodeHexTest(String str){
try {
str = Hex.encodeHexString(str.getBytes(“UTF-8”));

} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
System.out.println(“Hex 编码后：”+str);
return str;
}

private static String decodeHexTest(String str){
Hex hex = new Hex();
try {
str = new String((byte[])hex.decode(str));
} catch (DecoderException e) {
e.printStackTrace();
}
System.out.println(“Hex 编码后：”+str);
return str;
}

3、 MD5加密

private static String MD5Test(String str){
try {
System.out.println(“MD5 编码后：”+new String(DigestUtils.md5Hex(str.getBytes(“UTF-8”))));
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
return str;
}

4、 SHA编码

private static String ShaTest(String str){
try {
System.out.println(“SHA 编码后：”+newString(DigestUtils.shaHex(str.getBytes(“UTF-8”))));
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
return str;
}

5、 Metaphone和Soundex

import org.apache.commons.codec.language.*;
import org.apache.commons.codec.*;


public class LanguageTest {
public static void main(String args[]) {
Metaphone metaphone = new Metaphone();
RefinedSoundex refinedSoundex = new RefinedSoundex();
Soundex soundex = new Soundex();

for (int i=0; i<2; i++ ) {
String str=(i==0)?”resume”:”resin”;

String mString = null;
String rString = null;
String sString = null;

try {
mString = metaphone.encode(str);
rString = refinedSoundex.encode(str);
sString = soundex.encode(str);

} catch (Exception ex) {
;
}
System.out.println(“Original:”+str);
System.out.println(“Metaphone:”+mString);
System.out.println(“RefinedSoundex:”+rString);
System.out.println(“Soundex:”+sString +”\\n”);


}
}
}

2.commons-lang3

​​maven​​包

<!-- https://mvnrepository.com/artifact/org.apache.commons/commons-lang3 --><dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-lang3</artifactId>
<version>3.9</version>
</dependency>

字符串的处理类（​​StringUtils​​)

//缩短到某长度,用...结尾.其实就是(substring(str, 0, max-3) + "...")
//public static String abbreviate(String str,int maxWidth)
StringUtils.abbreviate("abcdefg", 6);// ---"abc..." //字符串结尾的后缀是否与你要结尾的后缀匹配，若不匹配则添加后缀
StringUtils.appendIfMissing("abc","xyz");//---"abcxyz"
StringUtils.appendIfMissingIgnoreCase("abcXYZ","xyz");//---"abcXYZ"


//首字母大小写转换
StringUtils.capitalize("cat");//---"Cat"
StringUtils.uncapitalize("Cat");//---"cat"


//字符串扩充至指定大小且居中（若扩充大小少于原字符大小则返回原字符，若扩充大小为 负数则为0计算 ）
StringUtils.center("abcd", 2);//--- "abcd"
StringUtils.center("ab", -1);//--- "ab"
StringUtils.center("ab", 4);//---" ab "
StringUtils.center("a", 4, "yz");//---"yayz"
StringUtils.center("abc", 7, "");//---" abc "


//去除字符串中的"\n", "\r", or "\r\n"
StringUtils.chomp("abc\r\n");//---"abc"


//判断一字符串是否包含另一字符串
StringUtils.contains("abc", "z");//---false
StringUtils.containsIgnoreCase("abc", "A");//---true


//统计一字符串在另一字符串中出现次数
StringUtils.countMatches("abba", "a");//---2


//删除字符串中的梭有空格
StringUtils.deleteWhitespace(" ab c ");//---"abc"


//比较两字符串，返回不同之处。确切的说是返回第二个参数中与第一个参数所不同的字符串
StringUtils.difference("abcde", "abxyz");//---"xyz"


//检查字符串结尾后缀是否匹配
StringUtils.endsWith("abcdef", "def");//---true
StringUtils.endsWithIgnoreCase("ABCDEF", "def");//---true
StringUtils.endsWithAny("abcxyz", new String[] {null, "xyz", "abc"});//---true


//检查起始字符串是否匹配
StringUtils.startsWith("abcdef", "abc");//---true
StringUtils.startsWithIgnoreCase("ABCDEF", "abc");//---true
StringUtils.startsWithAny("abcxyz", new String[] {null, "xyz", "abc"});//---true


//判断两字符串是否相同
StringUtils.equals("abc", "abc");//---true
StringUtils.equalsIgnoreCase("abc", "ABC");//---true


//比较字符串数组内的所有元素的字符序列，起始一致则返回一致的字符串，若无则返回""
StringUtils.getCommonPrefix(new String[] {"abcde", "abxyz"});//---"ab"


//正向查找字符在字符串中第一次出现的位置
StringUtils.indexOf("aabaabaa", "b");//---2
StringUtils.indexOf("aabaabaa", "b", 3);//---5(从角标3后查找)
StringUtils.ordinalIndexOf("aabaabaa", "a", 3);//---1(查找第n次出现的位置)


//反向查找字符串第一次出现的位置
StringUtils.lastIndexOf("aabaabaa", ‘b‘);//---5
StringUtils.lastIndexOf("aabaabaa", ‘b‘, 4);//---2
StringUtils.lastOrdinalIndexOf("aabaabaa", "ab", 2);//---1


//判断字符串大写、小写
StringUtils.isAllUpperCase("ABC");//---true
StringUtils.isAllLowerCase("abC");//---false


//判断是否为空(注：isBlank与isEmpty 区别)
StringUtils.isBlank(null);StringUtils.isBlank("");StringUtils.isBlank(" ");//---true
StringUtils.isNoneBlank(" ", "bar");//---false


StringUtils.isEmpty(null);StringUtils.isEmpty("");//---true
StringUtils.isEmpty(" ");//---false
StringUtils.isNoneEmpty(" ", "bar");//---true


//判断字符串数字
StringUtils.isNumeric("123");//---false
StringUtils.isNumeric("12 3");//---false (不识别运算符号、小数点、空格……)
StringUtils.isNumericSpace("12 3");//---true


//数组中加入分隔符号
//StringUtils.join([1, 2, 3], ‘;‘);//---"1;2;3"


//大小写转换
StringUtils.upperCase("aBc");//---"ABC"
StringUtils.lowerCase("aBc");//---"abc"
StringUtils.swapCase("The dog has a BONE");//---"tHE DOG HAS A bone"


//替换字符串内容……（replacePattern、replceOnce）
StringUtils.replace("aba", "a", "z");//---"zbz"
StringUtils.overlay("abcdef", "zz", 2, 4);//---"abzzef"(指定区域)
StringUtils.replaceEach("abcde", new String[]{"ab", "d"},
new String[]{"w", "t"});//---"wcte"(多组指定替换ab->w，d->t)


//重复字符
StringUtils.repeat(‘e‘, 3);//---"eee"


//反转字符串
StringUtils.reverse("bat");//---"tab"


//删除某字符
StringUtils.remove("queued", ‘u‘);//---"qeed"


//分割字符串
StringUtils.split("a..b.c", ‘.‘);//---["a", "b", "c"]
StringUtils.split("ab:cd:ef", ":", 2);//---["ab", "cd:ef"]
StringUtils.splitByWholeSeparator("ab-!-cd-!-ef", "-!-", 2);//---["ab", "cd-!-ef"]
StringUtils.splitByWholeSeparatorPreserveAllTokens("ab::cd:ef", ":");//-["ab"," ","cd","ef"]


//去除首尾空格，类似trim……（stripStart、stripEnd、stripAll、stripAccents）
StringUtils.strip(" ab c ");//---"ab c"
StringUtils.stripToNull(null);//---null
StringUtils.stripToEmpty(null);//---""


//截取字符串
StringUtils.substring("abcd", 2);//---"cd"
StringUtils.substring("abcdef", 2, 4);//---"cd"


//left、right从左(右)开始截取n位字符
StringUtils.left("abc", 2);//---"ab"
StringUtils.right("abc", 2);//---"bc"
//从第n位开始截取m位字符 n m
StringUtils.mid("abcdefg", 2, 4);//---"cdef"


StringUtils.substringBefore("abcba", "b");//---"a"
StringUtils.substringBeforeLast("abcba", "b");//---"abc"
StringUtils.substringAfter("abcba", "b");//---"cba"
StringUtils.substringAfterLast("abcba", "b");//---"a"


StringUtils.substringBetween("tagabctag", "tag");//---"abc"
StringUtils.substringBetween("yabczyabcz", "y", "z");//---"abc"

随机数生成类（​​RandomStringUtils​​）

//随机生成n位数数字
RandomStringUtils.randomNumeric(n);
//在指定字符串中生成长度为n的随机字符串
RandomStringUtils.random(n, "abcdefghijk");
//指定从字符或数字中生成随机字符串
System.out.println(RandomStringUtils.random(n, true, false)); System.out.println(RandomStringUtils.random(n, false, true));

数字类​​NumberUtils​​

//从数组中选出最大值
NumberUtils.max(new int[] { 1, 2, 3, 4 });//---4
//判断字符串是否全是整数
NumberUtils.isDigits("153.4");//--false
//判断字符串是否是有效数字
NumberUtils.isNumber("0321.1");//---false

数组类 ​​ArrayUtils​​

//创建数组
String[] array = ArrayUtils.toArray("1", "2");
//判断两个数据是否相等，如果内容相同， 顺序相同 则返回 true
ArrayUtils.isEquals(arr1,arr2);
//判断数组中是否包含某一对象
ArrayUtils.contains(arr, "33");
//二维数组转换成MAP
Map map = ArrayUtils.toMap(new String {
{ "RED", "#FF0000" }, { "GREEN", "#00FF00" }, { "BLUE", "#0000FF" } });

日期类​​DateUtils​​

//日期加n天
DateUtils.addDays(new Date(), n);
//判断是否同一天
DateUtils.isSameDay(date1, date2);
//字符串时间转换为Date
DateUtils.parseDate(str, parsePatterns);

附: ​​StringUtile​​

/*


Copyright 2015-2017 the original author or authors.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at


Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/


package com.funtl.leesite.common.utils;


import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
import java.util.List;
import java.util.Locale;
import java.util.regex.Matcher;
import java.util.regex.Pattern;


import javax.servlet.http.HttpServletRequest;


import com.google.common.collect.Lists;


import org.apache.commons.lang3.StringEscapeUtils;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import org.springframework.web.servlet.LocaleResolver;


/**
* 字符串工具类, 继承org.apache.commons.lang3.StringUtils类
*
* @author Lusifer
* @version 2013-05-22
*/
public class StringUtils extends org.apache.commons.lang3.StringUtils {


private static final char SEPARATOR = '_';
private static final String CHARSET_NAME = "UTF-8";


/**
* 转换为字节数组
*
* @param str
* @return
*/
public static byte[] getBytes(String str) {
if (str != null) {
try {
return str.getBytes(CHARSET_NAME);
} catch (UnsupportedEncodingException e) {
return null;
}
} else {
return null;
}
}
/**
* 转换为字节数组
*
* @param str
* @return
*/
public static String toString(byte[] bytes) {
try {
return new String(bytes, CHARSET_NAME);
} catch (UnsupportedEncodingException e) {
return EMPTY;
}
}


/**
* 是否包含字符串
*
* @param str 验证字符串
* @param strs 字符串组
* @return 包含返回true
*/
public static boolean inString(String str, String... strs) {
if (str != null) {
for (String s : strs) {
if (str.equals(trim(s))) {
return true;
}
}
}
return false;
}


/**
* 替换掉HTML标签方法
*/
public static String replaceHtml(String html) {
if (isBlank(html)) {
return "";
}
String regEx = "<.+?>";
Pattern p = Pattern.compile(regEx);
Matcher m = p.matcher(html);
String s = m.replaceAll("");
return s;
}
/**
* 替换为手机识别的HTML，去掉样式及属性，保留回车。
*
* @param html
* @return
*/
public static String replaceMobileHtml(String html) {
if (html == null) {
return "";
}
return html.replaceAll("<([a-z]+?)\\s+?.*?>", "<$1>");
}


/**
* 替换为手机识别的HTML，去掉样式及属性，保留回车。
*
* @param txt
* @return
*/
public static String toHtml(String txt) {
if (txt == null) {
return "";
}
return replace(replace(Encodes.escapeHtml(txt), "\n", "<br/>"), "\t", " ");
}


/**
* 缩略字符串（不区分中英文字符）
*
* @param str 目标字符串
* @param length 截取长度
* @return
*/
public static String abbr(String str, int length) {
if (str == null) {
return "";
}
try {
StringBuilder sb = new StringBuilder();
int currentLength = 0;
for (char c : replaceHtml(StringEscapeUtils.unescapeHtml4(str)).toCharArray()) {
currentLength += String.valueOf(c).getBytes("GBK").length;
if (currentLength <= length - 3) {
sb.append(c);
} else {
sb.append("...");
break;
}
}
return sb.toString();
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
return "";
}


public static String abbr2(String param, int length) {
if (param == null) {
return "";
}
StringBuffer result = new StringBuffer();
int n = 0;
char temp;
boolean isCode = false; // 是不是HTML代码
boolean isHTML = false; // 是不是HTML特殊字符,如
for (int i = 0; i < param.length(); i++) {
temp = param.charAt(i);
if (temp == '<') {
isCode = true;
} else if (temp == '&') {
isHTML = true;
} else if (temp == '>' && isCode) {
n = n - 1;
isCode = false;
} else if (temp == ';' && isHTML) {
isHTML = false;
}
try {
if (!isCode && !isHTML) {
n += String.valueOf(temp).getBytes("GBK").length;
}
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}


if (n <= length - 3) {
result.append(temp);
} else {
result.append("...");
break;
}
}
// 取出截取字符串中的HTML标记
String temp_result = result.toString().replaceAll("(>)[^<>]*(<?)", "$1$2");
// 去掉不需要结素标记的HTML标记
temp_result = temp_result.replaceAll("</?(AREA|BASE|BASEFONT|BODY|BR|COL|COLGROUP|DD|DT|FRAME|HEAD|HR|HTML|IMG|INPUT|ISINDEX|LI|LINK|META|OPTION|P|PARAM|TBODY|TD|TFOOT|TH|THEAD|TR|area|base|basefont|body|br|col|colgroup|dd|dt|frame|head|hr|html|img|input|isindex|li|link|meta|option|p|param|tbody|td|tfoot|th|thead|tr)[^<>]*/?>", "");
// 去掉成对的HTML标记
temp_result = temp_result.replaceAll("<([a-zA-Z]+)[^<>]*>(.*?)</\\1>", "$2");
// 用正则表达式取出标记
Pattern p = Pattern.compile("<([a-zA-Z]+)[^<>]*>");
Matcher m = p.matcher(temp_result);
List<String> endHTML = Lists.newArrayList();
while (m.find()) {
endHTML.add(m.group(1));
}
// 补全不成对的HTML标记
for (int i = endHTML.size() - 1; i >= 0; i--) {
result.append("</");
result.append(endHTML.get(i));
result.append(">");
}
return result.toString();
}
/**
* 转换为Double类型
*/
public static Double toDouble(Object val) {
if (val == null) {
return 0D;
}
try {
return Double.valueOf(trim(val.toString()));
} catch (Exception e) {
return 0D;
}
}


/**
* 转换为Float类型
*/
public static Float toFloat(Object val) {
return toDouble(val).floatValue();
}


/**
* 转换为Long类型
*/
public static Long toLong(Object val) {
return toDouble(val).longValue();
}


/**
* 转换为Integer类型
*/
public static Integer toInteger(Object val) {
return toLong(val).intValue();
}


/**
* 获得i18n字符串
*/
public static String getMessage(String code, Object[] args) {
LocaleResolver localLocaleResolver = (LocaleResolver) SpringContextHolder.getBean(LocaleResolver.class);
HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
Locale localLocale = localLocaleResolver.resolveLocale(request);
return SpringContextHolder.getApplicationContext().getMessage(code, args, localLocale);
}


/**
* 获得用户远程地址
*/
public static String getRemoteAddr(HttpServletRequest request) {
String remoteAddr = request.getHeader("X-Real-IP");
if (isNotBlank(remoteAddr)) {
remoteAddr = request.getHeader("X-Forwarded-For");
} else if (isNotBlank(remoteAddr)) {
remoteAddr = request.getHeader("Proxy-Client-IP");
} else if (isNotBlank(remoteAddr)) {
remoteAddr = request.getHeader("WL-Proxy-Client-IP");
}
return remoteAddr != null ? remoteAddr : request.getRemoteAddr();
}


/**
* 驼峰命名法工具
*
* @return toCamelCase("hello_world") == "helloWorld"
* toCapitalizeCamelCase("hello_world") == "HelloWorld"
* toUnderScoreCase("helloWorld") = "hello_world"
*/
public static String toCamelCase(String s) {
if (s == null) {
return null;
}


s = s.toLowerCase();


StringBuilder sb = new StringBuilder(s.length());
boolean upperCase = false;
for (int i = 0; i < s.length(); i++) {
char c = s.charAt(i);


if (c == SEPARATOR) {
upperCase = true;
} else if (upperCase) {
sb.append(Character.toUpperCase(c));
upperCase = false;
} else {
sb.append(c);
}
}


return sb.toString();
}
/**
* 驼峰命名法工具
*
* @return toCamelCase("hello_world") == "helloWorld"
* toCapitalizeCamelCase("hello_world") == "HelloWorld"
* toUnderScoreCase("helloWorld") = "hello_world"
*/
public static String toCapitalizeCamelCase(String s) {
if (s == null) {
return null;
}
s = toCamelCase(s);
return s.substring(0, 1).toUpperCase() + s.substring(1);
}


/**
* 驼峰命名法工具
*
* @return toCamelCase("hello_world") == "helloWorld"
* toCapitalizeCamelCase("hello_world") == "HelloWorld"
* toUnderScoreCase("helloWorld") = "hello_world"
*/
public static String toUnderScoreCase(String s) {
if (s == null) {
return null;
}


StringBuilder sb = new StringBuilder();
boolean upperCase = false;
for (int i = 0; i < s.length(); i++) {
char c = s.charAt(i);


boolean nextUpperCase = true;


if (i < (s.length() - 1)) {
nextUpperCase = Character.isUpperCase(s.charAt(i + 1));
}


if ((i > 0) && Character.isUpperCase(c)) {
if (!upperCase || !nextUpperCase) {
sb.append(SEPARATOR);
}
upperCase = true;
} else {
upperCase = false;
}


sb.append(Character.toLowerCase(c));
}


return sb.toString();
}


/**
* 如果不为空，则设置值
*
* @param target
* @param source
*/
public static void setValueIfNotBlank(String target, String source) {
if (isNotBlank(source)) {
target = source;
}
}
/**
* 转换为JS获取对象值，生成三目运算返回结果
*
* @param objectString 对象串
* 例如：row.user.id
* 返回：!row?'':!row.user?'':!row.user.id?'':row.user.id
*/
public static String jsGetVal(String objectString) {
StringBuilder result = new StringBuilder();
StringBuilder val = new StringBuilder();
String[] vals = split(objectString, ".");
for (int i = 0; i < vals.length; i++) {
val.append("." + vals[i]);
result.append("!" + (val.substring(1)) + "?'':");
}
result.append(val.substring(1));
return result.toString();
}


/**
* 通过正则表达式获取内容
*
* @param regex 正则表达式
* @param from 原字符串
* @return
*/
public static String[] regex(String regex, String from) {
Pattern pattern = Pattern.compile(regex);
Matcher matcher = pattern.matcher(from);
List<String> results = new ArrayList<String>();
while (matcher.find()) {
for (int i = 0; i < matcher.groupCount(); i++) {
results.add(matcher.group(i + 1));
}
}
return results.toArray(new String[]{});
}


}

3.commons-io

<dependency>
<groupId>commons-io</groupId>
<artifactId>commons-io</artifactId>
<version>2.6</version>
</dependency>

一、工具类

​​IOUtils ​​包含一些工具类,用于处理读,写和拷贝,这些方法基于 ​​InputStream​​, ​​OutputStream​​, ​​Reader ​​和 ​​Writer​​工作.

​​FileUtils ​​包含一些工具类,它们基于File对象工作，包括读，写，拷贝和比较文件

​​FilenameUtils​​​包含一些工具类,它们基于文件名工作而不是File对象。这个类旨在 在​​Unix​​和​​Windows​​环境下保持一致,帮助在两个环境下过渡(如从开发环境到生成环境)

​​FileSystemUtils​​​包含一些工具类，基于文件系统访问功能不被JDK支持。目前，只有一个方法就是得到驱动器空余空间。注意这使用命令行而不是 ​​native code​​。

​​EndianUtils ​​包含静态方法来交换​​Java​​基本类型和流的字节序

​​SwappedDataInputStream​​实现了​​DataInput​​接口。可以从文件中读取非本地字节序。

​​IOUtils​​的使用：

IOUtils.copy(InputStream input, OutputStream output) // 此方法有多个重载方法，满足不同的输入输出流

IOUtils.copy(InputStream input, OutputStream output, int bufferSize)

IOUtils.copy(InputStream input, Writer output, String inputEncoding)

IOUtils.copy(Reader input, Writer output)

IOUtils.copy(Reader input, OutputStream output, String outputEncoding)

// 这个方法适合拷贝较大的数据流，比如2G以上

IOUtils.copyLarge(Reader input, Writer output) // 默认会用1024*4的buffer来读取

IOUtils.copyLarge(Reader input, Writer output, char[] buffer)

IOUtils.toInputStream(String input, String encoding) // 通过文本获取输入流 ， 可以指定编码格式

IOUtils.toInputStream(String input, Charset encoding)


IOUtils.toBufferedInputStream(InputStream input) // 获取一个缓冲输入流，默认缓冲大小 1KB

IOUtils.toBufferedInputStream(InputStream input, int size) // 获取一个指定缓冲流的大小的输入流

IOUtils.toBufferedReader(Reader reader) // 获取一个字符缓冲流

IOUtils.toBufferedReader(Reader reader, int size)

// 获取缓冲流

IOUtils.buffer(InputStream inputStream)

IOUtils.buffer(OutputStream outputStream)

IOUtils.buffer(Reader reader)

IOUtils.buffer(Writer writer)

// 将输入流转换成字符串

IOUtils.toString(Reader input)

IOUtils.toString(byte[] input, String encoding)

IOUtils.toString(InputStream input, Charset encoding)

IOUtils.toString(InputStream input, String encoding)

IOUtils.toString(URI uri, String encoding)

IOUtils.toString(URL url, String encoding)

// 将输入流转换成字符数组

IOUtils.toByteArray(InputStream input)

IOUtils.toByteArray(InputStream input, int size)

IOUtils.toByteArray(URI uri)

IOUtils.toByteArray(URL url)

IOUtils.toByteArray(URLConnection urlConn)

IOUtils.toByteArray(Reader input, String encoding)

// 字符串读写

IOUtils.readLines(Reader input)

IOUtils.readLines(InputStream input, Charset encoding)

IOUtils.readLines(InputStream input, String encoding)

IOUtils.writeLines(Collection<?> lines, String lineEnding, Writer writer)

IOUtils.writeLines(Collection<?> lines, String lineEnding, OutputStream output, Charset encoding)

IOUtils.writeLines(Collection<?> lines, String lineEnding, OutputStream output, String encoding)

// 从一个流中读取内容

IOUtils.read(InputStream input, byte[] buffer)

IOUtils.read(InputStream input, byte[] buffer, int offset, int length) IOUtils.read(Reader input, char[] buffer)

IOUtils.read(Reader input, char[] buffer, int offset, int length)

// 把数据写入到输出流中

IOUtils.write(byte[] data, OutputStream output)

IOUtils.write(byte[] data, Writer output, Charset encoding)

IOUtils.write(byte[] data, Writer output, String encoding)

IOUtils.write(char[] data, Writer output)

IOUtils.write(char[] data, OutputStream output, Charset encoding) IOUtils.write(char[] data, OutputStream output, String encoding)

IOUtils.write(String data, Writer output)

IOUtils.write(CharSequence data, Writer output)

// 从一个流中读取内容，如果读取的长度不够，就会抛出异常

IOUtils.readFully(InputStream input, int length)

IOUtils.readFully(InputStream input, byte[] buffer)

IOUtils.readFully(InputStream input, byte[] buffer, int offset, int length) IOUtils.readFully(Reader input, char[] buffer)

IOUtils.readFully(Reader input, char[] buffer, int offset, int length)

IOUtils.contentEquals(InputStream input1, InputStream input2) // 比较两个流是否相等

IOUtils.contentEquals(Reader input1, Reader input2)

IOUtils.contentEqualsIgnoreEOL(Reader input1, Reader input2) // 比较两个流，忽略换行符

IOUtils.skip(InputStream input, long toSkip) // 跳过指定长度的流

IOUtils.skip(Reader input, long toSkip)

IOUtils.skipFully(InputStream input, long toSkip) // 如果忽略的长度大于现有的长度，就会抛出异常

IOUtils.skipFully(Reader input, long toSkip)

// 读取流，返回迭代器

IOUtils.lineIterator(Reader reader)

IOUtils.lineIterator(InputStream input, Charset encoding)

IOUtils.lineIterator(InputStream input, String encoding)

// 关闭流

IOUtils.close(URLConnection conn)

// 其他的关闭方法推荐使用 Closeable.close()

FileUtils的使用：

// 复制文件夹

FileUtils.copyDirectory(File srcDir, File destDir) // 复制文件夹（文件夹里面的文件内容也会复制）

FileUtils.copyDirectory(File srcDir, File destDir, FileFilter filter) // 复制文件夹，带有文件过滤功能

FileUtils.copyDirectoryToDirectory(File srcDir, File destDir) // 以子目录的形式将文件夹复制到到另一个文件夹下

// 复制文件

FileUtils.copyFile(File srcFile, File destFile) // 复制文件

FileUtils.copyFile(File input, OutputStream output) // 复制文件到输出流

FileUtils.copyFileToDirectory(File srcFile, File destDir) // 复制文件到一个指定的目录

FileUtils.copyInputStreamToFile(InputStream source, File destination) // 把输入流里面的内容复制到指定文件

FileUtils.copyURLToFile(URL source, File destination) // 把URL 里面内容复制到文件(可以下载文件)

FileUtils.copyURLToFile(URL source, File destination, int connectionTimeout, int readTimeout)

// 把字符串写入文件

FileUtils.writeStringToFile(File file, String data, String encoding)

FileUtils.writeStringToFile(File file, String data, String encoding, boolean append)

// 把字节数组写入文件

FileUtils.writeByteArrayToFile(File file, byte[] data)

FileUtils.writeByteArrayToFile(File file, byte[] data, boolean append) FileUtils.writeByteArrayToFile(File file, byte[] data, int off, int len) FileUtils.writeByteArrayToFile(File file, byte[] data, int off, int len, boolean append)

// 把集合里面的内容写入文件

// encoding：文件编码，lineEnding：每行以什么结尾

FileUtils.writeLines(File file, Collection<?> lines)

FileUtils.writeLines(File file, Collection<?> lines, boolean append)

FileUtils.writeLines(File file, Collection<?> lines, String lineEnding)

FileUtils.writeLines(File file, Collection<?> lines, String lineEnding, boolean append)

FileUtils.writeLines(File file, String encoding, Collection<?> lines)

FileUtils.writeLines(File file, String encoding, Collection<?> lines, boolean append)

FileUtils.writeLines(File file, String encoding, Collection<?> lines, String lineEnding)

FileUtils.writeLines(File file, String encoding, Collection<?> lines, String lineEnding, boolean append)

// 往文件里面写内容

FileUtils.write(File file, CharSequence data, Charset encoding)

FileUtils.write(File file, CharSequence data, Charset encoding, boolean append)

FileUtils.write(File file, CharSequence data, String encoding)

FileUtils.write(File file, CharSequence data, String encoding, boolean append)

// 文件移动

FileUtils.moveDirectory(File srcDir, File destDir) // 文件夹在内的所有文件都将移动FileUtils.moveDirectoryToDirectory(File src, File destDir, boolean createDestDir) // 以子文件夹的形式移动到另外一个文件下

FileUtils.moveFile(File srcFile, File destFile) // 移动文件

FileUtils.moveFileToDirectory(File srcFile, File destDir, boolean createDestDir) // 以子文件的形式移动到另外一个文件夹下

FileUtils.moveToDirectory(File src, File destDir, boolean createDestDir) // 移动文件或者目录到指定的文件夹内

// 清空和删除文件夹

FileUtils.deleteDirectory(File directory) // 删除文件夹，包括文件夹和文件夹里面所有的文件

FileUtils.cleanDirectory(File directory) // 清空文件夹里面的所有的内容

FileUtils.forceDelete(File file) // 删除，会抛出异常

FileUtils.deleteQuietly(File file) // 删除，不会抛出异常

// 创建文件夹

FileUtils.forceMkdir(File directory) // 创建文件夹(可创建多级)

FileUtils.forceMkdirParent(File file) // 创建文件的父级目录

// 获取文件输入/输出流

FileUtils.openInputStream(File file)

FileUtils.openOutputStream(File file)

// 读取文件

FileUtils.readFileToByteArray(File file) // 把文件读取到字节数组

FileUtils.readFileToString(File file, Charset encoding) // 把文件读取成字符串

FileUtils.readFileToString(File file, String encoding)

FileUtils.readLines(File file, Charset encoding) // 把文件读取成字符串集合

FileUtils.readLines(File file, String encoding)

// 测试两个文件的修改时间

FileUtils.isFileNewer(File file, Date date)

FileUtils.isFileNewer(File file, File reference)

FileUtils.isFileNewer(File file, long timeMillis)

FileUtils.isFileOlder(File file, Date date)

FileUtils.isFileOlder(File file, File reference)

FileUtils.isFileOlder(File file, long timeMillis)

// 文件/文件夹的迭代

FileUtils.iterateFiles(File directory, IOFileFilter fileFilter, IOFileFilter dirFilter)

FileUtils.iterateFiles(File directory, String[] extensions, boolean recursive)

FileUtils.iterateFilesAndDirs(File directory, IOFileFilter fileFilter, IOFileFilter dirFilter)

FileUtils.lineIterator(File file)

FileUtils.lineIterator(File file, String encoding)

FileUtils.listFiles(File directory, IOFileFilter fileFilter, IOFileFilter dirFilter)

FileUtils.listFiles(File directory, String[] extensions, boolean recursive)

FileUtils.listFilesAndDirs(File directory, IOFileFilter fileFilter, IOFileFilter dirFilter)

// 其他

FileUtils.isSymlink(File file) // 判断是否是符号链接

FileUtils.directoryContains(File directory, File child) // 判断文件夹内是否包含某个文件或者文件夹

FileUtils.sizeOf(File file) // 获取文件或者文件夹的大小

FileUtils.getTempDirectory()// 获取临时目录文件

FileUtils.getTempDirectoryPath()// 获取临时目录路径

FileUtils.getUserDirectory()// 获取用户目录文件

FileUtils.getUserDirectoryPath()// 获取用户目录路径

FileUtils.touch(File file) // 创建文件

FileUtils.contentEquals(File file1, File file2) // 比较两个文件内容是否相同

FilenameUtils的使用

FilenameUtils.concat(String basePath, String fullFilenameToAdd) // 合并目录和文件名为文件全路径

FilenameUtils.getBaseName(String filename) // 去除目录和后缀后的文件名

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

FilenameUtils.getFullPath(String filename) // 获取文件的目录

FilenameUtils.getName(String filename) // 获取文件名


FilenameUtils.getPath(String filename) // 去除盘符后的路径

FilenameUtils.getPrefix(String filename) // 盘符

FilenameUtils.indexOfExtension(String filename) // 获取最后一个.的位置

FilenameUtils.indexOfLastSeparator(String filename) // 获取最后一个/的位置

FilenameUtils.normalize(String filename) // 获取当前系统格式化路径

FilenameUtils.removeExtension(String filename) // 移除文件的扩展名

FilenameUtils.separatorsToSystem(String path) // 转换分隔符为当前系统分隔符

FilenameUtils.separatorsToUnix(String path) // 转换分隔符为linux系统分隔符

FilenameUtils.separatorsToWindows(String path) // 转换分隔符为windows系统分隔符

FilenameUtils.equals(String filename1, String filename2) // 判断文件路径是否相同，非格式化

FilenameUtils.equalsNormalized(String filename1, String filename2) // 判断文件路径是否相同，格式化

FilenameUtils.directoryContains(String canonicalParent, String canonicalChild) // 判断目录下是否包含指定文件或目录

FilenameUtils.isExtension(String filename, String extension) // 判断文件扩展名是否包含在指定集合(数组、字符串)中

FilenameUtils.wildcardMatch(String filename, String wildcardMatcher) // 判断文件扩展名是否和指定规则匹配

FileSystemUtils的使用：

// 仅有这一个方法，及其重载方法

FileSystemUtils.freeSpaceKb() throws IOException

//推荐使用

java.nio.file.FileStore.getUsableSpace()

二、输入、输出

在org.apache.commons.io.input包下有许多InputStrem类的实现，我们来测试一个最实用的类，TeeInputStream，将InputStream以及OutputStream作为参数传入其中，自动实现将输入流的数据读取到输出流中。

@Test
public void test() throws IOException {

// XmlStreamReader
File xml = new File("E:\\test\\data\\io\\test.xml");
XmlStreamReader xmlReader = new XmlStreamReader(xml);
System.out.println("XML encoding: " + xmlReader.getEncoding());
String INPUT = "This should go to the output.";

// TeeInputStream
ByteArrayInputStream in = new ByteArrayInputStream(INPUT.getBytes("US-ASCII"));
ByteArrayOutputStream out = new ByteArrayOutputStream();
TeeInputStream tee = new TeeInputStream(in, out, true);
tee.read(new byte[INPUT.length()]);
System.out.println("Output stream: " + out.toString());

}

同样，在 org.apache.commons.io.output包中同样有OutputStream类的实现，这里介绍TeeOutputStream，它可以将输出流进行分流，换句话说我们可以用一个输入流将数据分别读入到两个不同的输出流。

@Test
public void test8() throws IOException {
String INPUT = "This should go to the output.";

// TeeOutputStream
ByteArrayInputStream in = new ByteArrayInputStream(INPUT.getBytes("US-ASCII"));
ByteArrayOutputStream out1 = new ByteArrayOutputStream();
ByteArrayOutputStream out2 = new ByteArrayOutputStream();
TeeOutputStream teeOut = new TeeOutputStream(out1, out2);
TeeInputStream teeIn = new TeeInputStream(in, teeOut, true);
teeIn.read(new byte[INPUT.length()]);

System.out.println("Output stream 1: " + out1.toString());
System.out.println("Output stream 2: " + out2.toString());

}

三、Filters过滤器

1.基本功能过滤器

类型：

​​FileFileFilter ​​ 仅接受文件

​​DirectoryFilter ​​ 仅接受目录

名称：

​​PrefixFileFilter ​​ 基于前缀（不带路径的文件名)

​​SuffixFileFilter ​​ 基于后缀(不带路径的文件名)

​​NameFileFilter ​​ 基于文件名称(不带路径的文件名)

​​WildcardFileFilter ​​基于通配符(不带路径的文件名)

​​RegexFileFilter ​​ 基于正则表达式

时间：

​​AgeFileFilter ​​ 基于最后修改时间

​​MagicNumberFileFileter ​​ 基于Magic Number

大小：

​​EmptyFileFilter ​​ 基于文件或目录是否为空

​​SizeFileFilter ​​ 基于文件尺寸

隐藏属性：

​​HiddenFileFilter ​​ 基于文件或目录是否隐藏

读写属性：

​​CanReadFileFilter ​​基于是否可读

​​CanWriteFileFilter ​​ 基于是否可写入

​​DelegateFileFilter ​​​将普通的​​FileFilter​​​和​​FilenameFilter​​​包装成​​IOFileFilter​​

2.逻辑关系过滤器​​AndFileFilter ​​ 基于AND逻辑运算

​​OrFileFilter ​​ 基于OR逻辑运算

​​NotFileFilter ​​ 基于NOT逻辑运算

​​TrueFileFilter ​​ 不进行过滤

​​FalseFileFilter ​​ 过滤所有文件及目录

工具类：​​FileFilterUtils​​

提供一些工厂方法用于生成各类文件过滤器

提供一些静态方法用于对指定的File集合进行过滤

FileFilterUtils.ageFileFilter(Date cutoffDate)


FileFilterUtils.and(IOFileFilter... filters)


FileFilterUtils.asFileFilter(FileFilter filter)


FileFilterUtils.directoryFileFilter()


FileFilterUtils.falseFileFilter()


FileFilterUtils.fileFileFilter()


FileFilterUtils.filter(IOFileFilter filter, File... files)


FileFilterUtils.filterList(IOFileFilter filter, File... files)


FileFilterUtils.filterSet(IOFileFilter filter, File... files)


FileFilterUtils.nameFileFilter(String name)


FileFilterUtils.notFileFilter(IOFileFilter filter)


FileFilterUtils.or(IOFileFilter... filters)


FileFilterUtils.prefixFileFilter(String prefix)


FileFilterUtils.sizeFileFilter(long threshold)


FileFilterUtils.suffixFileFilter(String suffix)


FileFilterUtils.trueFileFilter()@Test


public void test() throws IOException {

String PARENT_DIR = "E:\\test\\data\\io\\filter";
File dir = new File(PARENT_DIR);

String[] acceptedNames = { "test", "testTxt.txt" };

// 匹配文件名
for (String file : dir.list(new NameFileFilter(acceptedNames, IOCase.INSENSITIVE))) {
System.out.println("File found, named: " + file);
}

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

// 根据通配符匹配


for (String file : dir.list(new WildcardFileFilter("*est*"))) {
System.out.println("Wildcard file found, named: " + file);
}

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

// 匹配前缀
for (String file : dir.list(new PrefixFileFilter("test"))) {
System.out.println("Prefix file found, named: " + file);
}
System.out.println("=========================================");

// 匹配后缀
for (String file : dir.list(new SuffixFileFilter(".txt"))) {
System.out.println("Suffix file found, named: " + file);
}
System.out.println("=========================================");

// 逻辑或
for (String file : dir
.list(new OrFileFilter(new WildcardFileFilter("*est*"), new SuffixFileFilter(".txt")))) {
System.out.println("Or file found, named: " + file);
}
System.out.println("=========================================");

// 逻辑与
for (String file : dir.list(new AndFileFilter(new WildcardFileFilter("*est*"),
new NotFileFilter(new SuffixFileFilter(".txt"))))) {
System.out.println("And/Not file found, named: " + file);
}
}

四、​​Comparators​​比较器

​​org.apache.commons.io.comparator​​包下只有这四个类：

CompositeFileComparator


DefaultFileComparator


DirectoryFileComparator


ExtensionFileComparator


LastModifiedFileComparator


NameFileComparator


PathFileComparator


SizeFileComparator

都有着四个方法：

compare(File file1, File file2)


sort(File... files)


sort(List<File> files)


toString()@Test


public void test() {


String dir = "E:\\test\\data\\io\\comparator";
// NameFileComparator 按名称
File dirFile = new File(dir);
NameFileComparator comparator = new NameFileComparator(IOCase.SENSITIVE);
File[] files = comparator.sort(dirFile.listFiles());
System.out.println("\nSorted by name files in parent directory: ");

for (File f : files) {
System.out.println("t" + f.getAbsolutePath());
}

// SizeFileComparator 按大小
SizeFileComparator sizeComparator = new SizeFileComparator(true);
File[] sizeFiles = sizeComparator.sort(dirFile.listFiles());
System.out.println("\nSorted by size files in parent directory: ");

for (File f : sizeFiles) {
System.out.println(f.getName() + " with size (kb): " + f.length());
}

// LastModifiedFileComparator 按修改时间
LastModifiedFileComparator lastModified = new LastModifiedFileComparator();
File[] lastModifiedFiles = lastModified.sort(dirFile.listFiles());

System.out.println("\nSorted by last modified files in parent directory: ");

for (File f : lastModifiedFiles) {
Date modified = new Date(f.lastModified());
System.out.println(f.getName() + " last modified on: " + modified);
}

}

五、Monitor文件监控

原理：

由文件监控类​​FileAlterationMonitor​​​中的线程按指定的间隔不停的扫描文件观察器​​FileAlterationObserver​​，如果有文件的变化，则根据相关的文件比较器，判断文件时新增，还是删除，还是更改。（默认为1000毫秒执行一次扫描）

使用方法：

1、创建一个​​FileAlterationObserver​​对象，传入一个要监控的目录，这个对象会观察这些变化。

2、通过调用​​addListener()​​​方法，为observer对象添加一个 ​​FileAlterationListener​​对象。你可以通过很多种方式来创建，继承适配器类或者实现接口或者使用匿名内部类，实现所需要的监控方法。

3、创建一个​​FileAlterationMonitor​​​ 对象，将已经创建好的​​observer​​对象添加其中并且传入时间间隔参数（单位是毫秒）。

4、调用​​start()​​​方法即可开启监视器，如果你想停止监视器，调用​​stop()​​方法即可。

// 继承FileAlterationListenerAdaptor适配器类或者是实现FileAlterationListener接口


class MyFileListener extends FileAlterationListenerAdaptor {

private Log log = LogFactory.getLog(MyFileListener.class);

// 文件创建
@Override
public void onFileCreate(File file) {
log.info("[新建]:" + file.getAbsolutePath());
}

// 文件修改
@Override
public void onFileChange(File file) {
log.info("[修改]:" + file.getAbsolutePath());
}

// 文件删除
@Override
public void onFileDelete(File file) {
log.info("[删除]:" + file.getAbsolutePath());
}

// 目录创建
@Override
public void onDirectoryCreate(File directory) {
log.info("[新建]:" + directory.getAbsolutePath());
}

// 目录修改
@Override
public void onDirectoryChange(File directory) {
log.info("[修改]:" + directory.getAbsolutePath());
}

// 目录删除
@Override
public void onDirectoryDelete(File directory) {
log.info("[删除]:" + directory.getAbsolutePath());
}

@Override
public void onStart(FileAlterationObserver observer) {
super.onStart(observer);
}

@Override
public void onStop(FileAlterationObserver observer) {
super.onStop(observer);
}


}


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

String rootDir = "E:\\test\\data\\io\\monitor";

// 创建一个文件观察器用于处理文件的格式

// FileAlterationObserver _observer = new FileAlterationObserver(rootDir,

// FileFilterUtils.and(FileFilterUtils.fileFileFilter(),

// FileFilterUtils.suffixFileFilter(".txt")), null);// 过滤文件格式

FileAlterationObserver observer = new FileAlterationObserver(rootDir);

observer.addListener(new MyFileListener()); // 设置文件变化监听器

FileAlterationMonitor monitor = new FileAlterationMonitor(5000, observer);// 创建文件变化监听器,间隔5秒

monitor.start();// 开始监控


} 【文章转自印度服务器 http://www.558idc.com/yd.html提供，感恩】