Apache 开源宝藏库，程序员的“百宝箱”

Apache Commons是Apache软件基金会旗下超实用的Java开源工具库，由一系列子项目构成，堪称Java开发者的得力助手。

拿Commons Lang举例，其处理字符串时优势尽显，以往判断字符串是否为空，要写繁琐的条件判断，防止空指针异常，现在只需用StringUtils的isEmpty、isBlank方法，非常便捷。

而Commons Collections专注集合操作，它能创建不可变集合，像是配置信息存储场景，一经设定，内容不可变动，其中的SynchronizedMap能将普通Map转为线程安全版本，解决多线程并发修改共享数据的难题。

Commons Lang

字符串操作（使用StringUtils）
判空操作
使用isEmpty方法判断字符串是否为空字符串。

String str1 = "";
String str2 = "not empty";
System.out.println(StringUtils.isEmpty(str1)); // true
System.out.println(StringUtils.isEmpty(str2)); // false

isBlank方法可以判断字符串是否为空字符串，或者只包含空白字符（如空格、制表符等）。

String str3 = "   ";
System.out.println(StringUtils.isBlank(str3)); // true

字符串拼接与分割
join方法：用于将数组或集合中的元素拼接成一个字符串。

String[] array = {"a", "b", "c"};
String joinedStr = StringUtils.join(array, ", ");
System.out.println(joinedStr); // a,b,c
split方法：用于分割字符串。
String str4 = "a,b,c";
String[] splitArray = StringUtils.split(str4, ",");
for (String s : splitArray) {
    System.out.println(s);
}

字符串截取与替换
substring方法：截取字符串的一部分。

String str5 = "Hello, World!";
String subStr = StringUtils.substring(str5, 0, 5);
System.out.println(subStr); // Hello

replace替换字符串中的指定内容。

String str6 = "Hello, World!";
String replacedStr = StringUtils.replace(str6, "World", "Java");
System.out.println(replacedStr); // Hello, Java!

对象操作（ObjectUtils）

对象比较
使用equals：比较两个对象是否相等，考虑了对象可能为null的情况。

String str7 = null;
String str8 = "o";
System.out.println(ObjectUtils.equals(str7, str8)); // false

对象克隆
使用clone方法：用于克隆对象。

class MyClass implements Cloneable {
    private int value;
    public MyClass(int value) {
        this.value = value;
    }
    @Override
    public MyClass clone() throws CloneNotSupportedException {
        return (MyClass) super.clone();
    }
}
try {
    MyClass original = new MyClass(5);
    MyClass cloned = (MyClass) ObjectUtils.clone(original);
    System.out.println(cloned.value); // 5
} catch (CloneNotSupportedException e) {
    e.printStackTrace();
}

数字和基本类型操作（NumberUtils）
类型转换
toInt方法：将字符串转换为整数，在转换失败时返回默认值。

String numStr1 = "123";
String numStr2 = "abc";
int num1 = NumberUtils.toInt(numStr1);
int num2 = NumberUtils.toInt(numStr2);
System.out.println(num1); // 123
System.out.println(num2); // 0（转换失败返回默认值0）

数字范围判断
isDigits方法：判断字符串是否只包含数字字符。

String str9 = "123";
String str10 = "abc";
System.out.println(NumberUtils.isDigits(str9)); // true
System.out.println(NumberUtils.isDigits(str10)); // false

数组操作（ArrayUtils）

数组元素添加和删除
add方法：向数组中添加元素。

Integer[] array1 = {1, 2, 3};
Integer[] newArray1 = ArrayUtils.add(array1, 4);
for (Integer i : newArray1) {
    System.out.print(i + " "); // 1 2 3 4
}

remove方法：从数组中删除指定位置的元素。

Integer[] array2 = {1, 2, 3};
Integer[] newArray2 = ArrayUtils.remove(array2, 1);
for (Integer i : newArray2) {
    System.out.print(i + " "); // 1 3
}

数组的比较和复制

equals方法：比较两个数组是否相等。

Integer[] array3 = {1, 2, 3};
Integer[] array4 = {1, 2, 3};
System.out.println(ArrayUtils.equals(array3, array4)); // true

clone方法：复制数组。

Integer[] array5 = {1, 2, 3};
Integer[] clonedArray = ArrayUtils.clone(array5);
System.out.println(ArrayUtils.equals(array5, clonedArray)); // true

日期和时间操作（DateUtils）

日期格式化和解析
parseDate方法：将字符串按照指定格式解析为日期对象。

String dateStr = "2024-12-01";
try {
    Date date = DateUtils.parseDate(dateStr, "yyyy-MM-dd");
    System.out.println(date);
} catch (ParseException e) {
    e.printStackTrace();
}

formatDate方法：将日期对象格式化为指定格式的字符串。

Date date = new Date();
String formattedDate = DateUtils.formatDate(date, "yyyy-MM-dd HH:mm:ss");
System.out.println(formattedDate);

日期计算
addDays方法：在日期上添加指定天数。

Date baseDate = new Date();
Date newDate = DateUtils.addDays(baseDate, 7);
System.out.println(newDate);

Commons Collections

不可变集合

不可变集合是指创建后不能被修改的集合，在多线程环境下或需要确保数据不被意外更改的场景中非常有用。

创建一个可变的ArrayList，然后将其转换为不可变的List:

List<String> mutableList = new ArrayList<>();
mutableList.add("item1");
List<String> immutableList = ListUtils.unmodifiableList(mutableList);
// 下面这行代码会抛出UnsupportedOperationException，因为不可变集合不允许修改
// immutableList.add("item2");

装饰器模式的集合

通过装饰器模式，可以将普通的集合转换为具有特殊功能的集合。

SynchronizedMap（线程安全的Map）
将一个普通的Map转换为线程安全的 Map 。

Map<String, Integer> map = new HashMap<>();
Map<String, Integer> synchronizedMap = new SynchronizedMap<>(map);
// 在多个线程中访问synchronizedMap时会自动进行同步操作
new Thread(() -> {
      synchronizedMap.put("key1", 1);
}).start();
  new Thread(() -> {
System.out.println(synchronizedMap.get("key1"));
   }).start();

集合转换和复制

将List转换为Set
利用CollectionUtils进行集合类型转换。

List<String> list = new ArrayList<>();
list.add("item1");
list.add("item2");
Set<String> set = new HashSet<>(list);
// 或者使用Commons Collections的方式
Set<String> convertedSet = CollectionUtils.collect(list, input -> input, HashSet::new);

集合复制
使用ListUtils复制List 。

List<String> originalList = new ArrayList<>();
originalList.add("item1");
originalList.add("item2");
List<String> copiedList = ListUtils.lazyList(new ArrayList<>(), null);
for (String element : originalList) {
         copiedList.add(element);
}

集合的迭代和过滤

增强的迭代器（ListIterator）
使用 ListIterator 进行向前和向后遍历，并插入和删除元素。

List<String> list = new ArrayList<>();
list.add("item1");
list.add("item2");
ListIterator<String> listIterator = ListIteratorUtils.lazyListIterator(list.listIterator());
System.out.println("向后遍历:");
while (listIterator.hasNext()) {
     System.out.println(listIterator.next());
}
System.out.println("向前遍历:");
while (listIterator.hasPrevious()) {
    System.out.println(listIterator.previous());
}
// 在迭代过程中插入元素
listIterator.add("newItem");
System.out.println("插入元素后向后遍历:");
while (listIterator.hasNext()) {
    System.out.println(listIterator.next());
}

过滤集合元素
使用CollectionUtils的select方法过滤集合中的元素。

List<Integer> numbers = new ArrayList<>();
numbers.add(5);
numbers.add(10);
numbers.add(15);
Predicate<Integer> greaterThanTen = new Predicate<Integer>() {
     @Override
     public boolean evaluate(Integer number) {
           return number > 10;
      }
};
Collection<Integer> selectedNumbers = CollectionUtils.select(numbers, greaterThanTen);
for (Integer number : selectedNumbers) {
       System.out.println(number);
}