Apache Commons工具类库使用整理

Apache Commons

Apache Commons 是一个开源软件项目，旨在为 Java 开发人员提供常用的工具类和组件。它提供了很多可重复使用的函数库，涵盖了各种领域，包括集合操作、文件操作、网络操作等。

工具类库分类

- commons-lang3

提供了许多Java基本工具类，包括字符串操作、对象操作、数组操作、类型转换等。

maven依赖：

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

常用工具类：

字符串工具：StringUtils

日期工具：DateUtils

数值工具：NumberUtils

对象工具：ObjectUtils

数组工具：ArrayUtils

异常工具：ExceptionUtils

枚举工具：EnumUtils

字符串随机数工具：RandomStringUtils

- commons-io

maven依赖：

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

文件工具：FileUtils

提供了一系列的文件操作方法，包括复制、移动、删除、比较文件内容等。

I/O工具：IOUtils

包含了一些常见的 I/O 操作方法，用于简化流的打开、关闭和读写，以及处理流的复制、转换等操作。

文件名工具：FilenameUtils

用于处理文件名的工具类，包括路径和文件名的解析、提取文件扩展名、路径合并等操作。

- commons-pool2

是一个用于管理对象池的工具库。对象池是一种常见的设计模式，用于管理可重复使用的对象，以减少对象的创建和销毁开销，同时提高对象的利用率。Commons Pool 2 提供了一套通用的对象池实现，可以用于管理任意类型的对象。如数据库连接池、线程池等。

maven依赖：

<dependency>
   <groupId>org.apache.commons</groupId>
   <artifactId>commons-pool2</artifactId>
   <version>2.11.1</version>
</dependency>

对象池核心组件

Commons Pool2 的核心组件：

• GenericObjectPool：通用的对象池实现，是 Commons Pool 2 的核心类。它可以管理任意类型的对象，并提供了一系列的配置选项，如最大对象数量、最大空闲对象数量、对象生命周期管理等。

• PooledObjectFactory：对象工厂接口，定义了对象的创建、销毁、验证等方法。每个对象池都需要实现这个接口来管理对象的生命周期。

• BasePooledObjectFactory：提供了一些方法的默认实现，简化了自定义对象工厂的实现。

• PooledObject：表示被对象池管理的对象，提供了对对象的状态信息和操作方法，如获取对象、释放对象等。

• EvictionPolicy：用于定义对象池中对象的驱逐策略，决定哪些对象应该被驱逐出池。

使用示例：

// 自定义的对象类
class MyObject {
    private String name;

    public MyObject(String name) {
        this.name = name;
        System.out.println("Creating object: " + name);
    }

    public void doSomething() {
        System.out.println("Doing something with object: " + name);
    }
}

// 自定义的对象工厂
class MyObjectFactory extends BasePooledObjectFactory<MyObject> {
    @Override
    public MyObject create() throws Exception {
        return new MyObject("Object");
    }

    @Override
    public PooledObject<MyObject> wrap(MyObject obj) {
        return new DefaultPooledObject<>(obj);
    }
}


public class CommonsPoolTest {

    public static void main(String[] args) throws Exception {
        // 创建对象工厂
        MyObjectFactory factory = new MyObjectFactory();

        // 创建对象池
        GenericObjectPool<MyObject> objectPool = new GenericObjectPool<>(factory);

        // 从对象池获取对象
        MyObject obj1 = objectPool.borrowObject();
        obj1.doSomething();

        // 归还对象到对象池
        objectPool.returnObject(obj1);

        // 再次从对象池获取对象
        MyObject obj2 = objectPool.borrowObject();
        obj2.doSomething();

        // 关闭对象池
        objectPool.close();
    }
}

- commons-codec

提供了一组用于编码和解码数据的通用工具类。它支持各种常见的编码算法，如 Base64、URL 编码、十六进制编码、MD5、SHA 等，以及一些其他常见的编码和散列算法。

maven依赖：

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

Base64编解码：Base64

org.apache.commons.codec.binary.Base64

	public static void main(String[] args) {
        // 原始字符串
        String originalString = "Hello, Base64!";

        // Base64 编码
        byte[] encodedBytes = Base64.encodeBase64(originalString.getBytes());
        String encodedString = new String(encodedBytes);
        System.out.println("Base64 编码: " + encodedString);

        // Base64 解码
        byte[] decodedBytes = Base64.decodeBase64(encodedBytes);
        String decodedString = new String(decodedBytes);
        System.out.println("Base64 解码: " + decodedString);
    }

URL编解码：URLCodec

org.apache.commons.codec.net.URLCodec

	public static void main(String[] args) throws Exception {
        // 原始URL
        String originalUrl = "http://127.0.0.1:8888/?username=哈哈";

        // URL 编码
        URLCodec codec = new URLCodec();
        String encodedUrl = codec.encode(originalUrl);
        System.out.println("URL 编码: " + encodedUrl);

        String decodeUrl = codec.decode(encodedUrl);
        System.out.println("URL 解码: " + decodeUrl);
    }

十六进制编解码：Hex

org.apache.commons.codec.binary.Hex

	public static void main(String[] args) throws DecoderException {
        // 原始字符串
        String originalString = "Hex Example";

        // 十六进制编码
        String encodedString = Hex.encodeHexString(originalString.getBytes());
        System.out.println("十六进制编码: " + encodedString);

        // 十六进制解码
        byte[] decodedBytes = Hex.decodeHex(encodedString);
        String decodedString = new String(decodedBytes);
        System.out.println("十六进制解码: " + decodedString);
    }

加密工具：DigestUtils

主要方法：

使用示例：

    public static void main(String[] args) {
        // 原始字符串
        String originalString = "Hello";

        // 计算MD5摘要
        String md5Hex = DigestUtils.md5Hex(originalString);
        System.out.println("MD5摘要: " + md5Hex);

        // 计算SHA-256摘要
        String sha256Hex = DigestUtils.sha256Hex(originalString);
        System.out.println("SHA-256摘要: " + sha256Hex);

        // 计算SHA-512摘要
        String sha512Hex = DigestUtils.sha512Hex(originalString);
        System.out.println("SHA-512摘要: " + sha512Hex);
    }

- commons-collections4

提供了一组扩展和增强了 Java 标准集合框架的工具类和数据结构。提供了更多功能和更丰富的选项，例如扩展的集合、映射、迭代器等。

maven依赖：

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

主要功能：

• 集合操作：CollectionUtils 类包含了许多静态方法，用于各种常见的集合操作，如查找、过滤、转换等。

• 集合扩展：Apache Commons Collections4 提供了一些有用的集合类，如 ListUtils、SetUtils 和 MapUtils 等。这些类通过静态方法提供了一系列的集合操作，如合并、交集、差集、过滤等。

• 高效实现：Commons Collections4 提供了许多高效的集合实现，比如 LinkedMap、TreeBag、FixedSizeList 等。这些实现在特定场景下可以提供更好的性能和功能。

• 装饰器模式：Commons Collections4 还提供了一系列装饰器类，用于扩展或修改现有的集合类。通过装饰器模式，可以在不改变现有代码的情况下增加或修改集合的功能，如 SynchronizedCollection、UnmodifiableMap 等。

• 迭代器和迭代器：Commons Collections4 提供了许多增强的迭代器和迭代器工具类，如 IteratorUtils、IterableUtils 和 EnumerationUtils 等。这些工具类可以简化集合的遍历和操作。

• 转换器和变形器：Commons Collections4 提供了一些转换器和变形器，用于在集合元素之间进行转换或变换，如 TransformerUtils 和 PredicateUtils 等。这些工具类可以方便地进行元素的转换、过滤及其他操作。

• 额外的数据结构：Commons Collections4 还提供了一些额外的数据结构，如 BidiMap、MultiMap、Bag 等。这些数据结构可以满足一些特定的需求，如双向映射、多值映射和可重复的元素计数等。

集合操作

CollectionUtils主要方法：

集合扩展

• 合并两个列表：

  List<String> list1 = Arrays.asList("apple", "banana");
  List<String> list2 = Arrays.asList("banana", "orange");
  List<String> mergedList = ListUtils.union(list1, list2);
  System.out.println("Merged List: " + mergedList);
  

• 计算两个集合的交集：

  Set<Integer> set1 = new HashSet<>(Arrays.asList(1, 2, 3));
  Set<Integer> set2 = new HashSet<>(Arrays.asList(3, 4, 5));
  Set<Integer> intersection = SetUtils.intersection(set1, set2);
  System.out.println("Intersection: " + intersection);
  

• 过滤Map中满足条件的条目：

  Map<String, Integer> map = new HashMap<>();
  map.put("apple", 3);
  map.put("banana", 2);
  map.put("orange", 5);
  Map<String, Integer> filteredMap = MapUtils.predicatedMap(map, (key, value) -> value > 2);
  System.out.println("Filtered Map: " + filteredMap);
  

高效实现

• 使用 LinkedMap 保持键值对的插入顺序：

  Map<String, Integer> linkedMap = new LinkedMap<>();
  linkedMap.put("apple", 3);
  linkedMap.put("banana", 2);
  linkedMap.put("orange", 5);
  System.out.println("Linked Map: " + linkedMap);
  

• 使用 TreeBag 对元素进行排序和计数：

  Bag<String> treeBag = new TreeBag<>(Arrays.asList("apple", "banana", "banana", "orange"));
  System.out.println("Tree Bag: " + treeBag);
  

• 创建固定大小的列表：

  List<String> fixedSizeList = FixedSizeList.decorate(new ArrayList<>(Arrays.asList("apple", "banana", "orange")));
  System.out.println("Fixed Size List: " + fixedSizeList);
  

装饰器模式

• 创建一个线程安全的集合：

  Collection<String> synchronizedCollection = SynchronizedCollection.synchronizedCollection(new ArrayList<>());
  

• 创建一个不可修改的映射：

  Map<String, Integer> unmodifiableMap = UnmodifiableMap.unmodifiableMap(new HashMap<>());
  

迭代器和迭代器

• 使用 IteratorUtils 迭代器工具类来操作集合：

  List<String> list = Arrays.asList("apple", "banana", "orange");
  Iterator<String> iterator = IteratorUtils.filteredIterator(list.iterator(), s -> s.startsWith("a"));
  while (iterator.hasNext()) {
      System.out.println(iterator.next());
  }
  

转换器和变形器

• 使用 Transformer 对集合元素进行转换：

  List<String> list = Arrays.asList("apple", "banana", "orange");
  Transformer<String, Integer> transformer = input -> input.length();
  Collection<Integer> transformedCollection = CollectionUtils.collect(list, transformer);
  System.out.println("Transformed Collection: " + transformedCollection);
  

额外的数据结构

• 使用 BidiMap 进行双向映射：

  BidiMap<String, String> bidiMap = new DualHashBidiMap<>();
  bidiMap.put("apple", "red");
  bidiMap.put("banana", "yellow");
  System.out.println("Value for key 'banana': " + bidiMap.get("banana"));
  System.out.println("Key for value 'yellow': " + bidiMap.inverseBidiMap().get("yellow"));
  

• 使用 MultiMap 存储多个值的映射：

  MultiValuedMap<String, String> multiMap = new ArrayListValuedHashMap<>();
  multiMap.put("fruits", "apple");
  multiMap.put("fruits", "banana");
  System.out.println("All fruits: " + multiMap.get("fruits"));
  

• 使用 Bag 对元素进行计数：

  Bag<String> bag = new HashBag<>(Arrays.asList("apple", "banana", "banana", "orange"));
  System.out.println("Count of 'banana': " + bag.getCount("banana"));
  

- commons-math3

maven依赖：

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

- commons-compress

提供了对各种压缩格式的支持和处理。它提供了一组用于处理压缩文件和流的工具和类。

• 支持的压缩格式：Commons Compress支持许多常见的压缩格式，例如ZIP、GZIP、BZIP2、TAR等。它允许你对这些格式的文件进行压缩、解压缩和存储操作。

• 压缩和解压缩功能：Commons Compress提供了用于压缩和解压缩文件和流的API和类。你可以使用这些类来创建、读取和写入压缩文件，并对其进行解压缩操作。

• 支持多种压缩算法：Commons Compress支持多种压缩算法，包括Deflate（在ZIP和GZIP中使用）、BZIP2、LZMA等。它通过提供不同的压缩器和解压缩器类来处理不同的算法。

• 文件和目录的压缩：Commons Compress允许你对单个文件或整个目录进行压缩和解压缩操作。你可以递归地压缩目录中的所有文件和子目录，并选择性地包含或排除特定的文件。

• 流式压缩和解压缩：除了处理文件和目录外，Commons Compress还允许你对输入流和输出流进行压缩和解压缩操作。这使得你可以在不创建实际文件的情况下对数据进行压缩和解压缩。

注意事项：

1. GZIP命令本身只能压缩单个文件，无法直接压缩多个文件或压缩整个文件夹。要压缩多个文件或压缩整个文件夹，你可以使用TAR命令结合GZIP命令来完成。

maven依赖：

<dependency>
   <groupId>org.apache.commons</groupId>
   <artifactId>commons-compress</artifactId>
   <version>1.21</version>
</dependency>

常用压缩解压方式：ZIP、GZIP、TAR、TARGZ

常见压缩解压

使用工具：

@Slf4j
public class CompressUtil {

    private static final int BUFFER_SIZE = 4096;

    /**
     * ZIP压缩
     *
     * @param files   待压缩文件列表
     * @param zipFile 压缩文件
     */
    public static void zip(List<File> files, File zipFile) {
        if (zipFile.isDirectory()) {
            throw new IllegalArgumentException("zipFile is not a directory");
        }
        if (!zipFile.getParentFile().exists()) {
            zipFile.getParentFile().mkdirs();
        }
        try (ArchiveOutputStream outputStream = new ArchiveStreamFactory().createArchiveOutputStream(ArchiveStreamFactory.ZIP, new FileOutputStream(zipFile))) {
            for (File file : files) {
                addEntry(outputStream, file, "");
            }
        } catch (Exception e) {
            log.error("ZIP压缩出错", e);
        }
    }

    private static void addEntry(ArchiveOutputStream outputStream, File file, String basePath) throws IOException {
        String entryName = basePath + file.getName();
        if (file.isDirectory()) {
            File[] nestedFiles = file.listFiles();
            for (File nestedFile : nestedFiles) {
                addEntry(outputStream, nestedFile, entryName + "/");
            }
        } else {
            ArchiveEntry entry = outputStream.createArchiveEntry(file, entryName);
            outputStream.putArchiveEntry(entry);
            IOUtils.copy(new FileInputStream(file), outputStream);
            outputStream.closeArchiveEntry();
        }
    }

    /**
     * ZIP解压
     *
     * @param zipFile   解压文件
     * @param directory 解压目录
     */
    public static void unzip(File zipFile, File directory) {
        if (directory.isFile()) {
            throw new IllegalArgumentException("directory is not a file");
        }
        if (!directory.exists()) {
            directory.mkdirs();
        }
        try (ArchiveInputStream inputStream = new ArchiveStreamFactory().createArchiveInputStream(new BufferedInputStream(new FileInputStream(zipFile)))) {
            ArchiveEntry entry;
            while ((entry = inputStream.getNextEntry()) != null) {
                if (!inputStream.canReadEntryData(entry)) continue;
                File currentFile = new File(directory, entry.getName());
                if (entry.isDirectory()) {
                    currentFile.mkdirs();
                } else {
                    currentFile.getParentFile().mkdirs();
                    try (OutputStream outputFileStream = new FileOutputStream(currentFile)) {
                        IOUtils.copy(inputStream, outputFileStream);
                    }
                }
            }
        } catch (Exception e) {
            log.error("ZIP解压出错", e);
        }
    }

    /**
     * GZIP压缩
     *
     * @param file     待压缩文件
     * @param gzipFile 压缩文件
     */
    public static void gzip(File file, File gzipFile) {
        if (gzipFile.isDirectory()) {
            throw new IllegalArgumentException("gzipFile is not a directory");
        }
        if (!gzipFile.getParentFile().exists()) {
            gzipFile.getParentFile().mkdirs();
        }
        try (FileInputStream fis = new FileInputStream(file);
             FileOutputStream fos = new FileOutputStream(gzipFile);
             GzipCompressorOutputStream gzos = new GzipCompressorOutputStream(fos)) {

            byte[] buffer = new byte[BUFFER_SIZE];
            int len;
            while ((len = fis.read(buffer)) > 0) {
                gzos.write(buffer, 0, len);
            }
        } catch (Exception e) {
            log.error("GZIP压缩出错", e);
        }
    }

    /**
     * GZIP解压
     *
     * @param gzipFile 待解压文件
     * @param file     解压文件
     */
    public static void ungzip(File gzipFile, File file) {
        if (file.isDirectory()) {
            throw new IllegalArgumentException("file is not a directory");
        }
        if (!file.getParentFile().exists()) {
            file.getParentFile().mkdirs();
        }
        try (FileInputStream fis = new FileInputStream(gzipFile);
             GzipCompressorInputStream gzis = new GzipCompressorInputStream(fis);
             FileOutputStream fos = new FileOutputStream(file)) {

            byte[] buffer = new byte[BUFFER_SIZE];
            int len;
            while ((len = gzis.read(buffer)) > 0) {
                fos.write(buffer, 0, len);
            }
        } catch (Exception e) {
            log.error("GZIP解压出错", e);
        }
    }

    /**
     * TAR压缩
     *
     * @param files   待压缩文件列表
     * @param tarFile 压缩文件
     */
    public static void tar(List<File> files, File tarFile) {
        if (tarFile.isDirectory()) {
            throw new IllegalArgumentException("tarFile is not a directory");
        }
        if (!tarFile.getParentFile().exists()) {
            tarFile.getParentFile().mkdirs();
        }
        try (TarArchiveOutputStream tarOut = new TarArchiveOutputStream(new FileOutputStream(tarFile))) {
            for (File inputFile : files) {
                addFileToTar(tarOut, inputFile, "");
            }
        } catch (Exception e) {
            log.error("TAR压缩出错", e);
        }
    }

    /**
     * 将文件添加到tar压缩包中
     *
     * @param tarOut
     * @param file
     * @param parentEntryName
     * @throws IOException
     */
    private static void addFileToTar(TarArchiveOutputStream tarOut, File file, String parentEntryName) throws IOException {
        String entryName = parentEntryName + file.getName();
        TarArchiveEntry tarEntry = new TarArchiveEntry(file, entryName);
        tarOut.putArchiveEntry(tarEntry);
        if (file.isFile()) {
            try (InputStream in = new FileInputStream(file)) {
                IOUtils.copy(in, tarOut);
            }
            tarOut.closeArchiveEntry();
        } else if (file.isDirectory()) {
            tarOut.closeArchiveEntry();
            File[] children = file.listFiles();
            if (children != null) {
                for (File child : children) {
                    addFileToTar(tarOut, child, entryName + "/");
                }
            }
        }
    }

    /**
     * TAR解压
     *
     * @param tarFile   待解压文件
     * @param directory 解压目录
     */
    public static void untar(File tarFile, File directory) {
        if (directory.isFile()) {
            throw new IllegalArgumentException("file is not a file");
        }
        try (TarArchiveInputStream tarIn = new TarArchiveInputStream(new FileInputStream(tarFile))) {
            ArchiveEntry entry;
            while ((entry = tarIn.getNextEntry()) != null) {
                if (!tarIn.canReadEntryData(entry)) {
                    continue;
                }
                File entryFile = new File(directory, entry.getName());
                if (entry.isDirectory()) {
                    if (!entryFile.exists()) {
                        entryFile.mkdirs();
                    }
                } else {
                    File parent = entryFile.getParentFile();
                    if (!parent.exists()) {
                        parent.mkdirs();
                    }
                    try (OutputStream out = new FileOutputStream(entryFile)) {
                        IOUtils.copy(tarIn, out);
                    }
                }
            }
        } catch (Exception e) {
            log.error("TAR解压出错", e);
        }
    }

    /**
     * TARGZ压缩
     *
     * @param files     待压缩文件列表
     * @param targzFile 压缩文件
     */
    public static void targz(List<File> files, File targzFile) {
        if (targzFile.isDirectory()) {
            throw new IllegalArgumentException("targzFile is not a directory");
        }
        if (!targzFile.getParentFile().exists()) {
            targzFile.getParentFile().mkdirs();
        }
        try (FileOutputStream fos = new FileOutputStream(targzFile);
             BufferedOutputStream bos = new BufferedOutputStream(fos);
             GzipCompressorOutputStream gzos = new GzipCompressorOutputStream(bos);
             TarArchiveOutputStream tarOutput = new TarArchiveOutputStream(gzos)) {
            for (File file : files) {
                addFileToTar(tarOutput, file, "");
            }
            tarOutput.finish();
        } catch (Exception e) {
            log.error("TARGZ压缩出错", e);
        }
    }

    /**
     * TARGZ解压
     *
     * @param targzFile 待解压文件
     * @param directory 解压目录
     */
    public static void untargz(File targzFile, File directory) {
        if (directory.isFile()) {
            throw new IllegalArgumentException("directory is not a file");
        }
        try (FileInputStream fis = new FileInputStream(targzFile);
             BufferedInputStream bis = new BufferedInputStream(fis);
             GzipCompressorInputStream gzis = new GzipCompressorInputStream(bis);
             TarArchiveInputStream tarInput = new TarArchiveInputStream(gzis)) {
            TarArchiveEntry entry;
            while ((entry = tarInput.getNextTarEntry()) != null) {
                File outputFile = new File(directory, entry.getName());
                if (entry.isDirectory()) {
                    if (!outputFile.exists()) {
                        outputFile.mkdirs();
                    }
                } else {
                    outputFile.getParentFile().mkdirs();
                    try (FileOutputStream fos = new FileOutputStream(outputFile);
                         BufferedOutputStream bos = new BufferedOutputStream(fos)) {
                        byte[] buffer = new byte[BUFFER_SIZE];
                        int bytesRead;
                        while ((bytesRead = tarInput.read(buffer)) != -1) {
                            bos.write(buffer, 0, bytesRead);
                        }
                    }
                }
            }
        } catch (Exception e) {
            log.error("TARGZ解压出错", e);
        }
    }

    public static void main(String[] args) {
        List<File> sourceFiles = Arrays.asList(new File("E:\\test\\a.txt"), new File("E:\\test\\b.txt"), new File("E:\\test\\aaa"));
        File compressFile;
        File decompresDir;

        File sourceFile;
        File decompresFile;

        // zip
        compressFile = new File("E:\\test\\zip\\zip\\hhhh.zip");
        CompressUtil.zip(sourceFiles, compressFile);
        decompresDir = new File("E:\\test\\zip\\unzip");
        CompressUtil.unzip(compressFile, decompresDir);

        // gzip
        sourceFile = new File("E:\\test\\a.txt");
        compressFile = new File("E:\\test\\gzip\\gzip\\a.txt.gz");
        CompressUtil.gzip(sourceFile, compressFile);
        decompresFile = new File(("E:\\test\\gzip\\ungzip\\a.txt"));
        CompressUtil.ungzip(compressFile, decompresFile);

        // tar
        compressFile = new File("E:\\test\\tar\\tar\\hhhh.tar");
        CompressUtil.tar(sourceFiles, compressFile);
        decompresDir = new File("E:\\test\\tar\\untar");
        CompressUtil.untar(compressFile, decompresDir);

        // targz
        compressFile = new File("E:\\test\\targz\\targz\\hhhh.tar.gz");
        CompressUtil.targz(sourceFiles, compressFile);
        decompresDir = new File("E:\\test\\targz\\untargz");
        CompressUtil.untargz(compressFile, decompresDir);
    }
}

- commons-net

提供了一套用于网络协议的API，包括FTP、SMTP、POP3、IMAP等。使用Apache Commons Net库可以简化Java程序对网络协议的处理，实现FTP、SMTP等协议的功能，并且在这些协议的基础上可以进行更高层次的封装，实现更复杂的网络应用。

maven依赖：

<dependency>
   <groupId>commons-net</groupId>
   <artifactId>commons-net</artifactId>
   <version>3.8.0</version>
</dependency>

常见组件：

FTP

Apache Commons Net提供了FTP协议的API，实现了FTP的各种功能，如登陆、上传下载、创建文件夹、删除文件、列举目录等。如需使用FTP连接，可以使用FTPClient类。

    private static void ftpTest() throws IOException {
        FTPClient ftpClient = new FTPClient();
        // 设置控制编码为UTF-8
        ftpClient.setControlEncoding("UTF-8");
        // 创建连接
        ftpClient.connect("127.0.0.1", 21);
        // 登录
        ftpClient.login("anonymous", "");
        // 设置数据编码为UTF-8
        ftpClient.setFileType(FTPClient.BINARY_FILE_TYPE);
        ftpClient.setFileTransferMode(FTPClient.STREAM_TRANSFER_MODE);
        ftpClient.setCharset(Charset.forName("UTF-8"));
        // 当前目录
        System.out.println(ftpClient.printWorkingDirectory());
        // cd /upload目录
        ftpClient.changeWorkingDirectory("/upload");
        System.out.println(ftpClient.printWorkingDirectory());
        // 上传文件
        boolean flag = ftpClient.storeFile("/upload/a.txt", new FileInputStream(new File("E:\\test\\a.txt")));
        System.out.println(String.format("上传文件：%s", flag));
        // 关闭连接
        ftpClient.disconnect();
    }

SMTP

Apache Commons Net提供了SMTP协议的API，实现了SMTP的各种功能，如发送邮件、附件，对邮件进行编码、解码等。如需使用SMTP协议进行发送邮件，可以使用SMTPClient类。

POP3

Apache Commons Net提供了POP3协议的API，实现了POP3的各种功能，如接收邮件，查看邮件，删除邮件等。如需使用POP3协议接收邮件，可以使用POP3Client类。

IMAP

Apache Commons Net提供了IMAP协议的API，实现了IMAP的各种功能，如接收邮件，查看邮件，删除邮件等。如需使用IMAP协议接收邮件，可以使用IMAPClient类。

- commons-csv

Apache Commons CSV 是一个 Java 库，用于解析和生成以逗号分隔的值（CSV）格式的数据。它提供了简单易用的 API，可以方便地读取和写入 CSV 文件。

maven依赖：

<dependency>
   <groupId>org.apache.commons</groupId>
   <artifactId>commons-csv</artifactId>
   <version>1.9.0</version>
</dependency>

CSV读取写入

使用示例：

@Data
@NoArgsConstructor
@AllArgsConstructor
public class User {


    public String userId;

    public String userName;

    public String sex;
}

public class CsvTest {

    public static void main(String[] args) throws Exception {
        String fileName = "E:\\test\\user.csv";

        // 写入
        List<User> data = new ArrayList<>();
        data.add(new User("111", "哈^哈", "男"));
        data.add(new User("222", "呵呵", "男"));
        data.add(new User("333", "嘻\"嘻", "女"));
        PrintWriter printWriter = new PrintWriter(fileName);
        CSVPrinter printer = CSVFormat.DEFAULT.builder()
                .setHeader("userId", "userName", "sex")
                .setDelimiter("^")
                .setQuoteMode(QuoteMode.MINIMAL)
                .setQuote('"')
                .build()
                .print(printWriter);
        for (User user : data) {
            printer.printRecord(user.getUserId(), user.getUserName(), user.getSex());
        }
        printer.flush();
        printer.close();

        // 读取
        FileReader fileReader=new FileReader(fileName);
        CSVParser parser = CSVFormat.DEFAULT.builder()
                .setHeader("userId", "userName", "sex")
                .setSkipHeaderRecord(true)
                .setDelimiter('^')
                .setQuoteMode(QuoteMode.MINIMAL)
                .setQuote('"')
                .build()
                .parse(fileReader);
        List<User> list = new LinkedList<>();
        for (CSVRecord record : parser.getRecords()) {
            list.add(new User(record.get("userId"), record.get("userName"), record.get("sex")));
        }
        System.out.println(String.format("读取到的数据：%s", JSON.toJSONString(list)));
        fileReader.close();
        parser.close();
    }
}

user.csv

日志

读取到的数据：[{"sex":"男","userId":"111","userName":"哈^哈"},{"sex":"男","userId":"222","userName":"呵呵"},{"sex":"女","userId":"333","userName":"嘻\"嘻"}]

- commons-configuration2

Apache Commons Configuration 是 Apache 软件基金会下的一个开源项目，提供了一套用于处理配置信息的工具库。

maven依赖：

<dependency>
   <groupId>org.apache.commons</groupId>
   <artifactId>commons-configuration2</artifactId>
   <version>2.7</version>
</dependency>

主要功能：

• 支持读取和保存多种配置格式，如 properties、XML、JSON、YAML 等。
• 提供了配置值的类型转换功能，允许配置值被解释成程序中的合适的数据类型。
• 支持对配置文件进行动态更新，当配置文件发生改变时，能够自动重新加载最新的配置信息。
• 提供了支持表达式和变量替换的功能，在配置文件中可以使用变量和动态表达式。

功能分类：

• 配置文件的加载和管理：

  使用 Commons Configuration 2 可以轻松地加载和管理配置文件。它提供了一种统一的接口，可以方便地加载和获取各种格式的配置信息，并支持跨多种配置格式的无缝切换。

• 类型转换：

  Commons Configuration 2 具有强大的类型转换功能，可以自动将配置值转换成需要的数据类型。这使得开发者在读取配置值时无需手动进行类型转换，简化了代码逻辑。

• 动态更新：

  该库支持动态更新配置信息，当配置文件发生变化时，应用程序可以自动重新加载最新的配置信息，而无需重启应用程序。

• 表达式和变量替换：

  Commons Configuration 2 支持在配置文件中使用表达式和变量替换，这使得配置文件中的值更加灵活和动态化。

- commons-text

Apache Commons Text 是 Apache Commons 项目下的一个子项目，旨在提供一组文本处理相关的实用工具类。

maven依赖：

<dependency>
   <groupId>org.apache.commons</groupId>
   <artifactId>commons-text</artifactId>
   <version>1.10.0</version>
</dependency>

主要功能：

• 字符串操作：提供了字符串操作的工具类，例如字符串切割、字符串连接、字符串替换等。

• 格式化和解析：提供了各种文本格式化和解析的工具类，例如数字格式化、日期格式化、货币格式化等。

• 字符串转义：提供了字符串转义的工具类，例如Unicode转义、HTML实体转义等。

• 字符串生成：提供了生成随机字符串、密码等的工具类。

单词处理工具：WordUtils

WordUtils 是一个用于处理单词的工具类，提供了一些常见的文本操作，特别是对单词进行格式化和修正。

大小写转换工具：CaseUtils

CaseUtils 是一个用于处理字符串大小写的工具类，提供了多种方法来改变字符串的大小写格式，特别是在不同的命名约定之间转换时非常有用。

转义工具：StringEscapeUtils

StringEscapeUtils 是一个用于处理字符串转义和反转义的工具类，主要用于处理与 HTML、XML、Java 字符串等相关的转义和反转义操作。

字符串转义工具类。

使用示例：

public class TextTest {

    public static void main(String[] args) {
        System.out.println("---------------------------------------------------------");
        String str = "HellO worlD";
        System.out.println("原字符串：" + str);

        // 单词首字母大写
        System.out.println("单词首字母大写：" + WordUtils.capitalize(str));

        // 单词首字母大写，其它小写
        System.out.println("单词首字母大写，其它小写：" + WordUtils.capitalizeFully(str));

        // 单词首字母大写
        System.out.println("单词首字母小写：" + WordUtils.uncapitalize(str));
        System.out.println("---------------------------------------------------------");

        String input = "user_type-desc";
        System.out.println("原字符串：" + input);

        // 字符串转驼峰，首字母小写，指定分隔符为_、-
        String camelCase = CaseUtils.toCamelCase(input, false, '_','-');
        System.out.println("字符串转驼峰，首字母小写：" + camelCase);

        // 字符串转驼峰，首字母大写，指定分隔符为_、-
        String camelCaseCapitalized = CaseUtils.toCamelCase(input, true, '_','-');
        System.out.println("字符串转驼峰，首字母大写：" + camelCaseCapitalized);
        System.out.println("---------------------------------------------------------");

        String htmlString = "<div>Hello, world!</div>";
        System.out.println("原字符串：" + htmlString);

        // HTML实体转义
        String escapedHtml = StringEscapeUtils.escapeHtml4(htmlString);
        System.out.println("转义后的HTML字符串：" + escapedHtml);

        // HTML实体反转义
        String unescapedHtml = StringEscapeUtils.unescapeHtml4(escapedHtml);
        System.out.println("反转义后的HTML字符串：" + unescapedHtml);
        System.out.println("---------------------------------------------------------");

        // 生成随机字符串
        RandomStringGenerator generator = new RandomStringGenerator.Builder()
                .withinRange('0', 'z')
                .filteredBy(Character::isLetter)
                .build();
        String randomString = generator.generate(10);
        System.out.println("生成的随机字符串：" + randomString);
        System.out.println("---------------------------------------------------------");
    }
}

日志：

---------------------------------------------------------
原字符串：HellO worlD
单词首字母大写：HellO WorlD
单词首字母大写，其它小写：Hello World
单词首字母小写：hellO worlD
---------------------------------------------------------
原字符串：user_type-desc
字符串转驼峰，首字母小写：userTypeDesc
字符串转驼峰，首字母大写：UserTypeDesc
---------------------------------------------------------
原字符串：<div>Hello, world!</div>
转义后的HTML字符串：&lt;div&gt;Hello, world!&lt;/div&gt;
反转义后的HTML字符串：<div>Hello, world!</div>
---------------------------------------------------------
生成的随机字符串：zEkAgsMDiQ
---------------------------------------------------------