JAVA最全常用工具类，初学者必备

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

---

前言

整理的工具类及使用方法只是其中一部分，有其他更多实用的方法欢迎大家补充

---

一、Collections

A.包路径

import java.util.Collections;

B.常用方法

1.集合排序（升序、降序、随机、交换）

ArrayList list = new ArrayList();
      list.add(3);
      list.add(-2);
      list.add(9);
      list.add(5);
      list.add(-1);
      list.add(6);
      //输出：[3, -2, 9, 5, -1, 6]
      System.out.println(list);
      //集合元素的次序反转
      Collections.reverse(list);
      //输出：[6, -1, 5, 9, -2, 3]
      System.out.println(list);
      //排序：按照升序排序
      Collections.sort(list);
      //[-2, -1, 3, 5, 6, 9]
      System.out.println(list);
      //根据下标进行交换
      Collections.swap(list, 2, 5);
      //输出：[-2, -1, 9, 5, 6, 3]
      System.out.println(list);
      //随机排序
      Collections.shuffle(list);
      //每次输出的次序不固定
      System.out.println(list);*/
      //后两个整体移动到前边
      Collections.rotate(list, 2);
      //输出：[6, 9, -2, -1, 3, 5]
      System.out.println(list);

2.查询、替换

List<Integer> list = new ArrayList<>();
//获取最大值
Integer max = Collections.max(list);
//获取最小值
Integer min = Collections.min(list);
//将list中的-2用1来代替
System.out.println(Collections.replaceAll(list, -2, 1));   
//判断9在集合中出现的次数
System.out.println(Collections.frequency(list, 9));

3.转换线程安全集合

java中的很多集合，比如：ArrayList、LinkedList、HashMap、HashSet等，都是线程不安全的。在多线程的环境中，添加数据会出现异常

使用synchronizedxxx方法，将这些线程不安全的集合，直接转换成线程安全集合

List<Integer> integers = Collections.synchronizedList(list);//将ArrayList转换成线程安全集合

它的底层会创建SynchronizedRandomAccessList或者SynchronizedList类，这两个类的很多方法都会用synchronized加锁。

      //同步的集合对象
      Collection c = Collections.synchronizedCollection(new ArrayList());
      List list = Collections.synchronizedList(new ArrayList());
      Set s = Collections.synchronizedSet(new HashSet());
      Map m = Collections.synchronizedMap(new HashMap());

4.空集合

private List<Integer> fun(List<Integer> list) {
    if (list == null || list.size() == 0) {
    	//返回空集合
        return Collections.emptyList();
    }
    //业务处理
    return list;
}

注意：这是创建了一个不可变的集合，如果操作此集合，会出现添加出现异常：java.lang.UnsupportedOperationException

5.二分查找

binarySearch方法提供了一个非常好用的二分查找功能，只用传入指定集合和需要找到的key即可

List<Integer> list = new ArrayList<>();
list.add(2);
list.add(1);
list.add(3);
int i = Collections.binarySearch(list, 3);//二分查找
System.out.println(i);

6.转换成不可修改集合

为了防止后续的程序把某个集合的结果修改了，有时候我们需要把某个集合定义成不可修改的，使用Collections的unmodifiablexxx方法就能轻松实现：

List<Integer> list = new ArrayList<>();
list.add(2);
list.add(1);
list.add(3);

List<Integer> integers = Collections.unmodifiableList(list);
integers.add(4);
System.out.println(integers);

二、CollectionUtils

A.包路径

import org.apache.commons.collections.CollectionUtils;

B.常用方法

1.集合判空

CollectionUtils.isEmpty(list)
CollectionUtils.isNotEmpty(list)
/**
* 5、如果参数是null，则返回不可变的空集合，否则返回参数本身。（很实用 ,最终返回List EMPTY_LIST = new EmptyList<>()）
*/
CollectionUtils.emptyIfNull(Collection<T> collection)

2.对两个集合进行操作

List<Integer> list = new ArrayList<>();
list.add(2);
list.add(1);
list.add(3);

List<Integer> list2 = new ArrayList<>();
list2.add(2);
list2.add(4);

//获取并集
Collection<Integer> unionList = CollectionUtils.union(list, list2);

//获取交集
Collection<Integer> intersectionList = CollectionUtils.intersection(list, list2);

//获取交集的补集
Collection<Integer> disjunctionList = CollectionUtils.disjunction(list, list2);

//获取差集
Collection<Integer> subtractList = CollectionUtils.subtract(list, list2);

3.其他方法（去除null元素、排序）

        /**
         * 1、除非元素为null，否则向集合添加元素
         */
        CollectionUtils.addIgnoreNull(list,null);
        /**
         * 2、将两个已排序的集合a和b合并为一个已排序的列表，以便保留元素的自然顺序
         */
        CollectionUtils.collate(Iterable<? extends O> a, Iterable<? extends O> b)
        /**
         * 3、将两个已排序的集合a和b合并到一个已排序的列表中，以便保留根据Comparator c的元素顺序。
         */
        CollectionUtils.collate(Iterable<? extends O> a, Iterable<? extends O> b, Comparator<? super O> c)
        /**
         * 4、返回该个集合中是否含有至少有一个元素
         */
        CollectionUtils.containsAny(Collection<?> coll1, T... coll2)

三、Lists

A.包路径

import com.google.common.collect.Lists;

B.常用方法

1.创建空集合、快速初始化集合

List<Integer> list = Lists.newArrayList();
List<Integer> list = Lists.newArrayList(1, 2, 3);

2.笛卡尔积

List<Integer> list1 = Lists.newArrayList(1, 2, 3);
List<Integer> list2 = Lists.newArrayList(4,5);
List<List<Integer>> productList = Lists.cartesianProduct(list1,list2);
System.out.println(productList);
//结果
[[1, 4], [1, 5], [2, 4], [2, 5], [3, 4], [3, 5]]

3.拆分集合

//需要拆分的集合长度
Integer size =2;
List<Integer> list = Lists.newArrayList(1, 2, 3, 4, 5);
List<List<Integer>> partitionList = Lists.partition(list, size);
System.out.println(partitionList);
//结果
[[1, 2], [3, 4], [5]]

4.流处理

如果我们想把某个集合通过某些条件筛选后转换成另外一个集合，可以使用Lists的transform方法。例如：

List<String> list = Lists.newArrayList("a","b","c");
List<String> transformList = Lists.transform(list, x -> x.toUpperCase());

Map<String,String> map = Maps.newHashMap();
map.put("1","test1");
map.put("2","test2");
Map<String,String> map2 = Maps.newHashMap();
map2.put("1","test3");
map2.put("4","test2");
List<Map<String,String>> list2=Lists.newArrayList();
list2.add(map);
list2.add(map2);
List<String> list3=Lists.transform(list2,s->s.get("1"));
list3.forEach(s -> System.out.println(s));

5.颠倒排序

List<Integer> list = Lists.newArrayList(3, 1, 2);
List<Integer> reverseList = Lists.reverse(list);

四、Objects

A.包路径

import java.util.Objects;

A.常用方法

1.对象判空

Integer integer = new Integer(1);

if (Objects.isNull(integer)) {
    System.out.println("对象为空");
}

if (Objects.nonNull(integer)) {
    System.out.println("对象不为空");
}

如果我们想在对象为空时，抛出空指针异常，可以使用Objects的requireNonNull方法。例如

Integer integer1 = new Integer(128);

Objects.requireNonNull(integer1);
Objects.requireNonNull(integer1, "参数不能为空");
Objects.requireNonNull(integer1, () -> "参数不能为空");

2.判断两个对象是否相等

Integer integer1 = new Integer(1);
Integer integer2 = new Integer(1);

System.out.println(Objects.equals(integer1, integer2));

注意:Objects.equals() 方法是 Java 中用于比较两个对象是否相等的一个实用工具方法，它可以处理对象为 null 的情况，避免了因对象为 null 而产生 NullPointerException 的问题。具体来说，如果两个参数都是 null，则返回 true；如果一个参数是 null 而另一个不是 null，则返回 false；否则，调用第一个参数的 equals 方法进行比较。这样就避免了空指针异常了

3.获取对象的hashCode

如果你想获取某个对象的hashCode，可以使用Objects的hashCode方法。例如：

String str = new String("abc");
System.out.println(Objects.hashCode(str));
//结果
96354

五、BooleanUtils

A.包路径

import org.apache.commons.lang3.BooleanUtils;

B.常用方法

布尔的包装类：Boolean，总感觉有点麻烦，因为它有三种值：null、true、false。我们在处理Boolean对象时，需要经常判空。

1.判断true或false

//isTrue或isFalse
Boolean aBoolean = Boolean.TRUE;
System.out.println(BooleanUtils.isTrue(aBoolean));
System.out.println(BooleanUtils.isFalse(aBoolean));
//isNotTrue、isNotFalse方法
Boolean aBoolean = Boolean.TRUE;
Boolean aBoolean1 = null;
System.out.println(BooleanUtils.isNotTrue(aBoolean));
System.out.println(BooleanUtils.isNotTrue(aBoolean1));
System.out.println(BooleanUtils.isNotFalse(aBoolean));
System.out.println(BooleanUtils.isNotFalse(aBoolean1));

2.转换成数字

Boolean aBoolean = Boolean.TRUE;
Boolean aBoolean1 = Boolean.FALSE;
System.out.println(BooleanUtils.toInteger(aBoolean));
System.out.println(BooleanUtils.toInteger(aBoolean1));

六、StringUtils

A. 包路径

import org.apache.commons.lang.StringUtils;

B.主要方法

1.字符串判空

其实空字符串，不只是null一种，还有"“，” "，"null"等等，多种情况。
StringUtils给我们提供了多个判空的静态方法，例如：

String str;
StringUtils.isEmpty(str);
StringUtils.isNotEmpty(str);
StringUtils.isBlank(str);
StringUtils.isNotBlank(str);
// 去掉字符串两端的控制符, 如果输入为 null 则返回null 
StringUtils.trim(str);
//去掉字符串两端的控制符 ,如果变为 null 或""，则返回 null 
StringUtils.trimToNull(str);
//去掉字符串两端的控制符,如果变为 null 或 "" ，则返回 "" 
StringUtils.trimToEmpty(str);
// 去掉字符串两端的空白符，如果输入为 null 则返回 null 
StringUtils.strip(str);
//去掉字符串两端的空白符，如果变为 null 或"" ，则返回"" 
StringUtils.stripToNull(str);

优先推荐使用isBlank和isNotBlank方法，因为它会把" "也考虑进去。

2.分隔字符串

使用StringUtils的split方法会返回null，而直接使用String类的split方法，就可能会出现空指针异常

//分隔字符串
StringUtils.split(str1,",")

3.判断是否纯数字

给定一个字符串，判断它是否为纯数字，可以使用isNumeric方法。例如：

String str="1";
StringUtils.isNumeric(str)

4.将集合拼接成字符串

有时候，我们需要将某个集合的内容，拼接成一个字符串，然后输出，这时可以使用join方法。例如：

List<String> list = Lists.newArrayList("a", "b", "c");
List<Integer> list2 = Lists.newArrayList(1, 2, 3);
StringUtils.join(list, ",");
StringUtils.join(list2, " ");

5.判断字符串中某字符出现的位置

// 返回字符串 searchStr 在字符串 str 中第 ordinal 次出现的位置。
// 如果 str=null 或 searchStr=null 或 ordinal<=0 则返回-1
//*代表任意字符串
public static int ordinalIndexOf(String str, String searchStr, int ordinal) 

// 返回字符串 searchStr 从 startPos 开始在字符串 str 中第一次出现的位置。
//*代表任意字符串
public static int indexOf(String str, String searchStr, int startPos) 

StringUtils.ordinalIndexOf(str, searchStr, *);
StringUtils.indexOf(str, searchStr, *);
StringUtils.lastIndexOf(str, searchStr, *);

七、ClassUtils

A.包路径

import org.apache.commons.lang.ClassUtils;

B.主要方法

1.获取对象的所有接口

Class<?>[] allInterfaces = ClassUtils.getAllInterfaces(new User());

2.获取某个类的包名

String packageName = ClassUtils.getPackageName(User.class);

3.判断某个类是否内部类

ClassUtils.isInnerClass(User.class);

4.判断对象是否代理对象

ClassUtils.isCglibProxy(new User());

八、BeanUtils

A.包路径

import org.apache.commons.beanutils.BeanUtils;

B.主要方法

1.拷贝对象的属性

BeanUtils.copyProperties(user1, user2);

2.实例化某个类

如果你想通过反射实例化一个类的对象，可以使用BeanUtils的instantiateClass方法。例如：

User user = BeanUtils.instantiateClass(User.class);

3.获取指定类的指定方法

如果你想获取某个类的指定方法，可以使用BeanUtils的findDeclaredMethod方法。例如：

Method declaredMethod = BeanUtils.findDeclaredMethod(User.class, "getId");

九、ReflectionUtils

A.包路径

import org.springframework.util.ReflectionUtils;

B.主要方法

1.获取方法

Method method = ReflectionUtils.findMethod(User.class, "getId");

2.获取字段

Field field = ReflectionUtils.findField(User.class, "id");

3.执行方法

如果你想通过反射调用某个方法，传递参数，可以使用ReflectionUtils类的invokeMethod方法。例如：

ReflectionUtils.invokeMethod(method, springContextsUtil.getBean(beanName), param);

4.判断字段是否常量

Field field = ReflectionUtils.findField(User.class, "id");
System.out.println(ReflectionUtils.isPublicStaticFinal(field));

5.判断是否equals方法

Method method = ReflectionUtils.findMethod(User.class, "getId");
System.out.println(ReflectionUtils.isEqualsMethod(method));

十、HttpStatus

A.包路径

import org.apache.http.HttpStatus;

B.主要方法

很多时候，我们会在代码中定义http的返回码，比如：接口正常返回200，异常返回500，接口找不到返回404，接口不可用返回502等。
HttpStatus枚举，已经把常用的http返回码给我们定义好了，直接拿来用就可以了，真的不用再重复定义了

十一、RestTemplate

A.包路径

import org.springframework.web.client.RestTemplate;

B.主要方法

包含：GET、POST、PUT、DELETE、HEAD、OPTIONS、EXCHANGE、EXECUTE
第三方接口对接 RestTemplate发送http请求（httpclient 和 okhttp也可以）：

    RestTemplate restTemplate = new RestTemplate();
    String responseEntity =  restTemplate.getForObject("http://100.100.100.100：8080/evnCountListQuery", String.class);
    JSONArray jsonArray = JSON.parseArray(responseEntity);

        ResponseEntity<Object> forEntity = restTemplate.getForEntity("https://restapi.amap.com/v3/weather/weatherInfo?city=510100&key=e7a5fa943f706602033b6b329c49fbc6", Object.class);
        System.out.println("状态码:"+forEntity.getStatusCode());
        System.out.println("状态码内容:"+forEntity.getStatusCodeValue());
        HttpHeaders headers = forEntity.getHeaders();
        System.out.println("响应头:"+headers);
        Object body = forEntity.getBody();
        System.out.println("响应内容:"+body);

十二、Hutool中那些常用的工具类和方法

A.依赖

<dependency>
    <groupId>cn.hutool</groupId>
    <artifactId>hutool-all</artifactId>
    <version>4.6.3</version>
</dependency>

B.主要方法

1.类型转换

//转换为字符串
int a = 1;
String aStr = Convert.toStr(a);
//转换为指定类型数组
String[] b = {"1", "2", "3", "4"};
Integer[] bArr = Convert.toIntArray(b);
//转换为日期对象
String dateStr = "2017-05-06";
Date date = Convert.toDate(dateStr);
//转换为列表
String[] strArr = {"a", "b", "c", "d"};
List<String> strList = Convert.toList(String.class, strArr);

2.日期时间工具类

//Date、long、Calendar之间的相互转换
//当前时间
Date date = DateUtil.date();
//Calendar转Date
date = DateUtil.date(Calendar.getInstance());
//时间戳转Date
date = DateUtil.date(System.currentTimeMillis());
//自动识别格式转换
String dateStr = "2017-03-01";
date = DateUtil.parse(dateStr);
//自定义格式化转换
date = DateUtil.parse(dateStr, "yyyy-MM-dd");
//格式化输出日期
String format = DateUtil.format(date, "yyyy-MM-dd");
//获得年的部分
int year = DateUtil.year(date);
//获得月份，从0开始计数
int month = DateUtil.month(date);
//获取某天的开始、结束时间
Date beginOfDay = DateUtil.beginOfDay(date);
Date endOfDay = DateUtil.endOfDay(date);
//计算偏移后的日期时间
Date newDate = DateUtil.offset(date, DateField.DAY_OF_MONTH, 2);
//计算日期时间之间的偏移量
long betweenDay = DateUtil.between(date, newDate, DateUnit.DAY);

3.字符串操作

//判断是否为空字符串
String str = "test";
StrUtil.isEmpty(str);
StrUtil.isNotEmpty(str);
//去除字符串的前后缀
StrUtil.removeSuffix("a.jpg", ".jpg");
StrUtil.removePrefix("a.jpg", "a.");
//格式化字符串
String template = "这只是个占位符:{}";
String str2 = StrUtil.format(template, "我是占位符");
LOGGER.info("/strUtil format:{}", str2);

4.反射类工具

//获取某个类的所有方法
Method[] methods = ReflectUtil.getMethods(PmsBrand.class);
//获取某个类的指定方法
Method method = ReflectUtil.getMethod(PmsBrand.class, "getId");
//使用反射来创建对象
PmsBrand pmsBrand = ReflectUtil.newInstance(PmsBrand.class);
//反射执行对象的方法
ReflectUtil.invoke(pmsBrand, "setId", 1);

5.数字处理工具类，可用于各种类型数字的加减乘除操作及判断类型

double n1 = 1.234;
double n2 = 1.234;
double result;
//对float、double、BigDecimal做加减乘除操作
result = NumberUtil.add(n1, n2);
result = NumberUtil.sub(n1, n2);
result = NumberUtil.mul(n1, n2);
result = NumberUtil.div(n1, n2);
//保留两位小数
BigDecimal roundNum = NumberUtil.round(n1, 2);
String n3 = "1.234";
//判断是否为数字、整数、浮点数
NumberUtil.isNumber(n3);
NumberUtil.isInteger(n3);
NumberUtil.isDouble(n3);

6.Map与JavaBean对象的互相转换以及对象属性的拷贝

PmsBrand brand = new PmsBrand();
brand.setId(1L);
brand.setName("小米");
brand.setShowStatus(0);
//Bean转Map
Map<String, Object> map = BeanUtil.beanToMap(brand);
LOGGER.info("beanUtil bean to map:{}", map);
//Map转Bean
PmsBrand mapBrand = BeanUtil.mapToBean(map, PmsBrand.class, false);
LOGGER.info("beanUtil map to bean:{}", mapBrand);
//Bean属性拷贝
PmsBrand copyBrand = new PmsBrand();
BeanUtil.copyProperties(brand, copyBrand);
LOGGER.info("beanUtil copy properties:{}", copyBrand);

7.集合操作

//数组转换为列表
String[] array = new String[]{"a", "b", "c", "d", "e"};
List<String> list = CollUtil.newArrayList(array);
//join：数组转字符串时添加连接符号
String joinStr = CollUtil.join(list, ",");
LOGGER.info("collUtil join:{}", joinStr);
//将以连接符号分隔的字符串再转换为列表
List<String> splitList = StrUtil.split(joinStr, ',');
LOGGER.info("collUtil split:{}", splitList);
//创建新的Map、Set、List
HashMap<Object, Object> newMap = CollUtil.newHashMap();
HashSet<Object> newHashSet = CollUtil.newHashSet();
ArrayList<Object> newList = CollUtil.newArrayList();
//判断列表是否为空
CollUtil.isEmpty(list);

8.Map操作

//将多个键值对加入到Map中
Map<Object, Object> map = MapUtil.of(new String[][]{
    {"key1", "value1"},
    {"key2", "value2"},
    {"key3", "value3"}
});
//判断Map是否为空
MapUtil.isEmpty(map);
MapUtil.isNotEmpty(map);

9.注解工具类，获取注解与注解中指定的值。

//获取指定类、方法、字段、构造器上的注解列表
Annotation[] annotationList = AnnotationUtil.getAnnotations(HutoolController.class, false);
LOGGER.info("annotationUtil annotations:{}", annotationList);
//获取指定类型注解
Api api = AnnotationUtil.getAnnotation(HutoolController.class, Api.class);
LOGGER.info("annotationUtil api value:{}", api.description());
//获取指定类型注解的值
Object annotationValue = AnnotationUtil.getAnnotationValue(HutoolController.class, RequestMapping.class);

---

总结

持续更新，欢迎大家补充，感谢关注，祝愿大家事业节节高升