常用 工具类

1.Map工具类

基于jdk 自带的Map 增强一些方法

package utils;

import cn.hutool.core.lang.Opt;
import org.springframework.util.ReflectionUtils;

import java.lang.reflect.Field;
import java.util.*;
import java.util.function.Predicate;
import java.util.stream.Collectors;

/**
 * @Author NoDreamJava
 * @Date 2023-5-12 16:53
 * @Version 1.0
 */
public class MapUtils implements Map<Object, Object> {

    private Map<Object, Object> map = new HashMap<>();


    public MapUtils(Map<?, ?> paramMap) {
        map.putAll(paramMap);
    }


    public Date getDate(Object key) {
        Object val = map.get(key);
        return com.alibaba.fastjson2.util.TypeUtils.toDate(val);
    }

    public String getString(Object key) {
        Object value = get(key);
        return value == null ? null : value.toString();
    }

    public Integer getInt(Object key) {
        Object value = get(key);

        if (value == null) {
            return null;
        }

        if (value instanceof Integer) {
            return ((Integer) value);
        }

        if (value instanceof Number) {
            return ((Number) value).intValue();
        }

        if (value instanceof String) {
            String str = (String) value;

            if (str.isEmpty() || "null".equalsIgnoreCase(str)) {
                return null;
            }

            if (str.indexOf('.') != -1) {
                return (int) Double.parseDouble(str);
            }

            return Integer.parseInt(str);
        }


        throw new ClassCastException("Can not cast '" + value.getClass() + "' to int value");
    }

    public Object get(Object key) {
        Object val = map.get(key);

        if (val == null
                && (key instanceof Number || key instanceof Boolean || key instanceof Character)) {
            val = map.get(key.toString());
        }

        return val;
    }

    public <T> T getObject(Object key, Class<T> clazz) {
        Object obj = map.get(key);
        if (obj == null) {
            return null;
        }
        // 判读是否为 object 并且 当前类型是否匹配value类型
        if (clazz != Object.class && clazz.isInstance(obj)) {
            return (T) obj;
        }
        return null;

    }

    public void removeBlankValue() {
        map.entrySet().removeIf(entry -> entry.getValue() == null || "".equals(entry.getValue() + ""));
    }

    /**
     * 反射赋值 Map转对象
     *
     * @param clazz
     * @param <T>
     * @return
     */

    public <T> T toJavaObject(Class<T> clazz) {
        try {
            T newInstance = clazz.newInstance();
            Field[] filedArray = clazz.getDeclaredFields();

            for (Field field : filedArray) {
                ReflectionUtils.makeAccessible(field);
                Opt.ofNullable(map.get(field.getName())).ifPresent(
                        value -> {
                            try {
                                field.set(newInstance, value);
                            } catch (IllegalAccessException e) {
                                e.printStackTrace();
                            }
                        }
                );
            }
            return newInstance;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }


    public List<Entry<Object, Object>> toList() {
        return new ArrayList<>(map.entrySet());
    }

    /**
     * 获取当前key的值 如果为空 将此key和默认value 放进map
     *
     * @param key
     * @param defaultValue
     * @return
     */

    public Object getOrPut(Object key, Object defaultValue) {
        Object value = map.get(key);
        if (value == null) {
            put(key, defaultValue);
            return defaultValue;
        } else {
            return value;
        }
    }

    public Map<Object, Object> filter(Predicate<? super Entry<Object, Object>> predicate) {
        return map.entrySet().stream().filter(predicate).collect(Collectors.toMap(Entry::getKey, Entry::getValue, (k1, k2) -> k1));

    }

    /**
     * 创建只读Map
     *
     * @param keyValuePairs
     * @param <K>
     * @param <V>
     * @return
     */
    public static <K, V> Map<K, V> mapOf(Object... keyValuePairs) {
        return Collections.unmodifiableMap(mutableMapOf(keyValuePairs));
    }

    /**
     * 创建可变Map
     *
     * @return
     */
    private static <K, V> Map<K, V> mutableMapOf(Object... keyValuePairs) {
        if (keyValuePairs.length % 2 != 0) {
            throw new IllegalArgumentException("keyValuePairs must be even");
        }
        Map<K, V> map = new HashMap<>();
        for (int i = 0; i < keyValuePairs.length; i += 2) {
            K key = (K) keyValuePairs[i];
            V value = (V) keyValuePairs[i + 1];
            map.put(key, value);
        }
        return map;
    }

    @Override
    public int size() {
        return map.size();
    }

    @Override
    public boolean isEmpty() {
        return map.isEmpty();
    }

    @Override
    public boolean containsKey(Object key) {
        return map.containsKey(key);
    }

    @Override
    public boolean containsValue(Object value) {
        return map.containsValue(value);
    }

    @Override
    public Object put(Object key, Object value) {
        return map.put(key, value);
    }

    @Override
    public Object remove(Object key) {
        return map.remove(key);
    }

    @Override
    public void putAll(Map<?, ?> m) {
        map.putAll(m);
    }

    @Override
    public void clear() {
        map.clear();
    }

    @Override
    public Set<Object> keySet() {
        return map.keySet();
    }

    @Override
    public Collection<Object> values() {
        return map.values();
    }

    @Override
    public Set<Entry<Object, Object>> entrySet() {
        return map.entrySet();
    }

    @Override
    public String toString() {
        return map.toString();
    }
    
}

2.If-Else 工具类

使用链式编程代替 if -else

package com.bonc.lnsy.label.utils;

import java.util.HashMap;
import java.util.Map;
import java.util.Optional;
import java.util.function.Function;
import java.util.function.Predicate;

public class IfElseChain<T, R> {
    private T obj;
    private Map<Predicate<T>, Function<T, R>> chain = new HashMap<>();
    private Optional<Function<T, R>> defaultAction = Optional.empty();
    private R defaultValue;

    private IfElseChain(T obj) {
        this.obj = obj;
    }

    public static <T> IfElseChain<T, Void> of(T obj) {
        return new IfElseChain<>(obj);
    }

    public static <T, R> IfElseChain<T, R> of(T obj, R defaultValue) {
        IfElseChain<T, R> ifElseChain = new IfElseChain<>(obj);
        ifElseChain.defaultValue = defaultValue;
        return ifElseChain;
    }

    public IfElseChain<T, R> when(Predicate<T> condition, Function<T, R> action) {
        chain.put(condition, action);
        return this;
    }

    public IfElseChain<T, R> otherwise(Function<T, R> action) {
        defaultAction = Optional.of(action);
        return this;
    }

    public void execute() {
        for (Map.Entry<Predicate<T>, Function<T, R>> entry : chain.entrySet()) {
            if (entry.getKey().test(obj)) {
                entry.getValue().apply(obj);
                return;
            }
        }
        defaultAction.ifPresent(action -> action.apply(obj));
    }

    public R apply() {
        for (Map.Entry<Predicate<T>, Function<T, R>> entry : chain.entrySet()) {
            if (entry.getKey().test(obj)) {
                return entry.getValue().apply(obj);
            }
        }
        return defaultAction.map(action -> action.apply(obj)).orElse(defaultValue);
    }

//    public static void main(String[] args) {
//        String name = "2222";
//
//        IfElseChain.of(name)
//                .when(s -> s.equals(name), s -> {
//                    System.out.println("11");
//                    return null;
//                })
//                .when("333"::equals, s -> {
//                    System.out.println("222");
//                    return null;
//                })
//                .otherwise(s -> {
//                    System.out.println("other");
//                    return null;
//                })
//                .execute();
//
//        String result = IfElseChain.of(name, "default")
//                .when(s -> s.equals(name), s -> "222")
//                .when("333"::equals, s -> "333")
//                .otherwise(s -> "other")
//                .apply();
//
//        System.out.println(result);
//    }
}

3.HanLP自然语言处理(可以分词、中文转换拼音等)

github官网 https://github.com/krisjin/HanLP

添加maven依赖

 <dependency>
     <groupId>com.hankcs</groupId>
     <artifactId>hanlp</artifactId>
     <version>portable-1.8.3</version>
 </dependency>

中文转英文

 String str = HanLP.convertToPinyinString("我是一个拼音字符串", "", false);
 System.out.println(str);

输出如下

woshiyigepinyinzifuchuan