记录下java中常用得工具类，以便开发使用方便快捷。
java中常用用具类介绍
spring工具类
文件操作
加载资源文件
@Test
public void test() throws IOException {
//----------------- FileSourceExample ----------------------------
String filePath = String.format("D:\\temp\\%s","java_demo.txt");
//使用系统文件路径方式加载文件,获取resource对象
Resource resource = new FileSystemResource(filePath);
//可以利用resource获取输入流
InputStream inputStream = resource.getInputStream();
System.out.println(resource.getFilename());
//使用类路径方式加载文件,获取resource对象
Resource res = new ClassPathResource("application.properties");
System.out.println(res.getFilename());
//----------------------ResourceUtilsExample
//不显式使用 Resource 实现类
//提供了一个 ResourceUtils 工具类，它支持“classpath:”和“file:”的地址前缀，它能够从指定的地址加载文件资源
File clsFile = ResourceUtils.getFile("classpath:application.properties");
System.out.println(clsFile.getName());
File file = ResourceUtils.getFile("fire:" + filePath);
System.out.println(file.getName());
}
结果
java_demo.txt
application.properties
application.properties
java_demo.txt
操作文件
@Test
public void test1() throws IOException {
Resource resource = new ClassPathResource("application.properties");
//1 将文件内容拷贝到一个 字节数组 byte[] 中
byte[] byteArray = FileCopyUtils.copyToByteArray(resource.getFile());
System.out.println(new String(byteArray, Charset.forName("utf8")));
// 将文件内容拷贝到一个 String 中
String s = FileCopyUtils.copyToString(new FileReader(resource.getFile()));
System.out.println(s);
// 将文件内容拷贝到另一个目标文件
String s1 = resource.getFile().getParent() + "\\application2.properties";
File file = new File(s1);
FileCopyUtils.copy(resource.getFile(), file);
// 将文件内容拷贝到一个输出流中，字节数组输出流
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
FileCopyUtils.copy(resource.getInputStream(),byteArrayOutputStream);
// new ByteArrayInputStream("".getBytes());
//加载资源文件
Properties props = PropertiesLoaderUtils.loadAllProperties("application.properties");
System.out.println(props.getProperty("username"));
//防止乱码
EncodedResource encodedResource = new EncodedResource(resource,"UTF-8");
String content = FileCopyUtils.copyToString(encodedResource.getReader());
}
web工具类
@Test
public void test2(HttpServletRequest request) throws IOException {
//根据request 获取 cookie 值
Cookie name = WebUtils.getCookie(request, "name");
//根据request 获取 session 值
Object name1 = WebUtils.getSessionAttribute(request, "name");
}
路径匹配
- ？匹配一个字符
- *匹配0个或多个字符
- **匹配0个或多个目录
AntPathMatcher默认路径分隔符为“/”，而在匹配文件路径时，需要注意Windows下路径分隔符为“\”，Linux下为“/”，写法即为
AntPathMatcher matcher = new AntPathMatcher(File.separator)；
AntPathMatcher matcher = new AntPathMatcher(System.getProperty("file.separator"))；
AntPathMatcher matcher = new AntPathMatcher();
@Test
public void test3() throws IOException {
AntPathMatcher matcher = new AntPathMatcher();
matcher.match("/a/b/?", "/a/b/c"); // true
matcher.match("/a/b/*", "/a/b/abc"); // true
matcher.match("/a/b/**", "/a/b/cde/abc"); // true
}
占位符解析
@Test
public void tes(){
//设置前置与后置
PropertyPlaceholderHelper helper = new PropertyPlaceholderHelper("${", "}");
String text = "name: ${name},age: ${age}";
Properties props = new Properties();
props.setProperty("name", "张三");
props.setProperty("age", "22");
String s = helper.replacePlaceholders(text, props);
System.out.println(s); // name: 张三,age: 22
//递归替换属性
props.setProperty("username","${name} ${age}");
String username = "real name ${username}";
String s1 = helper.replacePlaceholders(username, props);
System.out.println(s1); // real name 张三 22
}
获取方法参数名字
@Test
public void test4() throws NoSuchMethodException {
Class<? extends Demo> aClass = this.getClass();
Method method = aClass.getDeclaredMethod("method",String.class, String.class);
ParameterNameDiscoverer parameterNameDiscoverer = new LocalVariableTableParameterNameDiscoverer();
String[] parameterNames = parameterNameDiscoverer.getParameterNames(method);
for (String parameterName : parameterNames) {
System.out.println(parameterName); // a b
}
}
UUID 生成器
代替 jdk 的 UUID 生成器，效率更高
@Test
public void test4() {
AlternativeJdkIdGenerator alternativeJdkIdGenerator = new AlternativeJdkIdGenerator();
System.out.println(alternativeJdkIdGenerator.generateId());
}
反射工具类
@Test
public void test4() throws InvocationTargetException, IllegalAccessException {
//访问属性
Person person = new Person("张三", 18);
Field field = ReflectionUtils.findField(Person.class, "name");
//强制访问
field.setAccessible(true);
System.out.println(ReflectionUtils.getField(field, person)); //张三
ReflectionUtils.setField(field,person,"李四");
System.out.println(person); // Person{name='李四', age=18}
//访问方法
Method getName = ReflectionUtils.findMethod(Person.class, "getName");
System.out.println(getName.invoke(person)); //李四
//获取类的所有方法
Method[] allDeclaredMethods = ReflectionUtils.getAllDeclaredMethods(Person.class);
//只会保留一个同名的方法（保留子类的）
Method[] uniqueDeclaredMethods = ReflectionUtils.getUniqueDeclaredMethods(Person.class);
}
class Person{
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
序列化工具类
对象与二进制的相互转化。（基于JDK的序列化方式）
public static byte[] serialize(@Nullable Object object);
public static Object deserialize(@Nullable byte[] bytes);
StringUtils
建议使用apache的工具类，主要较少几个比较常用的工具类。
操作文件方法
//获取文件后缀，以点分割
StringUtils.unqualify("Hello.java"); // java
//获取以指定分隔符最后一个字符
StringUtils.unqualify("com/cn/Hello.java", File.separatorChar); // Hello.java
//首字母大写
StringUtils.capitalize("zhangsan"); // Zhangsan
//首字母小写
StringUtils.uncapitalize("Java"); // java
//获取文件名
StringUtils.getFilename("/a/b.txt"); // b.txt
//获取后缀
StringUtils.getFilenameExtension("/a/b.txt"); // txt
//截取掉文件路径后缀
StringUtils.stripFilenameExtension("/a/b.txt"); // /a/b
//找到给定的文件，和另一个相对路径的文件，返回第二个文件的全路径，不支持 ../
StringUtils.applyRelativePath("d:/a/b/c.java", "d/e.java"); //d:/a/b/d/e.java
//清理文件路径,这个方法配合applyRelativePath就可以计算一些简单的相对路径了
StringUtils.cleanPath("d:/a/b/../c/d.java"); // d:/a/c/d.java
StringUtils.cleanPath("d:/a/b\\c/d.java"); // d:/a/b/c/d.java \\ ----> /
// 组合使用，处理简单路径
String s1 = StringUtils.cleanPath(StringUtils.applyRelativePath("d:/a/b/c.java", "../../d/e.java")); // d:/d/e.java
System.out.println(s1);
其余操作
@Test
public void test6(){
//判断从指定索引开始，是否匹配子字符串
StringUtils.substringMatch("abcdefg", 0, "a"); // true
//判断子字符串在字符串中出现的次数
StringUtils.countOccurrencesOf("ababaabab", "ab"); // 4
//在字符串中使用子字符串替换
StringUtils.replace("cdcdcdcd", "cd", "ee"); // eeeeeeee
//删除所有匹配的子字符串.
StringUtils.delete("cdcdcdcd", "c"); // dddd
//删除子字符串中任意出现的字符
StringUtils.deleteAny("cdcdcdcd", "card"); // ""
//在字符串前后增加单引号
StringUtils.quote("hello"); // 'hello'
//只会分割第一次
String[] split = StringUtils.split("zhangsan.cn.ag", "."); // [zhangsan , cn.ag]
String[] strings = StringUtils.delimitedListToStringArray("zhangsan.cn.ag", ".");// [zhangsan , cn , ag]
System.out.println();
}
断言工具类
略
apache工具类
lang3
EnumUtils
- getEnum(Class enumClass, String enumName) 通过类返回一个枚举
- getEnumList(Class enumClass) 返回一个枚举集合
- getEnumMap(Class enumClass) 返回一个枚举map
- isValidEnum(Class enumClass, String enumName) 验证enumName是否在枚举中，boolean
@Test
public void test7() {
// 通过类返回一个枚举，可能返回空
Student xiaoxuesheng = EnumUtils.getEnum(Student.class, "XIAOXUESHENG");
System.out.println(xiaoxuesheng.type); // 1
// 通过类返回一个枚举集合
List<Student> enumList = EnumUtils.getEnumList(Student.class);
//返回一个枚举map
Map<String, Student> enumMap = EnumUtils.getEnumMap(Student.class);
boolean xiaoxuesheng1 = EnumUtils.isValidEnum(Student.class, "XIAOXUESHENG");
}
enum Student{
XIAOXUESHENG(1),GAOZHOGNSHENG(2),DAXUESHEGN(3);
int type;
Student(int type){
this.type = type;
}
}
RandomUtils、RandomStringUtils
@Test
public void test7() {
// RandomStringUtils string类型工具类
//在指定范围内随机,随机1个
String random = RandomStringUtils.random(1,'a','b','c','d','e');
//生成指定长度随机数字字符串
//String randomNumeric = RandomStringUtils.randomNumeric(5);
//随机一个 5 - 10 之间的数字
String randomNumeric = RandomStringUtils.randomNumeric(5,10);
//生成指定长度的随机大小写字母组合的字符串
System.out.println(RandomStringUtils.randomAlphabetic(5));
//生成指定长度的字母数字组合的字符串
System.out.println(RandomStringUtils.randomAlphanumeric(5));
//生成指定范围内的随机 int 数 含头不含尾
System.out.println(RandomUtils.nextInt(1, 100));
//生成指定范围的随机 double 数 含头不含尾
System.out.println(RandomUtils.nextDouble(1, 100));
}
StringUtils重要工具类
@Test
public void test7() {
// null和空串返回true，注意 “ ”返回false
StringUtils.isEmpty("");
// 任意一个参数为null、""的话，返回true
StringUtils.isAnyEmpty("","");
// null和空串和“ ”返回true
StringUtils.isBlank("");
// 任意一个参数为null和空串和“ ”的话，返回true
StringUtils.isAnyBlank("","");
//移除字符串两端的空字符串
StringUtils.trim("");
//正向 字符串在另外一个字符串里，出现第 n 次的位置 没有返回-1
StringUtils.ordinalIndexOf("abcdefgabcdefgabcdefgabcdefg", "g", 4); // 27
//逆向 字符串在另外一个字符串里，出现第 n 次的位置 没有返回-1
StringUtils.lastOrdinalIndexOf("abcdefgabcdefgabcdefgabcdefg", "g", 4); // 6
//字符换截取
StringUtils.substring("abcdefgabcdefgabcdefgabcdefg", 21); // abcdefg
//从左边开始截取指定个数
StringUtils.left("abcdefgabcdefgabcdefgabcdefg", 7); // abcdefg
StringUtils.right("abcdefgabcdefgabcdefgabcdefg", 2); // fg
StringUtils.mid("abcdefgabcdefgabcdefgabcdefg", 2,3); // cde
//数组拼接字符串
StringUtils.join(new String[]{
"a", "b", "c"}, ","); // a,b,c
//删除所有空格
StringUtils.deleteWhitespace(" a b c "); // abc
//删除以特定字符串开头的字符串，如果没有的话，就不删除。
StringUtils.removeStart("abcde", "abc"); // de
//为了保证长度统一，可以右边自动用指定的字符补全至指定长度
StringUtils.rightPad("abc", 10, "*"); //abc*******
//左侧填充
StringUtils.leftPad("abc", 10, "*"); // *******abc
//两侧填充
StringUtils.center("abc", 11, "*"); // ****abc****
//首字母大、小写
StringUtils.capitalize("abc");
StringUtils.uncapitalize("abc");
//取反
StringUtils.swapCase("abc");
//判断字符串是否全由字母组成 （只要存在汉字、中文、数字都为false）
StringUtils.isAlpha("abc");
//字符串翻转
StringUtils.reverse("abc");
// 缩略字符串，省略号要占三位 表示最大长度是4，就是说后3位就是 ...
// 如果字符串小于 maxWidth ，返回原字符串
StringUtils.abbreviate("abcdefg", 4); // a...
StringUtils.abbreviate("abcdefg", 12); // abcdefg
// 如果大于maxWidth, 则 字符串 + 省略号 == 6
System.out.println(StringUtils.abbreviate("abcdefg", 6)); //abc...
}
日期操作
@Test
public void test() throws ParseException {
String date = "2021-2-28 10:13:555";
String dateStr = "yyyy-MM-dd HH:mm:SSS";
//字符串转date类型
Date now = DateUtils.parseDate(date, dateStr); //Sun Feb 28 10:13:00 CST 2021
//date 转 字符串
String format = DateFormatUtils.format(now, dateStr); //2021-02-28 10:13:555
long time = now.getTime();
//毫秒转字符串
String format1 = DateFormatUtils.format(time, dateStr); // 2021-02-28 10:13:555
//天数加减
DateUtils.addDays(now,1);
//小时加减
DateUtils.addHours(now,1);
//分钟加减
DateUtils.addMinutes(now,1);
//月
DateUtils.addMonths(now,1);
//年
DateUtils.addYears(now,1);
//当月过去多少天了
long fragmentInDays = DateUtils.getFragmentInDays(now, Calendar.MONTH); //28
//今年过去多少天了
long fragmentIn = DateUtils.getFragmentInDays(now, Calendar.YEAR); //28
//一次类推 小时 毫秒等
// DateUtils.getFragmentInHours()
//是否是同一天
DateUtils.isSameDay(now,now);
//判断两个时间是否为同一毫秒
DateUtils.isSameInstant(now,now);
//给定日期 设置年份
DateUtils.setYears(now, 3000); // 3000-02-28 10:13:555
DateUtils.setHours(now,1); // 设置小时
//给定日期四舍五入
DateUtils.round(now, Calendar.YEAR); // 2021-01-01 00:00:000
DateUtils.round(now, Calendar.MONTH); // 2021-03-01 00:00:000
DateUtils.round(now, Calendar.HOUR_OF_DAY);// 2021-02-28 10:00:000
DateUtils.round(now, Calendar.DAY_OF_MONTH);// 2021-02-28 00:00:000
DateUtils.round(now, Calendar.HOUR);// 2021-02-28 10:00:000
//日期截取，跟四舍五入不同，这个不会四舍五入 这个是截取
DateUtils.truncate(now, Calendar.YEAR); // 截取到年 2021-01-01 00:00:000
DateUtils.truncate(now, Calendar.MONTH); // 截取到月 2021-02-01 00:00:000
DateUtils.truncate(now, Calendar.DAY_OF_MONTH);//截取到天 2021-02-28 00:00:000
DateUtils.truncate(now, Calendar.HOUR_OF_DAY); //截取到小时 2021-02-28 10:00:000
DateUtils.truncate(now, Calendar.HOUR); //截取到小时 2021-02-28 10:00:000
DateUtils.truncate(now, Calendar.MINUTE); //截取到分钟 2021-02-28 10:13:000
//截取到天
DateUtils.truncate(now, Calendar.DATE);//截取到天 2021-02-28 00:00:000
//语法糖
//获取月初
//先获取下个月
Date next = DateUtils.addMonths(now, 1);
// 下个月的1月1日
Date setDays = DateUtils.setDays(next, 1);
// 再减一天
Date date1 = DateUtils.addDays(setDays, -1); // 2021-02-28 10:13:555
//处理最晚时间
Date date2 = DateUtils.setHours(date1, 23);
Date date3 = DateUtils.setMinutes(date2, 59);
Date date4 = DateUtils.setSeconds(date3, 59); // 2021-02-28 23:59:555
}
Collections4
主要是集合判空，新集合类型不讲了，建议用前面讲的guava集合类型
@Test
public void test2() throws ParseException {
List<Object> objects = new ArrayList<>();
boolean empty = CollectionUtils.isEmpty(objects);
Map<Object, Object> objectObjectHashMap = new HashMap<>();
MapUtils.isEmpty(objectObjectHashMap);
}
beanutils
@Test
public void test2() throws InvocationTargetException, IllegalAccessException, NoSuchMethodException, InstantiationException {
Student student = new Student();
student.setAge("14");
student.setName("张三");
//给属性赋值
BeanUtils.setProperty(student,"name","李四"); // Student{name='李四', age='14'}
BeanUtils.getProperty(student, "name"); // 李四
// map 属性 转 对象
Map<String,String> map = new HashMap<>();
map.put("name","王五");
BeanUtils.populate(student,map); // Student{name='王五', age='14'}
Student o = (Student) BeanUtils.cloneBean(student); //浅copy
Student student1 = new Student();
BeanUtils.copyProperties(student,student1); //浅copy
}
codec
@Test
public void test3() throws IOException, DecoderException {
// Base64编码
Base64 base64 = new Base64();
String s = base64.encodeToString("我们都是神枪手".getBytes()); // 5oiR5Lus6YO95piv56We5p6q5omL
new String(base64.decode(s));// 我们都是神枪手
// MD5摘要运算
DigestUtils.md5Hex("我们都是神枪手"); // c97b0a7d06adc58425945ba37415cb4d
DigestUtils.md5Hex(new ByteArrayInputStream("我们都是神枪手".getBytes())); // c97b0a7d06adc58425945ba37415cb4d
// sh1 sh1
DigestUtils.sha1("我们都是神枪手"); //[B@727803de
DigestUtils.sha256("我们都是神枪手"); // [B@727803de
// hmac sha1 加密算法
// scrypt bcrypt和scrypt
//用户密码
String password = "我们都是神枪手";
//密码加密
BCryptPasswordEncoder passwordEncoder=new BCryptPasswordEncoder();
//加密
String newPassword = passwordEncoder.encode(password);
System.out.println("加密密码为："+newPassword);
//对比这两个密码是否是同一个密码
boolean matches = passwordEncoder.matches(password, newPassword);
System.out.println("两个密码一致:"+matches);
//URLCodec
URLCodec codec = new URLCodec();
String sa = codec.encode("api/v2/get", "utf-8"); // api%2Fv2%2Fget
String s1 = codec.decode(sa, "utf-8"); // api/v2/get
}
发送邮件工具类
Commons-io
@Test
public void test5() throws IOException {
String fire1 = "D:\\temp\\java_demo.txt";
String fire2 = "D:\\temp\\java_demo2.txt";
// 拷贝文件 源文件 目标文件
FileUtils.copyFile(new File(fire1),new File(fire2));
// 拷贝文件 源文件 目标目录
FileUtils.copyFileToDirectory(new File(fire1),new File("D:\\temp\\two"));
//拷贝文件到输出流中
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
FileUtils.copyFile(new File(fire1),byteArrayOutputStream);
System.out.println(new String(byteArrayOutputStream.toByteArray()));
//输入流到 文件
FileUtils.copyInputStreamToFile(new ByteArrayInputStream("aaa".getBytes()),new File(fire2));
//移动文件 需要移动的文件 移动到的目录
//FileUtils.moveToDirectory(new File(fire1),new File("D:\\temp\\two2"),true);
//读取文件内容 到字符串
FileUtils.readFileToString(new File(fire1), Charset.forName("utf-8"));
//对目标文件写入内容
FileUtils.writeStringToFile(new File(fire2),"aaa",Charset.forName("utf-8"),true);
//递归删除一个目录(包括内容)。
FileUtils.deleteDirectory(new File(fire2));
//清理内容而不删除它。
FileUtils.cleanDirectory(new File(fire2));
//删除一个文件，不会抛出异常。如果文件是一个目录，删除它和所有子目录。
FileUtils.deleteQuietly(new File(fire2));
//删除文件 非递归删除 文件正在被占用、:没有close输入输出流是无法删除的 会抛出异常
FileUtils.forceDelete(new File(fire2));
//一次可以创建单级或者多级目录
FileUtils.forceMkdir(new File("d:/Users/wuguibin/Downloads/folder"));
}
Commons Chain
责任链模式工具
guava集合操作工具类
见前面博客
其他
字符串模板替换
Velocity 字符串替换
支持 对象.属性的写法
// 初始化并取得Velocity引擎
VelocityEngine engine = new VelocityEngine();
// 字符串模版
String template = "${user.name}：您的年龄 ${user.age}";
VelocityContext context = new VelocityContext();
Map<Object, Object> objectObjectHashMap = new HashMap<>();
// 把数据填入上下文
objectObjectHashMap.put("name", "张三");
objectObjectHashMap.put("age", 22);
context.put("user", objectObjectHashMap);
StringWriter writer = new StringWriter();
engine.evaluate(context, writer, "", template);
System.out.println(writer.toString());
apache common 字符串替换
Map<String, String> valuesMap = new HashMap<String, String>();
valuesMap.put("name", "张三");
valuesMap.put("age", "15");
String templateString = "The ${name} age is ${age}.";
StrSubstitutor sub = new StrSubstitutor(valuesMap);
String resolvedString = sub.replace(templateString);
System.out.println(resolvedString);
jdk自带
@Test
public void test7(){
//name 张三 age 22
String name = String.format("name %s age %d", "张三", 22);
//name 张三 age 22
String name2 = MessageFormat.format("name {0} age {1}", "张三", 22);
}
上面spring的占位符解析
Aviator语法糖衣也可以解析字符串模板
Aviator表达式求值引擎
主要是处理java代码字符串解析逻辑
@Test
public void test7(){
//求数学表达式
//不需要传递map
Object execute = AviatorEvaluator.execute("3+6+6"); //15
//传递map 将参数传递
Map<String, Object> map = new HashMap<String, Object>();
map.put("age", 18);
Object execute1 = AviatorEvaluator.execute(" '年龄乘以年龄等于：' + age*age",map); // 324
System.out.println(execute1);
//自定义函数
AviatorEvaluator.addFunction(new AbstractFunction() {
@Override
public String getName() {
return "chengfa";
}
@Override
public AviatorObject call(Map<String, Object> env, AviatorObject arg1, AviatorObject arg2) {
double num1 = FunctionUtils.getNumberValue(arg1, env).doubleValue();
double num2 = FunctionUtils.getNumberValue(arg2, env).doubleValue();
return new AviatorDouble(num1 * num2);
}
});
Object execute2 = AviatorEvaluator.execute("chengfa(5, 8)"); // 40.0
// 自带函数
Object execute3 = AviatorEvaluator.execute("'日期 ：' + sysdate() + '。毫秒 ：' + now()");
// string.length(s) 求字符串长度,返回Long
// string.startsWith(s1,s2)
// math.abs(d) 求d的绝对值
// math.sqrt(d) 求d的平方根
// math.pow(d1,d2) 求d1的d2次方
// 。。。。。。。。。。。。。。。。。
System.out.println(execute3);
// 访问数组和集合
Map<String, Object> env = new HashMap<>();
env.put("list", new ArrayList<>());
env.put("array", new String[2]);
//Map<String, Object> map = new HashMap<String, Object>();
//map.put("age", 18);
env.put("map", map);
//可以调用 对象.属性
Object execute4 = AviatorEvaluator.execute("list[0]+':'+array[0]+':'+'age is '+map.age", env);
//age is 18
}