代码开发常用工具类

刺骨的言语ヽ痛彻心扉 2023-10-04 11:34 10阅读 0赞

# 字符串 #

## String ##

构造方法：

String() //空参数构造方法
        
    String(String original) //把字符串转换为String对象
        
    String(char[] value) //把字符数组转换为String对象
        
    String(char[] value, int offset, int count)
        // 把字符数组的一部分转换为String对象
        // int offset：数组的开始索引
        // int count：转换的个数
        
    String(byte[] bytes)
        // 把字节数组转换为String类
        // 通过使用平台(操作系统)的默认字符集(操作系统的编码)解码指定的 byte 数组，构造一个新的 String。
        // 根据编码表查询字节对应的编码，把字节转换为字符串
        // 编码表：IO流 生活中的文字和计算机文字的一个对应关系表(ASCII)
        	// 0==>48==>计算机只能识别二进制==>00110000 存储到计算机中
        	// A==>65==>1000001 存储到计算机中
       		// a==>97==>1100001 存储到计算机中
    
    String(byte[] bytes, int offset, int length)
        // 参数是一个字节数组一部分的构造方法，把字节数组的一部分转换为String对象

判断功能的方法

// 将此字符串与指定对象进行比较
    boolean equals (Object anObject)	
    // 将此字符串与指定对象进行比较，忽略大小写
    boolean equalsIgnoreCase (String anotherString) 
    // 判断参数字符串在当前字符串中是否存在(区分大小写)。存在，返回true，否则，返回false
    boolean contains (CharSequence s)
    // 测试此字符串是否以指定的后缀结尾(区分大小写)
    boolean endsWith(String suffix)
    // 测试此字符串是否以指定的前缀开始(区分大小写)
    boolean startsWith(String prefix)

获取功能的方法

// 返回此字符串的长度。
    int length() 
    // 将指定的字符串连接到该字符串的末尾。
    String concat (String str)
    // 返回指定索引处的 char值。
    char charAt (int index) 
    // 返回指定子字符串第一次出现在该字符串内的索引。
    int indexOf (String str)
    // 返回指定子字符串最后一次出现的字符串中的索引。 如果不包含，则返回-1。
    int lastIndexOf(String str)
    // 返回一个子字符串，从beginIndex开始截取字符串到字符串结尾。
    String substring (int beginIndex)
    // 返回一个子字符串，从beginIndex到endIndex截取字符串。含beginIndex，不含endIndex。
    String substring (int beginIndex, int endIndex)

转换功能的方法

// 将此字符串转换为新的字符数组。 
    char[] toCharArray () 
    // 使用平台的默认字符集将该 String编码转换为新的字节数组。
    byte[] getBytes ()
    // 使用默认语言环境的规则将此 String所有字符转换为小写。
    String toLowerCase()
    // 将此 String所有字符转换为大写，使用默认语言环境的规则。
    String toUpperCase()
    // 将与target匹配的字符串使用replacement字符串替换。
    String replace (CharSequence target, CharSequence replacement)

分割功能的方法

// 将此字符串按照给定的regex（规则）拆分为字符串数组。
    String[] split(String regex)
    // 去掉当前字符串的前后空格，并返回一个新字符串，原字符串不变。
    String trim()

## StringBuilder ##

常用构造方法：

public StringBuilder()		//构造一个空的StringBuilder容器。
    
    public StringBuilder(String str)	//构造一个StringBuilder容器，并将字符串添加进去。

常用的方法：

// 添加任意类型数据的字符串形式，并返回当前对象自身。
    StringBuilder append(...)
    // 将此字符序列用其反转形式取代。
    StringBuilder reverse()

## StringBuilder <==> String ##

// StringBuilder ==> 为String
    // StringBuilder 的 toString()
    String toString()
    
    // String ==> StringBuilder
    // StringBuilder 的构造方法
    StringBuilder(String s)

## StringUtils 工具类 ##

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

包路径：org.apache.commons.lang3.StringUtils

null 安全的(即如果输入参数 String 为 null 则不会抛出 NullPointerException ，而是做了相应处理，例如，如果输入为 null 则返回也是 null。

常用方法（示例链接：https://blog.csdn.net/weixin\_42290280/article/details/82591161）：

// 判断某字符串是否为空或长度为0或由空白符(whitespace) 构成
    static boolean isBlank(String str)
    // 判断某字符串是否不为空且长度不为0且不由空白符(whitespace) 构成，等于 !isBlank(String str) 
    static boolean isNotBlank(String str)
    
    // 比较两个字符串是否相等，如果两个均为空则也认为相等。
    static boolean equals(String str1, String str2)
    // 比较两个字符串是否相等，不区分大小写，如果两个均为空则也认为相等。
    static boolean equalsIgnoreCase(String str1, String str2)
    
    // 判断某字符串是否为空，为空的标准是 str==null 或 str.length()==0 ，注意在 StringUtils 中空格作非空处理
    static boolean isEmpty(String str)
    // 判断某字符串是否非空，等于 !isEmpty(String str) 
    static boolean isNotEmpty(String str)
    
    // 去掉字符串两端的【控制符】(control characters, char <= 32) ，如果输入为 null 则返回null
    static String trim(String str)
    // 去掉字符串两端的控制符(control characters, char <= 32) ，如果变为 null 或""，则返回 null
    static String trimToNull(String str)
    // 去掉字符串两端的控制符(control characters, char <= 32) ，如果变为 null 或 "" ，则返回 "" 
    static String trimToEmpty(String str)
    
    // 去掉字符串两端的【空白符】(whitespace) ，如果输入为 null 则返回 null
    static String strip(String str) 
    // 去掉字符串两端的空白符(whitespace) ，如果变为 null 或""，则返回 null
    static String stripToNull(String str)
    // 去掉字符串两端的空白符(whitespace) ，如果变为 null 或"" ，则返回"" 
    static String stripToEmpty(String str)

# 集合/数组 #

## Collection 接口 ##

成员方法

// 将指定的元素追加到此集合的末尾
    boolean add(E e)
    // 删除指定索引处的元素，返回被删除的元素
    boolean remove(E e)
        
    // 判断集合中是否包含指定的元素 包含返回true,不包含返回false
    boolean contains(Object obj)
    // 判断当前集合是否为空
    boolean isEmpty()
    // 返回集合中的元素的个数
    int size()
    // 把集合中的元素，存储到数组中
    Object[] toArray()
    // 清空集合中所有的元素
    void clear()

### List 接口（ArrayList） ###

常用特有成员方法

// 在此集合中的指定位置插入指定的元素
    void add(int index,E   element)
    // 删除指定索引处的元素，返回被删除的元素
    E remove(int index)
        
    // 修改指定索引处的元素，返回被修改的元素
    E set(int index,E element)
    // 返回指定索引处的元素
    E get(int index)

org.assertj.core.util.**Lists** 工具类可以快速生成动态 ArrayList 集合

public static <T> ArrayList<T> newArrayList()
    public static <T> ArrayList<T> newArrayList(T... elements)
    public static <T> ArrayList<T> newArrayList(Iterable<? extends T> elements)
    public static <T> ArrayList<T> newArrayList(Iterator<? extends T> elements)
    public static <T> List<T> list(T... elements)
    public static <T> List<T> emptyList()

### LinkedList ###

常用特有成员方法

// 将指定元素插入此列表的开头
    void addFirst(E e)
    // 将元素推入此列表所表示的堆栈，等效于 addFirst(E)
    void push(E e)
    // 将指定元素添加到此列表的结尾
    void addLast(E e)
    
    // 返回此列表的第一个元素
    E getFirst()
    // 返回此列表的最后一个元素
    E getLast()
    
    // 移除并返回此列表的第一个元素
    E removeFirst()
    // 从此列表所表示的堆栈处弹出一个元素，等效于 removeFirst()
    E pop()
    // 移除并返回此列表的最后一个元素
    E removeLast()

注意：使用LinkedList集合特有的方法，不能使用多态创建对象

List<String> list = new LinkedList<>();		// 弊端:不能使用实现类特有的操作首尾元素的方法
    LinkedList<String> linked = (LinkedList<String>)list;	// 向下转型

## Map 接口 ##

常用成员方法：

// 把指定的键与值添加到Map集合中。key不重复,返回值V就是null，key重复，返回的V就是被替换的value
    V put(K key, V value)
    // 根据指定的键,删除Map集合中的键值对,返回被删除的值
    V remove(Object key)
    // 根据key获取value
    V get(Object key)
    // 判断Map集合中是否包含指定的key
    boolean containsKey(Object key)
    // 判断Map集合中是否包含指定的value
    boolean containsValue(Object value)
    // 返回指定key的value值，如果指定key不存在于Map集合中，则返回指定的defaultValue值
    default V getOrDefault(Object key, V defaultValue)

## Arrays 工具类 ##

包路径：java.util.Arrays

描述：操作数据的工具类

常用成员方法：

// 返回指定数组内容的字符串表示形式。对数组进行遍历，把数组中的元素组合成一个字符串返回
    static String toString(Object[] a)
    // 根据元素的自然顺序对指定对象数组按升序进行排序
    static void sort(Object[] a)
    // 返回由指定数组支持的固定大小的列表
        
    static List asList(T… a)
    	// 注意：Arrays.asList将数组转集合不能进行add和remove操作
        // 原因：调用Arrays.asList()生产的List的add、remove方法时报异常，这是由`Arrays.asList() 返回的市Arrays的内部类ArrayList， 而不是java.util.ArrayList`。Arrays的内部类ArrayList和java.util.ArrayList都是继承AbstractList，remove、add等方法AbstractList中是默认throw UnsupportedOperationException而且不进行任何操作。java.util.ArrayList重新了这些方法而Arrays的内部类ArrayList没有重新，所以会抛出异常。
        //正确做法：
    String[] array = {
        "1","2","3","4","5"};
    List<String> list = Arrays.asList(array);
    List arrList = new ArrayList(list);
    arrList.add("6");
    
    // 使用二叉搜索算法搜索指定对象的指定数组，并返回索引
    static int binarySearch(Object[] a, Object key)
    // 将指定数组的指定范围复制到新数组中
    static int[] copyOfRange(int[] original, int from, int to)
    // 将指定的对象引用分配给指定的对象数组的每个元素
    static void fill(Object[] a, Object val)

## Collections 工具类 ##

包路径：java.util.Collections

该工具类提供了大量针对Collection/Map的操作，总体可分为四类，都为静态(staic)方法

/**
    * 排序操作（主要针对List接口相关）
    */
    // 对List里的元素根据自然升序排序
    static void sort(List<T> list)
    // 自定义比较器进行排序
    static void sort(List<T> list, Comparator<? super T> c)
    // 对List中的元素进行随机排序(洗牌)
    static void shuffle(List<T> list)
    // 反转指定List集合中元素的顺序
    static void reverse(List<T> list)
    // 将指定List集合中i 处元素和j 处元素进行交换
    static void swap(List<T> list, int i, int j)
    // 将所有元素向右移位指定长度，如果distance等于size那么结果不变
    static void rotate(List<T> list, int distance)
    
    /**
    * 查找和替换（主要针对Collection接口相关）
    */
    // 使用二分法查找，以获得指定对象在List中的索引，前提是集合已经排序
    static int binarySearch(List<T> list, Object key)
    // 返回最大元素
    static T max(Collection<T> coll)
    // 根据自定义比较器，返回最大元素
    static T max(Collection<T> coll, Comparator<? super T> c)
    // 返回最小元素
    static T min(Collection<T> coll)
    // 根据自定义比较器，返回最小元素
    static T min(Collection<T> coll, Comparator<? super T> c)
    // 使用指定对象填充
    static void fill(List<T> list, Object obj)
    // 返回指定集合中指定对象出现的次数
    static int frequency(Collection<T> Object obj)
    // 用给定的新元素 替换 List中存在的给定旧元素的所有出现
    static boolean replaceAll(List<T> list, Object old, Object new)
    
    /**
    * 同步控制
    */
    // 返回指定集合对象对应的同步对象，从而解决多线程并发访问集合时线程的安全问题
        // HashSet、ArrayList、HashMap都是线程不安全的，如果需要考虑同步，则使用这些方法。
        // 特别需要注意：在使用迭代方法遍历集合时需要手工同步返回的集合。{否则会有线程安全的问题}
    static <T> List<T> synchronizedList(List<T> list)
    static <T> Collection<T> synchronizedCollection(Collection<T> c)
    static <T> SortedSet<T> synchronizedSortedSet(SortedSet<T> s)
    static <K,V> Map<K,V> synchronizedMap(Map<K,V> m)
    static <K,V> SortedMap<K,V> synchronizedSortedMap(SortedMap<K,V> m)
    
    /**
    * 返回不可变的集合；不可变集合对象只能访问不能修改
    */
    emptyXxx():        返回一个空的不可变的集合对象
    singletonXxx():    返回一个只包含指定对象的，不可变的集合对象
    unmodifiableXxx(): 返回指定集合对象的不可变版本
    
    /**
    * 其它
    */
    // 如果两个指定collection中没有相同的元素，则返回true
    static boolean disjoint(Collections<?>c1,Collections<?>c2)
    // 一种方便的方式，将所有指定元素添加到指定collection中
    static boolean addAll(Collection<?super T>c,T...a)
    
    // 返回可以使集合反转的比较器Comparator；它对实现 Comparable接口的对象集合施加了 自然排序的相反
    static <T> Comparator<T> reverseOrder()
    // 返回一个比较器，它强行反转指定比较器的顺序。如果指定比较器为null，则此方法等同于reverseOrder()
    static Comparator<T> reverseOrder(Comparator<? super T> c)

## 集合排序：Comparator比较器 ##

java.utl.Comparator接口：强行对某个对象 collection 进行整体排序 的比较函数。

Comparator<? super T> c：对集合进行排序的比较器

Comparator接口中的抽象方法：

// 比较用来排序的两个参数。
    int compare(T o1, T o2) 
    参数:
    	T o1, T o2：内部自动获取的集合中的元素。
    比较的规则(重点):
    	o1是靠后的元素，o2是靠前的元素。
    	升序：o1-o2
        降序：o2-o1
        两个元素相等：o1==o2
        
        返回值为正值时：顺序
        返回值为正值时：逆序

### 单字段排序 ###

// 按照id升序（简化格式）
    list.sort(comparing(Persion::getId));
    // 按照id降序（简化格式）
    list.sort(comparing(Persion::getId).reversed());
    
    // 年龄升序排序。（lamda表达式-了解）
    list.sort((o1, o2) -> o1.getAge().compare(o2.getAge()));

### 多字段排序 ###

// 根据性别升序，再以年龄age升序
    pigs.sort(
        comparing(Persion::getGender)
        	.thenComparing(Persion::getAge)
    );
    
    // 根据性别升序，再以年龄age降序。注意：下面的reversed()在thenComparing()里面
    pigs.sort(
        comparing(Persion::getGender)
        	.thenComparing(comparing(Persion::getAge).reversed())
    );
    
    // 根据性别降序，再以年龄age升序
    pigs.sort(
        comparing(Persion::getGender).reversed()
        	.thenComparing(Persion::getAge)
    );
    
    // 根据性别降序，再以年龄age降序。注意：下面的reversed()在thenComparing()外面
    pigs.sort(
        comparing(Persion::getGender)
        	.thenComparing(Persion::getAge)
        	.reversed()
    );
    
    // 按照两个人的年龄升序排序，如果两个人的年龄相同，按照姓名的首字母降序排序。（原始格式-了解）
    list.sort(new Comparator<Person>() {
        
        @Override
        public int compare(Person o1, Person o2) {
        
            //按照两个人的年龄升序排序
            int a = o1.getAge()-o2.getAge();
            //判断两个人的年龄是否相等
            if(a==0){
        
                //按照姓名的首字母降序排序
                a = o2.getName().charAt(0) - o1.getName().charAt(0);
            }
            return a;
        }
    });

### Null值参与排序 ###

如果集合中某个数据的某个字段值是null，那就得特殊处理，否则报异常。

// null值排在后面。单字段排序（简化格式）
    list.sort(comparing(Person::getAge, Comparator.nullsLast(Integer::compareTo)));
    // null值排在前面。单字段排序（简化格式）
    list.sort(comparing(Person::getAge, Comparator.nullsFirst(Integer::compareTo)));
    
    // null值排在前面。多字段排序（简化格式）
    pigs.sort(
            comparing(Person::getName)
                    .thenComparing(Person::getAge, Comparator.nullsFirst(Integer::compareTo))
    );
    
    // null值排在后面。单字段排序（lamda表达式）
    list.sort((o1, o2) -> {
        
        int a = 0;
        if(o1.getAge() == null){
        
            a = o2.getAge() == null ? 0 : 1;
        }else if(o2.getAge() == null){
        
            a = -1;
        }else {
        
            a = o1.getAge().compareTo(o2.getAge());
        }
        return a;
    });

### 中文排序 ###

// 根据姓名升序（lamda表达式）
    list.sort((o1, o2) -> Collator.getInstance(Locale.CHINA).compare(o1.getName(), o2.getName()));

### List<Map<String, Object>> 排序 ###

List<Map<String, Object>> sortedCats = lits.stream().sorted((map1, map2) -> {
        
        int age1 = (int) map1.getOrDefault("age", 0);
        int age2 = (int) map2.getOrDefault("age", 0);
        return age1 - age2;
    }).collect(Collectors.toList());

## CollectionUtils 工具类 ##

<dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-collections4</artifactId>
            <version>4.3</version>
        </dependency>

包路径：org.apache.commons.commons-collections4.CollectionUtils

常用方法：

// 空安全检查指定的集合是否为空
    static boolean isEmpty(Collection<?> coll)
    // 空安全检查指定的集合是否为空。
    static boolean isNotEmpty(Collection<?> coll)
    
    // 除非元素为null，否则向集合添加元素
    static boolean addIgnoreNull(Collection<T> collection, T object)
    // 将两个已排序的集合a和b合并为一个已排序的列表，以便保留元素的自然顺序
    static collection<O> collate(Iterable<? extends O> a, Iterable<? extends O> b)
    // 将两个已排序的集合a和b合并到一个已排序的列表中，以便保留根据Comparator c的元素顺序。
    static collection<O> collate(Iterable<? extends O> a, Iterable<? extends O> b, Comparator<? super O> c)
    // 返回该个集合中是否含有至少有一个元素
    static boolean containsAny(Collection<?> coll1, T... coll2)
    // 如果参数是null，则返回不可变的空集合，否则返回参数本身。（很实用 ,最终返回List EMPTY_LIST = new EmptyList<>()）
    static collection<T> emptyIfNull(Collection<T> collection)
    // 反转给定数组的顺序。
    static void reverseArray(Object[] array);
    
    // 差集
    static collection<O> subtract(Iterable<? extends O> a, Iterable<? extends O> b)
    // 并集
    static collection<O> union(Iterable<? extends O> a, Iterable<? extends O> b)
    // 交集
    static collection<O> intersection(Collection a, Collection b)
    // 交集的补集（析取）
    static collection<O> disjunction(Collection a, Collection b)

三种集合交、并、差处理（链接：https://www.cnblogs.com/qdhxhz/p/10787130.html）

# 时间/日期/日历 #

## Date ##

包路径：java.util.Date

java时间原点：0毫秒的时间点  
1970 年 1 月 1 日 00:00:00 英国格林威治的时间(世界标准时间)

构造方法：

Date()	//获取当前系统(你自己的操作系统)的时间和日期
    Date(long date)		//参数传递毫秒值，把毫秒值转换为Date日期

成员方法：

// 把当前的时间和日期转换为毫秒值(当前日期和时间原点之间的差值)。返回自1970年1月1日00:00:00GMT以来此 Date 对象表示的毫秒数。 
    long getTime()
    //相当于 System.currentTimeMillis()
    
    // 把毫秒值转换为Date日期。设置此 Date 对象，以表示1970年1月1日00:00:00GMT以后 time 毫秒的时间点。
    void setTime(long time)

## SimpleDateFormat ##

包路径：java.text.SimpleDateFormat

构造方法：

SimpleDateFormat(String pattern) 	// 用给定的模式和默认语言环境的日期格式符号构造 SimpleDateFormat。
       	// 参数：String pattern：传递日期和时间的模式
    	//	y：年		M：月		d：日		H：时		m：分		s：秒		S：毫秒
        // "yyyy-MM-dd HH:mm:ss"	"2020-06-17 11:52:03"
        // "yyyy年MM月dd日 HH时mm分ss秒"
        // "yyyy/MM/dd HH:mm:ss"

成员方法：

// 参数传递日期，把日期格式化为符合模式的字符串
    String format(Date date)
    
    // 把符合模式的字符串解析为Date日期
    Date parse(String source)  
    // 示例
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    Date date = null;
    try {
        
        date = sdf.parse("2018-11-27 20:40:33");
    }catch (ParseException e){
        
        e.printStackTrace();

## Calendar ##

包路径：java.util.Calendar

获取Calendar类的对象：

static Calendar getInstance()  使用默认时区和语言环境获得一个日历。

常用成员方法：

// 获取指定日历字段的值
    int get(int field)
    // 将给定的日历字段设置为给定值
    void set(int field, int value)
    // 把日历字段增加|减少指定的值
    void add(int field, int amount)
    // 把日历对象转换为日期Date对象
    Date getTime()
    // 使用给定的 Date 设置此 Calendar 的时间。 把日期Date对象转换为日历对象
    void setTime(Date date)

注意：

*  以上方法的参数(int field)，让我们传递指定的日历字段，这些日历字段在Calendar类中被定义为了常量  
    年：public final static int **YEAR** = 1;  
    月：public final static int **MONTH** = 2;  
    日：public final static int **DATE** = 5;  
    日：public final static int **DAY\_OF\_MONTH** = 5;  
    时：public final static int **HOUR** = 10;  
    分：public final static int **MINUTE** = 12;  
    秒：public final static int **SECOND** = 13;  
    毫秒：public final static int **MILLISECOND** = 14;  
    星期：public final static int **DAY\_OF\_WEEK** = 7;
 *  西方的月份：0-11月  
    东方的月份：1-12月  
    西方的星期：星期日-星期六  
    东方的星期：星期一-星期日

## DateFormatUtils 工具类 ##

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

包路径：org.apache.commons.lang3.time.DateFormatUtils

链接：https://blog.csdn.net/yaomingyang/article/details/79143954

常用方法：

// 将日期格式化为特定的模式
    static String format(Date date, String pattern)
    // 参数：date-格式化的日期对象，非null；pattern-用于格式化日期的模式,非null
    // 示例：
    DateFormatUtils.format(new Date(),"yyyy-MM-dd HH:mm:ss");	//2018-11-26 22:42:22
    
    // 将日期格式化为特定的模式
    static String format(Date date,String pattern,TimeZone timeZone)
    // 参数：timeZone-时区
    // 示例：
    DateFormatUtils.format(date, "yyyy-MM-dd HH:mm:ss", TimeZone.getDefault());
    
    // 将日历格式化为特定的模式
    static String format(Calendar calendar, String pattern)	
    // 参数：calendar-格式化的日历对象，非null；pattern-用于格式化日历的模式,非null
    // 示例
    DateFormatUtils.format(Calendar.getInstance(), "yyyy-MM-dd HH:mm:ss");		//2018-01-23 19:50:55
    
    // 将日期/时间格式化为特定的模式
    static String format(long millis,String pattern)	
    // 参数：mills-以毫秒表示格式的日期

## DateUtils 工具类 ##

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

包路径：org.apache.commons.lang3.time.DateUtils

链接：https://blog.csdn.net/zhou520yue520/article/details/84557235

常用方法：

// 将 String 类型的日期数据转换成 Date 类型的日期数据（String -> Date）
    // 第二个参数（日期格式）可以有多个值。传入多个格式，如果多个格式中至少有一个可以成功解析该字符串，就可以成功解析；否则方法将报错
    static Date parseDate(final String str, final String... parsePatterns)
    //示例：
    try {
        
        //传入字符串数组
        Date date = DateUtils.parseDate("2018.11.22", {
        "yyyy-MM-dd","yyyy.MM.dd"});
        //或者这样也可以
        //date = DateUtils.parseDate(str, "yyyy-MM-dd","yyyy.MM.dd");
    }catch (ParseException e){
        
        e.printStackTrace();
    }
    
    // String -> Date
    static Date parseDateStrictly(final String str, final String... parsePatterns)
    // 传入的字符串日期需精确到秒，否则报错
        
    // Date -> Calendar
    static Calendar toCalendar(Date date)
        
    // 比较两个日期是否是同一天（即年、月、日是否都相等），只比较年月日，时分秒不管。
    static boolean isSameDay(Date date1, Date date2)
        
    // 比较两个日期是否相等（即年、月、日、时、分、秒都相等）
    //实际上是先将两个 Date 都转化为毫秒（Date getTime()），然后再进行对比的
    static boolean isSameInstant(Date date1, Date date2)
        
    // 两个日期截取相同的部分，比较值是否相等
    static boolean truncatedEquals(Date date1, Date date2, int field)
        
    // 给日期时间的指定部分（年/月/日/时/分/秒/毫秒）加上指定大小的值
    static Date addXxx(Date date, int amount)
        
    // 截取日期时间的部分值，截取部分外的其他部分使用默认初始值（年、月、日、时、分、秒 的默认初始值分别为：0001、01、01、00、00、00）
    static Date truncate(Date date, int field)
    // 示例：	截取年、月、日，而时、分、秒使用初始值00		
    result = DateUtils.truncate(date,Calendar.DAY_OF_MONTH);	//2018-11-23 00:00:00
        
    // 两个日期截取相同的部分进行比较
    // 如果 date1更大（更晚）则返回 1，如果 date2 更大（更晚）则返回 -1 ，如果相等，则返回 0
    static int truncatedCompareTo(Date date1, Date date2, int field)
    //示例：	两个日期都截取到日再对比，date1更小，返回 -1
    printDate(date1);//2018-11-23 10:39:28
    printDate(date2);//2018-11-24 10:39:28
    int b = DateUtils.truncatedCompareTo(date1,date2,Calendar.DATE);	//-1
    int c = DateUtils.truncatedCompareTo(date2,date1,Calendar.DATE);	//1
        
    // 截取日期时间的部分值，截取的末尾部分向上取整，截取部分外的其他部分使用默认初始值（年、月、日、时、分、秒 的默认初始值分别为：0001、01、01、00、00、00）
    static Date ceiling(Date date, int field)
    //示例：
    date = parseDate("2018-11-23 15:59:29", "yyyy-MM-dd HH:mm:ss")
    Date ceilYear = DateUtils.ceiling(date,Calendar.YEAR);
        //2019-01-01 00:00:00，截取到年，年向上取整（即+1）
    DateUtils.ceiling(date,Calendar.DAY_OF_MONTH);
        //2018-11-24 00:00:00，截取到日，日向上取整（即+1）；如果是30（或28/31）的话，日进1变成01，月进1
        
    // 截取日期时间的部分值，截取的末尾部分四舍五入，截取部分外的其他部分使用默认初始值（年、月、日、时、分、秒 的默认初始值分别为：0001、01、01、00、00、00）
    static Date round(Date date, int field)
    //示例：
    date = DateUtils.parseDate("2018-11-23 15:59:29", "yyyy-MM-dd HH:mm:ss")
    Date roundYear = DateUtils.round(date,Calendar.YEAR);
        //2019-01-01 00:00:00，截取到年，根据月份四舍五入，7月之后（包含）进1
    Date roundMonth = DateUtils.round(date,Calendar.MONTH);
        //2018-12-01 00:00:00，截取到月，根据日四舍五入，28天的月分15号（包含）之后进1，30天的月16号（包含）之后进1，31天的月17号（包含）之后进1

# 数值 #

## Math 工具类 ##

包路径：java.lang.Math

数学工具类

常用的成员方法：

// 获取参数a的绝对值
    public static int abs(int a)
    // 向上取整  1.1==>2.0  1.9==>2.0
    public static double ceil(double a)
    // 向下取整 1.1==>1.0  1.9==>1.0
    public static double floor(double a)
    // 四舍五入取整 5.5==>6  5.4999999==>5
    public static long round(double a)
    //获取a的b次幂  2^3=8  2^4=16
    public static double pow(double a, double b)

## BigInteger ##

包路径：java.math.BigInteger

不可变的任意精度的整数。可以操作超过long类型范围的整数

构造方法：

// 将 BigInteger 的十进制字符串表示形式转换为 BigInteger
    BigInteger(String val) 
    	// 参数：String val:传递字符串格式的整数，不限制长度 "1231314231424321412343214132432141343214134"

成员方法：

// 加法
    BigInteger add(BigInteger val)	// 返回其值为 (this + val) 的 BigInteger。
    // 减法
    BigInteger subtract(BigInteger val)	// 返回其值为 (this - val) 的 BigInteger。
    // 乘法
    BigInteger multiply(BigInteger val)	// 返回其值为 (this * val) 的 BigInteger。
    // 除法
    BigInteger divide(BigInteger val)	// 返回其值为 (this / val) 的 BigInteger。

## BigDecimal ##

包路径：java.math.BigDecimal

用于小数(浮点数)的精确计算

构造方法：

// 将 BigDecimal 的字符串表示形式转换为 BigDecimal
    BigDecimal(String val)	
    	// 参数:String val：传递一个字符串类型的小数 "1.11111"

成员方法：

// 加法
    BigDecimal add(BigDecimal augend)	// 返回一个 BigDecimal，其值为 (this + augend)
    // 减法
    BigDecimal subtract(BigDecimal subtrahend)	// 返回一个 BigDecimal，其值为 (this - subtrahend)
    // 乘法
    BigDecimal multiply(BigDecimal multiplicand)	// 返回一个 BigDecimal，其值为 (this × multiplicand)
    // 除法
    BigDecimal divide(BigDecimal divisor)
        // 返回一个 BigDecimal，其值为 (this / divisor)
        // 如果无法表示准确的商值（除法除不尽10.0/3.0=3.333333...），则抛出 ArithmeticException(数学计算异常)。
    BigDecimal divide(BigDecimal divisor, int scale, RoundingMode roundingMode) 
        // 返回一个 BigDecimal，其值为 (this / divisor)
        // divisor - 此 BigDecimal 要除以的值。
        // scale - 保留的小数位数(2位小数,3位小数...)  3.33  3.333
        // roundingMode - 要应用的舍入模式。
        // RoundingMode.HALF_UP：四舍五入模式  3.3333333...==>3.33   3.666666666...==>3.67

## 基本类型 <== > 字符串 ##

*  基本数据类型 ==> 字符串
    
        // a.基本数类型的值 + "" ：工作中最常用  1 + "" ==> "1"
              
        // b.使用 包装类 中的静态方法 toString
        static String toString(int i)
        
        // c.使用 String类 中的静态方法 valueOf
        static String valueOf(int i)
 *  字符串类型 ==> 基本数据类型数据
    
        // 在包装类中有一个方法叫parseXXX,可以把字符串格式的基本数据类型的值，转换为基本数据类型
        // Integer类
        static int parseInt(String s)
        // Double类
        static double parseDouble(String s)

注意：

1.除了 Character 类之外，其他所有的包装类都具有 parseXXX 静态方法  
字符串转换为 char 类型：使用toCharArray变成字符数组，使用charAt方法取出字符串中指定字符

2.parseXXX方法参数必须传递基本数据类型的字符串，否则会抛出数字格式化异常。 “100”：正确；“a”：异常

# IO流 #

## File ##

参考：https://www.runoob.com/java/java-file.html

路径：java.io.File;

描述：文件和目录路径名的抽象表示形式

常用静态变量：

// 与系统有关的路径分隔符。 windows中分号";"，Linux中冒号":"
    static String pathSeparator
    static char pathSeparatorChar
    
    // 与系统有关的默认名称(文件夹名称)分隔符。windows中右斜杠"\"，Linux中左斜杠"/"
    static String separator
    static char separatorChar

构造方法：

public File(String pathname)
    public File(String parent, String child)
    public File(File parent, String child)

常用方法：

// 此File表示的文件或目录是否实际存在
    boolean exists()
    // 是否为目录(文件夹)。若路径存在且为目录返回true，若路径不存在或路径存在但为文件返回false
    boolean isDirectory()
    // 是否为文件。若路径存在且为文件返回true，若路径不存在或路径存在但为文件夹返回false
    boolean isFile()
    // 测试此抽象路径名是否为绝对路径名
    boolean isAbsolute()
    // 测试此抽象路径名与给定对象是否相等
    boolean equals(Object obj)
    // 测试应用程序是否可以读取此抽象路径名表示的文件
    boolean canRead()
    // 测试应用程序是否可以修改此抽象路径名表示的文件
    boolean canWrite()
        
    // 当且仅当具有该名称的文件尚不存在时，创建一个新的空文件。
    // 路径必须是存在的和有权访问的，否则会抛出异常。文件存在，不会创建返回false；构造方法中传递路径不存在，返回false
    boolean createNewFile() throws IOException
    // 创建单级文件夹 // 文件夹存在，不会创建返回false；构造方法中传递路径不存在，返回false
    boolean mkdir()
    // 即可以创建单级文件夹，又可以创建多级文件夹 // 文件夹存在，不会创建返回false；构造方法中传递路径不存在，返回false
    boolean mkdirs()
    // 删除文件或文件夹，不走回收站 // 路径不存在或者文件夹中有内容，不会删除，返回false
    boolean delete()
    
    // 返回一个String数组，表示该File目录中的所有子文件或目录。路径必须是目录，否则会抛异常
    String[] list()
    // 返回一个File数组，表示该File目录中的所有的子文件或目录。路径必须是目录，否则会抛异常
    File[] listFiles()
    
    // 返回由此抽象路径名表示的文件或目录的名称(末尾部分)
    String getName()
    // 返回抽象路径名的绝对路径名字符串
    String getAbsolutePath()
    // 获取文件的大小，单位是字节
    long length()
    // 重新命名此抽象路径名表示的文件
    boolean renameTo(File dest)

## commons-io 工具包 ##

<dependency>
        <groupId>commons-io</groupId>
        <artifactId>commons-io</artifactId>
        <version>2.4</version>
    </dependency

commons-io是apache开源基金组织提供的一组有关IO操作的类库，可以挺提高IO功能开发的效率。commons-io工具包提供了很多有关io操作的类

### IOUtils 工具类 ###

包路径：org.apache.commons.io.IOUtils;

处理输入 - 输出流。所有成员字段和方法都是静态的

链接：https://blog.csdn.net/l2580258/article/details/89227761

常用静态变量：

static String LINE_SEPARATOR;						// 行分隔符
    static String LINE_SEPARATOR_UNIX = "\n";			// Unix系统的行分隔符
    static String LINE_SEPARATOR_WINDOWS = "\r\n";		// Windows系统的行分隔符

常用静态方法：

注：类中的所有处理InputStream的方法都带有内部的缓冲区，所以不需要再使用 `BufferedReader`或者 `BufferedInputStream`，默认的缓冲区大小为4K，不过也可以自定义它的大小。

// 把input输入流中的内容拷贝到output输出流中，返回拷贝的字节个数(适合文件大小为2GB以下)
    static int copy(Reader input, Writer output)							// 字符流
    static int copy(InputStream input, OutputStream output)					// 字节流
    static void copy(InputStream input, Writer output, Charset encoding)
    // 把input输入流中的内容拷贝到output输出流中，返回拷贝的字节个数(适合文件大小为2GB以上)
    static long copyLarge(InputStream input, OutputStream output)
    static long copyLarge(Reader input, Writer output)
        
    // 从流中读取内容，并转换为String的list
    static List<String> readLines(InputStream input)
    static List<String> readLines(InputStream input, String encoding)
            // input 的类型可以为 InputStream，Reader
            // encoding 的类型可以为 Charset，String
    
    // 把数据写入到输出流中
    static void write(String data, OutputStream output)
    static void write(String data, OutputStream output, String encoding)
    // 把string的List写入到输出流中
    static void writeLines(Collection<?> lines, String lineEnding, OutputStream output)
    static void writeLines(Collection<?> lines, String lineEnding, OutputStream output, String encoding)
            // data 的类型可以为 byte[]，CharSequence，StringBuffer，String
            // output 的类型可以为 OutputStream，Writer
            // encoding 的类型可以为 Charset，String
    
    // 无条件的关闭一个可被关闭的对象而不抛出任何异常。
    // 重载支持关闭所有的InputStream、OutputStream、Reader和Writer。
    static void closeQuietly(Closeable closeable)
    
    // 比较两个Reader对象的内容是否相同，相同返回true，否则返回false
    static boolean contentEquals(Reader input1, Reader input2)
    static boolean contentEquals(InputStream input1, InputStream input2)
    // 比较两个Reader对象的内容是否相同，忽略行结束符而比较内容
    static boolean contentEqualsIgnoreEOL(Reader input1, Reader input2)
    
    // 从InputStream中返回一个行迭代器。行迭代器将持有一个打开的InputStream的引用。迭代结束后，应当关闭stream来释放内部资源。
    static LineIterator lineIterator(InputStream input, String encoding)
        	// input 的类型可以为 InputStream，Reader
            // encoding 的类型可以为 Charset，String。传null则使用默认的
    
    // 返回字符输入流缓冲流
    static BufferedReader toBufferedReader(Reader reader)
    static BufferedReader toBufferedReader(Reader reader, int size)
    // 返回字节输入流缓冲流
    static InputStream toInputStream(CharSequence input)
    static InputStream toInputStream(CharSequence input, String encoding)
    
    // 返回字符串
    static String toString(Reader input)
    static String toString(InputStream input, String encoding)
    static String toString(URI uri)
    static String toString(URI uri, Charset encoding)
    static String toString(URL url, Charset encoding)
    static String toString(URL url, String encoding)
        	// input 的类型可以为 InputStream，Reader，byte[]

### FileUtils 工具类 ###

包路径：org.apache.commons.io.FileUtils;

操作文件的工具类

常见工具类：

// 读取一个文件以字符串形式返回
    static String readFileToString(File file)
    static String readFileToString(File file, String encoding)
    
    // 文件复制
    static void copyFile(File srcFile, File destFile)
    // 复制整个文件夹到另外一个地方
    static void copyDirectory(File source, File destination)
    // 复制整个文件夹到另外一个地方，过滤一些指定的文件（比如名字，修改时时间等等）
    static void copyDirectory(File source, File destination, FileFilter filter)
    // 把一个文件复制到一个文件夹中
    static void copyFileToDirectory(File srcFile, File destDir)
    // 文件夹复制
    static void copyDirectoryToDirectory(File srcDir, File destDir)
    
    // 使用指定的编码将CharSequence写入文件中
    static void write(File file, CharSequence data)
    // 将集合按行写入到文件中
    static void writeLines(File file, Collection<?> lines)
    // 把字符串写入到一个文件中
    static void writeStringToFile(File file, String data)
    
    // 返回一个File对象
    static File getFile(String... names)
    // 返回表示系统临时目录的File对象
    static String getTempDirectory()
    // 返回表示用户目录的File对象
    static String getUserDirectory()
    // 创建了一个迭代器，可以按行遍历给定的文件
    static LineIterator lineIterator(File file)
    // 返回目录内容的大小
    static long sizeOfDirectory(File directory)
    
    // 比较两个文件的内容，返回比较的结果
    static boolean contentEquals(File file1, File file2)
    
    // 递归的删除一个文件夹
    static void deleteDirectory(File directory)

### FilenameUtils 工具类 ###

参考：https://www.cnblogs.com/xwb583312435/p/9014868.html

路径：org.apache.commons.io.FilenameUtils;

常用方法：

// 获取当前系统格式化路径
    static String normalize(String filename)
    // 获取当前系统无结尾分隔符的路径
    static String normalizeNoEndSeparator(String filename)
    
    // 合并目录和文件名为文件全路径
    static String concat(String basePath, String fullFilenameToAdd)
    
    // 获取文件名称，包含后缀
    static String getName(String filename)
    // 获取文件路径去除目录和后缀后的文件名
    static String getBaseName(String filename)
    // 获取文件的后缀
    static String getExtension(String filename)
    // 获取文件的完整目录(示例：/D:/aa/bb/cc/)
    static String getFullPath(String filename)
    // 获取文件的目录不包含结束符(示例：/D:/aa/bb/cc)
    static String getFullPathNoEndSeparator(String filename)
    // 获取去除前缀的路径(示例：D:/aa/bb/cc/)
    static String getPath(String filename)
    // 获取去除前缀并结尾去除分隔符的路径(示例：D:/aa/bb/cc)
    static String getPathNoEndSeparator(String filename)
    // 获取前缀
    static String getPrefix(String filename)
    // 获取最后一个.(文件名与拓展名的分隔符)的位置
    static int indexOfExtension(String filename)
    // 获取最后一个分隔符的位置
    static int indexOfLastSeparator(String filename)
    
    // 转换分隔符为当前系统分隔符
    static String separatorsToSystem(String path)
    // 转换分隔符为linux系统分隔符
    static String separatorsToUnix(String path)
    // 转换分隔符为windows系统分隔符
    static String separatorsToWindows(String path)
    
    // 判断文件路径是否相同
    static boolean equals(String filename1, String filename2)
    // 判断文件路径是否相同，格式化并大小写不敏感	// IOCase.INSENSITIVE
    static boolean equals(String filename1, String filename2, boolean normalized, IOCase caseSensitivity)
    // 判断文件路径是否相同，格式化并大小写敏感
    static boolean equalsNormalized(String filename1, String filename2)
    // 判断文件路径是否相同，不格式化，大小写敏感根据系统规则：windows：敏感；linux：不敏感
    static boolean equalsOnSystem(String filename1, String filename2)
    
    // 判断文件扩展名是否等于指定扩展名
    static boolean isExtension(String filename, String extension)
    // 判断文件扩展名是否包含在指定字符串数组中
    static boolean isExtension(String filename, String[] extensions)
    // 判断文件扩展名是否包含在指定集合中
    static boolean isExtension(String filename, Collection<String> extensions)
    
    // 判断文件扩展名是否和指定规则匹配，大小写敏感
    static boolean wildcardMatch(String filename, String wildcardMatcher)
    // 判断文件扩展名是否和指定规则匹配，大小写不敏感		// IOCase.INSENSITIVE
    static boolean wildcardMatch(String filename, String wildcardMatcher, IOCase caseSensitivity)
    // 判断文件扩展名是否和指定规则匹配，根据系统判断敏感型：windows:不敏感；linux：敏感
    static boolean wildcardMatchOnSystem(String filename, String wildcardMatcher)
        
    // 移除文件的扩展名
    static String removeExtension(String filename)
    // 判断目录下是否包含指定文件或目录
    static boolean directoryContains(String canonicalParent, String canonicalChild)

# JDK工具类 #

## Objects 工具类 ##

包路径：java.util.Objects

Objects中的方法都是**空指针安全**的

// 判断两个对象是否相等，相等返回true，相等返回false
    static boolean equals(Object a, Object b)
    
    // 判断传递的对象是否为null
    static <T> T requireNonNull(T obj)
    static <T> T requireNonNull(T obj, String message)
    /*	如果传递的对象是null，方法内部就会抛出空指针异常
    	如果传递的对象不是null，则方法内部会返回这个对象 */

## System 工具类 ##

包路径： java.lang.System

常用成员方法：

// 终止当前运行的 Java 虚拟机，非零表示异常终止
    static void exit(int status)
    // 返回当前时间(以毫秒为单位)
    static long currentTimeMillis()
    // 复制数组的方法
    static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
        // src - 源数组。
        // srcPos - 源数组中的起始位置。
        // dest - 目标数组。
        // destPos - 目标数据中的起始位置。
        // length - 要复制的数组元素的数量。

## RandomStringUtils 工具类 ##

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

生成随机数工具类

包路径：org.apache.commons.commons-lang3.RandomStringUtils

常用方法：

// 生成一个长度为count的字符串，随机内容包含数字（0～9）的编码。
    static String randomNumeric(int count)
    // 生成一个长度介于包含最小值和最大最大值之间的字符串，随机内容包含数字（0～9）的编码。
    static String randomNumeric(int minLengthInclusive, int maxLengthExclusive)
    		minLengthInclusive ：要生成的字符串的包含最小长度
    		maxLengthExclusive ：要生成的字符串的包含最大长度
    
    // 生成一个长度为count的字符串，随机内容包含全部的编码。中文环境下是乱码
    static String random(int count)
    // 生成一个长度为count的字符串
    static String random(int count, boolean letters, boolean numbers)
    		// letters     true，生成的字符串可以包括字母字符
    		// numbers     true，生成的字符串可以包含数字字符
    // 生成一个长度为count的字符串，随机内容包含chars。第二个参数如果NULL，则使用所有字符集
    static String random(int count, char[] chars)
    // 生成一个长度为count的字符串，字符将从字符串指定的字符集中选择，不能为空。如果NULL，则使用所有字符集。
    static String random(int count, String chars)
    // 生成一个长度为count的字符串
    static String random(int count, int start,int end,boolean letters, boolean numbers)
        // start：字符集在开始时的位置
        // end：字符集在结束前的位置，必须大于65
        // letters     true，生成的字符串可以包括字母字符
        // numbers     true，生成的字符串可以包含数字字符
    // 生成汉字的方法，参考：utf-8汉字的编码范围
    RandomStringUtils.random(20, 0x4e00, 0x9fa5, false,false)
    
    // 生成一个长度为count的字符串，随机内容仅包含Ascii编码
    static String randomAscii(int count)
    // 生成一个长度介于包含最小值和最大最大值之间的字符串，随机内容仅包含Ascii编码
    static String randomAscii(int minLengthInclusive, int maxLengthExclusive)
    // 生成一个长度为count的字符串，随机内容包含字母（含大小）的编码
        
    static String randomAlphabetic(int count)
    // 生成一个长度介于包含最小值和最大最大值之间的字符串，字符将从拉丁字母（a～z、A～Z的选择）
    static String randomAlphabetic(int minLengthInclusive, int maxLengthExclusive)
    // 生成一个长度为count的字符串，随机内容包含字母（含大小）数字（0～9）的编码
    static String randomAlphanumeric(int count)
    // 生成一个字符串，其长度介于包含最小值和最大最大值之间，字符将从拉丁字母（a～z、A～Z）和数字（0～9）中选择
    static String randomAlphanumeric(int minLengthInclusive,int maxLengthExclusive)

## JSON ##

<dependency>  
        <groupId>com.alibaba</groupId>  
        <artifactId>fastjson</artifactId>  
        <version>1.2.41</version>  
    </dependency>

JSON对象 <==> json字符串

包路径：com.alibaba.fastjson.JSON

// json字符串 ==> Object
    static Object parse(String string)
    // json字符串 ==> JSON对象
    static JSONObject parseObject(String text)
    // json字符串 ==> 泛型对象		类中，多的属性，会为null；缺的属性，不做任何处理
    static <T> T parseObject(String text, Class<T> clazz)
    // JSON对象 ==> 字符串
    static String toJSONString(Object object)

## JavaBean的属性拷贝 ##

### BeanUtils 工具类 ###

包路径：org.springframework.beans.BeanUtils

BeanUtils提供对Java反射和自省API的包装。其主要目的是利用反射机制对JavaBean的属性进行处理。

常用方法：

// 实现对象的拷贝
    static void copyProperties(Object source, Object target)
    // 注意：
        // 1.参数为空时会抛异常，故需要先做非空判断
        // 2.要拷贝的属性的名字相同时，该属性才会copy成功
    	// 3.相同的属性都会被替换，不管是否有值。如果source的属性值为null，也会覆盖target的同名属性值。
        // 4.属性的类型为自定义类时，要保证有无参构造方法。（@Data和@Builder同时使用时，需手动添加非注解形式的无参构造方法）
    	// 5.要拷贝的属性要有getter和setter方法
    	// 6.属于各自的内部类，则spring会认为属性不同，不会copy，故内部类需要单独copy

### BeanCopyUtil 自定义工具类 ###

参考：https://www.cnblogs.com/vandusty/p/12757992.html

对 BeanUtils工具类 进行了封装，可用于拷贝集合和对象，便于链式编程

**BeanCopyUtil：**

import lombok.extern.slf4j.Slf4j;
    import org.springframework.beans.BeanUtils;
    import org.springframework.beans.BeanWrapper;
    import org.springframework.beans.BeanWrapperImpl;
    
    import java.beans.FeatureDescriptor;
    import java.beans.PropertyDescriptor;
    import java.util.*;
    import java.util.function.Supplier;
    import java.util.stream.Collectors;
    
    @Slf4j
    public class BeanCopyUtil extends BeanUtils {
        
        /**
         * 集合数据的拷贝
         * @param sources: 数据源对象集合
         * @param target: 目标类::new（eg: UserVO::new）
         */
        public static <S, T> List<T> copyList(List<S> sources, Supplier<T> target) {
        
            return copyList(sources, target, null);
        }
    
    
        /**
         * 带回调函数的集合数据的拷贝（可自定义字段拷贝规则）
         * @param sources: 数据源对象集合
         * @param target: 目标类::new（eg: UserVO::new）
         * @param callBack: 回调函数
         */
        public static <S, T> List<T> copyList(List<S> sources, Supplier<T> target, CallBack<S, T> callBack) {
        
            List<T> list = new ArrayList<>(sources.size());
            for (S source : sources) {
        
                T t = target.get();
                copyProperties(source, t);
                list.add(t);
                if (callBack != null) {
        
                    // 回调
                    callBack.callBack(source, t);
                }
            }
            return list;
        }
    
        /**
         * 忽略某些属性的集合数据的拷贝
         * @param sources: 数据源对象集合
         * @param target: 目标类::new（eg: UserVO::new）
         * @param ignoreProperties：拷贝时需要忽略的属性
         */
        public static <S, T> List<T> copyListIgnore(List<S> sources, Supplier<T> target, String... ignoreProperties) {
        
            List<T> list = new ArrayList<>(sources.size());
            for (S source : sources) {
        
                T t = target.get();
                copyProperties(source, t, ignoreProperties);
                list.add(t);
            }
            return list;
        }
    
        /**
         * 对象属性的拷贝（便于链式编程）
         * @param source: 数据源对象
         * @param target: 目标类::new（eg: UserVO::new）
         */
        public static <S, T> T copyProperties(S source, Supplier<T> target) {
        
            T t = target.get();
            copyProperties(source, t);
            return t;
        }
    
        /**
         * 忽略某些属性的对象属性的拷贝（便于链式编程）
         * @param source: 数据源对象
         * @param target: 目标类::new（eg: UserVO::new）
         * @param ignoreProperties：拷贝时需要忽略的属性
         */
        public static <S, T> T copyPropertiesIgnore(S source, Supplier<T> target, String... ignoreProperties) {
        
            T t = target.get();
            copyProperties(source, t, ignoreProperties);
            return t;
        }
    
        /**
         * 忽略 null 值的对象属性的拷贝（便于链式编程）
         * @param source: 数据源对象
         * @param target: 目标对象
         */
        public static <S, T> T copyPropertiesIgnoreNull(S source, T target) {
        
            copyProperties(source, target, getNullPropertyNames(source));
            return target;
        }
    
        /**
         * 获取对象中值为 null 的属性的名称
         */
        public static String[] getNullPropertyNames(Object source){
        
            final BeanWrapper src = new BeanWrapperImpl(source);
            java.beans.PropertyDescriptor[] pds = src.getPropertyDescriptors();
    
            return Arrays.stream(pds)
                    .filter(pd -> Objects.isNull(src.getPropertyValue(pd.getName())))
                    .map(FeatureDescriptor::getName)
                    .collect(Collectors.toList())
                    .toArray(new String[]{
        });
        }
    
        /**
         * 万能设置对象属性值
         * @param source: 数据源对象
         * @param propertyName：属性名称
         * @param value：属性值
         */
        public static void setProperty(Object source, String propertyName, Object value){
        
            final BeanWrapper src = new BeanWrapperImpl(source);
    
            Optional<PropertyDescriptor> propOptional = Arrays.stream(src.getPropertyDescriptors())
                    .filter(pd -> pd.getName().equalsIgnoreCase(propertyName)).findFirst();
            if (!propOptional.isPresent()){
        
                return;
            }
            PropertyDescriptor pd = propOptional.get();
    
            try {
        
                pd.getWriteMethod().invoke(source, value);
            }catch (Exception e){
        
                log.error("set property exception", e);
            }
        }
    
        /**
         * 合并extendArr数组到originArr数组
         * @param originArr：原数组
         * @param extendArr：扩充数组
         */
        public static String[] mergeStringArray(String[] originArr, String[] extendArr){
        
            if (Objects.isNull(originArr)){
        
                originArr = new String[]{
        };
            }
    
            if (Objects.isNull(extendArr) || extendArr.length < 1){
        
                return originArr;
            }
    
            int originArrLength = originArr.length;
            int extendArrLength = extendArr.length;
    
            originArr = Arrays.copyOf(originArr, originArrLength + extendArrLength);
            System.arraycopy(extendArr, 0, originArr, originArrLength, extendArrLength);
            return originArr;
    
        }
    
        /**
         * 回调函数
         */
        @FunctionalInterface
        interface CallBack<S, T> {
        
            /**
             * 定义默认回调方法
             */
            void callBack(S t, T s);
        }
    }