hutool工具类

前言

「添加Hutool的所有依赖」

 cn.hutool hutool-all 5.3.3

模拟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 userList = JSONUtil.toList(new JSONArray(userMapList),User.class);
// 同fastjson
List 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 saveRecord(@ApiIgnore @RequestBody Map 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 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 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 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 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 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 list = CollUtil.newArrayList(array);
              	// 数组转字符串时添加连接符号
              	String joinStr = CollUtil.join(list, ",");
              	LOGGER.info("collUtil join:{}", joinStr);
              	// 将以连接符号分隔的字符串再转换为列表
              	List splitList = StrUtil.split(joinStr, ',');
              	LOGGER.info("collUtil split:{}", splitList);
              	// 创建新的Map、Set、List
              	HashMap newMap = CollUtil.newHashMap();
              	HashSet newHashSet = CollUtil.newHashSet();
              	ArrayList 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 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\r\n\t\tdfdsfdsfdsf\r\nBBBB";
                        // 结果为:pre\r\n\t\tdfdsfdsfdsf\r\nBBBB
                        String result = HtmlUtil.cleanHtmlTag(str);
                        

                        HtmlUtil.removeHtmlTag

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

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

                        过滤 HTML 文本,防止 XSS 攻击

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

                        String html = "";
                        // 结果为:""
                        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 files = FileUtil.loopFiles(newPath(filePath));