木道寻08

这个屌丝很懒，什么也没留下！

热门标签

Java开发工具类(JDK、Hutool、Guava)_guava hutool

作者：木道寻08 | 2024-07-02 22:26:34

踩

guava hutool

Java开发常用的工具类

1、JDK自带

程序读取控制台输入内容（调试程序或者学习的时候比较有用）

public static void main(String[] args) {
       try ( BufferedReader reader = new BufferedReader(new InputStreamReader(System.in))){
           String input;
           while ((input = reader.readLine()) != null){
               System.out.println(input);
           }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
1
2
3
4
5
6
7
8
9
10

或者

public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String line = scanner.nextLine();
        while (line!=null) {
            System.out.println(line);
            line = scanner.nextLine();
        }
    }
1
2
3
4
5
6
7
8

Arrays工具类数组转集合

public static void main(String[] args) {
        List<String> list = Arrays.asList("123", "456", "789");
        System.out.println(list);

        // 注意 Arrays.asList 返回的集合是 静态内部类private static class ArrayList<E> extends AbstractList<E>
        // 并不支持集合修改操作  如果需要修改Arrays.asList转化的集合  需要再转成 java.util.List的实现
        list = new ArrayList<>(list); //比如 转成ArrayList
        list.add("ok");
        System.out.println(list);
    }
1
2
3
4
5
6
7
8
9
10

Collections 集合工具类排序

public static void main(String[] args) {

        List<String> list = new ArrayList<>();
        list.add("1哈士奇");
        list.add("2斗牛");
        list.add("3博美");
        list.add("4斗牛");
        list.add("5哈士奇");

        System.out.println("原始顺序：" + list);

        // 反转
        Collections.reverse(list);
        System.out.println("反转：" + list);

        // 洗牌，随机打乱
        Collections.shuffle(list);
        System.out.println("洗牌：" + list);


        // 自然升序
        Collections.sort(list);
        System.out.println("自然升序：" + list);


        // 交换  注意后两个参数是下标
        Collections.swap(list, 0,4);
        System.out.println("交换：" + list);


        // 自定义比较器
        Collections.sort(list, new Comparator<String>() {
            @Override
            public int compare(String obj1, String obj2) {
                // 返回0 说明相等  大于0 说明obj1大   小于0 obj2大
                // 现在我想自定义排序 从小到大排   带哈士奇的就大  其余的都小
                if(obj1.equals(obj2)){
                    return 0;
                }else if(obj1.contains("哈士奇")){
                    return 1;
                }else {
                    return -1;
                }
            }
        });

        System.out.println(list);
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

Collections 集合工具类查找

public static void main(String[] args) {

        List<String> list = new ArrayList<>();
        list.add("1哈士奇");
        list.add("2斗牛");
        list.add("3博美");
        list.add("4斗牛");
        list.add("5哈士奇");
        System.out.println("集合数据：" + list);

        // 查找自然排序下的最大元素
        String max = Collections.max(list);
        System.out.println("最大： "+max);

        // 查找自然排序下的最小元素
        String min = Collections.min(list);
        System.out.println("最小： "+min);

        // 自定义比较器 返回最大元素
        String pomeranian = Collections.max(list, new Comparator<String>() {
            @Override
            public int compare(String obj1, String obj2) {
                // 返回0 说明相等  大于0 说明obj1大   小于0 obj2大
                // 现在我想自定义排序 从小到大排   带博美的就大  其余的都小
                if (obj1.equals(obj2)) {
                    return 0;
                } else if (obj1.contains("博美")) {
                    return 1;
                } else {
                    return -1;
                }
            }
        });

        System.out.println("自定义排序下的最大元素： "+pomeranian);
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

Lambda表达式操作集合收集、转map、分组

public static void main(String[] args) {

        List<Dog> list = new ArrayList<>();
        // 名称、爱好
        Dog dog1 = new Dog("秀逗", "吃骨头");
        Dog dog2 = new Dog("四眼", "吃馒头");
        Dog dog3 = new Dog("大黄", "吃骨头");
        Dog dog4 = new Dog("小黑", "吃馒头");
        Dog dog5 = new Dog("跳跳", "跳来跳去");
        list.add(dog1);
        list.add(dog2);
        list.add(dog3);
        list.add(dog4);
        list.add(dog5);

        System.out.println("集合数据：" + list);

        // 收集 集合中对象的某一个元素
        List<String> names = list.stream().map(Dog::getName).collect(Collectors.toList());
        System.out.println(names);

        // 转map  根据 集合中元素的 某个属性 准换成map集合   key是name属性  value是对象本身
        Map<String, Dog> dogMap = list.stream()
                .collect(Collectors.toMap(Dog::getName, Function.identity(),(oldValue, newValue) -> oldValue));
        System.out.println(dogMap);

        // 分组  根据 hobby 分组
        Map<String, List<Dog>> dogGroup = list.stream().collect(Collectors.groupingBy(Dog::getHobby));
        System.out.println(dogGroup);

    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

2、Apache 的 commons-lang3 和 commons-collections4

<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-lang3</artifactId>
    <version>3.14.0</version>
</dependency>

<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-collections4</artifactId>
    <version>4.5.0-M1</version>
</dependency>
1
2
3
4
5
6
7
8
9
10
11

字符串和集合的工具类

判断字符串集合是否为空，字符串拼接，字符串填充

public static void main(String[] args) {

        // =============== 判断字符串
        String a = "   ";
        // isNotBlank  如果字符串既非null又至少有一个非空白字符，则返回true；否则返回false
        if(StringUtils.isNotBlank(a)){
            System.out.println("isNotBlank");
        }

        // isNotEmpty  如果字符串非null且长度大于0，则返回true；否则返回false。
        if(StringUtils.isNotEmpty(a)){
            System.out.println("isNotEmpty");
        }

        // 字符串拼接
        List<String> list1 = Arrays.asList("秀逗", "大黄", "四眼");
        String join = StringUtils.join(list1, ",");
        System.out.println(join);

        // 字符串填充  如果不满多少位 就左填充 或者 右填充多少位
        String tt = "123";
        String leftPad = StringUtils.leftPad(tt, 6, "0");
        String rightPad = StringUtils.rightPad(tt, 6, "0");
        System.out.println(leftPad);
        System.out.println(rightPad);


        // =============== 判断集合
        List<String> list = new ArrayList<>(Arrays.asList("1", "2"));
        if(CollectionUtils.isNotEmpty(list)){
            System.out.println("list集合不为空");
        }
        Map<String, String> map = new HashMap<>();
        map.put("1","1");
        if(MapUtils.isNotEmpty(map)){
            System.out.println("map集合不为空");
        }

    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

3、Hutool

Hutool官网https://www.hutool.cn

官方文档：https://doc.hutool.cn/pages/index/

Maven坐标

<dependency>
    <groupId>cn.hutool</groupId>
    <artifactId>hutool-all</artifactId>
    <version>5.8.27</version>
</dependency>
1
2
3
4
5

下面这张图片来自 https://javabetter.cn/common-tool/hutool.html#_01%E3%80%81%E5%BC%95%E5%85%A5-hutool
在这里插入图片描述

功能太多了，简单举几个常用的例子：

处理日期 cn.hutool.core.date.DateUnit

public static void main(String[] args) {

        // 日期时间处理

        //============ 字符串转日期 ==============
        // 支持常见的格式
        // yyyy-MM-dd HH:mm:ss
        // yyyy-MM-dd
        // HH:mm:ss
        // yyyy-MM-dd HH:mm
        // yyyy-MM-dd HH:mm:ss.SSS
        DateTime dateTime = DateUtil.parse("2024-05-01 12:00:00");
        System.out.println(dateTime);

        // 日期转字符串
        String format = DateUtil.format(dateTime, "yyyy-MM-dd HH:mm:ss");
        System.out.println(format);



        //========== 计算两个时间差  可以计算相差的 毫秒、秒、分钟、小时、天、星期
        String dateStr1 = "2024-05-01 12:00:00";
        String dateStr2 = "2024-05-05 15:00:00";
        DateTime date1 = DateUtil.parse(dateStr1);
        DateTime date2 = DateUtil.parse(dateStr2);

        // 计算相差多少天
        long betweenDay = DateUtil.between(date1, date2, DateUnit.DAY);
        System.out.println(betweenDay);

        // ========= 给定日期的开始时间 和最后时间  ===========
        String dateStrBegin = "2024-05-23";
        DateTime dateBegin = DateUtil.parse(dateStrBegin);
        DateTime beginOfDay = DateUtil.beginOfDay(dateBegin);
        System.out.println(DateUtil.format(beginOfDay,"yyyy-MM-dd HH:mm:ss"));


        String dateStrEnd = "2024-05-23";
        DateTime dateEnd = DateUtil.parse(dateStrEnd);
        DateTime endOfDay = DateUtil.endOfDay(dateEnd);
        System.out.println(DateUtil.format(endOfDay,"yyyy-MM-dd HH:mm:ss"));
        
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

处理字符串 cn.hutool.core.util.StrUtil;

public static void main(String[] args) {
        // ============= 字符串填充 =============
        String str = "秀逗喜欢吃{},也喜欢{}";
        String format = StrUtil.format(str, "骨头", "跑着玩");
        System.out.println(format);
    }
1
2
3
4
5
6

IO操作（文件读取、复制、写入、压缩）

public static void main(String[] args) {
        // ============= 获取输入输出流 ==========
        BufferedInputStream inputStream = FileUtil.getInputStream("C:\\Users\\Administrator\\Desktop\\123.txt");
        BufferedOutputStream outputStream = FileUtil.getOutputStream("C:\\Users\\Administrator\\Desktop\\123_copy.txt");

        // ============= 复制文件 ==========
        FileUtil.copy("C:\\Users\\Administrator\\Desktop\\123.txt",
                "C:\\Users\\Administrator\\Desktop\\123_copy.txt",
                true);


        // ============ 读取文件 ============
        List<String> list = FileUtil.readUtf8Lines("C:\\Users\\Administrator\\Desktop\\123.txt");
        System.out.println(list);

        // ============ 写文件 ============
        List<String> lines = new ArrayList<>();
        lines.add("123");
        lines.add("456");
        lines.add("789");
        FileUtil.writeUtf8Lines(lines,"C:\\Users\\Administrator\\Desktop\\123.txt");

        // ============ 压缩文件 压缩成.zip格式 =============
        ZipUtil.zip("C:\\Users\\Administrator\\Desktop\\12333","C:\\Users\\Administrator\\Desktop\\12333.zip");

        // ============ 解压文件 解压.zip格式压缩包 =============
        ZipUtil.unzip("C:\\Users\\Administrator\\Desktop\\12333.zip","C:\\Users\\Administrator\\Desktop\\12333");

    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

反射工具 cn.hutool.core.util.ReflectUtil

public static void main(String[] args) throws IllegalAccessException, InvocationTargetException, InstantiationException {

        // ================== 获取默认构造器
        Constructor<Dog> constructor = ReflectUtil.getConstructor(Dog.class);

        // ================== 获取对象
        Dog dog = ReflectUtil.newInstance(Dog.class);

        // ================== 获取全部字段
        Field[] fields = ReflectUtil.getFields(Dog.class);

        // ================== 获取某个字段
        Field name = ReflectUtil.getField(Dog.class, "name");

        // ================== 获取全部方法
        Method[] methods = ReflectUtil.getMethods(Dog.class);

        // ================== 获取某个方法
        Method eat = ReflectUtil.getMethod(Dog.class, "eat");

        // 执行某个方法
        ReflectUtil.invoke(ReflectUtil.newInstance(Dog.class), "bulk");

    }
class Dog{

    private String name;

    private String hobby;

    public void eat(){
        System.out.println("狗喜欢吃骨头！");
    }

    public void bulk(){
        System.out.println("汪汪汪！");
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getHobby() {
        return hobby;
    }

    public void setHobby(String hobby) {
        this.hobby = hobby;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

校验字段 (身份证、手机号、邮箱)

 public static void main(String[] args) {

        // =============== 校验身份证
        String right = "120222198412136012";
        String error = "340411199505250212999";

        System.out.println(IdcardUtil.isValidCard(right));
        System.out.println(IdcardUtil.isValidCard(error));

        // ============== 手机号
        boolean phone = PhoneUtil.isPhone("19905240696");
        System.out.println(phone);


        // ============== 邮箱
        boolean email = Validator.isEmail("123@qq.com");
        System.out.println(email);

    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

简单的外部配置信息获取

public static void main(String[] args) {
        // 初始化配置文件
        String settings = "C:\\Users\\Administrator\\Desktop\\配置文件.txt";
        Setting setting = new Setting(settings);
       
        // 获取配置文件内信息
        String url = setting.get("url");
        String name = setting.get("name");

        System.out.println(url);
        System.out.println(name);
    }
1
2
3
4
5
6
7
8
9
10
11
12

图片工具

public static void main(String[] args) {
       // ========== 图片工具 =============
        // 压缩
        Img.from(FileUtil.file("C:\\Users\\Administrator\\Desktop\\123\\dog.jpg"))
                .setQuality(0.8)//压缩比率
                .write(FileUtil.file("C:\\Users\\Administrator\\Desktop\\123\\dog_1.jpg"));
        
        // 添加水印
        ImgUtil.pressText(//
                FileUtil.file("C:\\Users\\Administrator\\Desktop\\123\\dog.jpg"),
                FileUtil.file("C:\\Users\\Administrator\\Desktop\\123\\dog_text.jpg"),
                "二哈", Color.WHITE, //文字
                new Font("黑体", Font.BOLD, 15), //字体
                0, //x坐标修正值。 默认在中间，偏移量相对于中间偏移
                0, //y坐标修正值。 默认在中间，偏移量相对于中间偏移
                0.8f//透明度：alpha 必须是范围 [0.0, 1.0] 之内（包含边界值）的一个浮点数字
        );
        
        // 剪裁
        ImgUtil.cut(
                FileUtil.file("C:\\Users\\Administrator\\Desktop\\123\\dog.jpg"),
                FileUtil.file("C:\\Users\\Administrator\\Desktop\\123\\dog_text_2.jpg"),
                new Rectangle(0, 0, 259, 175)//裁剪的矩形区域
        );
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

加密解密

public static void main(String[] args) {
       // ========== 加密工具 =============


        // 对称加密 解密
        AES aes = SecureUtil.aes();
        String s = aes.encryptHex("123456");
        System.out.println(s);

        String s1 = aes.decryptStr(s);
        System.out.println(s1);

        // 非对称加密
        RSA rsa = SecureUtil.rsa();
        // 公钥加密
        String s2 = rsa.encryptHex("123456", KeyType.PublicKey);
        System.out.println(s2);
        // 私钥解密
        String s3 = rsa.decryptStr(s2, KeyType.PrivateKey);
        System.out.println(s3);
        
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

缓存

public static void main(String[] args) {

        // =============== 缓存

        // =========== FIFO(first in first out) 先进先出策略。
        // 元素不停的加入缓存直到缓存满为止，当缓存满时，清理过期缓存对象，清理后依旧满则删除先入的缓存（链表首部对象）。
        Cache<String,String> fifoCache = CacheUtil.newFIFOCache(3);

        //加入元素，每个元素可以设置其过期时长，DateUnit.SECOND.getMillis()代表每秒对应的毫秒数，在此为3秒
        fifoCache.put("key1", "value1", DateUnit.SECOND.getMillis() * 3);
        fifoCache.put("key2", "value2", DateUnit.SECOND.getMillis() * 3);
        fifoCache.put("key3", "value3", DateUnit.SECOND.getMillis() * 3);

        //由于缓存容量只有3，当加入第四个元素的时候，根据FIFO规则，最先放入的对象将被移除
        fifoCache.put("key4", "value4", DateUnit.SECOND.getMillis() * 3);

        //value1为null
        String value1 = fifoCache.get("key1");




        // =========== LFU(least frequently used) 最少使用率策略。
        // 根据使用次数来判定对象是否被持续缓存（使用率是通过访问次数计算），
        // 当缓存满时清理过期对象，清理后依旧满的情况下清除最少访问（访问计数最小）
        // 的对象并将其他对象的访问数减去这个最小访问数，以便新对象进入后可以公平计数。

        Cache<String, String> lfuCache = CacheUtil.newLFUCache(3);
        //通过实例化对象创建
        //LFUCache<String, String> lfuCache = new LFUCache<String, String>(3);

        lfuCache.put("key1", "value1", DateUnit.SECOND.getMillis() * 3);
        lfuCache.get("key1");//使用次数+1
        lfuCache.put("key2", "value2", DateUnit.SECOND.getMillis() * 3);
        lfuCache.put("key3", "value3", DateUnit.SECOND.getMillis() * 3);
        lfuCache.put("key4", "value4", DateUnit.SECOND.getMillis() * 3);

        //由于缓存容量只有3，当加入第四个元素的时候，根据LRU规则，最少使用的将被移除（2,3被移除）
        String value2 = lfuCache.get("key2");//null
        String value3 = lfuCache.get("key3");//null



        // =========== LRU (least recently used)最近最久未使用缓存。根据使用时间来判定对象是否被持续缓存，
        // 当对象被访问时放入缓存，当缓存满了，最久未被使用的对象将被移除。
        // 此缓存基于LinkedHashMap，因此当被缓存的对象每被访问一次，这个对象的key就到链表头部。
        // 这个算法简单并且非常快，他比FIFO有一个显著优势是经常使用的对象不太可能被移除缓存。
        // 缺点是当缓存满时，不能被很快的访问。
        Cache<String, String> lruCache = CacheUtil.newLRUCache(3);
        //通过实例化对象创建
        //LRUCache<String, String> lruCache = new LRUCache<String, String>(3);
        lruCache.put("key1", "value1", DateUnit.SECOND.getMillis() * 3);
        lruCache.put("key2", "value2", DateUnit.SECOND.getMillis() * 3);
        lruCache.put("key3", "value3", DateUnit.SECOND.getMillis() * 3);
        lruCache.get("key1");//使用时间推近
        lruCache.put("key4", "value4", DateUnit.SECOND.getMillis() * 3);

        //由于缓存容量只有3，当加入第四个元素的时候，根据LRU规则，最少使用的将被移除（2被移除）
        String value_2 = lruCache.get("key");//null


        // =========== 定时缓存，对被缓存的对象定义一个过期时间，当对象超过过期时间会被清理。
        // 此缓存没有容量限制，对象只有在过期后才会被移除。
        //创建缓存，默认4毫秒过期
        TimedCache<String, String> timedCache = CacheUtil.newTimedCache(4);
        //实例化创建
        //TimedCache<String, String> timedCache = new TimedCache<String, String>(4);

        timedCache.put("key1", "value1", 1);//1毫秒过期
        timedCache.put("key2", "value2", DateUnit.SECOND.getMillis() * 5);
        timedCache.put("key3", "value3");//默认过期(4毫秒)

        //启动定时任务，每5毫秒清理一次过期条目，注释此行首次启动仍会清理过期条目
        timedCache.schedulePrune(5);

        //等待5毫秒
        ThreadUtil.sleep(5);

        //5毫秒后由于value2设置了5毫秒过期，因此只有value2被保留下来
        String value_1 = timedCache.get("key1");//null
        String value__2 = timedCache.get("key2");//value2

        //5毫秒后，由于设置了默认过期，key3只被保留4毫秒，因此为null
        String value_3 = timedCache.get("key3");//null

        //取消定时清理
        timedCache.cancelPruneSchedule();
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88

4、Guava

Guava是Google开源的一个Java库，它包含了很多Google核心库中使用的基础工具和高性能原语。
Guava的目标是提高Java程序员的生产力，特别是通过减少常见的编程任务中的 boilerplate code（样板代码），同时引入一些Java标准库中没有的功能和改进已有的功能。

Guava主要特性包括：
①、集合（Collections）: Guava提供了丰富的不可变集合（Immutable Collections）、多值映射（Multimap）、双向映射（BiMap）、表（Table）等数据结构，以及强大的集合操作工具类，如Iterables、Lists、Sets等，这些都大大增强了Java集合框架的功能。

②、缓存（Cache）: 提供了一个强大且可自定义的缓存实现——Cache，支持多种缓存淘汰策略（如基于容量、基于时间等），使得在Java中实现高性能缓存变得更加简单。

③、并发（Concurrency）: Guava提供了并发工具类，比如ListenableFuture用于异步编程，以及一些并发工具方法，帮助开发者更安全、高效地处理并发问题。

④、字符串处理（Strings）: 扩展了Java的字符串处理能力，提供了更多方便的方法，如字符串连接、前缀判断、后缀移除等。

⑤、原生类型支持（Primitives）: Guava对Java基本类型提供了丰富的支持，包括基本类型的数组操作、集合转换等，提高了处理基本类型数据的效率。

⑥、函数式编程支持（Functional Programming）: 包括函数接口（Function、Predicate等）和流式操作，尽管不如Java 8引入的Stream API那样全面，但提供了基础的函数式编程支持。

⑦、校验器（Validators）: 用于数据验证，提供了一套可组合的校验规则，方便构建复杂的校验逻辑。

⑧、I/O操作: 简化了文件读写操作，提供了基于流的读写工具类，以及一些实用的I/O工具方法。

⑨、范围（Range）: 用于表示和操作数值范围，简化区间判断逻辑。

⑩、事件总线（EventBus）: 一种发布/订阅模式的通信机制，用于解耦应用程序的不同部分，简化组件间的通信。

引入Maven坐标：

<dependency>
	<groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>33.2.0-jre</version>
</dependency>
1
2
3
4
5

示例：
只举一些常用的集合和缓存的例子，更多的内容可以去 Guava的在线文档内学习

Guava在线文档-英文版https://tool.oschina.net/apidocs/apidoc?api=guava

集合

public static void main(String[] args) {

        // ============== 创建快速初始化的集合
        ArrayList<String> arrayList = Lists.newArrayList("123", "456", "789");


        // ============== 不可变集合
        ImmutableList<String> immutableList = ImmutableList.of("1", "2");
//        immutableList.add("2"); // 报异常 java.lang.UnsupportedOperationException

        // 把可变集合转换成不可变集合
        ImmutableList<String> immutableList1 = ImmutableList.copyOf(arrayList);


        // ============== Multiset
        // 可以把 Multiset 看成 没有元素顺序限制的ArrayList
        // 存储结构 Map<E, Integer>，键为元素，值为计数
        Multiset<String> multiset = HashMultiset.create();
        multiset.add("1");
        multiset.add("1");
        multiset.add("2");
        multiset.add("3");
        System.out.println("1的个数：" + multiset.count("1"));
        System.out.println("multiset内元素的个数：" + multiset.size());
        System.out.println("multiset内不重复元素的集合：" + multiset.elementSet());


        // ============== MultiMap
        // 类似分组操作  一个key 可以对应一个集合  集合里面有多个值
        // 常用的接口 ListMultimap 和 SetMultimap

        Multimap<String,String> multimap = ArrayListMultimap.create();
        multimap.put("1","1");
        multimap.put("1","2");
        multimap.put("3","3");
        multimap.putAll("3",Lists.newArrayList("A","B","C","D"));

        Collection<String> strings = multimap.get("1");
        System.out.println(strings);

        Map<String, Collection<String>> asMap = multimap.asMap();
        System.out.println("asMap视图："+ Joiner.on(";").withKeyValueSeparator("=").join(asMap));


        // ============== BiMap
        // 可以根据key查询value  也可以根据value查询key
        // 保证值是唯一的
        BiMap<String, String> biMap = HashBiMap.create();
        biMap.put("1","秀逗");
        biMap.put("2","四眼");

        String value = biMap.get("1");
        String key = biMap.inverse().get("秀逗");

        System.out.println(value);
        System.out.println(key);

        // biMap.put("3","秀逗"); // 报错   java.lang.IllegalArgumentException: value already present: 秀逗
        biMap.forcePut("3","秀逗"); // 强制替换 会覆盖已有的映射关系

        System.out.println(biMap);
        
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

缓存

说到缓存马上想到的可能是Redis这类缓存数据库，实际上JVM内存缓存也是实现缓存的一种手段。

那么用 JVM本地内存缓存有什么优势呢？

①、性能优势： 对于小规模或访问极为频繁的数据，JVM本地缓存（如Guava Cache）由于省去了网络通信的开销，能够提供更低的访问延迟。数据直接存储在应用的内存中，使得读写速度极快。
②、缓存分级策略： 在一些大型系统中，可能会采用多级缓存策略，即首先查询本地JVM缓存（如Guava Cache），未命中时再查询Redis等分布式缓存，最后才是数据库。这种策略可以进一步提升数据访问速度，减少数据库系统的压力。

有优势就有劣势：

①、数据存放在本机的内存,未持久化到硬盘,应用重启数据会丢失
②、单机缓存,容量有限
③、多个实例部署应用会出现缓存数据不一致的问题

com.google.common.cache.Cache示例：

public static void main(String[] args) {

        // 使用 CacheBuilder 构建JVM缓存
        // expireAfterWrite 设置缓存项在写入后3秒后过期。
        // .initialCapacity(1): 指定缓存的初始容量为1。
        // .maximumSize(2): 设置缓存的最大容量为2。当缓存项的数量超过这个限制时，
        // 根据Guava的默认实现（LRU，最近最少使用策略），最不常使用的条目会被移除以腾出空间给新的条目

        // .removalListener(...): 添加一个缓存移除监听器。每当有条目从缓存中移除时
        // （无论是因为过期、容量达到上限还是显式删除），都会调用这个监听器的方法。

        Cache<String, String> cache = CacheBuilder.newBuilder()
                .expireAfterWrite(10, TimeUnit.SECONDS)
                .initialCapacity(1)
                .maximumSize(2)
                .removalListener((RemovalListener<String, String>) notification ->
                        System.out.println(notification.getKey() + "移除了,value:" + notification.getValue()))
                .build();


        // getIfPresent(key)：从现有的缓存中获取,如果缓存中有key,则返回value,如果没有则返回null
        String value = cache.getIfPresent("1");
        System.out.println(value); //null

        cache.put("1", "秀逗");
        cache.put("2", "四眼");
        cache.put("3", "大黄");

        System.out.println(cache.getIfPresent("1"));
        System.out.println(cache.getIfPresent("2"));
        System.out.println(cache.getIfPresent("3"));
        
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

使用Guava Cache时需要注意的事项：（需要深入研究）

①、明确缓存目的： 在设计缓存之前，明确其目的是提高读取速度、减少数据库负载还是其他。这将帮助你决定合适的缓存策略。
②、选择合适的缓存淘汰策略：
使用.expireAfterWrite或.expireAfterAccess根据业务需求设置过期时间。
结合.maximumSize设置缓存最大容量，采用LRU（最近最少使用）或FIFO（先进先出）等淘汰策略。
线程安全：Guava Cache天生线程安全，但确保在访问和更新缓存时逻辑正确，避免不必要的锁竞争。
③、监听器的合理使用： 利用.removalListener监听缓存项移除事件，可以进行日志记录、资源清理等工作，但注意不要在监听器中执行耗时操作，以免影响性能。
④、弱引用与软引用： 根据应用场景，适当使用.weakKeys()、.weakValues()或.softValues()来控制缓存项的生命周期，尤其是在内存敏感的应用中。
⑤、统计与监控： 启用统计功能(.recordStats())来监控缓存命中率、加载次数等指标，帮助分析缓存效率，适时调整策略。
⑥、异步加载与刷新： 对于耗时的缓存项加载，可以使用.loadingCache并结合.refreshAfterWrite来异步刷新缓存，避免阻塞主线程。
⑦、避免过度缓存： 不是所有数据都适合缓存，特别是频繁变化、占用大量内存或访问频率很低的数据。合理评估并选择真正能带来性能提升的数据进行缓存。
⑧、资源管理： 当不再需要缓存时，通过.cleanUp()手动清理资源，或者确保应用关闭时能正确释放缓存资源。

5、其它工具类收集

金额转换成大写汉字

public class MoneyUtil {
    /** 大写数字 */
    private static final String[] NUMBERS = { "零", "壹", "贰", "叁", "肆", "伍",
            "陆", "柒", "捌", "玖" };

    /** 整数部分的单位 */
    private static final String[] IUNIT = { "元", "拾", "佰", "仟", "万", "拾", "佰",
            "仟", "亿", "拾", "佰", "仟", "万", "拾", "佰", "仟" };

    /** 小数部分的单位 */
    private static final String[] DUNIT = { "角", "分", "厘" };

    /**
     * 得到大写金额。
     */
    public static String toChinese(String str) {
        str = str.replaceAll(",", "");// 去掉","
        String integerStr;// 整数部分数字
        String decimalStr;// 小数部分数字
        // 初始化：分离整数部分和小数部分
        if (str.indexOf(".") > 0) {
            integerStr = str.substring(0, str.indexOf("."));
            decimalStr = str.substring(str.indexOf(".") + 1);
        } else if (str.indexOf(".") == 0) {
            integerStr = "";
            decimalStr = str.substring(1);
        } else {
            integerStr = str;
            decimalStr = "";
        }
        // integerStr去掉首0，不必去掉decimalStr的尾0(超出部分舍去)
        if (!integerStr.equals("")) {
            integerStr = Long.toString(Long.parseLong(integerStr));
            if (integerStr.equals("0")) {
                integerStr = "";
            }
        }
        // overflow超出处理能力，直接返回
        if (integerStr.length() > IUNIT.length) {
            System.out.println(str + ":超出处理能力");
            return str;
        }

        int[] integers = toArray(integerStr);// 整数部分数字
        boolean isMust5 = isMust5(integerStr);// 设置万单位
        int[] decimals = toArray(decimalStr);// 小数部分数字
        return getChineseInteger(integers, isMust5)
                + getChineseDecimal(decimals);
    }

    /**
     * 整数部分和小数部分转换为数组，从高位至低位
     */
    private static int[] toArray(String number) {
        int[] array = new int[number.length()];
        for (int i = 0; i < number.length(); i++) {
            array[i] = Integer.parseInt(number.substring(i, i + 1));
        }
        return array;
    }

    /**
     * 得到中文金额的整数部分。
     */
    private static String getChineseInteger(int[] integers, boolean isMust5) {
        StringBuffer chineseInteger = new StringBuffer("");
        int length = integers.length;
        for (int i = 0; i < length; i++) {
            // 0出现在关键位置：1234(万)5678(亿)9012(万)3456(元)
            // 特殊情况：10(拾元、壹拾元、壹拾万元、拾万元)
            String key = "";
            if (integers[i] == 0) {
                if ((length - i) == 13)// 万(亿)(必填)
                    key = IUNIT[4];
                else if ((length - i) == 9)// 亿(必填)
                    key = IUNIT[8];
                else if ((length - i) == 5 && isMust5)// 万(不必填)
                    key = IUNIT[4];
                else if ((length - i) == 1)// 元(必填)
                    key = IUNIT[0];
                // 0遇非0时补零，不包含最后一位
                if ((length - i) > 1 && integers[i + 1] != 0)
                    key += NUMBERS[0];
            }
            chineseInteger.append(integers[i] == 0 ? key
                    : (NUMBERS[integers[i]] + IUNIT[length - i - 1]));
        }
        return chineseInteger.toString();
    }

    /**
     * 得到中文金额的小数部分。
     */
    private static String getChineseDecimal(int[] decimals) {
        StringBuffer chineseDecimal = new StringBuffer("");
        for (int i = 0; i < decimals.length; i++) {
            // 舍去3位小数之后的
            if (i == 3)
                break;
            chineseDecimal.append(decimals[i] == 0 ? ""
                    : (NUMBERS[decimals[i]] + DUNIT[i]));
        }
        return chineseDecimal.toString();
    }

    /**
     * 判断第5位数字的单位"万"是否应加。
     */
    private static boolean isMust5(String integerStr) {
        int length = integerStr.length();
        if (length > 4) {
            String subInteger = "";
            if (length > 8) {
                // 取得从低位数，第5到第8位的字串
                subInteger = integerStr.substring(length - 8, length - 4);
            } else {
                subInteger = integerStr.substring(0, length - 4);
            }
            return Integer.parseInt(subInteger) > 0;
        } else {
            return false;
        }
    }

//    public static void main(String[] args) {
//        MoneyUtil moneyUtil = new MoneyUtil();
//        System.out.println(moneyUtil.toChinese("520"));
//    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

POI获取单元格内的数据

主要兼容几种常见的格式，数值，日期，文本。
会将获取到的数据都转换成字符串格式返回

/**
     * @param cell 单元格
     * @param dateFormat  日期格式化器  如果不传值，默认 yyyy-MM-dd HH:mm:ss 格式
     * @return 字符串格式的文本
     */
    public static String getCellValue(Cell cell, SimpleDateFormat... dateFormat) {
        if (cell == null) {
            return "";
        }
        if (dateFormat.length == 0) {
            dateFormat = new SimpleDateFormat[]{new SimpleDateFormat("yyyy-MM-dd HH:mm:ss")};
        }
        SimpleDateFormat simpleDateFormat = dateFormat[0];
        if (cell.getCellTypeEnum() == CellType.NUMERIC) {
            if (DateUtil.isCellDateFormatted(cell)) {
                // 如果是日期格式，获取日期并转换为字符串
                Date date = cell.getDateCellValue();
                return simpleDateFormat.format(date);
            } else {
                // 处理数值型数据
                return String.valueOf(cell.getNumericCellValue());
            }
        } else if (cell.getCellTypeEnum() == CellType.STRING) {
            // 处理字符串型数据
            return cell.getStringCellValue();
        } else if (cell.getCellTypeEnum() == CellType.BOOLEAN) {
            // 处理布尔型数据
            return String.valueOf(cell.getBooleanCellValue());
        } else if (cell.getCellTypeEnum() == CellType.FORMULA) {
            // 处理公式型数据
            return cell.getCellFormula();
        } else {
            // 处理其他类型的数据
            return cell.toString();
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/木道寻08/article/detail/781125