Hutool是一个小而全的Java工具类库,通过静态方法封装,降低相关API的学习成本,提高工作效率,使Java拥有函数式语言般的优雅,让Java语言也可以“甜甜的”。
?
在我们的maven中引入糊涂的依赖即可
<!--引入Hutool工具类-->
<dependency>
<groupId>cn.hutool</groupId>
<artifactId>hutool-all</artifactId>
<version>5.8.16</version>
</dependency>
因为我们使用的是单元测试,所以我们还需要引入junit的依赖。如果是spring boot项目,就不需要引入,引入junit,因为springboot已经继承了,要是maven项目就需要引入。
<!--引入junit单元测试-->
<dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter</artifactId>
<scope>test</scope>
</dependency>
主要封装了对数组和集合类的操作
新建一个ColUtilTest测试类:
public class ColUtilTest {
}
在这个类上添加? @Slf4j注解
@Slf4j
public class ColUtilTest {
}
就是将一个集合转换成字符串。
@Test
@DisplayName(value = "测试集合转成字符串")
void testListToStr(){
String[] str = {"a","b","c","d"};
ArrayList<String> list = CollUtil.newArrayList(str);
String join = CollUtil.join(list, ","); //用指定分隔符分割
log.info(join);
}
这是一个组合方法,功能是将给定的多个集合放到一个集合(list)中,根据给定的
Comparator
对象排序,然后分页取数据。
?
@Test
@DisplayName(value = "合并集合到一个集合中,并按照分页的数据按需取出")
void testToList(){
//Integer类型的比较器
Comparator<Integer> comparator = new Comparator<>() {
@Override
public int compare(Integer o1, Integer o2) {
return o1.compareTo(o2);
}
};
//新建三个集合
ArrayList<Integer> list1 = CollUtil.newArrayList(1, 2, 3);
ArrayList<Integer> list2 = CollUtil.newArrayList(4, 5, 6);
ArrayList<Integer> list3 = CollUtil.newArrayList(7, 8, 9);
//把list1,list2,list3,按照从小到大排序,取 0~3个
List<Integer> result = CollUtil.sortPageAll(0, 3, comparator, list1, list2, list3);
System.out.println(result);
}
popPart方法
传入一个栈对象,然后弹出指定数目的元素对象,弹出是指
pop()
方法,会从原栈中删掉。并否则删除的元素。
@Test
@DisplayName(value = "测试出栈")
void testPopPart(){
Stack stack = new Stack();
stack.push(1);
stack.push(2);
stack.push(3);
stack.push(4);
List popPart = CollUtil.popPart(stack, 2);
System.out.println(popPart); //输出,出栈的元素
System.out.println(stack); //查看原来的stack
}
在数组末尾添加一个元素,其实就是List.add()方法实现的。
@Test
@DisplayName(value = "给数组末尾添加元素")
void testToAppend(){
Integer[] ids = {4,5};
Integer[] append = ArrayUtil.append(ids, 1, 2, 3);
System.out.println(Arrays.toString(append)); //输出数组元素
System.out.println(ArrayUtil.toString(append)); //输出数组元素
}
重新调整数组的大小,如果调整后的大小比原来小,截断,如果比原来大,则多出的位置用null补位。
@Test
@DisplayName("重新调整数据的大小")
void testResize(){
Object[] array = ArrayUtil.newArray(5); //创建一个长度为5的数组
array[0] = 1;
array[1] = 2;
array[2] = 3;
array[3] = 4;
System.out.println(ArrayUtil.toString(array)); //输出数据的数据
System.out.println(ArrayUtil.length(array)); //查看这个数组的长度
Object[] resize = ArrayUtil.resize(array, 3); //调整数组大小为3
System.out.println(ArrayUtil.length(resize)); //输出调整后数组的大小
System.out.println(ArrayUtil.toString(resize));
Object[] newSize = ArrayUtil.resize(resize, 6); //调整数组大小为6
System.out.println(ArrayUtil.toString(newSize)); //测试新数组里面的数据
System.out.println(ArrayUtil.length(newSize)); //测试新数组的长度
}
将多个集合添加到一个
Collection
中
@Test
@DisplayName(value = "把多个集合,合并到一个集合中")
void testAddAll(){
Collection coll = new ArrayList();
coll.add(88);
coll.add(99);
Collection<Integer> collection = CollUtil.addAll(CollUtil.newArrayList(1, 2, 3, 4), CollUtil.newArrayList(6, 7, 8));
collection.addAll(coll);
System.out.println(collection);
}
对集合切片,其他类型的集合会转换成List,
自动修正越界等问题,完全避免
IndexOutOfBoundsException
异常。
@Test
@DisplayName(value = "测试对集合进行切片")
void testSubList(){
ArrayList<Integer> list = CollUtil.newArrayList(1, 2, 3, 4, 5, 6);
List<Integer> subList = CollUtil.sub(list, 0, 3);
System.out.println(subList); //输出切片的数据
System.out.println(CollUtil.sub(list, 0, list.size() + 3)); //已经明显超出集合长度了
System.out.println(list); //原集合
}
判断集合是否为空(包括null和没有元素的集合)
@Test
@DisplayName(value = "list集合转成map")
void testListToMap(){
ArrayList<Integer> keys = CollUtil.newArrayList(1, 2, 3, 4);
ArrayList<String> values = CollUtil.newArrayList("a", "b", "c", "d");
Map<Integer, String> map = CollUtil.zip(keys, values);
System.out.println(map);
}
给定两个集合,然后两个集合中的元素一一对应,组成一个Map。此方法还有一个重载方法,可以传字符,然后给定分隔符,字符串会被split成列表。
@Test
@DisplayName(value = "list集合转成map")
void testListToMap(){
ArrayList<Integer> keys = CollUtil.newArrayList(1, 2, 3, 4);
ArrayList<String> values = CollUtil.newArrayList("a", "b", "c", "d");
Map<Integer, String> map = CollUtil.zip(keys,values);
System.out.println(map);
}
List在集合中使用最为频繁,因此新版本的Hutool中针对
List
单独封装了工具方法
查找某个元素,在集合中的位置(返回的是索引)
@Test
@DisplayName(value = "查找某个元素在集合中出现的位置")
void test1(){
LinkedList<String> linkedList = ListUtil.toLinkedList("1", "2", "3", "4", "3", "2", "1");
int[] ints = ListUtil.indexOfAll(linkedList, "2"::equals); //输出的是索引
System.out.println(ArrayUtil.toString(ints));
}
用下面的方法,可以帮助我们快速的生成list集合。
@Test
@DisplayName(value = "快速生成list集合")
void testFindOption(){
List<Integer> list = ListUtil.of(1, 2, 3, 4, 5);
list.forEach(l ->{
System.out.println(l); //遍历集合
});
ArrayList<Integer> arrayList = ListUtil.toList(1, 2, 3, 4);
System.out.println(arrayList);
LinkedList<Integer> linkedList = ListUtil.toLinkedList(1, 2, 3, 4, 5, 6, 7);
System.out.println(linkedList);
List<Integer> integerList = Arrays.asList(1, 2, 3, 4);
System.out.println(integerList);
}
此方法是列表截取,根据起始索引截取。不会影响原来的集合
@Test
@DisplayName(value = "集合数据截取")
void testSubList(){
ArrayList<Integer> list = ListUtil.toList(1, 2, 3, 4, 5, 6);
List<Integer> sub = ListUtil.sub(list, 0, 3);
System.out.println(sub); //截取出来的集合
System.out.println(list); //原集合
}
按照bean对象的某个数字类型的字段值排序
先创建一个 TestBean实体类对象,添加 @Data,和@AllArgsConstructor注解
@Data
@NoArgsConstructor
@AllArgsConstructor
class TestBean{
private Integer id;
private String name;
}
@Test
@DisplayName(value = "按照我们自定义的bean对象中的id属性排序")
void testSort(){
ArrayList<TestBean> list = ListUtil.toList(
new TestBean(2, "测试2"),
new TestBean(4, "测试4"),
new TestBean(1, "测试1"),
new TestBean(3, "测试3")
);
list.forEach(System.out::println); //排序前
ListUtil.sortByProperty(list,"id");
System.out.println("************************************************");
list.forEach(l -> System.out.println(l)); //排序后
}
将指定元素和指定下标位置的元素交换位置
@Test
@DisplayName(value = "元素交换")
void testSwap(){
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7);
ListUtil.swapTo(list,5,1); // 元素为5 的和下标是1的交换位置
System.out.println(list);
}
- 这个方法起到分组的作用。
- 通过传入要分组的集合,每个分组区间的大小,将一个集合分成不同的块。
@Test
@DisplayName(value = "集合分组")
void testPart(){
ArrayList<Integer> list = ListUtil.toList(1, 2, 3, 4, 5, 6,7);
List<List<Integer>> partition = ListUtil.partition(list, 3); //三个元素是一组
System.out.println(partition);
System.out.println(ListUtil.partition(list, 2)); //两个元素是一组
}
RandomUtil
主要针对JDK中Random
对象做封装,严格来说,Java产生的随机数都是伪随机数,所以Hutool封装后产生的随机结果也是伪随机结果。
新建一个 RandomTest测试类:在添加@slf4j注解
@Slf4j
@DisplayName(value = "测试生成随机数")
public class RandomTest {
}
RandomUtil.randomInt
?获得指定范围内的随机数- 前包后不包
@Test
@DisplayName("测试生成指定范围的随机数")
void randomTest1(){
log.info("测试生成指定范围的随机数");
for (int i = 0; i < 100; i++) {
int random = RandomUtil.randomInt(10, 100);
if (random == 10){
log.info("包含了{}",random);
}
if (random == 100){
log.info("包含了{}",random);
}
System.out.println("生成的随机数是:"+random);
}
}
randomBytes
?方法
- 生成一个 byte类型范围内的随机数,包含正数和负数。
- 可以传递一个参数,表示生成几个。
@Test
@DisplayName("测试生成在byte范围内的随机数,包括正数和负数,返回在一个数组中")
void randomTest2(){
log.info("测试生成在byte范围内的随机数,包括正数和负数,返回在一个数组中");
byte[] bytes = RandomUtil.randomBytes(10);
System.out.println(ArrayUtil.toString(bytes));
}
randomString
?方法
- 获得一个随机的字符串(只包含数字和字符)
- 传入一个参数指定,生成的随机字符串的长度
@Test
@DisplayName(value = "获得一个随机的字符串(包含数字和字符)")
void testRandomStr(){
String s1 = RandomUtil.randomString(10);
String s2 = RandomUtil.randomString(4);
System.out.println(s1);
System.out.println(s2);
}
randomNumbers
?方法?获得一个只包含数字的字符串
@Test
@DisplayName(value = "获得一个随机的字符串(包含数字)")
void testRandomNums(){
String numbers1 = RandomUtil.randomNumbers(10);
String numbers2 = RandomUtil.randomNumbers(7);
System.out.println(numbers1);
System.out.println(numbers2);
}
唯一ID生成应用十分广泛,生成方法也多种多样,Hutool针对一些常用生成策略做了简单封装。
唯一ID生成器的工具类,涵盖:
- UUID
- ObjectId(MongoDB)
- Snowflake(Twitter)
UUID全称通用唯一识别码(universally unique identifier),JDK通过
java.util.UUID
提供了 Leach-Salz 变体的封装。Hutool中,生成一个UUID字符串方法如下:?
我们先新建一个测试类:UuidTest,然后加上@Slf4j的注解
@Slf4j
@DisplayName(value = "UUID的测试类")
public class UuidTest {
}
生成的UUID是带 - 的字符串
@Test
@DisplayName(value = "测试生成带 - 的UUID")
public void testId1(){
log.info("测试生成带 - 的UUID");
String uuid = cn.hutool.core.util.IdUtil.randomUUID();
System.out.println(uuid);
生成不带 - 的字符串
@Test
@DisplayName(value = "测试生成不带 - 的UUID")
public void testId2(){
log.info("测试生成不带 - 的UUID");
String uuid = cn.hutool.core.util.IdUtil.simpleUUID();
System.out.println(uuid);
}
说明:
Hutool重写了java.util.UUID的逻辑,使用糊涂工具生成不带 - UUID字符串,不需要做字符串替换,性能提高一倍左右。
ObjectId是MongoDB数据库的一种唯一ID生成策略,是UUID version1的变种
我们新建一个ObjectIdTest测试类,加上@Slf4j的注解。
@Slf4j
@DisplayName(value = "ObjectId的测试类")
public class ObjectIdTest {
}
生成类似于:?5bsf78fg878dsg7svdsf98dsds9
@Test
@DisplayName(value = "测试生成一串的ObjectId")
void testObjectIdTest1(){
log.info("测试生成一大串的ObjectId");
String next = ObjectId.next();
System.out.println(next);
}
这个方法是 Hutool-4.1.14才开始提供
@Test
@DisplayName(value = "测试生成一串的ObjectId")
void testObjectIdTest2(){
log.info("测试生成一大串的ObjectId");
String id = IdUtil.objectId();
System.out.println(id);
}