春眠不觉晓♞

java实用必备工具库

java实用必备工具库，高效率完成开发

很多对编程感兴趣的朋友不知道是否会有这样的感触，敲了很多年代码，才发现有很多工具类库，这些工具类库可以大大的简化代码量，从而提升开发效率，下面和大家分享一下我所了解的工具类库。

1. java自带工具方法

1.1 List集合拼接成以逗号分隔的字符串

 @Test
    public void test1(){
        //如何把list集合拼接成以逗号分隔的字符串a,b,c (---Arrays.asList:该方法是将数组转化成List集合的方法)
        List<String> list = Arrays.asList("a", "b", "c");
        System.out.println("list集合:"+list);
        //第一种方法，可以用Stream流
        //(---stream.collect(Collectors.joining()):收集数据到指定的集合中。)
        //(---Collectors.joining(","):会根据指定的连接符，将所有元素连接成一个字符串。)
        String collect = list.stream().collect(Collectors.joining(","));
        System.out.println("第一种方法:"+collect);
        //第二种方法，可以用String的join方法来实现该功能
        String join = String.join(",", list);
        System.out.println("第二种方法:"+join);
    }

输出结果：
		list:[a, b, c]
		第一种方法:a,b,c
		第二种方法:a,b,c

1.2 比较两个字符串是否相等（忽略大小写）

@Test
    public void test2(){
        String str1 = "1234ABC";
        String str2 = "1234abc";
        if (str1.equalsIgnoreCase(str2)){
            System.out.println("相等");
        }
    }

输出结果：相等

1.3 比较两个对象是否相等

当我们用equals比较两个对象是否相等的时候，还需要对左边的对象进行判空，不然可能会报出空指针异常，这时我们可以用java.utils包下的Objects封装好的比较是否相等的方法。

Objects.equals(StrA,StrB)

附上源码：

public static boolean equals(Objects a,Objects b){
	return (a==b)||(a!=null && a.equals(b));
}

1.4 两个List集合取交集

@Test
    public void test3(){
        List<String> list1 = new ArrayList<>();
        list1.add("a");
        list1.add("b");
        list1.add("c");

        List<String> list2 = new ArrayList<>();
        list2.add("a");
        list2.add("c");
        list2.add("d");

        //取得两个List的交集，retainAll()方法
        /* A.retainAll(B)
        可以看到这个方法改变了集合A中的元素，将存在于集合A中但不存在于集合B中的元素移除。
        如果集合A的大小发生了改变，返回true，即使两个集合完全没有交集，也会返回true。
        如果集合A的大小没有发生改变，返回false，即使两个集合完全相同，也会返回false。*/
        boolean b = list1.retainAll(list2);
        System.out.println(b);
        System.out.println(list1);
    }

输出结果：true
		[a, c]

2.apache commons工具类库

apache commons是最强大的，也是使用最广泛的工具类库，它里面的子库非常之多，下面分享几个常用的：

2.1 commons-lang , java.lang的增强版

建议使用commons-lang3,优化了一些api，原来的commons-lang好像已经停止更新了。Maven依赖如下：

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

2.1.1字符串判空

传参CharSequence类型是String,StringBuffer,StringBuilder的父类，这些都可以直接用下面的方法进行判空，代码如下：

public static boolean isEmpty(final CharSequence cs){
	return cs == null||cs.length == 0;
}

public static boolean isNotEmpty(final CharSequence cs){
	return !isEmpty(cs);
}

//判空的时候，会去除字符串中的空白字符串，比如空格、换行、制表符
public static boolean isBlank(final CharSequence cs){
	final int strLen = length(cs);
	if（strLen == 0）{
		return true;
	}
	for(int i = 0;i<strLen;i++ ){
		if(!Character.isWhitespace(cs.charAt(i))){
			return false;
		}
	}
	return true;
	
}

public static boolean isNotBlank(final CharSequence cs){
	return !isBlank(cs);
}

2.1.2 首字母转成大写

 @Test
    public void test4(){
        String str = "abcd";
        String capitalize = StringUtils.capitalize(str);
        System.out.println("转换结果："+capitalize);
    }

转换结果：Abcd

2.1.3 重复拼接字符串

String str = StringUtils.repeat("ab",2)
sysytem.out.println(str);//输出abab

2.1.4 格式化日期

@Test

    public void test5() throws ParseException {
        //Date类型转成String类型
        String date = DateFormatUtils.format(new Date(), "yyyy-MM-dd HH:mm:ss");
        System.out.println("String类型日期："+date);

        //String类型转换成Date类型
        String str = "2020-05-01 01:01:01";
        Date date1 = DateUtils.parseDate(str, "yyyy-MM-dd HH:mm:ss");
        System.out.println("String类型转换成Date类型:"+str);
        //计算一个小时后的日期
        Date date2 = DateUtils.addHours(new Date(), 1);
        System.out.println("一小时后的日期："+date2);
    }

String类型日期：2021-07-02 11:10:16
String类型转换成Date类型:2020-05-01 01:01:01
一小时后的日期：Fri Jul 02 12:10:16 CST 2021

2.1.5 包装临时对象

@Test
    public void test6(){
        //返回两个字段
        ImmutablePair<Integer, String> pair = ImmutablePair.of(1, "test");
        System.out.println("返回两个字段的结果："+pair.getRight()+","+pair.getLeft());

        //返回三个字段
        ImmutableTriple<Integer, String, Date> triple = ImmutableTriple.of(1, "hello", new Date());
        System.out.println("返回三个字段的结果："+triple.getLeft()+","+triple.getMiddle()+","+triple.getRight());
    }
}

返回两个字段的结果：test,1
返回三个字段的结果：1,hello,Fri Jul 02 11:48:47 CST 2021

2.2 commns-collections集合工具类

先附上Maven依赖：

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

2.2.1 集合判空

封装了集合判空的方法，以下是源码：

public static boolean isEmpty(final Collection<?> coll){
	return coll == null || coll.isEmpty();
}

public static boolean isNotEmpty(final Collection<?> coll){
	return !isEmpty(coll);
}

//两个集合取交集
@Test
    public void test7(){
        List<Object> list1 = new ArrayList<>();
        List<Object> list2 = new ArrayList<>();
        list1.add("tom");
        list1.add("jerry");
        list1.add("peter");

        list2.add("peter");
        list2.add("jack");
        list2.add("jerry");

        boolean b = list1.retainAll(list2);
        System.out.println("\n\n集合1与集合2是否有交集元素：" + b);
        System.out.println("集合1与集合2的交集为："+ list1);

    }

集合1与集合2是否有交集元素：true
集合1与集合2的交集为：[jerry, peter]

//两个集合取并集
@Test
    public void test8(){
        String[] arrayA = new String[] { "A", "B", "C", "D", "E", "F" };
        String[] arrayB = new String[] { "B", "D", "F", "G", "H", "K" };
        List<String> listA = Arrays.asList(arrayA);
        List<String> listB = Arrays.asList(arrayB);
        //2个数组取并集
        System.out.println(ArrayUtils.toString(CollectionUtils.union(listA, listB)));
        //[A, B, C, D, E, F, G, H, K]
    }

// 两个集合取差集 
@Test
public void testDisjunction(){
    String[] arrayA = new String[] { "A", "B", "C", "D", "E", "F" };  
    String[] arrayB = new String[] { "B", "D", "F", "G", "H", "K" };
    List<String> listA = Arrays.asList(arrayA);
    List<String> listB = Arrays.asList(arrayB);
    //2个数组取交集 的补集
    System.out.println(ArrayUtils.toString(CollectionUtils.disjunction(listA, listB)));
    //[A, C, E, G, H, K]
}

2.3 commons-beanutils操作对象

Maven依赖

<dependency>  
    <groupId>commons-beanutils</groupId>  
    <artifactId>commons-beanutils</artifactId>  
    <version>1.9.4</version>  
</dependency>

创建对象

public class User {  
    private Integer id;  
    private String name;  
}

设置对象属性

@Test
    public void test8() throws InvocationTargetException, IllegalAccessException, NoSuchMethodException {
        Demo demo = new Demo();
        BeanUtils.setProperty(demo,"id",1);
        BeanUtils.setProperty(demo,"name","peter");
        String name = BeanUtils.getProperty(demo, "name");
        System.out.println(name);
        System.out.println(demo);

    }

输出结果：peter
		Demo(id=1, name=peter)

对象和Map互转

@Test
    public void test10() throws IllegalAccessException, NoSuchMethodException, InvocationTargetException {
        Demo demo = new Demo();
        BeanUtils.setProperty(demo,"id",1);
        BeanUtils.setProperty(demo,"name","peter");
        String name = BeanUtils.getProperty(demo, "name");
        System.out.println(name);
        System.out.println(demo);
        //对象转map
        Map<String, String> describe = BeanUtils.describe(demo);
        System.out.println("对象转map(demo--->describle):"+describe);
        //map转对象
        Demo demo2 = new Demo();
        //这个方法会遍历map中的key，如果bean中有这个属性，就把这个key对应的value值赋给bean的属性。
        BeanUtils.populate(demo2,describe);
        System.out.println("map转对象(describle--->demo2):"+demo2);
    }

输出结果：
Demo(id=1, name=peter)
对象转map(demo--->describle):{name=peter, id=1}
map转对象(describle--->demo2):Demo(id=1, name=peter)

2.4 commons-io文件流处理

Maven依赖：

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

  @Test
    public void test11() throws IOException {
        File file = new File("D:\\demo.txt");
        //读取文件
        List<String> lines = FileUtils.readLines(file, Charset.defaultCharset());
        System.out.println("读取文件内容："+lines);
        //写入文件（如果没有文件会自动创建，并且将集合元素以行来划分，多次写入会覆盖原有内容。）
        File file2 = new File("D:\\demo2.txt");
        FileUtils.writeLines(file2,lines);
        //复制文件
        File file3= new File("D:\\demo3.txt");
        FileUtils.copyFile(file,file3);

    }

输出结果：读取文件内容：[测试使用，hello world，每日练习]

实际效果如下：建立第一个新文档demo,写入文件是会自动写入demo2,复制文件会将demo1内容复制到demo3文件中。

3.Google Guava工具库类