hutool工具类

前言

「添加Hutool的所有依赖」

<dependency>
    <groupId>cn.hutool</groupId>
    <artifactId>hutool-all</artifactId>
    <version>5.3.3</version>
</dependency>

模拟HTTP请求**（get、post）

hutool提供了**「HttpUtil」** 和 「HttpRequest」 两个工具类都可用来模拟发送http请求，这两个用法大同小异这里只拿**「HttpRequest」**举例 「示例场景：」 在项目开发中Swagger可作为后端接口测试的良方，但在和别人对接，或使用别人提供的接口时常常需要后端自己去模拟请求发送，去校验接口

import cn.hutool.http.HttpRequest;
import cn.hutool.http.HttpResponse;
import cn.hutool.json.JSONObject;
import cn.hutool.json.JSONUtil;
import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;

/**
 * @author 遇见0和1
 * @company lingStudy
 * @create 2021-06-03 17:04
 */
@Slf4j
public class HttpTest {

    /**
     * putOnce：一次性Put 键值对，如果key已经存在抛出异常，如果键值中有null值，忽略
     * putOpt：在键和值都为非空的情况下put到JSONObject中
     */
    @Test
    void postTest(){
        JSONObject jsonObject = JSONUtil.createObj();// 或 JSONObject jsonObject = new JSONObject();
        jsonObject.putOnce("customerTel","17563964456");
        jsonObject.putOnce("remarks","备注1：我是HttpRequest测试请求！");

        HttpResponse response = HttpRequest.post("http://127.0.0.1:9001/caiyun-record/saveRecord")
                //设置请求头(可任意加)
                .header("Content-Type", "application/json")
                // 添加token
                .header("Authorization","eyJhbGciOiJIUzI1NiJ9.eyJqdGkiOiJ7E3NjJ9.9vgMKLpftjcXxmvViSyJDnBcXrO6c3bLlatwD83frAs")
                //请求参数
                .body(jsonObject.toString())
                .execute();
        log.info("请求响应结果：{}",response);
        log.info("响应数据：{}",response.body());
    }

    @Test
    void getTest(){
        HttpResponse response = HttpRequest.get("http://127.0.0.1:9001/caiyun-record/login?paramData=I0CZZJYUBP9JixsyeDkhRnIfFgyXP-NaP1DiJ8_AWoY1eEeZN5BwF_HMSfb4wl6oE")
                .execute();
        log.info("get请求返回：{}",response.body());
    }

}

JSONUtil 工具类

将一个对象序列化，也是后端开发中常遇到的，阿里以前挺火的 「fastjson」 「示例场景：」 返回给前端的token中要存对象时可将对象转为字符串，在拦截器中再将该字符串重新转为对象，若在登录后存的是该对象到session中，还可以在拦截器中通过判断session中的值是否为空，来解决**「后端重启后session丢失」**的问题。

//对象转字符串
String userInfoStr = JSONUtil.toJsonStr(userInfoDTO);
log.info("对象转字符串userInfoStr：{}", userInfoStr);

//生成token
String jwtToken = TokenUtil.createJwtToken(userInfoStr);

//字符串转对象
UserInfoDTO userInfo = JSONUtil.toBean(jti, UserInfoDTO.class);
request.getSession().setAttribute("userInfo",userInfo);
log.info("重设session后：{}",request.getSession().getAttribute("userInfo"));

字符串转JSONObject

import cn.hutool.json.JSONObject;
import cn.hutool.json.JSONUtil;

public class Demo {

public static void main(String[] args) {
    String jsonStr="{\"id\":\"1\",\"name\":\"张三\",\"age\":25}";
    JSONObject jsonObject = JSONUtil.parseObj(jsonStr);
    System.out.println(jsonObject);
}

}

Json格式的字符串转对象

import cn.hutool.json.JSONUtil;
import com.bc.model.UserModel;

public class Demo {

public static void main(String[] args){
    String jsonStr="{\"name\":\"张三\",\"sex\":\"男\",\"age\":23,\"address\":\"杭州西湖\"}";
    UserModel user=JSONUtil.toBean(jsonStr,UserModel.class);
    System.out.println(user);
}

}
执行上述代码，其输出结果为：

UserModel(name=张三, sex=男, age=23, address=杭州西湖)

List< Map >转List< Entity >

// HuTool
List<User> userList = JSONUtil.toList(new JSONArray(userMapList),User.class);
// 同fastjson
List<User> userList = JSON.parseObject(JSON.toJSONString(userMapList),new TypeReference<>() {});

BeanUtil：Map与javaBean的转换**

「示例场景：」 面对POST或者一些参数较多的GET请求等，懒得新建参数对象，可用Map来接收前端传递的参数

@ApiOperation(value = "新增记录")
@ApiImplicitParams({
         @ApiImplicitParam(paramType = "query", dataType = "String", name = "customerTel", value = "客户号码",required = true),
         @ApiImplicitParam(paramType = "query", dataType = "String", name = "remarks", value = "备注")
 })
 @PostMapping("/saveRecord")
 public ResultVo<Object> saveRecord(@ApiIgnore @RequestBody Map<String, Object> param){
     log.info("新增登记记录 param：{}",param);
     try {
         HecaiyunRecord hecaiyunRecord = new HecaiyunRecord();
         //将map赋值给HecaiyunRecord中与map的key对应的字段
         BeanUtil.fillBeanWithMap(param,hecaiyunRecord,false);
         UserInfoDTO userInfo = (UserInfoDTO) request.getSession().getAttribute("userInfo");
         //用userInfo填充与hecaiyunRecord相同的字段
         BeanUtils.copyProperties(userInfo,hecaiyunRecord);
         //添加系统日志
         sysLogService.saveSysLog(userInfo,request,"add","新增登记");

         return recordService.saveRecord(hecaiyunRecord);
     } catch (Exception e) {
         log.error("新增登记记录失败");
         e.printStackTrace();
         throw new MyException(StatusEnum.ERROR);
     }
 }

「反过来：将 JavaBean 转为 Map」

User user = new User();
user.setAge(3);
user.setName("遇见0和1");
 
 //将 user 转成map
Map<String, Object> map = BeanUtil.beanToMap(user);

//将userInfo对象复制给map，key保留userInfo中属性的驼峰形式不做下划线处理，不忽略userInfo中值为null的属性
BeanUtil.beanToMap(userInfo,map,false,false); //不会清空map （个人常用）

Bean属性拷贝

PmsBrand copyBrand = new PmsBrand();
BeanUtil.copyProperties(brand, copyBrand);
LOGGER.info(“beanUtil copy properties:{}”, copyBrand);

CaptchaUtil 生成图形验证码**

「示例场景：」 图形验证码在登录时非常常见，Hutool也用几种类型的验证码，这里只举例个人常用的一种。

@ApiOperation(value = "获得图形验证码")
@GetMapping("/getCaptcha")
public void getCaptcha(HttpServletResponse response){
    //生成验证码图片(定义图形的宽和高,验证码的位数，干扰线的条数)
    //CircleCaptcha circleCaptcha = CaptchaUtil.createCircleCaptcha(200, 100, 4, 25);
    CircleCaptcha circleCaptcha = CaptchaUtil.createCircleCaptcha(100, 50, 4, 25);
    //告诉浏览器输出内容为jpeg类型的图片
    response.setContentType("image/jpeg");
    //禁止浏览器缓存
    response.setHeader("Pragma","No-cache");
    try {
        ServletOutputStream outputStream = response.getOutputStream();
        //图形验证码写出到流，也可以写出到文件如：circleCaptcha.write(“d:/circle25.jpeg”);
        circleCaptcha.write(outputStream);
        //从图形验证码图片中获取它的字符串验证码(获取字符串验证码要在图形验证码wirte写出后面才行，不然得到的值为null)
        String captcha = circleCaptcha.getCode();
        request.getSession().setAttribute("captcha",captcha);
        log.info("生成的验证码:{}",captcha);
        log.info("session id:{}",request.getSession().getId());
        //关闭流
        outputStream.close();
    } catch (IOException e) {
        e.printStackTrace();
        throw new MyException(StatusEnum.ERROR);
    }
}

UserAgentUtil**(判断设备)

「示例场景：」 系统操作日志里常常需要判断访问的是什么设备 「UserAgentUtil」 可以获取到服务的浏览器详细信息，也可以判断访问是不是移动设备。

//自己实现
public String isDevice(HttpServletRequest request){
    String requestHeader = request.getHeader("user-agent");
    //定义移动端请求的所有可能类型
    String[] deviceArray = {"android", "iphone","ipod","ipad", "windows phone","mqqbrowser"};
    //将字符串转换为小写
    requestHeader = requestHeader.toLowerCase();
    for (String device : deviceArray) {
        if (requestHeader.contains(device)){
            return "移动端";
        }
    }
    return "PC端";
}

//使用UserAgentUtil
public String isDeviceHuTool(HttpServletRequest request){
    String requestHeader = request.getHeader("user-agent");
    UserAgent userAgent = UserAgentUtil.parse(requestHeader);
    if (userAgent.isMobile()){
        return "移动端";
    }
    return "PC端";
}

访问者的ip地址常常也是需要保存的一个数据，个人暂时没找到hutool对这个的支持，方便后面来抄作业，下面放一个搬来的获取ip的方法

import cn.hutool.core.util.StrUtil;
import lombok.extern.slf4j.Slf4j;

import javax.servlet.http.HttpServletRequest;

/**
 * @author 遇见0和1
 * @company lingStudy
 * @create 2021-03-30 9:31
 */
@Slf4j
public class IPUtils {

    /**
     * 获取IP地址
     *
     * 使用Nginx等反向代理软件， 则不能通过request.getRemoteAddr()获取IP地址
     * 如果使用了多级反向代理的话，X-Forwarded-For的值并不止一个，而是一串IP地址，X-Forwarded-For中第一个非unknown的有效IP字符串，则为真实IP地址
     */
    public static String getIpAddr(HttpServletRequest request) {
        String ip = null;
        try {
            ip = request.getHeader("x-forwarded-for");
            if (StrUtil.isEmpty(ip) || "unknown".equalsIgnoreCase(ip)) {
                ip = request.getHeader("Proxy-Client-IP");
            }
            if (StrUtil.isEmpty(ip) || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
                ip = request.getHeader("WL-Proxy-Client-IP");
            }
            if (StrUtil.isEmpty(ip) || "unknown".equalsIgnoreCase(ip)) {
                ip = request.getHeader("HTTP_CLIENT_IP");
            }
            if (StrUtil.isEmpty(ip) || "unknown".equalsIgnoreCase(ip)) {
                ip = request.getHeader("HTTP_X_FORWARDED_FOR");
            }
            if (StrUtil.isEmpty(ip) || "unknown".equalsIgnoreCase(ip)) {
                ip = request.getRemoteAddr();
            }
        } catch (Exception e) {
            log.error("IPUtils ERROR：",e);
        }

        //对于通过多个代理的情况，第一个IP为客户端真实IP,多个IP按照','分割
        if(!StrUtil.isEmpty(ip) && ip.length() > 15) {
   if(ip.indexOf(",") > 0) {
    ip = ip.substring(0, ip.indexOf(","));
   }
  }

        return ip;
    }

}

FileUtil**(文件上传)

「示例场景：」 文件上传下载在项目中也是一个常见并且重要的业务点，Hutool的**「FileUtil」**类对着方面也做了很好的支持。

@Value("${upload-file.img-path}")
private String imgPath;

@ApiOperation(value = "上传图片")
@PostMapping(value = "/uploadImg",headers = "content-type=multipart/form-data")
public ResultVo<Object> uploadFile(@ApiParam(value = "file") @RequestParam(value = "file" ,required = false) MultipartFile file){

    if (file == null){
        throw new MyException(StatusEnum.BUSINID);
    }
    if (!FileUtil.exist(imgPath)){
        FileUtil.mkdir(imgPath);
    }
    //String fileName = UUID.randomUUID().toString() + "@" + multipartFile.getOriginalFilename();
    log.info("原文件名：{}",file.getOriginalFilename());//包括扩展名
    //文件扩展名
    String suffix = Objects.requireNonNull(file.getOriginalFilename()).substring(file.getOriginalFilename().lastIndexOf(".") + 1);
    String fileName = System.currentTimeMillis() + RandomUtil.randomNumbers(4) + "." +suffix;
    try {
        File file1 = FileUtil.writeBytes(file.getBytes(), imgPath + fileName);
        log.info("file1：{}",file1);
        return ResultVo.success();
    } catch (IOException e) {
        e.printStackTrace();
        throw new MyException(StatusEnum.ERROR);
    }

}

Http文件下载

import cn.hutool.http.HttpUtil;
import java.io.File;

public class Demo {

public static void main(String[] args){
    String url="http://127.0.0.1:8080/group1/M00/03/BB/123456.pdf";
    String filePath="E:\\测试文件.pdf";
    HttpUtil.downloadFile(url,new File(filePath));
}

}

加密解密

加密分为三种：

• 「对称加密（symmetric）」：例如：AES、DES等
• 「非对称加密（asymmetric）」：例如：RSA、DSA等
• 「摘要加密（digest）」：例如：MD5、SHA-1、SHA-256、HMAC等

对常用到的算法，HuTool提供**「SecureUtil」**工具类用于快速实现加解密

// 对称加密
SecureUtil.aes
SecureUtil.des
// 摘要算法
SecureUtil.md5
SecureUtil.sha1
SecureUtil.hmac
SecureUtil.hmacMd5
SecureUtil.hmacSha1
// 非对称加密
SecureUtil.rsa
SecureUtil.dsa
// UUID
SecureUtil.simpleUUID 方法提供无“-”的UUID
// 密钥生成
SecureUtil.generateKey 针对对称加密生成密钥
SecureUtil.generateKeyPair 生成密钥对（用于非对称加密）
SecureUtil.generateSignature 生成签名（用于非对称加密）

SecureUtil(MD5加密**)

• 此工具用于MD5加密

  	// MD5加密
  	String str = "123456";
  	String md5Str = SecureUtil.md5(str);
  	LOGGER.info("secureUtil md5:{}", md5Str);
  

字符串校验

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-EFF5Y0VO-1667801632037)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20221107090204048.png)]

StrUtil(操作字符串的方法**)

• 此工具定义了一些操作字符串的方法

	// 判断是否为空字符串
	String str = "test";
	StrUtil.isEmpty(str);
	StrUtil.isNotEmpty(str);

	// 去除字符串的前后缀
	StrUtil.removeSuffix("a.jpg", ".jpg");
	StrUtil.removePrefix("a.jpg", "a.");

	// 格式化字符串
	String template = "这只是个占位符:{}";
	String str2 = StrUtil.format(template, "我是占位符");
	LOGGER.info("/strUtil format:{}", str2);

similar(计算两个字符串的相似度)

//计算两个字符串的相似度

double similar = StrUtil.similar(str1, str2);

split(字符串切分）

import cn.hutool.core.util.StrUtil;
import java.util.Arrays;
import java.util.List;

public class Demo {

public static void main(String[] args){
    String[] arr=StrUtil.split("11a22a33a44a","a");
    System.out.println(Arrays.toString(arr));
    List<String> list=StrUtil.splitTrim("11a22a33a44a","a");
    System.out.println(list.toString());
}

}
输出结果：

[11, 22, 33, 44, ]
[11, 22, 33, 44]

join(字符串拼接)

import cn.hutool.core.util.StrUtil;
import java.util.HashSet;
import java.util.Set;

public class Demo {

public static void main(String[] args) {
    Set<String> set=new HashSet<>();
    set.add("1");
    set.add("2");
    set.add("3");
    String message = StrUtil.join("，",set);
    System.out.println(message);
}

}
输出结果：

1，2，3

count(统计指定内容中包含指定字符串的数量）

import cn.hutool.core.util.StrUtil;

public class Demo {

public static void main(String[] args) {
    String str="2022.5.5";
    String searchStr=".";
    int count = StrUtil.count(str,searchStr);
    System.out.println(count);
}

}
输出结果：

2

ObjectUtil 判断对象是否为null

import cn.hutool.core.util.ObjectUtil;

public class Demo {

public static void main(String[] args){
    Object o=null;
    if(ObjectUtil.isEmpty(o)){
        System.out.println("该对象为null");
    }else{
        System.out.println("该对象不为null");
    }
}

}
输出结果：

该对象为null

ReUtil判断字符串是否包含指定字符

import cn.hutool.core.util.ReUtil;

public class Demo {

public static void main(String[] args){
    Boolean flag = ReUtil.contains("[a-zA-Z]","Java是世界上最好的语言!");
    System.out.println(flag);
}

}
输出结果：

true

根据正则表达式提取文本内容

import cn.hutool.core.util.ReUtil;

public class Demo {

public static void main(String[] args) {
    String[] arr = new String[]{"2022.5.5", "2022.5.15", "2022.11.5", "2022.11.15"};
    for (String str : arr) {
        String regexStr = "([0-9]{4})[\\.]([0-9]{1,2})[\\.]([0-9]{1,2})";
        String year = ReUtil.get(regexStr, str, 1);
        String month = ReUtil.get(regexStr, str, 2);
        String day = ReUtil.get(regexStr, str, 3);
        System.out.println(year + "-" + month + "-" + day);
    }
}

}
输出结果：

2022-5-5
2022-5-15
2022-11-5
2022-11-15

format方法 替换字符串

这貌似就是打印日志的~~~

String template = "{}爱{}，就像老鼠爱大米";
String str = StrUtil.format(template, "我", "你");

AnnotationUtil(获取注解和注解中指定的值**)

• 此工具可用于获取注解和注解中指定的值

  // 获取指定类、方法、字段、构造器上的注解列表
  	Annotation[] annotationList = AnnotationUtil.getAnnotations(HutoolController.class, false);
  	LOGGER.info("annotationUtil annotations:{}", annotationList);
  
  	// 获取指定类型注解
  	Api api = AnnotationUtil.getAnnotation(HutoolController.class, Api.class);
  	LOGGER.info("annotationUtil api value:{}", api.description());
  
  	// 获取指定类型注解的值
  	Object annotationValue = AnnotationUtil.getAnnotationValue(HutoolController.class, RequestMapping.class);
  

MapUtil(创建Map和判断Map)

• 此工具可用于创建Map和判断Map是否为null

	// 将多个键值对加入到Map中
	Map<Object, Object> map = MapUtil.of(new String[][]{
		{"key1", "value1"},
		{"key2", "value2"},
		{"key3", "value3"}
	});

	// 判断Map是否为空
	MapUtil.isEmpty(map);
	MapUtil.isNotEmpty(map);

CollUtil(集合的一些操作**)

• 此工具是集合的一些操作

	// 数组转换为列表
	String[] array = new String[]{"a", "b", "c", "d", "e"};
	List<String> list = CollUtil.newArrayList(array);

	// 数组转字符串时添加连接符号
	String joinStr = CollUtil.join(list, ",");
	LOGGER.info("collUtil join:{}", joinStr);

	// 将以连接符号分隔的字符串再转换为列表
	List<String> splitList = StrUtil.split(joinStr, ',');
	LOGGER.info("collUtil split:{}", splitList);

	// 创建新的Map、Set、List
	HashMap<Object, Object> newMap = CollUtil.newHashMap();
	HashSet<Object> newHashSet = CollUtil.newHashSet();
	ArrayList<Object> newList = CollUtil.newArrayList();

	// 判断列表是否为空
	CollUtil.isEmpty(list);

NumberUtil(各种类型数字的加减乘除)

• 此工具是用于各种类型数字的加减乘除操作及判断类型

double n1 = 1.234;
	double n2 = 1.234;
	double result;

	// 对float、double、BigDecimal做加减乘除操作
	result = NumberUtil.add(n1, n2);
	result = NumberUtil.sub(n1, n2);
	result = NumberUtil.mul(n1, n2);
	result = NumberUtil.div(n1, n2);

	// 保留两位小数
	BigDecimal roundNum = NumberUtil.round(n1, 2);
	String n3 = "1.234";

	// 判断是否为数字、整数、浮点数
	NumberUtil.isNumber(n3);
	NumberUtil.isInteger(n3);
	NumberUtil.isDouble(n3);

ReflectUtil(反射获取类的方法及创建对象**)

• 此工具是为了反射获取类的方法及创建对象

	// 获取某个类的所有方法
	Method[] methods = ReflectUtil.getMethods(PmsBrand.class);

	// 获取某个类的指定方法
	Method method = ReflectUtil.getMethod(PmsBrand.class, "getId");

	// 使用反射来创建对象
	PmsBrand pmsBrand = ReflectUtil.newInstance(PmsBrand.class);

	// 反射执行对象的方法
	ReflectUtil.invoke(pmsBrand, "setId", 1);

ClassPathResource(获取ClassPath下的文件)

• 此工具是获取ClassPath下的文件，在Tomcat等容器中，ClassPath一般为：WEB-INFO/classes

	// 获取定义在src/main/resources文件夹中的配置文件
	ClassPathResource resource = new ClassPathResource("generator.properties");
	Properties properties = new Properties();
	properties.load(resource.getStream());
	LOGGER.info("/classPath:{}", properties);

convert(各种类型数据的转换)

• 此工具用于于各种类型数据的转换

	// 转换为字符串
	int a = 1;
	String aStr = Convert.toStr(a);

	// 转换为指定类型数组
	String[] b = {"1", "2", "3", "4"};
	Integer[] bArr = Convert.toIntArray(b);

	// 转换为日期对象
	String dateStr = "2017-05-06";
	Date date = Convert.toDate(dateStr);

	// 转换为列表
	String[] strArr = {"a", "b", "c", "d"};
	List<String> strList = Convert.toList(String.class, strArr);

DataUtil（操作日期的方法）

• 此工具定义了一些操作日期的方法: Date、long、Calendar之间的相互转换

	// 当前时间
	Date date = DateUtil.date();

	// Calendar转Date
	date = DateUtil.date(Calendar.getInstance());

	// 时间戳转Date
	date = DateUtil.date(System.currentTimeMillis());
	// 自动识别格式转换
	String dateStr = "2017-03-01";
	date = DateUtil.parse(dateStr);

	// 自定义格式化转换
	date = DateUtil.parse(dateStr, "yyyy-MM-dd");

	// 格式化输出日期
	String format = DateUtil.format(date, "yyyy-MM-dd");

	// 获得年的部分
	int year = DateUtil.year(date);

	// 获得月份，从0开始计数
	int month = DateUtil.month(date);

	// 获取某天的开始、结束时间
	Date beginOfDay = DateUtil.beginOfDay(date);
	Date endOfDay = DateUtil.endOfDay(date);

	// 计算偏移后的日期时间
	Date newDate = DateUtil.offset(date, DateField.DAY_OF_MONTH, 2);

	// 计算日期时间之间的偏移量
	long betweenDay = DateUtil.between(date, newDate, DateUnit.DAY);

日期格式(DatePattern)

package cn.hutool.core.date;

public class DatePattern {

public static final String NORM_DATE_PATTERN = "yyyy-MM-dd";
public static final String NORM_TIME_PATTERN = "HH:mm:ss";
public static final String NORM_DATETIME_MINUTE_PATTERN = "yyyy-MM-dd HH:mm";
public static final String NORM_DATETIME_PATTERN = "yyyy-MM-dd HH:mm:ss";
public static final String CHINESE_DATE_PATTERN = "yyyy年MM月dd日";
public static final String CHINESE_DATE_TIME_PATTERN = "yyyy年MM月dd日HH时mm分ss秒";
public static final String PURE_DATE_PATTERN = "yyyyMMdd";
public static final String PURE_TIME_PATTERN = "HHmmss";
...

}

字符串转日期时间

import cn.hutool.core.date.DatePattern;
import cn.hutool.core.date.DateTime;
import cn.hutool.core.date.DateUtil;

public class Demo {

public static void main(String[] args) {
    String dateStr = "2022-02-02";
    DateTime dateTime = DateUtil.parse(dateStr, DatePattern.NORM_DATE_PATTERN);
    System.out.println(dateTime);
}

}

日期时间转字符串

import cn.hutool.core.date.DatePattern;
import cn.hutool.core.date.DateUtil;
import java.util.Date;

public class Demo {

public static void main(String[] args) {
    Date date=new Date();
    String dateStr = DateUtil.format(date, DatePattern.NORM_DATE_PATTERN);
    System.out.println(dateStr);
}

}
输出结果：

2022-02-02

DateUtil.compare：两个日期之间进行比较大小

String currentDateStr=“2022-03-20 00:00:00”;
String specialDateStr=“2022-03-21 00:00:00”;
if (DateUtil.compare(DateUtil.parseDateTime(currentDateStr),DateUtil.parseDate(specialDateStr))<0){
System.out.println(“比specialDate日期要小一点”);
}

时间偏移

public static void main(String[] args){
    DateTime date=new DateTime();
    Date newDate = DateUtil.offset(date, DateField.MINUTE, 5);
    System.out.println(date);
    System.out.println(newDate);
}
2022-09-23 09:56:10
2022-09-23 10:01:10

图片工具

针对 awt 中图片处理进行封装，这些封装包括：缩放、裁剪、转为黑白、加水印等操作。

彩色转换成黑白

//黑白转换
ImgUtil.gray(FileUtil.file("d:/logo.png"), FileUtil.file("d:/result.png"));

添加文字水印

ImgUtil.pressText(//
    FileUtil.file("e:/pic/face.jpg"), //
    FileUtil.file("e:/pic/test2_result.png"), //
    "版权所有", Color.WHITE, //文字
    new Font("黑体", Font.BOLD, 100), //字体
    0, //x坐标修正值。 默认在中间，偏移量相对于中间偏移
    0, //y坐标修正值。 默认在中间，偏移量相对于中间偏移
    0.8f//透明度：alpha 必须是范围 [0.0, 1.0] 之内（包含边界值）的一个浮点数字
);

HTML 工具

比如清除富文本编辑器中的 HTML 文本的指定标签，或者只保留普通文本。

HtmlUtil.cleanHtmlTag

清除所有 HTM L标签，但是保留标签内的内容。

String str = "pre<div class=\"test_div\">\r\n\t\tdfdsfdsfdsf\r\n</div><div class=\"test_div\">BBBB</div>";

// 结果为：pre\r\n\t\tdfdsfdsfdsf\r\nBBBB
String result = HtmlUtil.cleanHtmlTag(str);

HtmlUtil.removeHtmlTag

清除指定HTML标签和被标签包围的内容

String str = "pre<img src=\"xxx/dfdsfds/test.jpg\">";

// 结果为：pre
String result = HtmlUtil.removeHtmlTag(str, "img");

过滤 HTML 文本，防止 XSS 攻击

这个作用就不必多说，防止用户在输入文本中写入 HTML 标签对后台造成攻击。

String html = "<alert></alert>";

// 结果为：""
String filter = HtmlUtil.filter(html);

ArrayUtil

isNotEmpty（判断数组不为空）**

public static void main(String[] args){
int[] a = {1,2};
if (ArrayUtil.isNotEmpty(a)) {
System.out.println(true);
}else{
System.out.println(false);
}
int[] b={};
if (ArrayUtil.isNotEmpty(b)) {
System.out.println(true);
}else{
System.out.println(false);
}
}

*filter（过滤）*

public static void main(String[] args) throws Exception {
Integer[] arr = {1, 2, 3, 4, 5, 6};
Integer[] filter = ArrayUtil.filter(arr, new Editor() {
@Override
public Integer edit(Integer t) {
return (t % 2 == 0) ? t : null;
}
});
for(Integer i:filter){
System.out.println(i);
}

contains（是否包含元素）

ArrayUtil.contains方法检测指定元素是否在数组中

import cn.hutool.core.util.ArrayUtil;

public class Demo {

public static void main(String[] args) throws Exception {
    int[] arr ={1,2,3};
    boolean flag = ArrayUtil.contains(arr,3);
    System.out.println(flag);
}

}

*join（数组转字符串，指定分割符）*

public static void main(String[] args){
//数组转字符串(指定分隔符)
int[] arr ={1,2,3};
String str = ArrayUtil.join(arr,“_”);
System.out.println(str);
}

信息脱敏工具-DesensitizedUtil

在数据处理或清洗中，可能涉及到很多隐私信息的脱敏工作,所谓脱敏就是隐藏掉信息中的一部分关键信息，用*代替
代码如下：

// 5***************1X
DesensitizedUtil.idCardNum(“51343620000320711X”, 1, 2);

// 180****1999
DesensitizedUtil.mobilePhone(“18049531999”);

// 比如密码，只保留了位数信息,**********
DesensitizedUtil.password(“1234567890”);

文件类

4.1 递归遍历目录 FileUtil.loopFiles（）

递归遍历目录以及子目录中的所有文件

  List<File> files = FileUtil.loopFiles(newPath(filePath));