526互联

Hutool工具包

发布时间 2023-09-23 17:50:46作者: 山治最好吃

Hutool工具包

1.String判断空

* StrUtil.isEmpty 判断是否为空(包含null和空字符串) 
 
* StrUtil.isBlank 判断是否为空白(包含null、空字符串和空白字符) 
 
* StrUtil.isNotEmpty判断不为空 
 
* StrUtil.isNotBlank判断不为空白
 
* StrUtil.removePrefix 字符串去除指定字符串开始的字符 
 
* StrUtil.removeSuffix 字符串去除指定字符串结束的字符

StrUtil.isEmpty:

判断字符串是否为空（包含null和空字符串）：

String str = ""; // 定义字符串
boolean isEmpty = StrUtil.isEmpty(str); // 调用静态方法判断字符串是否为空

System.out.println(isEmpty); // 输出结果为true，字符串为空

StrUtil.isBlank

判断字符串是否为空白（包含null、空字符串和空白字符）：

String str = "  "; // 定义字符串
boolean isBlank = StrUtil.isBlank(str); // 调用静态方法判断字符串是否为空白

System.out.println(isBlank); // 输出结果为true，字符串为空白

StrUtil.isNotEmpty

判断字符串是否不为空：

String str = "Hello, World!"; // 定义字符串
boolean isNotEmpty = StrUtil.isNotEmpty(str); // 调用静态方法判断字符串是否不为空

System.out.println(isNotEmpty); // 输出结果为true，字符串不为空

StrUtil.isNotBlank

判断字符串是否不为空白：

String str = " Hello "; // 定义字符串
boolean isNotBlank = StrUtil.isNotBlank(str); // 调用静态方法判断字符串是否不为空白

System.out.println(isNotBlank); // 输出结果为true，字符串不为空白

StrUtil.removePrefix

去除字符串的指定前缀：

String str = "Hello, World!"; // 定义字符串
String prefix = "Hello, "; // 待去除的前缀
String result = StrUtil.removePrefix(str, prefix); // 调用静态方法去除指定前缀

System.out.println(result); // 输出结果为"World!"

StrUtil.removeSuffix

去除字符串的指定后缀：

String str = "Hello, World!"; // 定义字符串
String suffix = ", World!"; // 待去除的后缀
String result = StrUtil.removeSuffix(str, suffix); // 调用静态方法去除指定后缀

System.out.println(result); // 输出结果为"Hello"

注意要导入正确的类，并根据实际需求传递参数和处理返回值。

2.字符串与数组的分割合并

* StrUtil.splitTrim 字符串根据分割字符转为数组 
 
* StrUtil.join 将数组用分隔字符串合并为字符串

StrUtil.splitTrim

字符串根据分割字符转为数组并去除空格：

String str = "apple, banana, orange"; // 定义字符串
char delimiter = ','; // 分割字符
String[] arr = StrUtil.splitTrim(str, delimiter); // 调用静态方法进行分割和去除空格

for (String item : arr) {
  System.out.println(item); // 输出结果为"apple", "banana", "orange"
}

StrUtil.join

将数组用分隔字符串合并为字符串：

String[] arr = {"apple", "banana", "orange"}; // 定义字符串数组
String delimiter = ", "; // 分隔字符串
String result = StrUtil.join(arr, delimiter); // 调用静态方法进行合并

System.out.println(result); // 输出结果为"apple, banana, orange"

3.日期格式化与解析

* DateUtil.format日期格式化 
 
* DateUtil.parse日期解析

DateUtil.format

日期格式化：

import cn.hutool.core.date.DateUtil;

Date date = new Date(); // 获取当前日期
String pattern = "yyyy-MM-dd HH:mm:ss"; // 定义日期格式
String formattedDate = DateUtil.format(date, pattern); // 调用静态方法进行日期格式化

System.out.println(formattedDate); // 输出结果为"2022-01-01 12:34:56"

DateUtil.parse

日期解析：

import cn.hutool.core.date.DateUtil;

String dateStr = "2022-01-01 12:34:56"; // 定义日期字符串
String pattern = "yyyy-MM-dd HH:mm:ss"; // 定义日期格式
Date parsedDate = DateUtil.parse(dateStr, pattern); // 调用静态方法进行日期解析

System.out.println(parsedDate); // 输出结果为"Sat Jan 01 12:34:56 CST 2022"

4.集合操作

* CollUtil.isEmpty 判断为空(null或空集)
* CollUtil.distinct 集合去重
* CollUtil. removeNull 集合去空
* CollUtil.union 并集
* CollUtil.disjunction 交集

CollUtil.isEmpty

判断集合是否为空（null或空集）：

import cn.hutool.core.collection.CollUtil;

List<String> list = new ArrayList<>(); // 定义空集合
boolean isEmpty = CollUtil.isEmpty(list); // 调用静态方法判断集合是否为空

System.out.println(isEmpty); // 输出结果为true，集合为空

CollUtil.distinct

对集合进行去重：

import cn.hutool.core.collection.CollUtil;

List<String> list = new ArrayList<>();
list.add("apple");
list.add("banana");
list.add("apple");
List<String> distinctList = CollUtil.distinct(list); // 调用静态方法对集合进行去重

System.out.println(distinctList); // 输出结果为["apple", "banana"]

CollUtil. removeNull

去除集合中的空元素：

import cn.hutool.core.collection.CollUtil;

List<String> list = new ArrayList<>();
list.add("apple");
list.add("");
list.add("banana");
List<String> nonNullList = CollUtil.removeNull(list); // 调用静态方法去除集合中的空元素

System.out.println(nonNullList); // 输出结果为["apple", "banana"]

CollUtil.union

求集合的并集：

import cn.hutool.core.collection.CollUtil;

List<String> list1 = new ArrayList<>();
list1.add("apple");
list1.add("banana");
List<String> list2 = new ArrayList<>();
list2.add("banana");
list2.add("orange");
Collection<String> union = CollUtil.union(list1, list2); // 调用静态方法求集合的并集

System.out.println(union); // 输出结果为["apple", "banana", "orange"]

CollUtil.disjunction

求集合的交集：

import cn.hutool.core.collection.CollUtil;

List<String> list1 = new ArrayList<>();
list1.add("apple");
list1.add("banana");
List<String> list2 = new ArrayList<>();
list2.add("banana");
list2.add("orange");
Collection<String> disjunction = CollUtil.disjunction(list1, list2); // 调用静态方法求集合的交集

System.out.println(disjunction); // 输出结果为["banana"]

5.万能转换

* Convert.toInt 转为整数
* Convert.toLong 转为长整数

Convert.toInt

转换为整数：

import cn.hutool.core.convert.Convert;

String str = "123"; // 定义字符串
int intValue = Convert.toInt(str); // 调用静态方法将字符串转换为整数

System.out.println(intValue); // 输出结果为123

Convert.toLong

转换为长整数：

import cn.hutool.core.convert.Convert;

String str = "123456789"; // 定义字符串
long longValue = Convert.toLong(str); // 调用静态方法将字符串转换为长整数

System.out.println(longValue); // 输出结果为123456789

6.摘要计算与Base64

* SecureUtil.md5  计算Md5摘要
* SecureUtil.sha1  计算SHA1摘要  
* Base64.encode  Base64字符串加密
* Base64.decodeStr Base64字符串解密

SecureUtil.md5

计算Md5摘要：

import cn.hutool.crypto.SecureUtil;

String str = "Hello, World!"; // 定义字符串
String md5Digest = SecureUtil.md5(str); // 调用静态方法计算Md5摘要

System.out.println(md5Digest); // 输出结果为"65a8e27d8879283831b664bd8b7f0ad4"

SecureUtil.sha1

计算SHA1摘要：

import cn.hutool.crypto.SecureUtil;

String str = "Hello, World!"; // 定义字符串
String sha1Digest = SecureUtil.sha1(str); // 调用静态方法计算SHA1摘要

System.out.println(sha1Digest); // 输出结果为"0a4d55a8d778e5022fab701977c5d840bbc486d0"

Base64.encode

Base64字符串加密：

import cn.hutool.core.codec.Base64;

String str = "Hello, World!"; // 定义字符串
String base64Encoded = Base64.encode(str); // 调用静态方法对字符串进行Base64加密

System.out.println(base64Encoded); // 输出结果为"SGVsbG8sIFdvcmxkIQ=="

Base64.decodeStr

Base64字符串解密：

import cn.hutool.core.codec.Base64;

String base64Str = "SGVsbG8sIFdvcmxkIQ=="; // 定义Base64字符串
String decodedStr = Base64.decodeStr(base64Str); // 调用静态方法对Base64字符串进行解密

System.out.println(decodedStr); // 输出结果为"Hello, World!"

7.JSON操作

* JSONUtil.toBean  JSON解析为对象
* JSONUtil.parseObj JSON解析为JSONObject
* JSONUtil.formatJsonStr JSON格式化

JSONUtil.toBean

JSON解析为对象：

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

String jsonStr = "{\"name\":\"John\", \"age\":30}"; // 定义JSON字符串
User user = JSONUtil.toBean(jsonStr, User.class); // 调用静态方法将JSON解析为对象

System.out.println(user.getName()); // 输出结果为"John"
System.out.println(user.getAge()); // 输出结果为30

JSONUtil.parseObj

JSON解析为JSONObject：

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

String jsonStr = "{\"name\":\"John\", \"age\":30}"; // 定义JSON字符串
JSONObject jsonObj = JSONUtil.parseObj(jsonStr); // 调用静态方法将JSON解析为JSONObject

String name = jsonObj.getStr("name"); // 获取指定字段的值
int age = jsonObj.getInt("age");

System.out.println(name); // 输出结果为"John"
System.out.println(age); // 输出结果为30

JSONUtil.formatJsonStr

JSON格式化：

import cn.hutool.json.JSONUtil;

String jsonStr = "{\"name\":\"John\", \"age\":30}"; // 定义JSON字符串
String formattedJsonStr = JSONUtil.formatJsonStr(jsonStr); // 调用静态方法对JSON进行格式化

System.out.println(formattedJsonStr); 
// 输出结果为：
// {
//    "name": "John",
//    "age": 30
// }

8.文件读写

* FileUtil.readBytes  按字节读
* FileUtil.readLines 按行读
* FileUtil.readString 全部读
* FileUtil.writeBytes 按字节写
* FileUtil.writeLines 按行写
* FileUtil.writeString 全部写

FileUtil.readBytes 按字节读

按字节读取文件：

import cn.hutool.core.io.FileUtil;
import cn.hutool.core.io.IoUtil;

byte[] bytes = FileUtil.readBytes("path/to/file.txt"); // 调用静态方法按字节读取文件
String content = IoUtil.readUtf8(new ByteArrayInputStream(bytes)); // 将字节数组转为字符串

System.out.println(content); // 输出文件内容

FileUtil.readLines 按行读

按行读取文件：

import cn.hutool.core.io.FileUtil;
import cn.hutool.core.io.LineHandler;

FileUtil.readLines("path/to/file.txt", new LineHandler() {
    @Override
    public void handle(String line) {
        System.out.println(line); // 输出文件的每一行内容
    }
});

FileUtil.readString 全部读

全部读取文件内容：

import cn.hutool.core.io.FileUtil;

String content = FileUtil.readString("path/to/file.txt"); // 调用静态方法读取文件内容

System.out.println(content); // 输出文件内容

FileUtil.writeBytes 按字节写

按字节写入文件：

import cn.hutool.core.io.FileUtil;
import cn.hutool.core.io.IoUtil;

byte[] bytes = "Hello, World!".getBytes(); // 定义字节数组
FileUtil.writeBytes(bytes, "path/to/file.txt"); // 调用静态方法按字节写入文件

FileUtil.writeLines 按行写

按行写入文件：

import cn.hutool.core.io.FileUtil;
import cn.hutool.core.io.IoUtil;

List<String> lines = new ArrayList<>();
lines.add("Hello");
lines.add("World");
FileUtil.writeLines(lines, "path/to/file.txt", "UTF-8"); // 调用静态方法按行写入文件

FileUtil.writeString 全部写

全部写入文件内容：

import cn.hutool.core.io.FileUtil;

String content = "Hello, World!"; // 定义字符串
FileUtil.writeString(content, "path/to/file.txt", "UTF-8"); // 调用静态方法全部写入文件内容