Java中那些让你爱不释手工具库，精炼代码量 _工具库

【Java中那些让你爱不释手工具库，精炼代码量】人生处万类,知识最为贤。这篇文章主要讲述Java中那些让你爱不释手工具库，精炼代码量相关的知识，希望能为你提供帮助。
java中那些让你爱不释手工具库，精炼代码量一、JDK1.8 Stream新特性 1、Stream流的常见生成方式
①Collection体系的集合可以使用默认方法stream()生成流

//list转stream流 List< String> list = new ArrayList< > (); Stream< String> listStream = list.stream(); //Set转stream流 Set< String> set = new HashSet< > (); Stream< String> setStream = set.stream(); //map转stream流 Map< String, Integer> map = new HashMap< > (); Stream< String> keyStream = map.keySet().stream(); Stream< Integer> valueStream = map.values().stream(); Stream< Map.Entry< String, Integer> > entryStream = map.entrySet().stream();

②数组转stream流

//第一种: 使用java.util.Arrays.stream(T[] array)方法用数组创建流 int[] array={1,3,5,6,8}; IntStream stream = Arrays.stream(array); //第二种: 可以通过Stream接口的静态方法of(T... values)生成流 String[] strArray = {"hello", "world", "java"}; Stream< String> strArrayStream = Stream.of(strArray); Stream< String> strArrayStream2 = Stream.of("hello", "world", "java"); Stream< Integer> intStream = Stream.of(10, 20, 30);

2、void forEach(Consumer< ? super T> action)

Stream< String> stringStream = Stream.of("景天", "雪见", "长卿", "紫萱"); stringStream.forEach(System.out::println); //打印结果: ["景天", "雪见", "长卿", "紫萱"]

3、Stream< T> filter(Predicate predicate)
?（说明: 用于对流中的数据进行过滤）

List< String> nameList = Arrays.asList("景天", "雪见", "长卿", "紫萱"); nameList.stream().filter(s -> s.startsWith("紫")).forEach(System.out::println); //打印结果: 紫萱

4、Stream map(Function< ? super T, ? extends R> mapper)
（说明: 可以将流中的元素映射到另一个流中）

List< Integer> num = Arrays.asList(1, 2, 3, 4, 5); num.stream().map(n -> n * 2).forEach(System.out::println); //打印结果: [2, 4, 6, 8, 10]

5、Stream flatMap(Function function)
（说明：flatmap是stream的一种中间操作，对流进行“扁平化” 处理，是它和stream的map一样，是一种收集类型的stream中间操作，但是与map不同的是，它可以对stream流中单个元素再进行拆分（切片），从另一种角度上说，使用了它，就是使用了双重for循环。）

// map 生成的是个 1:1 映射，每个输入元素，都按照规则转换成为另外一个元素。还有一些场景，是一对多映射关系的，这时需要 flatMap String[] strs = {"java8", "is", "easy", "to", "use"}; List< String[]> distinctStrs = Arrays.stream(strs) .map(str -> str.split(""))// 映射成为Stream< String[]> .distinct().collect(Collectors.toList()); //distinct操作是以 “字符串数组“为单元进行去重 /* 在执行map操作以后，我们得到是一个包含多个字符串数组的流，打印结果如下所示 [j, a, v, a, 8] [i, s] [e, a, s, y] [t, o] [u, s, e] */List< String> distinctStr = Arrays.stream(strs) .map(str -> str.split("")) // 映射成为Stream< String[]> .flatMap(Arrays::stream)// 扁平化为Stream< String> .distinct().collect(Collectors.toList()); /* flatMap将由map映射得到的Stream< String[]> ，转换成由各个字符串数组映射成的流Stream< String> ，再将这些小的流扁平化成为一个由所有字符串构成的大流Steam< String> ，从而能够达到我们的目的。打印结果： [j, a, v, 8, i, s, e, y, t, o, u] */

6、Stream< T> limit(long maxSize)
（说明: 返回此流中的元素组成的流,截取前指定参数个数的数据）

List< String> limitList = Arrays.asList("景天", "雪见", "长卿", "紫萱"); //取前3个数据在控制台输出 limitList.stream().limit(3).forEach(System.out::println); //打印结果:["景天", "雪见", "长卿"]

7、Stream< T> skip(long n)
（说明: 跳过指定参数个数的数据,返回由该流的剩余元素组成的流）

//跳过3个元素,把剩下的元素在控制台输出 List< String> list = Arrays.asList("景天", "雪见", "长卿", "紫萱"); list.stream().skip(3).forEach(System.out::println); //打印结果:["紫萱"]

8、static < T> Stream< T> concat(Stream a, Stream b)
（说明: 合并a和b两个流为一个流）

List< String> concatList1 = Arrays.asList("景天", "雪见", "长卿", "紫萱"); List< String> concatList2 = Arrays.asList("重楼", "茂茂", "必平", "龙葵"); Stream< String> stream1 = concatList1.stream(); Stream< String> stream2 = concatList2.stream(); Stream.concat(stream1, stream2).forEach(System.out::println); // 打印结果: ["景天", "雪见", "长卿", "紫萱","重楼", "茂茂", "必平", "龙葵"]

9、Stream< T> distinct()
（说明:对流中相同的元素进行去重处理）

List< String> distinctList = Arrays.asList("景天", "雪见", "长卿", "紫萱", "紫萱", "雪见"); distinctList.stream().distinct().forEach(System.out::println); // 打印结果: ["景天", "雪见", "长卿", "紫萱"]

10、Stream< T> sorted()
（说明:返回由此流的元素组成的流,根据自然顺序排序）

//题目: 按照字母顺序把数据在控制台输出 sorted()是正序 List< String> sortList = Arrays.asList("Lucy", "Jack", "Anny", "Vincent", "Charles","William"); sortList.stream().sorted().forEach(System.out::println); //打印结果: [Anny,Charles,Jack,Lucy，Vincent，William] //题目: 按照名称长度顺序从短到长把数据在控制台输出 sortList.stream().sorted(Comparator.comparingInt(String::length)) .forEach(System.out::println); //打印结果:[Lucy,Jack,Anny,Vincent,Charles,William]

11、Stream< E> parallelStream()
（说明: 并行的操作,多线程执行，在大数据量下会优于 stream()， parallelStream()的底层思想是ForkJoinPool主要用来使用分治法(Divide-and-Conquer Algorithm)来解决问题）

List< String> stringList = new ArrayList< > (); for (int i = 0; i < 10; i++) { stringList.add("第" + i + "条数据"); } long parallelStreamNowTime = System.currentTimeMillis(); stringList.parallelStream().forEach(s -> { try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } }); long parallelStreamTime = System.currentTimeMillis(); System.out.println("Stream需要时间" + (parallelStreamTime - parallelStreamNowTime)); //打印结果:Stream需要时间2027

?PS：除了直接创建并行流，还可以通过parallel()把顺序流转换成并行流

Optional< Integer> findFirst = list.stream().parallel().filter(x-> x> 6).findFirst();

12、count()
(说明: 返回集合流中元素的个数)

List< String> countList = Arrays.asList("Lucy", "Jack", "Anny", "Vincent","Charles", "William","William"); long count1 = countList.stream().count(); System.out.println("总元素个数是:"+count1); // 打印结果 : 总元素个数是:7 long count2 = countList.stream().distinct().count(); System.out.println("去重之后元素个数是:"+count2); // 打印结果 : 去重之后元素个数是:6

13、boolean allMatch(Predicate predicate)
(说明:allMatch表示，判断条件里的元素，所有的元素都满足条件，就返回true)

List< Integer> integerList= Arrays.asList(1,2,3,4,5); if(integerList.stream().allMatch(i-> i> 3)){ System.out.println( "值都大于3"); }

14、boolean anyMatch(Predicate predicate)
(说明:anyMatch表示，判断的条件里，任意一个元素符合条件，就返回true)

List< Integer> integerList= Arrays.asList(1,2,3,4,5); if(integerList.stream().anyMatch(i-> i> 3)){ System.out.println( "存在大于3的值"); }

15、boolean noneMatch(Predicate predicate)
（说明: noneMatch跟allMatch相反，判断条件里的元素，所有的都不符合条件，才返回true）

List< Integer> integerList= Arrays.asList(1,2,3,4,5); if(integerList.stream().noneMatch(i -> i > 3)){ System.out.println("值都小于3"); }

14、A[] toArray(IntFunction< A[]> generator);
(说明: 使用提供的 generator函数返回一个包含此流的元素的数组，以分配返回的数组，以及分区执行或调整大小可能需要的任何其他数组。)
15、Stream concat(Stream a,b)
（说明：合并2个stream流）

List< String> strings = Arrays.asList("abc", "def", "gkh", "abc"); //concat 合并流 List< String> strings2 = Arrays.asList("xyz", "jqx"); List< String> concatList = Stream.concat(strings2.stream(),strings.stream()) .collect(Collectors.toList()); System.out.println(concatList); //打印结果: [xyz, jqx, abc, def, gkh, abc]

16、IntSummaryStatistics summaryStatistics()
（说明:对stream流中的数据进行统计分析）

//对数组的统计，比如用 List< Integer> number = Arrays.asList(1, 2, 5, 4); IntSummaryStatistics statistics = number.stream().mapToInt((x) -> x).summaryStatistics(); System.out.println("列表中最大的数 : "+statistics.getMax()); System.out.println("列表中最小的数 : "+statistics.getMin()); System.out.println("平均数 : "+statistics.getAverage()); System.out.println("所有数之和 : "+statistics.getSum());

17、Optional< T> findAny()
（说明：findAny()操作，返回的元素是不确定的，对于同一个列表多次调用findAny() 有可能会返回不同的值。使用findAny()是为了更高效的性能。
①串行流情况下，一般会返回符合条件的第一个结果；

List< String> list1 = Arrays.asList("A1", "B1", "C1", "A2", "B2", "C2", "A3", "B3","C3"); for(int i=0; i< 10; i++) { Optional< String> c = list1.stream().filter(s -> s.contains("A")).findAny(); System.out.println("====串行流findAny()======" + c.get()); } //打印结果: //====串行流findAny()======A1 //====串行流findAny()======A1 //====串行流findAny()======A1 //====串行流findAny()======A1 //====串行流findAny()======A1 //====串行流findAny()======A1 //====串行流findAny()======A1 //====串行流findAny()======A1 //====串行流findAny()======A1 //====串行流findAny()======A1

②并行流的情况，在给定的元素中随机取一个元素，那就不能确保是第一个。）

List< String> list1 = Arrays.asList("A1", "B1", "C1", "A2", "B2", "C2", "A3", "B3","C3"); Optional< String> a = list1.parallelStream().filter(s -> s.contains("A")).findAny(); System.out.println("====findAny()======" + a.get()); //打印结果:每次执行打印的是A1或者A2或者A3中任意一个 // ====并行流findAny()======A3 // ====并行流findAny()======A3 // ====并行流findAny()======A2 // ====并行流findAny()======A1 // ====并行流findAny()======A1 // ====并行流findAny()======A2 // ====并行流findAny()======A3 // ====并行流findAny()======A3 // ====并行流findAny()======A3 // ====并行流findAny()======A2

18、Optional< T> findFirst()
(说明：返回Stream中的第一个元素)

List< String> list2 = Arrays.asList("A1", "B1", "C1", "A2", "B2", "C2", "A3", "B3","C3"); Optional< String> b = list2.parallelStream().filter(s -> s.contains("B")).findFirst(); System.out.println("====findFirst()====" + b.get()); // 打印结果:====findFirst()====B1

19、Optional< T> max(Comparator comparator)
(说明：返回比较器比较之后结果最大的那个元素)

//获取String集合中最长的元素。 List< String> maxList = Arrays.asList("Lucy", "Jack", "Anny", "Vincent","Charles","William"); Optional< String> max = maxList.stream(). max(Comparator.comparing(String::length)); System.out.println("最长的字符串:" + max.get()); //打印结果: 最长的字符串:Vincent

PS:Optional< T> min(Comparator< ? super T> comparator) 也是类似的，我就不多说了！
20、Optional< T> reduce(BinaryOperator accumulator)
(说明:根据指定的计算模型将Stream中的值计算得到一个最终结果)

List< Integer> reduceList = Arrays.asList(1, 3, 2, 8, 11, 4); // 求和方式1 Optional< Integer> sum = reduceList.stream().reduce((x, y) -> x + y); // 求和方式2 Optional< Integer> sum2 = reduceList.stream().reduce(Integer::sum); // 求和方式3 Integer sum3 = reduceList.stream().reduce(0, Integer::sum); // 求乘积 Optional< Integer> product = reduceList.stream().reduce((x, y) -> x * y); // 求最大值方式1 Optional< Integer> max2 = reduceList.stream().reduce((x, y) -> x > y ? x : y); // 求最大值写法2 Integer max3 = reduceList.stream().reduce(1, Integer::max); System.out.println("list求和：" + sum.get() + "," + sum2.get() + "," + sum3); //打印结果:list求和：29,29,29 System.out.println("list求积：" + product.get()); //打印结果:list求积：2112 System.out.println("list求最大值：" + max2.get() + "," + max3); //打印结果: list求最大值：11,11

二、List转String

// 如何把list集合拼接成以逗号分隔的字符串 a,b,c List< String> list = Arrays.asList("a", "b", "c"); // 第一种方法，可以用stream流 String join = list.stream().collect(Collectors.joining(",")); System.out.println(join); // 输出 a,b,c // 第二种方法，其实String也有join方法可以实现这个功能,合并数组为单一字符串，可传分隔符 String join1 = String.join(",", list); System.out.println(join1); // 输出 a,b,c

三、玩转StringUtils工具类

String str = "I love JavaAlliance forever"; // 1、删除字符串中指定字符，返回一个string String remove = StringUtils.remove(str, "forever"); // 移除字符串中的 forever System.out.println(remove); // 打印结果是I love JavaAlliance// 2、将字符串反转，返回一个string String reverse = StringUtils.reverse(str); System.out.println(reverse); // 打印结果是reverof ecnaillAavaJ evol I// 3、比较两个字符串是否相等,如果两个均为null，则也认为相等 StringUtils.equals("Java", "Java"); // 结果是true StringUtils.equals("", ""); // 结果是true StringUtils.equals(null, null); // 结果是true StringUtils.equals(null, ""); // 结果是false StringUtils.equals("", null); // 结果是false StringUtils.equals(null, ""); // 结果是false StringUtils.equalsIgnoreCase("java", "JAVA"); // 不区分大小写--结果是true// 4、重复拼接字符串 String str1 = StringUtils.repeat("ab", 2); System.out.println(str1); // 输出abab// 5、首字母转成大写 String str2 = "javaAlliance"; String capitalize = StringUtils.capitalize(str2); System.out.println(capitalize); // 输出JavaAlliance// 6、字符串固定长度填充 StringUtils.leftPad("test", 8, "0"); // 字符串固定长度 8位，若不足，往左补 0 StringUtils.rightPad("test", 8, "0"); // 字符串固定长度 8位，若不足，往右补 0// 7、字符串关键字替换 StringUtils.replace("aba", "a", "z")= "zbz"; // 默认替换所有关键字 StringUtils.replaceOnce("aba", "a", "z")= "zba"; // 替换关键字，仅替换一次 StringUtils.replacePattern("ABCabc123", "[^A-Z0-9]+", "")= "ABC123"; // 使用正则表达式替换// 8、将数组拼接成字符串 StringUtils.join(["a", "b", "c"], ",") ; //拼接结果是"a,b,c"// 9、字符串拆分 StringUtils.split("a..b.c", .)//拆分结果是 ["a", "b", "c"] StringUtils.splitByWholeSeparatorPreserveAllTokens("a..b.c", ".")//拆分结果是 ["a","", "b", "c"]

四、玩转BeanUtils工具类

User user = new User(); user.setUserName("JavaAlliance").setEmail("196432@qq.com"); // 对象转map Map< String, String> map = BeanUtils.describe(user); System.out.println(map); // 输出 // map转对象 User newUser = new User(); BeanUtils.populate(newUser, map); System.out.println(newUser); // 输出

五、玩转DateUtils/DateFormatUtils工具类

// Date类型转String类型 String date = DateFormatUtils.format(new Date(), "yyyy-MM-dd HH:mm:ss"); System.out.println(date); // 输出 2021-05-01 01:01:01// String类型转Date类型该方法会将日期字符串按照第二参数中的String数组，依次比对，选择合适的Pattern来解析。 Date date1 = DateUtils.parseDate("2021-05-01 01:01:01", new String[]{"yyyy-MM-dd HH:mm:ss"}); Date now = new Date(); // Date 加 1 天 Date addDays = DateUtils.addDays(now, 1); // Date 加 33 分钟 Date addMinutes = DateUtils.addMinutes(now, 33); // Date 减去 233 秒 Date addSeconds = DateUtils.addSeconds(now, -233); // 判断是否 Wie 同一天 boolean sameDay = DateUtils.isSameDay(addDays, addMinutes); // 过滤时分秒,若 now 为 2020-05-07 22:13:00 调用 truncate 方法以后 // 返回时间为 2020-05-07 00:00:00 Date truncate = DateUtils.truncate(now, Calendar.DATE);

六、玩转LocalDateTime工具类

Date now = new Date(); // Date转成LocalDateTime 这里指定使用当前系统默认时区 LocalDateTime localDateTime = now.toInstant().atZone(ZoneId.systemDefault()) .toLocalDateTime(); // LocalDateTime转成Date 这里指定使用当前系统默认时区 Date date = Date.from(localDateTime.atZone(ZoneId.systemDefault()).toInstant()); // 按照 yyyy-MM-dd HH:mm:ss 转化时间 LocalDateTime dateTime = LocalDateTime.parse("2020-05-07 22:34:00", DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")); // 将 LocalDateTime 格式化字符串 String format = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss").format(dateTime); //LocalDateTime 获取当前时间年份，月份 LocalDateTime now = LocalDateTime.now(); // 年 int year = now.getYear(); // 月 int month = now.getMonthValue(); // 日 int day = now.getDayOfMonth(); // LocalDateTime 进行日期加减，获取下一天的时间 LocalDateTime now = LocalDateTime.now(); // 当前时间加一天 LocalDateTime plusDays = now.plusDays(1l); // 当前时间减一个小时 LocalDateTime minusHours = now.minusHours(1l); // 还有很多其他方法

七、玩转CollectionUtils工具类

String[] arrayA = new String[]{"1", "2", "3", "4"}; String[] arrayB = new String[]{"3", "4", "5", "6"}; List< String> listA = Arrays.asList(arrayA); List< String> listB = Arrays.asList(arrayB); // 1、并集 union System.out.println(CollectionUtils.union(listA, listB)); // 输出: [1, 2, 3, 4, 5, 6]// 2、交集 intersection System.out.println(CollectionUtils.intersection(listA, listB)); // 输出:[3, 4]// 3、交集的补集（析取）disjunction System.out.println(CollectionUtils.disjunction(listA, listB)); // 输出:[1, 2, 5, 6]// 4、差集（扣除） System.out.println(CollectionUtils.subtract(listA, listB)); // 输出:[1, 2]// 1、交集 List< String> intersectionList = new ArrayList< > (listA); intersectionList.retainAll(listB); System.out.println(intersectionList); // 输出:[3, 4] // 2、差集 List< String> differenceList = new ArrayList< > (listA); differenceList.removeAll(listB); System.out.println(differenceList); // 输出:[1, 2]// 3、并集 (先做差集再做添加所有） List< String> unionList = new ArrayList< > (listA); unionList.removeAll(listB); // unionList [1, 2] unionList.addAll(listB); // 添加[3,4,5,6] System.out.println(unionList); // 输出:[1, 2, 3, 4, 5, 6]

注意 : 以上有2种取交集的方式即intersection和retainAll，我们这里说下它们之间的差别 ,要注意的是它们的返回类型是不一样的,intersection返回的是一个新的List集合，而retainAll返回是Bollean类型那就说明retainAll方法是对原有集合进行处理再返回原有集合,会改变原有集合中的内容。
思路点拨：
1、从性能角度来考虑的话,List自带会高点,因为它不用再创建新的集合。
2、需要注意的是：因为retainAll因为会改变原有集合,所以该集合需要多次使用就不适合用retainAll。
注意: 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没有重新，所以会抛出异常。
八、玩转 Guava工具包 1、Multiset
Multiset是什么？顾名思义，Multiset和Set的区别就是可以保存多个相同的对象。在JDK中，List和Set有一个基本的区别，就是List可以包含多个相同对象，且是有顺序的，而Set不能有重复，且不保证顺序（有些实现有顺序，例如LinkedHashSet和SortedSet等）< font color=red> 所以Multiset占据了List和Set之间的一个灰色地带：允许重复，但是不保证顺序。 < /font>
常见使用场景：Multiset有一个有用的功能，就是跟踪每种对象的数量，所以你可以用来进行数字统计。常见的普通实现方式如下：

String str = "张三李四李四王五王五王五"; String[] strArr = str.split(" "); List< String> words = new ArrayList< > (Arrays.asList(strArr)); //创建一个HashMultiset集合，并将words集合数据放入 Multiset< String> wordMultiset = HashMultiset.create(); wordMultiset.addAll(words); //将不同的元素放在一个集合set中 for (String key : wordMultiset.elementSet()) { //查看指定元素的个数 System.out.println(key + "--> " + wordMultiset.count(key)); //打印结果:李四--> 2张三--> 1王五--> 3 }

2、Multimap
Multimap能够实现一个键对应到多个值的效果

Multimap< String, String> myMultimap = ArrayListMultimap.create(); myMultimap.put("Fruits", "Bannana"); myMultimap.put("Fruits", "Apple"); myMultimap.put("Fruits", "Pear"); myMultimap.put("Fruits", "Pear"); myMultimap.put("Vegetables", "Carrot"); // 查询Multimap中的存储的元素个数 System.out.println(myMultimap.size()); // 打印结果: 5//查询键为“Fruits”所对应的value Collection< String> fruits = myMultimap.get("Fruits"); System.out.println(fruits); //打印结果:[Bannana, Apple, Pear, Pear] Collection< String> vegetables = myMultimap.get("Vegetables"); System.out.println(vegetables); //打印结果: [Carrot]// 循环迭代遍历整个 Multimap里存储的value值 for (String value : myMultimap.values()) { System.out.println(value); //打印结果: //Carrot //Bannana //Apple //Pear //Pear }//移除其中一个元素 myMultimap.remove("Fruits", "Pear"); System.out.println(myMultimap.get("Fruits")); //打印结果: [Bannana, Apple, Pear]//将键为"Fruits"所对应的value内容替换为集合Arrays.asList("178","910","123") //返回的oldValues是之前的旧值 Collection< String> oldValues = myMultimap.replaceValues("Fruits", Arrays.asList("178","910","123")); System.out.println("oldValues="+oldValues); //打印结果: oldValues=[Bannana, Apple, Pear] System.out.println("myMultimap="+myMultimap); //打印结果: myMultimap={Vegetables=[Carrot], Fruits=[178, 910,123]}//移除Multimap中键为“Fruits”的所有元素 myMultimap.removeAll("Fruits"); System.out.println(myMultimap.get("Fruits")); //打印结果: []

3、BiMap
BiMap 可以用来实现键值对的双向映射需求，这样我们就可以通过 Key 查找对对应的 Value，也可以使用 Value 查找对应的 Key。Bimap要求key和value都唯一，如果key不唯一则覆盖key，如果value不唯一则直接报错

//双向map BiMap< Integer,String> biMap=HashBiMap.create(); biMap.put(1,"张三"); biMap.put(2,"李四"); biMap.put(3,"王五"); biMap.put(4,"赵六"); biMap.put(5,"李七"); biMap.put(4,"小小"); //通过key值得到value值(注意key里面的类型根据泛行 String value= https://www.songbingjia.com/android/biMap.get(1); System.out.println("id为1的value值 --"+value); //打印结果: id为1的value值 --张三//通过value值得到key值 int key= biMap.inverse().get("张三"); System.out.println("value为张三的key值 --"+key); //打印结果: value为张三的key值 --1//通过key值重复，那么vakue值会被覆盖。 String valuename= biMap.get(4); System.out.println("id为4的value值 --"+valuename); //打印结果: id为4的value值 --小小

BiMap的常用实现有：
?1、HashBiMap: key 集合与 value 集合都有 HashMap 实现
?2、EnumBiMap: key 与 value 都必须是 enum 类型
?3、ImmutableBiMap: 不可修改的 BiMap
九、玩转FileUtils-文件操作工具类文件操作工具类提供一系列方法，可以让我们快速读取写入文件。
快速实现文件/文件夹拷贝操作 ,FileUtils.copyDirectory/FileUtils.copyFile
1、获取指定文件夹上所有文件

// 按照指定文件后缀如java,txt等去查找指定文件夹下的文件 File directory = new File("E:\\\\test"); FileUtils.listFiles(directory, new String[]{"txt"}, false);

2、读取该文件所有行

// 读取指定文件所有行不需要使用 while 循环读取流了 List< String> lines = FileUtils.readLines(fileA)

3、写文件

// 1、向一个文件写入一段文字 FileUtils.write(new File("D:/a/1.txt"), "文件内容", "UTF-8", true); // 2、以追加的方式写入 FileUtils.writeStringToFile(new File("D:/a/1.txt"), "author：apple", "UTF-8", true); //3、写入多行 List< String> list= new ArrayList< String> (); list.add("第一行"); list.add("第二行"); FileUtils.writeLines(new File("D:/a/1.txt"), list, true);

4、读文件

//读文件 System.out.println(FileUtils.readFileToString(new File("D:/a/1.txt"), "UTF-8")); //返回一个list System.out.println(FileUtils.readLines(new File("D:/a/1.txt"), "UTF-8"));

5、删除文件/文件夹

// 删除文件夹 FileUtils.deleteDirectory(new File("D:/a")); // 文件夹不是空仍然可以被删除，永远不会抛出异常 FileUtils.deleteQuietly(new File("D:/a"));

6、复制文件

//结果是a和a1在同一目录 FileUtils.copyDirectory(new File("D:/a"), new File("D:/a1")); //结果是将a拷贝到a2下 FileUtils.copyDirectoryToDirectory(new File("D:/a"), new File("D:/a2")); //拷贝文件方式1 FileUtils.copyFile(new File("d:/1.xml"), new File("d:/1.xml.bak")); //拷贝文件方式2 Writer write = new FileWriter("D：/abc_bak.txt"); InputStream ins = new FileInputStream(new File("D：/abc.txt")); IOUtils.copy(ins, write); write.close(); IOUtils.closeQuietly(ins); //拷贝文件到目录中 FileUtils.copyFileToDirectory(new File("d:/1.xml"), new File("d:/a")); //拷贝url到文件 FileUtils.copyURLToFile(new URL("http://www.a.com/1.xml"), new File("d:/1.xml")); //可实现快速下载 URL url = new URL("http://hzf-image-test.oss-cn-beijing.aliyuncs.com/hr_image/HF306268301810/1513632067664AbIB40pv_defalut.JPG?x-oss-process=image/resize,h_400"); File file = new File("/Users/jjs/Desktop/pic.jpg"); FileUtils.copyURLToFile(url, file);

7、移动文件

//移动文件或文件夹 //static void moveDirectory(File srcDir, File destDir) FileUtils.moveDirectory(new File("D:/a1"), new File("D:/a2")); //注意这里第二个参数文件不存在会引发异常//static void moveDirectoryToDirectory(File src, File destDir, boolean createDestDir) FileUtils.moveDirectoryToDirectory(new File("D:/a2"), new File("D:/a3"), true); /* 上面两个方法的不同是： * moveDirectory：D:/a2里的内容是D:/a1的内容。 * moveDirectoryToDirectory：D:/a2文件夹移动到到D:/a3里 */

8、实现快速下载文件

//下载方式1 URL url = new URL("http://www.baidu.com/img/baidu_logo.gif"); File file = new File("/Users/jjs/Desktop/baidu1.gif"); FileUtils.copyURLToFile(url, file); //下载方式2 InputStream in = new URL("http://www.baidu.com/img/baidu_logo.gif").openStream(); byte[] gif = IOUtils.toByteArray(in); FileUtils.writeByteArrayToFile(new File("D：/baidu2.gif"), gif); IOUtils.closeQuietly(in); //下载方式3 InputStream in3 = new URL("http://www.baidu.com/img/baidu_logo.gif").openStream(); byte[] gif3 = IOUtils.toByteArray(in3); IOUtils.write(gif3, new FileOutputStream(new File("D：/baidu3.gif"))); IOUtils.closeQuietly(in3);

专注Java技术进阶，系统设计，计算机网络，数据结构算法，操作系统，设计模式，计算机组成原理等等更多精彩内容，尽情期待