当前位置：首页 > article >正文

工具篇之Apache Commons

article 2024/11/20 21:24:07

一、简介

概述

Apache Commons包是Java中使用最广泛的工具包，它提供了常用的一些编程需要的工具类。
Commons Collections增强了Java集合框架。

Commons简介

Apache Commons库包含了许多子项目，每个子项目都专注于特定的功能领域。例如：

Commons Lang：增强Java核心类库的功能。
Commons IO：简化文件和流的操作。
Commons Collections：扩展Java集合框架。
Commons Codec：提供常用的编解码功能（如Base64、Hex等）。
Commons BeanUtils：简化Java Bean的操作。

组件	功能介绍
commons-beanutils	提供了对于JavaBean进行各种操作，克隆对象,属性等等.
commons-betwixt	XML与Java对象之间相互转换.
commons-codec	处理常用的编码方法的工具类包例如DES、SHA1、MD5、Base64等.
commons-collections	java集合框架操作.
commons-compress	java提供文件打包压缩类库.
commons-configuration	一个java应用程序的配置管理类库.
commons-dbcp	提供数据库连接池服务.
commons-dbutils	提供对jdbc 的操作封装来简化数据查询和记录读取操作.
commons-email	java发送邮件对javamail的封装.
commons-fileupload	提供文件上传功能.
commons-httpclient	提供HTTP客户端与服务器的各种通讯操作. 现在已改成HttpComponents
commons-io	io工具的封装.
commons-lang	Java基本对象方法的工具类包如：StringUtils,ArrayUtils,DateUtils,DateFormatUtils等等.
commons-logging	提供的是一个Java 的日志接口.
commons-validator	提供了客户端和服务器端的数据验证框架.

二、演示demo

commons-lang介绍

org.apache.commons.lang3这个包下提供了很多有用的包含static方法的Util类：

ArrayUtils：用于对数组的操作，如添加、查找、删除、子数组、倒序、元素类型转换等；
BitField：用于操作位元，提供了一些方便而安全的方法；
BooleanUtils：用于操作和转换 boolean 或者 Boolean 及相应的数组；
CharEncoding：包含了 Java 环境支持的字符编码，提供是否支持某种编码的判断；
CharRange：用于设定字符范围并做相应检查；
CharSet：用于设定一组字符作为范围并做相应检查；
CharSetUtils：用于操作 CharSet ；
CharUtils：用于操作 char 值和 Character 对象；
ClassUtils：用于对 Java 类的操作，不使用反射；
ObjectUtils：用于操作 Java 对象，提供 null 安全的访问和其他一些功能；
RandomStringUtils：用于生成随机的字符串；
SerializationUtils：用于处理对象序列化，提供比一般 Java 序列化更高级的处理能力；
StringEscapeUtils：用于正确处理转义字符，产生正确的 Java 、 JavaScript 、 HTML 、 XML和 SQL 代码；
StringUtils：处理 String 的核心类，提供了相当多的功能；
SystemUtils：在 java.lang.System 基础上提供更方便的访问，如用户路径、 Java 版本、时区、操作系统等判断；
Validate：提供验证的操作，有点类似 assert 断言；
WordUtils：用于处理单词大小写、换行等。

maven依赖

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

StringUtils

ArrayUtils

        //创建数组
        String[] array = ArrayUtils.toArray("1", "2");
        //判断两个数据是否相等，如果内容相同， 顺序相同 则返回 true
        ArrayUtils.isEquals(arr1,arr2);
        //判断数组中是否包含某一对象
        ArrayUtils.contains(arr, "33");
        //二维数组转换成MAP
        Map map = ArrayUtils.toMap(new String[][] { 
                { "RED", "#FF0000" }, { "GREEN", "#00FF00" }, { "BLUE", "#0000FF" } });

BooleanUtils

ClassUtils

RandomStringUtils

        //随机生成n位数数字
        RandomStringUtils.randomNumeric(n);
        //在指定字符串中生成长度为n的随机字符串
        RandomStringUtils.random(n, "abcdefghijk");
        //指定从字符或数字中生成随机字符串
        System.out.println(RandomStringUtils.random(n, true, false));  
        System.out.println(RandomStringUtils.random(n, false, true));

NumberUtils

       //从数组中选出最大值
        NumberUtils.max(new int[] { 1, 2, 3, 4 });//---4
        //判断字符串是否全是整数
        NumberUtils.isDigits("153.4");//--false
        //判断字符串是否是有效数字
        NumberUtils.isNumber("0321.1");//---false    
 // 找出最大值
        System.out.println(NumberUtils.max(1, 2, 3, 4)); // 输出 4

DateUtils

// 创建一个表示当前时间的 Date 对象
        Date currentDate = new Date();

        // 设置源时区和目标时区
        TimeZone sourceTimeZone = TimeZone.getTimeZone("UTC");
        TimeZone targetTimeZone = TimeZone.getTimeZone("Asia/Shanghai");

        // 计算两个时区之间的毫秒差
        int timeDifference = targetTimeZone.getRawOffset() - sourceTimeZone.getRawOffset();

        // 使用 DateUtils 的 truncate 方法截断日期到天，然后使用 add 方法添加时区差
        Date convertedDate = DateUtils.addMilliseconds(DateUtils.truncate(currentDate, Calendar.DAY_OF_MONTH), timeDifference);

        System.out.println("原始日期： " + currentDate);
        System.out.println("转换后的日期： " + convertedDate);

commons-collections4介绍

在Java开发中，集合框架是一个非常重要的组成部分。Apache Commons Collections 提供了大量的集合类和实用工具，扩展了Java标准库的功能，使得集合操作更加高效和便捷。

commons Collections 包含了一组丰富的集合实现和工具类，例如：

新的集合类型（如 Bag、MultiMap、BidiMap）
高效的集合操作工具
强大的集合装饰器

maven依赖

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

Bag

Bag 是一种集合类型，它允许重复元素，并可以统计每个元素的出现次数。

import org.apache.commons.collections4.Bag;
import org.apache.commons.collections4.bag.HashBag;

public class BagExample {
    public static void main(String[] args) {
        Bag<String> bag = new HashBag<>();

        // 添加元素
        bag.add("apple", 3);
        bag.add("banana", 2);

        // 获取元素出现次数
        System.out.println("Apple count: " + bag.getCount("apple")); // 输出 3
        System.out.println("Banana count: " + bag.getCount("banana")); // 输出 2

        // 移除元素
        bag.remove("apple", 1);
        System.out.println("Apple count after removal: " + bag.getCount("apple")); // 输出 2
    }
}

HashBag

HashBag使用HashMap作为数据存储，是一个标准的Bag实现。

TreeBag

TreeBag使用TreeMap作为数据存储，用法与HashBag类似，只是TreeBag会使用自然顺序对元素进行排序。

总结

使用的方式和List差不多，效果也大同小异。

场景：比如我们需要具体知道每个元素出现的次数的时候，并且实现快速去重，使用Bag会非常便捷

对应的BagUtils，能提供BagUtils.EMPTY_BAG、synchronizedBag、unmodifiableBag等编程同步、只读的快捷方法

MultiMap

MultiMap 是一种映射类型，它允许一个键对应多个值。

size(): 返回MultiMap中键的数量。
isEmpty(): 检查MultiMap是否为空。
put(K key, V value): 将指定的值添加到与指定键关联的集合中。
remove(Object key, Object value): 从与指定键关联的集合中移除指定的值。
removeAll(Object key): 移除与指定键关联的所有值。
clear(): 移除所有键和值。
keySet(): 返回包含MultiMap中所有键的集合。
values(): 返回包含MultiMap中所有值的集合。
entrySet(): 返回包含MultiMap中所有键值对的集合。
containsKey(Object key): 检查MultiMap是否包含指定的键。
containsValue(Object value): 检查MultiMap是否包含指定的值。
get(Object key): 返回与指定键关联的值的集合。
putAll(K key, Iterable<? extends V> values): 将指定的值集合添加到与指定键关联的集合中。
putAll(Multimap<? extends K,? extends V> multimap): 将另一个MultiMap的所有键值对添加到当前MultiMap中。
removeAll(Object key, Iterable<?> values): 从与指定键关联的集合中移除指定的值集合。
retainAll(Object key, Iterable<?> values): 保留与指定键关联的集合中同时存在于指定值集合中的值。
replaceValues(K key, Iterable<? extends V> values): 用指定的值集合替换与指定键关联的集合。
count(Object key): 返回与指定键关联的值的数量。
equals(Object o): 比较两个MultiMap是否相等。
hashCode(): 返回MultiMap的哈希码。

 public static void main(String[] args) {
        MultiValuedMap<String, String> multiMap = new ArrayListValuedHashMap<>();

        // 添加元素
        multiMap.put("fruit", "apple");
        multiMap.put("fruit", "banana");

        // 获取元素
        System.out.println("Fruit values: " + multiMap.get("fruit")); // 输出 [apple, banana]

        // 遍历 MultiMap
        // 遍历 MultiMap
        for (Map.Entry<String, Collection<String>> entry : multiMap.asMap().entrySet()) {
            String key = entry.getKey();
            Collection<String> values = entry.getValue();
            System.out.println("Key: " + key);
            for (String value : values) {
                System.out.println("Value: " + value);
            }
        }

        // 移除元素
        multiMap.removeMapping("fruit", "apple");
        System.out.println("Fruit values after removal: " + multiMap.get("fruit")); // 输出 [banana]
    }

MultiKeyMap：多键Map

MultiKeyMap能够解决我们平时可能遇到的一个痛点。

比如我们Map的key，可能是由多个字段的值联合决定的（有点类似联合索引的意思），这个时候我们一般方案为：自己拼接字符串，然后put进去。

但现在有了MultiKeyMap，我们可以非常优雅的解决这个问题：

     public static void main(String[] args) {
        // MultiKey功能很简单：装载多个key的一个对象
        MultiKey<String> multiKey = new MultiKey<>("a", "b");
        System.out.println(multiKey); //MultiKey[a, b]


        MultiKeyMap<String, String> multiKeyMap = new MultiKeyMap();

        // 多个键对应一个值 两个key：name和NAME
        multiKeyMap.put("name", "NAME", "jianggujin");
        System.out.println(multiKeyMap); //{MultiKey[name, NAME]=jianggujin}
        System.out.println(multiKeyMap.get("name")); //null
        System.out.println(multiKeyMap.get("NAME")); //null
        System.out.println(multiKeyMap.get("name", "NAME")); //jianggujin

        //测试key覆盖
        multiKeyMap.put("name", "shixiang", "cover");
        System.out.println(multiKeyMap); //{MultiKey[name, shixiang]=cover, MultiKey[name, NAME]=jianggujin}

        //这样子  value值才会被覆盖
        multiKeyMap.put("name", "NAME", "cover");
        System.out.println(multiKeyMap); //{MultiKey[name, shixiang]=cover, MultiKey[name, NAME]=cover}
    }

MultiValuedMap：多值Map

一个key可对应多个值，内部的数据结构逻辑交给它去维护。

我们平时使用的Map<String,List<Long>>这种数据结构，就可以被这种代替，使用起来非常方便

ArrayListValuedHashMap 见名之意，values采用ArrayList来存储

HashSetValuedHashMap 基本用法同上，但是很显然values用set去存储。那就无序，但是去重了

    public static void main(String[] args) {
        MultiValuedMap<String, String> map = new ArrayListValuedHashMap<>();

        map.put("key1", "value1");
        System.out.println(map); //{key1=[value1]}
        map.put("key1", "value11111");
        System.out.println(map); //{key1=[value1, value11111]}

        Collection<String> values = map.values();
        System.out.println(values); //[value1, value11111]

        //map.remove("key1");
        //System.out.println(map); //{}

        //强悍 可以直接干掉values里的某一个值
        map.removeMapping("key1", "value1");
        System.out.println(map); //{key1=[value11111]}

        //一次性放多个value
        map.putAll("key2", Arrays.asList("fang", "shi", "xiang"));
        System.out.println(map); //{key1=[value11111], key2=[fang, shi, xiang]}

		 //get方法  返回List
        Collection<String> collection = map.get("key2");
        MultiSet<String> keys = map.keys();
        Set<String> strings = map.keySet();
        System.out.println(keys); //[key1:1, key2:3] //后面的数字表示对应的value的数量
        System.out.println(strings); //[key1, key2]
        System.out.println(map.size()); //4 注意此处的size,是所有value的size 不是key的
        System.out.println(collection); //[fang, shi, xiang]

    }

BidiMap

BidiMap 是一种双向映射类型，它可以通过键找到值，也可以通过值找到键。

size(): 返回BidiMap中键值对的数量。
isEmpty(): 检查BidiMap是否为空。
put(K key, V value): 将指定的键值对添加到BidiMap中。
remove(Object key): 从BidiMap中移除指定键的键值对。
getKey(V value): 根据给定的值返回对应的键。
getValue(K key): 根据给定的键返回对应的值。
containsKey(Object key): 检查BidiMap是否包含指定的键。
containsValue(Object value): 检查BidiMap是否包含指定的值。
clear(): 移除BidiMap中的所有键值对。
keySet(): 返回BidiMap中所有键的集合。
values(): 返回BidiMap中所有值的集合。
entrySet(): 返回BidiMap中所有键值对的集合。
inverseBidiMap(): 返回一个新的BidiMap，其中原始BidiMap中的键和值互换。

 public static void main(String[] args) {
        BidiMap<String, Integer> bidiMap = new TreeBidiMap<>();

        // 添加元素
        bidiMap.put("one", 1);
        bidiMap.put("two", 2);

        // 通过键获取值
        System.out.println("Value for 'one': " + bidiMap.get("one")); // 输出 1

        // 通过值获取键
        System.out.println("Key for value 1: " + bidiMap.getKey(1)); // 输出 one

        System.out.println("BidiMap: " + bidiMap.entrySet());
        // 移除元素
        bidiMap.removeValue(1);
        System.out.println("BidiMap after removal: " + bidiMap); // 输出 {two=2}
    }

TreeBidiMap

注意TreeBidiMap和DualTreeBidiMap的区别

TreeBidiMap采用是红黑树：Node。一个node就是put的一个键值对，这样子来实现双端的Map，底层的原理和上面的不一样。这样的好处：可以最大程度的节约存储空间，从而提高效率。

DualHashBidiMap

底层维护两个HashMap，一个正向，一个逆向来达到效果的。

DualLinkedHashBidiMap

底层采用两个LinkedHashMap存储，其余同上

DualTreeBidiMap

底层采用两个TreeMap存储，其余同上

    public static void main(String[] args) {
        BidiMap<String, String> map = new DualHashBidiMap<>();
        map.put("key1", "value1");
        map.put("key2", "value2");
        map.put("key3", "value3");

        //多出来的一种遍历方式  还是分厂人性化的
        MapIterator<String, String> it = map.mapIterator();
        while (it.hasNext()) {
            it.next(); //此句话必须调用  返回的是key，效果同getKey，但必须调用
            System.out.println(it.getKey() + "---" + it.getValue());
        }

        System.out.println(map.get("key1")); //value1
        //根据value拿key
        System.out.println(map.getKey("value1")); //key1
        //这个方法是Map接口的
        System.out.println(map.getOrDefault("k", "defaultValue")); //defaultValue
        //返回一个逆序的视图  注意是视图
        BidiMap<String, String> inverseMap = map.inverseBidiMap();

        //根据key删除
        inverseMap.remove("key1");
        //根据value删除
        inverseMap.removeValue("value2");

        System.out.println(map); //{key1=value1, key2=value2, key3=value3}
        System.out.println(inverseMap); //{value2=key2, value1=key1, value3=key3}
    }
输出：
key1---value1
key2---value2
key3---value3
value1
key1
defaultValue
{key1=value1, key2=value2, key3=value3}
{value2=key2, value1=key1, value3=key3}

MapUtils

emptyIfNull 之前我们经常会这么写（不返回null的Map）
invertMap 对调key和value的值
    public static void main(String[] args) {
        Map<String, String> map = new HashMap<>();
        map.put("key1", "value1");
        map.put("key2", "value2");
        map.put("key3", "value3");

        //fanzhuan反转  对调key和value
        Map<String, String> invertMap = MapUtils.invertMap(map);
        System.out.println(map); //{key1=value1, key2=value2, key3=value3}
        System.out.println(invertMap); //{value2=key2, value1=key1, value3=key3}
    }
iterableMap 构建一个iterableMap，然后方便遍历、删除等等之前我们需要遍历删除Map中元素，需要

SetUtils

difference：找到两个set之间的不同元素'

返回的是第一个set里有的，但是第二个set里没有的元素们

emptyIfNull：见上MapUtils类似方法

isEqualSet：两个set里面的元素是否都一样（长度一样、元素一样），有时候判断还是非常有用的
union：合并两个set，生成一个新的set
    public static void main(String[] args) {
        Set<String> set1 = new HashSet<String>(){{
            add("a");
            add("b");
            add("c");
        }};
        Set<String> set2 = new HashSet<String>(){{
            add("c");
            add("d");
            add("e");
        }};

        SetUtils.SetView<String> union = SetUtils.union(set1, set2);

        System.out.println(union); //[a, b, c, d, e]
    }

CollectionUtils

CollectionUtils 提供了一组实用静态方法，用于操作和处理集合。

isEmpty: 检查给定的集合是否为空。
isNotEmpty: 检查给定的集合是否不为空。
size: 获取给定集合的大小。
addAll: 将一个集合的所有元素添加到另一个集合中。
containsAny: 检查一个集合是否包含另一个集合中的任何元素。
find: 根据给定的条件查找集合中的元素。
intersection: 返回两个集合的交集。
subtract: 从第一个集合中移除第二个集合中的所有元素。
union: 返回两个集合的并集。
transform: 对集合中的每个元素应用给定的转换函数。
filter: 根据给定的条件过滤集合中的元素。
collect: 使用给定的收集器对集合进行聚合操作。
exists: 检查集合中是否存在满足给定条件的元素。
toArray: 将集合转换为数组。
toList: 将集合转换为列表。
toBag: 将集合转换为 Bag 对象（一种可以存储重复元素的集合）。
toMap: 将集合转换为 Map 对象。
toMultiSet: 将集合转换为 MultiSet 对象（一种可以存储重复元素的集合）。
toSortedList: 将集合转换为排序后的列表。
toTypedList: 将集合转换为指定类型的列表。
retainAll: 保留第一个集合中与第二个集合相同的元素。
removeAll: 从第一个集合中移除第二个集合中的所有元素。

IteratorUtils

IteratorUtils 提供了一组实用方法，用于操作和处理迭代器。

import org.apache.commons.collections4.IteratorUtils;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;

public class IteratorUtilsExample {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("a", "b", "c");
        Iterator<String> iterator = list.iterator();

        // 迭代器转列表
        List<String> resultList = IteratorUtils.toList(iterator);
        System.out.println("Iterator to List: " + resultList); // 输出 [a, b, c]

        // 反向迭代器
        Iterator<String> reverseIterator = IteratorUtils.reversedIterator(list.iterator());
        while (reverseIterator.hasNext()) {
            System.out.println(reverseIterator.next()); // 输出 c b a
        }
    }
}

Commons-BeanUtils 介绍

整理了开发中常用的 JavaBean 处理工具类，包括 Beanutils、PropertyUtils、CollectionUtils、ConvertUtils。近期使用中发现 BeanUtils.populate 方法存在 bug，实体类属性与 Map 中 key 值一模一样，但是会有一些属性拷贝完未null，而且 debug 源码未果，在这里推荐大家一个集成程度更高的 Util 工具类 hutool

BeanUtils：主要提供了对于 JavaBean 进行各种操作，比如对象，属性复制等等，自动转换数据类型。
PropertyUtils：用处大致与 BeanUtils 相同，但是如果类型不能自动转换会抛异常。
CollectionUtils ：集合处理类，集合类型转化，取交集、并集等方法。
ConvertUtils：数据类型转换类，BeanUtils 的自动类型转换就要到了它。

maven依赖

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

BeanUtils

常用方法：

方法	说明
cloneBean(Object bean)	对象的克隆
copyProperties(Object dest, Object orig)	对象的拷贝
copyProperty(Object bean, String name, Object value)	拷贝指定的属性值到指定的bean
setProperty(Object bean, String name, Object value)	设置指定属性的值
populate(Object bean, Map<String,? extends Object> properties)	将map数据拷贝到javabean中（map的key要与javabean的属性名称一致）

ConvertUtils

类型转换工具类，有了这个就不用为记各种数据类型互转的方法而烦恼了。

使用的主要方法：

convert(Object value, Class<?> targetType)//将给定的value转换成指定的Class类型

举个例子：

    public static void main( String[] args ) throws IllegalAccessException,InvocationTargetException
    {
        String str = "10";
        Object obj = ConvertUtils.convert(str, BigDecimal.class);
        System.out.println(obj.getClass());//class java.math.BigDecimal
        Object obj2 = ConvertUtils.convert("100",Integer.class);
        System.out.println(obj2.getClass());//class java.lang.Integer
    }

Commons-IO介绍

Apache Commons IO 是 Apache Commons 项目的一部分，专注于提供简单易用的 API，用于处理输入和输出操作。Commons IO 提供了一组实用工具类和扩展类，极大地简化了文件和流的操作。常用的类包括：

FileUtils：文件操作
IOUtils：流操作
FilenameUtils：文件名操作
FileFilterUtils：文件过滤

参考

https://www.cnblogs.com/johnnyzen/p/18291766

https://cloud.tencent.com/developer/article/1497525

maven依赖

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

FileUtils

FileUtils 提供了一组实用方法，用于文件和目录的操作，例如复制、移动、删除、读取和写入文件等。

import org.apache.commons.io.FileUtils;
import java.io.File;
import java.io.IOException;

public class FileUtilsExample {
    public static void main(String[] args) throws IOException {
        File file = new File("example.txt");

        // 写入文件
        FileUtils.writeStringToFile(file, "Hello, World!", "UTF-8");

        // 读取文件
        String content = FileUtils.readFileToString(file, "UTF-8");
        System.out.println(content); // 输出 "Hello, World!"

        // 复制文件
        File destFile = new File("copy_example.txt");
        FileUtils.copyFile(file, destFile);

        // 删除文件
        FileUtils.forceDelete(file);
        FileUtils.forceDelete(destFile);
    }
}

IOUtils

该工具类可能是平时使用得最多的工具类了。 IOUtils包含处理读、写和复制的工具方法。方法对InputStream、OutputStream、Reader和Writer起作用。

IOUtils 的特点如下 −

为输入/输出操作提供静态实用方法。
toXXX() − 从流中读取数据。
write() − 将数据写入流。
copy() − 将所有数据复制到一个流到另一个流。
contentEquals − 比较两个流的内容。

import org.apache.commons.io.IOUtils;
import java.io.StringReader;
import java.io.StringWriter;
import java.io.IOException;

public class IOUtilsExample {
    public static void main(String[] args) throws IOException {
        StringReader reader = new StringReader("Hello, World!");
        StringWriter writer = new StringWriter();

        // 复制流
        IOUtils.copy(reader, writer);
        System.out.println(writer.toString()); // 输出 "Hello, World!"
    }
}

FilenameUtils

FilenameUtils 提供了一组实用方法，用于处理文件名和路径。

import org.apache.commons.io.FilenameUtils;

public class FilenameUtilsExample {
    public static void main(String[] args) {
        String filePath = "/path/to/example.txt";

        // 获取文件扩展名
        String extension = FilenameUtils.getExtension(filePath);
        System.out.println(extension); // 输出 "txt"

        // 获取文件名（不包括路径和扩展名）
        String baseName = FilenameUtils.getBaseName(filePath);
        System.out.println(baseName); // 输出 "example"

        // 获取文件路径
        String fullPath = FilenameUtils.getFullPath(filePath);
        System.out.println(fullPath); // 输出 "/path/to/"
    }
}

FileFilterUtils

FileFilterUtils 提供了一组实用方法，用于创建文件过滤器。

import org.apache.commons.io.FileFilterUtils;
import java.io.File;
import java.io.FileFilter;

public class FileFilterUtilsExample {
    public static void main(String[] args) {
        File directory = new File("/path/to/directory");

        // 创建文件过滤器
        FileFilter filter = FileFilterUtils.suffixFileFilter(".txt");

        // 列出符合条件的文件
        File[] files = directory.listFiles(filter);
        for (File file : files) {
            System.out.println(file.getName());
        }
    }
}

commons-codec介绍

commons-codec是Apache开源组织提供的用于摘要运算、编码的包。以下是Base64编解码、MD5加密和URLCodec编解码的基本操作。

maven依赖

<dependency>
    <groupId>commons-codec</groupId>
    <artifactId>commons-codec</artifactId>
    <version>1.15</version>
</dependency>

具体代码

import java.security.MessageDigest;
import org.apache.commons.codec.CharEncoding;
import org.apache.commons.codec.digest.DigestUtils;

/**
 * Codec  处理常用的编码方法的工具类包 例如DES、SHA1、MD5、Base64等
 * 常用类
 *  ① CharEncoding 编码，其实目前也是用java.nio.charset.StandardCharsets代替
 *  ② DigestUtils 加密工具类
 *
 */
public class CodecDemo {

    private static void testDigestUtils(){
        try {
            // MD5加密，返回16位字符串
            // 控制台乱码, 不清楚是啥原因
            System.out.println(new String(DigestUtils.md5("123456")));
            // MD5加密，返回32位字符串
            System.out.println(DigestUtils.md5Hex("123456"));

            // SHA-1加密
            System.out.println(new String(DigestUtils.sha1("123456")));
            System.out.println(DigestUtils.sha1Hex("123456"));
            // SHA-256加密
            System.out.println(new String(DigestUtils.sha256("123456")));
            System.out.println(DigestUtils.sha256Hex("123456"));
            // SHA-512加密
            System.out.println(new String(DigestUtils.sha512("123456")));
            System.out.println(DigestUtils.sha512Hex("123456"));

            //MD5表示加密算法，可以选择其他参数，如SHA-1等
            MessageDigest digest = MessageDigest.getInstance("MD5");
            //先调用update，再调动digest
            digest.update(org.apache.commons.codec.binary.StringUtils.getBytesUtf8("123456"));
            byte[] byteResult = digest.digest();
            System.out.println(new String(byteResult));


        }catch (Exception e){
            System.out.println(" DigestUtils Error");
            e.printStackTrace();
        }
    }

    private static void testCharEncoding(){
        // 可以用java.nio.charset.StandardCharsets替换org.apache.commons.codec.CharEncoding
        System.out.println(CharEncoding.UTF_8);
    }

    public static void main(String[] args) {
        //CodecDemo.testCharEncoding();
        CodecDemo.testDigestUtils();
    }
}

Commons-Math介绍

在Java开发中，数学计算和统计分析是许多应用程序中的重要组成部分。Apache Commons Math 是一个强大的数学和统计库，提供了丰富的API，用于处理各种数学运算、统计分析和数值计算。

Apache Commons Math 是 Apache Commons 项目的一部分，专注于提供数学和统计计算的工具类库。Commons Math 包含了许多常用的数学和统计功能，例如：

基本数学运算
线性代数
优化和方程求解
统计分析
随机数生成

maven依赖

<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-math3</artifactId>
    <version>3.6.1</version>
</dependency>

基本数学运算

Commons Math 提供了一组基本数学运算的工具类，例如 ArithmeticUtils、CombinatoricsUtils 和 Fraction 等。

import org.apache.commons.math3.util.ArithmeticUtils;
import org.apache.commons.math3.util.CombinatoricsUtils;
import org.apache.commons.math3.fraction.Fraction;

public class BasicMathExample {
    public static void main(String[] args) {
        // 最大公约数
        int gcd = ArithmeticUtils.gcd(24, 36);
        System.out.println("GCD of 24 and 36: " + gcd); // 输出 12

        // 阶乘
        long factorial = CombinatoricsUtils.factorial(5);
        System.out.println("Factorial of 5: " + factorial); // 输出 120

        // 分数运算
        Fraction fraction1 = new Fraction(1, 3);
        Fraction fraction2 = new Fraction(2, 3);
        Fraction result = fraction1.add(fraction2);
        System.out.println("1/3 + 2/3 = " + result); // 输出 1
    }
}

线性代数

Commons Math 提供了一组线性代数的工具类，例如 RealMatrix 和 RealVector。

import org.apache.commons.math3.linear.Array2DRowRealMatrix;
import org.apache.commons.math3.linear.RealMatrix;
import org.apache.commons.math3.linear.RealVector;
import org.apache.commons.math3.linear.ArrayRealVector;

public class LinearAlgebraExample {
    public static void main(String[] args) {
        // 创建矩阵
        double[][] matrixData = { {1, 2}, {3, 4} };
        RealMatrix matrix = new Array2DRowRealMatrix(matrixData);

        // 创建向量
        double[] vectorData = { 5, 6 };
        RealVector vector = new ArrayRealVector(vectorData);

        // 矩阵与向量相乘
        RealVector result = matrix.operate(vector);
        System.out.println("Matrix * Vector: " + result); // 输出 [17.0, 39.0]
    }
}

优化和方程求解

Commons Math 提供了一组优化和方程求解的工具类，例如 UnivariateSolver 和 MultivariateOptimizer。

import org.apache.commons.math3.analysis.UnivariateFunction;
import org.apache.commons.math3.analysis.solvers.BrentSolver;
import org.apache.commons.math3.analysis.solvers.UnivariateSolver;

public class OptimizationExample {
    public static void main(String[] args) {
        // 定义函数
        UnivariateFunction function = new UnivariateFunction() {
            @Override
            public double value(double x) {
                return x * x - 2;
            }
        };

        // 创建求解器
        UnivariateSolver solver = new BrentSolver();

        // 求解方程 f(x) = 0
        double root = solver.solve(100, function, 0, 2);
        System.out.println("Root: " + root); // 输出 1.414213562373095
    }
}

统计分析

Commons Math 提供了一组统计分析的工具类，例如 DescriptiveStatistics 和 SummaryStatistics。

import org.apache.commons.math3.stat.descriptive.DescriptiveStatistics;

public class StatisticsExample {
    public static void main(String[] args) {
        // 创建统计对象
        DescriptiveStatistics stats = new DescriptiveStatistics();

        // 添加数据
        stats.addValue(1.0);
        stats.addValue(2.0);
        stats.addValue(3.0);
        stats.addValue(4.0);
        stats.addValue(5.0);

        // 计算统计量
        double mean = stats.getMean();
        double stdDev = stats.getStandardDeviation();
        double median = stats.getPercentile(50);

        System.out.println("Mean: " + mean); // 输出 3.0
        System.out.println("Standard Deviation: " + stdDev); // 输出 1.5811388300841898
        System.out.println("Median: " + median); // 输出 3.0
    }
}

随机数生成

Commons Math 提供了一组随机数生成的工具类，例如 RandomDataGenerator 和 RandomGenerator.

import org.apache.commons.math3.random.RandomDataGenerator;

public class RandomExample {
    public static void main(String[] args) {
        // 创建随机数据生成器
        RandomDataGenerator randomData = new RandomDataGenerator();

        // 生成随机数
        int randomInt = randomData.nextInt(1, 100);
        double randomDouble = randomData.nextGaussian(0, 1);

        System.out.println("Random Integer: " + randomInt);
        System.out.println("Random Gaussian: " + randomDouble);
    }
}

查看全文

http://www.kler.cn/a/301095.html