排序

实现升序和降序

  List<Integer> list = new ArrayList<>();
  list.add(2);
  list.add(1);
  list.add(3);
  Collections.sort(list);//升序
  System.out.println(list);//    [1, 2, 3]
  Collections.reverse(list);//降序
  System.out.println(list);//    [3, 2, 1]

获取最大或最小值

找出集合中的最大值或者最小值，这时可以使用Collections的max和min方法

List<Integer> list = new ArrayList<>();
list.add(2);
list.add(1);
list.add(3);
Integer max = Collections.max(list);//获取最大值
Integer min = Collections.min(list);//获取最小值
System.out.println(max);// 3
System.out.println(min);// 1

转换线程安全集合

java中的很多集合，比如：ArrayList、LinkedList、HashMap、HashSet等，都是线程不安全的
这些集合在多线程的环境中，添加数据会出现异常
可以用Collections的synchronizedxxx方法，将这些线程不安全的集合，直接转换成线程安全集合

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

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

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

二分查找

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 );// 2

转换成不可修改集合

为了防止后续的程序把某个集合的结果修改了，有时候我们需要把某个集合定义成不可修改的，使用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);

执行结果：

Exception in thread "main" java.lang.UnsupportedOperationException
 at java.util.Collections$UnmodifiableCollection.add(Collections.java:1055)
 at com.wind.service.UtilTest.main(UtilTest.java:28)

其他常用方法

上述只列举几个常用场景的轮子，工具类中还有很多其他场景常用的方法，可以根据需要去探索

集合判空

通过CollectionUtils工具类的isEmpty方法可以轻松判断集合是否为空，isNotEmpty方法判断集合不为空

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

if (CollectionUtils.isEmpty(list)) {
    System.out.println("集合为空");
}

if (CollectionUtils.isNotEmpty(list)) {
    System.out.println("集合不为空");
}

对两个集合进行操作

有时候我们需要对已有的两个集合进行操作，比如取交集或者并集等

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);
System.out.println(unionList);// [1, 2, 3, 4]

//获取交集
Collection<Integer> intersectionList = CollectionUtils.intersection(list, list2);
System.out.println(intersectionList);// [2]

//获取交集的补集
Collection<Integer> disjunctionList = CollectionUtils.disjunction(list, list2);
System.out.println(disjunctionList);// [1, 3, 4]

//获取差集
Collection<Integer> subtractList = CollectionUtils.subtract(list, list2);
System.out.println(subtractList);// [1, 3]

其他常用方法

上述只列举几个常用场景的轮子，工具类中还有很多其他场景常用的方法，可以根据需要去探索

创建空集合

List<Integer> list = Lists.newArrayList();

笛卡尔积

将两个集合做笛卡尔积，Lists的cartesianProduct方法可以帮你实现

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]]

分页

一个大集合(5条)按大小为（2）分成若干个3（3页）小集合，可以使用Lists的partition方法

List<Integer> list = Lists.newArrayList(1, 2, 3, 4, 5);
List<List<Integer>> partitionList = Lists.partition(list, 2);
System.out.println(partitionList);

执行结果：

[[1, 2], [3, 4], [5]]

TIPS场景:现在有10000个id，需要调用批量用户查询接口，查出用户数据。但如果你直接查10000个用户，单次接口响应时间可能会非常慢。如果改成分页处理，每次只查1000个用户，异步调用10次接口，就不会有单次接口响应慢的问题

流处理

下述使用Lists的transform方法将小写字母转换成了大写字母

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

颠倒顺序

通过Lists的reverse实现颠倒顺序

List<Integer> list = Lists.newArrayList(3, 1, 2);
List<Integer> reverseList = Lists.reverse(list);
System.out.println(reverseList);// [2, 1, 3]

其他常用方法

上述只列举几个常用场景的轮子，工具类中还有很多其他场景常用的方法，可以根据需要去探索

对象判空

Objects的isNull方法判断对象是否为空，而nonNull方法判断对象是否不为空

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, () -> "参数不能为空");

获取对象的hashCode

获取某个对象的hashCode，可以使用Objects的hashCode方法

String str = new String("abc");
System.out.println(Objects.hashCode(str));

其他常用方法

上述只列举几个常用场景的轮子，工具类中还有很多其他场景常用的方法，可以根据需要去探索

判断true/false

判断某个参数的值是true或false，可以直接使用isTrue或isFalse方法

Boolean aBoolean = new Boolean(true);
System.out.println(BooleanUtils.isTrue(aBoolean));
System.out.println(BooleanUtils.isFalse(aBoolean));

判断不为true/不为false

某个参数不为true，即是null或者false。或者判断不为false，即是null或者true

Boolean aBoolean = new Boolean(true);
Boolean aBoolean1 = null;
System.out.println(BooleanUtils.isNotTrue(aBoolean));// false
System.out.println(BooleanUtils.isNotTrue(aBoolean1));// true
System.out.println(BooleanUtils.isNotFalse(aBoolean));// true
System.out.println(BooleanUtils.isNotFalse(aBoolean1));// true

转换数字

将true转换成数字1，false转换成数字0，可以使用toInteger方法

Boolean aBoolean = new Boolean(true);
Boolean aBoolean1 = new Boolean(false);
System.out.println(BooleanUtils.toInteger(aBoolean));// 1
System.out.println(BooleanUtils.toInteger(aBoolean1));// 0

Boolean转换成布尔值

将包装类Boolean对象，转换成原始的boolean对象，可以使用toBoolean方法

Boolean aBoolean = new Boolean(true);
Boolean aBoolean1 = null;
System.out.println(BooleanUtils.toBoolean(aBoolean));
System.out.println(BooleanUtils.toBoolean(aBoolean1));
System.out.println(BooleanUtils.toBooleanDefaultIfNull(aBoolean1, false));

其他常用方法

上述只列举几个常用场景的轮子，工具类中还有很多其他场景常用的方法，可以根据需要去探索

字符串判空

空字符串有""，" "，"null"等等，多种情况，StringUtils给提供了多个判空的静态方法，其中的isEmpty、isNotEmpty、isBlank和isNotBlank，这4个判空方法可以根据实际情况使用

String str1 = null;
String str2 = "";
String str3 = " ";
String str4 = "abc";
System.out.println(StringUtils.isEmpty(str1));// true
System.out.println(StringUtils.isEmpty(str2));// true
System.out.println(StringUtils.isEmpty(str3));// false
System.out.println(StringUtils.isEmpty(str4));// false
System.out.println("-----------------------");
System.out.println(StringUtils.isNotEmpty(str1));// false
System.out.println(StringUtils.isNotEmpty(str2));// false
System.out.println(StringUtils.isNotEmpty(str3));// true
System.out.println(StringUtils.isNotEmpty(str4));// true
System.out.println("-----------------------");
System.out.println(StringUtils.isBlank(str1));// true
System.out.println(StringUtils.isBlank(str2));// true
System.out.println(StringUtils.isBlank(str3));// true
System.out.println(StringUtils.isBlank(str4));// false
System.out.println("-----------------------");
System.out.println(StringUtils.isNotBlank(str1));// false
System.out.println(StringUtils.isNotBlank(str2));// false
System.out.println(StringUtils.isNotBlank(str3));// false
System.out.println(StringUtils.isNotBlank(str4));// true

分隔字符串

分隔字符串直接使用String类的split方法，就可能会出现空指针异常，StringUtils不会

String str1 = null;
System.out.println(StringUtils.split(str1,","));
System.out.println(str1.split(","));

执行结果：

null
Exception in thread "main" java.lang.NullPointerException
 at com.wind.service.UtilTest.main(UtilTest.java:28)

判断是否纯数字

判断一个字符串它是否为纯数字，可以使用isNumeric方法

String str1 = "280";
String str2 = "280l";
String str3 = "0.28";
System.out.println(StringUtils.isNumeric(str1));// true
System.out.println(StringUtils.isNumeric(str2));// false
System.out.println(StringUtils.isNumeric(str3));// false

将集合拼接成字符串

将某个集合的内容，拼接成一个字符串，然后输出，可以使用join方法

List<String> list = Lists.newArrayList("a", "b", "c");
List<Integer> list2 = Lists.newArrayList(2, 8, 0);
System.out.println(StringUtils.join(list, ","));// a,b,c
System.out.println(StringUtils.join(list2, " "));// 2 8 0

其他常用方法

上述只列举几个常用场景的轮子，工具类中还有很多其他场景常用的方法，可以根据需要去探索

断言参数是否为空

断言参数是否空，如果不满足条件，则抛出IllegalArgumentException异常

String str = null;
Assert.isNull(str, "str必须为空");
Assert.isNull(str, () -> "str必须为空");
Assert.notNull(str, "str不能为空");

断言集合是否为空

断言集合是否空，如果不满足条件，则抛出IllegalArgumentException异常

List<String> list = null;
Map<String, String> map = null;
Assert.notEmpty(list, "list不能为空");
Assert.notEmpty(list, () -> "list不能为空");
Assert.notEmpty(map, "map不能为空");

断言条件是否为空

断言是否满足某个条件，如果不满足条件，则直接抛异常

List<String> list = null;
Assert.isTrue(CollectionUtils.isNotEmpty(list), "list不能为空");
Assert.isTrue(CollectionUtils.isNotEmpty(list), () -> "list不能为空");

其他常用方法

上述只列举几个常用场景的轮子，工具类中还有很多其他场景常用的方法，可以根据需要去探索

读取文件

将某个txt文件中的数据，读取到字符串当中，可以使用IOUtils类的toString方法

String str = IOUtils.toString(new FileInputStream("/temp/test01.txt"), StandardCharsets.UTF_8);
System.out.println(str);

写入文件

将某个字符串的内容，写入到指定文件当中，可以使用IOUtils类的write方法

String str = "Lehman";
IOUtils.write(str, new FileOutputStream("/temp/test02.tx"), StandardCharsets.UTF_8);

文件拷贝

某个文件中的所有内容，都拷贝到另一个文件当中，可以使用IOUtils类的copy方法

IOUtils.copy(new FileInputStream("/temp/test01.txt"), new FileOutputStream("/temp/test02.txt"));

读取文件内容到字节数组

将某个文件中的内容，读取字节数组中，可以使用IOUtils类的toByteArray方法

byte[] bytes = IOUtils.toByteArray(new FileInputStream("/temp/a.txt"));

其他常用方法

上述只列举几个常用场景的轮子，工具类中还有很多其他场景常用的方法，可以根据需要去探索

获取对象的所有接口

获取某个对象的所有接口，可以使用ClassUtils的getAllInterfaces方法

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

获取某个类的包名

获取某个类的包名，可以使用ClassUtils的getPackageName方法

String packageName = ClassUtils.getPackageName(User.class);
System.out.println(packageName);

判断某个类是否内部类

判断某个类是否内部类，可以使用ClassUtils的isInnerClass方法

System.out.println(ClassUtils.isInnerClass(User.class));

判断对象是否代理对象

判断对象是否代理对象，可以使用ClassUtils的isCglibProxy方法

System.out.println(ClassUtils.isCglibProxy(new User()));

其他常用方法

上述只列举几个常用场景的轮子，工具类中还有很多其他场景常用的方法，可以根据需要去探索

拷贝对象的属性

把某个对象中的所有属性，都拷贝到另外一个对象中。可以使用BeanUtils的copyProperties方法

User user1 = new User();
user1.setId(1L);
user1.setName("Lehman");
user1.setAddress("上海");

User user2 = new User();
BeanUtils.copyProperties(user1, user2);
System.out.println(user2);

实例化某个类

通过反射实例化一个类的对象，可以使用BeanUtils的instantiateClass方法

User user = BeanUtils.instantiateClass(User.class);
System.out.println(user);

获取指定类的指定方法

获取某个类的指定方法，可以使用BeanUtils的findDeclaredMethod方法

Method declaredMethod = BeanUtils.findDeclaredMethod(User.class, "getId");
System.out.println(declaredMethod.getName());

获取指定方法的参数

获取某个方法的参数，可以使用BeanUtils的findPropertyForMethod方法

Method declaredMethod = BeanUtils.findDeclaredMethod(User.class, "getId");
PropertyDescriptor propertyForMethod = BeanUtils.findPropertyForMethod(declaredMethod);
System.out.println(propertyForMethod.getName());

其他常用方法

上述只列举几个常用场景的轮子，工具类中还有很多其他场景常用的方法，可以根据需要去探索

获取方法

获取某个类的某个方法，可以使用ReflectionUtils类的findMethod方法

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

获取字段

获取某个类的某个字段，可以使用ReflectionUtils类的findField方法

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

执行方法

通过反射调用某个方法，传递参数，可以使用ReflectionUtils类的invokeMethod方法

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

判断字段是否常量

判断某个字段是否常量，可以使用ReflectionUtils类的isPublicStaticFinal方法

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

判断是否equals方法

判断某个方法是否equals方法，可以使用ReflectionUtils类的isEqualsMethod方法

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

其他常用方法

上述只列举几个常用场景的轮子，工具类中还有很多其他场景常用的方法，可以根据需要去探索

编码

String str = "Lehman";
String encode = new String(Base64Utils.encode(str.getBytes()));
System.out.println("编码后：" + encode);

解码

try {
    // encode 是需要解密的字符
    String decode = new String(Base64Utils.decode(encode.getBytes()), "utf8");
    System.out.println("后：" + decode);
} catch (UnsupportedEncodingException e) {
    e.printStackTrace();
}

其他常用方法

上述只列举几个常用场景的轮子，工具类中还有很多其他场景常用的方法，可以根据需要去探索