java常用api

类复制 

import org.springframework.beans.BeanUtils;
// 将参数一的类属性值，复制到参数二的类里面
BeanUtils.copyProperties(basicRoadInfoDTO,basicRoadInfo);

import org.apache.commons.beanutils.BeanUtils;
// 将参数二的类属性值，复制到参数一的类里面
BeanUtils.copyProperties(basicRoadInfoDTO,basicRoadInfo);

字符串判空

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

import org.apache.commons.lang3.StringUtils;
// 为空返回true   包括：空白字符串、""、null 等
StringUtils.isBlank(str)
// 不为空返回true   
StringUtils.isNotBlank(str)

Objects类

import java.util.Objects;

1、isNull和noNull对象判空

Objects.isNull(loginUser)  // 为空返回true
Objects.noNull(loginUser)  // 不为空返回true

2、equals和deepEquals判断相等

equals

注意事项：
1、不同类型判断直接返回false
2、可以传入类型为null的对象
Objects.equals(1L, 1)  // false
Objects.equals(1, 1)  // true

deepEquals

deepEquals字面意思就是比equlas进行更深度的比较

        String[] s1 = {"q","w","e"};
		String[] s2 = {"q","w","e"};
		String[] s3 = {"a","s","d"};
		boolean result = Objects.deepEquals(s1, s2); // true
		result = Objects.deepEquals(s1, s3);  // false

这两种方法的区别就在于deepEquals是比较传入对象的值完全一致才会返回ture
所以在比较类类型，数组等引用类型时用deepEquals比较好，当然也可以选择
重写equalse方法来让比较更符合我们的要求

集合判空

// Collections集合工具类
// 集合为空返回true，不能判断为null的情况
if (list != null && list.isEmpty()) {
     System.out.print("集合中有数据")
}

MD5

一种加密技术，不可逆。java中由spring提供生成方式

import org.springframework.util.DigestUtils;

               //传入的参数为字节数组，返回值为String类型

String md5Pass = DigestUtils.md5DigestAsHex(参数（bytes[]）);

UUID

格式：5ed058eb-28a0-11ec-98c8-00e04d76ccc4

import java.util.UUID;

System.out.println(UUID.randomUUID().toString)

org.springframework.util.StringUtils

import org.springframework.util.StringUtils;

// 字符串判断工具
// 判断字符串是否为 null，或 ""。注意，包含空白符的字符串为非空
boolean isEmpty(Object str)
// 判断字符串是否是以指定内容结束。忽略大小写
boolean endsWithIgnoreCase(String str, String suffix)
// 判断字符串是否已指定内容开头。忽略大小写
boolean startsWithIgnoreCase(String str, String prefix) 
// 是否包含空白符
boolean containsWhitespace(String str)
// 判断字符串非空且长度不为 0，即，Not Empty
boolean hasLength(CharSequence str)
// 判断字符串是否包含实际内容，即非仅包含空白符，也就是 Not Blank
boolean hasText(CharSequence str)
// 判断字符串指定索引处是否包含一个子串。
boolean substringMatch(CharSequence str, int index, CharSequence substring)
// 计算一个字符串中指定子串的出现次数
int countOccurrencesOf(String str, String sub)


// 字符串操作工具
// 查找并替换指定子串
String replace(String inString, String oldPattern, String newPattern)
// 去除尾部的特定字符
String trimTrailingCharacter(String str, char trailingCharacter) 
// 去除头部的特定字符
String trimLeadingCharacter(String str, char leadingCharacter)
// 去除头部的空白符
String trimLeadingWhitespace(String str)
// 去除尾部的空白符
String trimTrailingWhitespace(String str)
// 去除头部和尾部的空白符
String trimWhitespace(String str)
// 删除开头、结尾和中间的空白符
String trimAllWhitespace(String str)
// 删除指定子串
String delete(String inString, String pattern)
// 删除指定字符（可以是多个）
String deleteAny(String inString, String charsToDelete)
// 对数组的每一项执行 trim() 方法
String[] trimArrayElements(String[] array)
// 将 URL 字符串进行解码
String uriDecode(String source, Charset charset)

// 路径相关字符串工具方法
// 解析路径字符串，优化其中的 “..” 
String cleanPath(String path)
// 解析路径字符串，解析出文件名部分
String getFilename(String path)
// 解析路径字符串，解析出文件后缀名
String getFilenameExtension(String path)
// 比较两个两个字符串，判断是否是同一个路径。会自动处理路径中的 “..” 
boolean pathEquals(String path1, String path2)
// 删除文件路径名中的后缀部分
String stripFilenameExtension(String path) 
// 以 “. 作为分隔符，获取其最后一部分
String unqualify(String qualifiedName)
// 以指定字符作为分隔符，获取其最后一部分
String unqualify(String qualifiedName, char separator)

CollectionUtils集合工具类

<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-core</artifactId>				  
	<version>5.0.8.RELEASE</version>
</dependency>

// 集合判断工具
// 判断 List/Set 是否为空
boolean isEmpty(Collection<?> collection)
// 判断 Map 是否为空
boolean isEmpty(Map<?,?> map)
// 判断 List/Set 中是否包含某个对象
boolean containsInstance(Collection<?> collection, Object element)
// 以迭代器的方式，判断 List/Set 中是否包含某个对象
boolean contains(Iterator<?> iterator, Object element)
// 判断 List/Set 是否包含某些对象中的任意一个
boolean containsAny(Collection<?> source, Collection<?> candidates)
// 判断 List/Set 中的每个元素是否唯一。即 List/Set 中不存在重复元素
boolean hasUniqueObject(Collection<?> collection)

// 集合操作工具
// 将 Array 中的元素都添加到 List/Set 中
<E> void mergeArrayIntoCollection(Object array, Collection<E> collection)  
// 将 Properties 中的键值对都添加到 Map 中
<K,V> void mergePropertiesIntoMap(Properties props, Map<K,V> map)
// 返回 List 中最后一个元素
<T> T lastElement(List<T> list)  
// 返回 Set 中最后一个元素
<T> T lastElement(Set<T> set) 
// 返回参数 candidates 中第一个存在于参数 source 中的元素
<E> E findFirstMatch(Collection<?> source, Collection<E> candidates)
// 返回 List/Set 中指定类型的元素。
<T> T findValueOfType(Collection<?> collection, Class<T> type)
// 返回 List/Set 中指定类型的元素。如果第一种类型未找到，则查找第二种类型，以此类推
Object findValueOfType(Collection<?> collection, Class<?>[] types)
// 返回 List/Set 中元素的类型
Class<?> findCommonElementType(Collection<?> collection)

net.sf.json.JsonArray与net.sf.json.JSONObject

net.sf.json.JsonArray和net.sf.json.JSONObject是在Java中使用的JSON处理工具。它们都属于json-lib库，用于处理JSON数据。

JsonArray表示JSON数组，它可以包含一组有序的值，类似于JavaScript中的数组。你可以通过索引来访问其中的元素，并且可以对其进行遍历、添加或删除元素等操作。

JSONObject表示JSON对象，它是一个键值对的集合，类似于JavaScript中的对象。你可以通过键来访问其中的值，也可以对其进行增加、删除、修改等操作。

在实际应用中，JsonArray通常用于表示JSON数据中的数组部分，而JSONObject则用于表示JSON数据中的对象部分，两者结合可以很方便地处理复杂的JSON数据结构。

// JSON解析为数组
Object[] = JSONArray.fromObject(strJson).toArray();
System.out.println(Object[0]);
 
// JSON解析为JSONArray（JSONArray可遍历）
JSONArray jsonArray = JSONArray.fromObject(strJson);   
for(int i = 0; i < jsonArray.size(); i++) {
   // 获得数组中每一项，继续解析为Map或者Object。如果类型复杂建议为Map，因为可以get出来，然后继续解析
   Map mp = jsonArray.getJSONObject(i)    
} 

对于这种及其复杂的结构，而且没有相应的实体类