超实用的java常用工具汇总，日常开发使用率百分百哦！（持续跟新中）

一、类型转换

1. Map 与 Bean 之间的转换

• Fastjson用法案例

<dependency>
    <groupId>com.alibaba.fastjson2</groupId>
    <artifactId>fastjson2</artifactId>
    <version>2.0.51</version>
</dependency>

@Data
public class TestClass {

    private String name;

    private int age;

    private String address;

}

@Test
public void test2(){

    Map<String, Object> map = new HashMap<>();
    map.put("name","张三");
    map.put("age",18);
    map.put("address","北京");

    TestClass testClass = JSONObject.parseObject(JSONUtil.toJsonStr(map), TestClass.class);
    System.out.println(testClass);

    Map<String, Object> jsonObject = JSONObject.parseObject(JSONUtil.toJsonStr(testClass));
    System.out.println(jsonObject);
    System.out.println(jsonObject.get("name"));

}

• Hutool用法案例

<dependency>
    <groupId>cn.hutool</groupId>
    <artifactId>hutool-all</artifactId>
    <version>5.8.25</version>
</dependency>

@Test
public void test1(){
    Map<String, Object> map = new HashMap<>();
    map.put("name","张三");
    map.put("age",18);
    map.put("address","北京");

    TestClass testClass = JSONUtil.toBean(JSONUtil.toJsonStr(map), TestClass.class);
    System.out.println(testClass);

    Map<String, Object> jsonObject = JSONUtil.parseObj(JSONUtil.toJsonStr(testClass));
    System.out.println(jsonObject);
    System.out.println(jsonObject.get("name"));

    Map<String, Object> params = BeanUtil.beanToMap(testClass);
    System.out.println(params);
}

2. 字符串转集合（非数字字符串）

@Test
public void test1(){
    String str = "a,b,c";
    String[] stringArr = str.split(",");

    // 1.Arrays.asList（集合不可变）
    List<String> list = Arrays.asList(stringArr);
    // list.add("d");// 报错：java.lang.UnsupportedOperationException
    System.out.println(list);// [a, b, c]
    // 注意：如果想支持可变
    list = new ArrayList<>(list);
    list.add("d");
    System.out.println(list);// [a, b, c, d]

    // 2.Arrays.stream流（集合可变）
    List<String> list1 = Arrays.stream(stringArr).collect(Collectors.toList());
    list1.add("d");
    System.out.println(list1);// [a, b, c, d]

    // 3.StrUtil（集合可变）
    List<String> list2 = StrUtil.split(str, ',');
    list2.add("d");
    System.out.println(list2);// [a, b, c, d]

    // 4.Stream.of（集合可变）
    List<String> list3 = Stream.of(stringArr).collect(Collectors.toList());
    list3.add("d");
    System.out.println(list3);// [a, b, c, d]

    // 5.java9 List.of（集合不可变）
    // List<String> list4 = List.of(stringArr);
    // System.out.println(list4);// [a, b, c]
}

3. 字符串转集合（数字字符串）

@Test
public void test2(){
    String str = "1,2,3";
    String[] stringArr = str.split(",");

    // 1.Arrays.stream流（集合可变）
    List<Integer> list1 = Arrays.stream(stringArr).map(Integer::new).collect(Collectors.toList());
    list1.add(4);
    System.out.println(list1);// [1, 2, 3, 4]

    // 2.StreamUtil（集合可变）
    List<Integer> list2 = StreamUtil.of(StrUtil.split(str, ',')).map(Integer::new).collect(Collectors.toList());
    list2.add(4);
    System.out.println(list2);// [1, 2, 3, 4]

    // 3.Stream.of（集合可变）
    List<Integer> list3 = Stream.of(stringArr).map(Integer::new).collect(Collectors.toList());
    list3.add(4);
    System.out.println(list3);// [1, 2, 3, 4]
}

4. 集合转字符串

@Test
public void test3() {

    List<String> list = Stream.of("1", "2", "3").collect(Collectors.toList());

    // 1.使用Stream流
    String str = list.stream().collect(Collectors.joining(","));
    System.out.println(str);// 1,2,3

    // 2.使用String
    String str3 = String.join(",", list);
    System.out.println(str3);// 1,2,3

    // 3.使用CollUtil
    String str2 = CollUtil.join(list, ",");
    System.out.println(str2);// 1,2,3

    // 4.使用CollectionUtil
    String str4 = CollectionUtil.join(list, ",");

    // 5.使用StringBuilder或StringBuffer
    StringBuilder str5 = new StringBuilder();
    for (String s : list) {
        str5.append(s).append(", ");
    }
    String result = str5.substring(0, str5.length() - 2); // 移除最后的逗号
    System.out.println(result);// 1,2,3

}

二、日期工具

1. 获取两个时间节点之间的月份列表

• 原始版本

/**
 * 获取两个时间节点之间的月份列表
 * 原始版本
 * @param startTime
 * @param endTime
 * @return
 */
public static List<String> getMonthListByDate(String startTime, String endTime) {
    
    ArrayList<String> result = new ArrayList<>();

    try {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM");//格式化为年月

        Calendar startDate = Calendar.getInstance();
        Calendar endDate = Calendar.getInstance();

        startDate.setTime(sdf.parse(startTime));
        startDate.set(startDate.get(Calendar.YEAR), startDate.get(Calendar.MONTH), 1);

        endDate.setTime(sdf.parse(endTime));
        endDate.set(endDate.get(Calendar.YEAR), endDate.get(Calendar.MONTH), 2);

        Calendar curr = startDate;
        while (curr.before(endDate)) {
            result.add(sdf.format(curr.getTime()));
            curr.add(Calendar.MONTH, 1);
        }
    } catch (ParseException e) {
        e.printStackTrace();
    }

    return result;
}

• 升级版

/**
 * 获取两个时间节点之间的月份列表
 * 升级版
 * @param startTime
 * @param endTime
 * @return
 */
public static List<String> getMonthListByDate(String startTime, String endTime) {
    if(StrUtil.isBlank(startTime) || StrUtil.isBlank(endTime)) {
        return Collections.emptyList();
    }
    ArrayList<String> result = new ArrayList<>();
    Date startDate = DateUtil.parse(startTime);
    Date endDate = DateUtil.parse(endTime);
    while (startDate.compareTo(endDate)<=0) {
        result.add(DateUtil.format(startDate,DatePattern.NORM_MONTH_PATTERN));
        startDate = DateUtil.offsetMonth(startDate,1);
    }
    return result;
}

2. 判断当前时间是否在某个时间范围内

• 原始版本

/**
 * 判断当前时间是否在[startTime, endTime]区间，注意时间格式要一致
 *
 * @param nowTime 当前时间
 * @param startTime 开始时间
 * @param endTime 结束时间
 * @return
 */
public static boolean isEffectiveDate(Date nowTime, Date startTime, Date endTime) {
    if(nowTime == null || startTime == null || endTime == null){
        return false;
    }
    
    if (nowTime.getTime() == startTime.getTime()
            || nowTime.getTime() == endTime.getTime()) {
        return true;
    }

    Calendar date = Calendar.getInstance();
    date.setTime(nowTime);

    Calendar begin = Calendar.getInstance();
    begin.setTime(startTime);

    Calendar end = Calendar.getInstance();
    end.setTime(endTime);

    if (date.after(begin) && date.before(end)) {
        return true;
    } else {
        return false;
    }
}

• 升级版

/**
 * 判断当前时间是否在[startTime, endTime]区间
 * 注意时间格式要一致
 * 升级版
 * @param nowTime 当前时间
 * @param startTime 开始时间
 * @param endTime 结束时间
 * @return
 */
public static boolean isEffectiveDate(Date nowTime, Date startTime, Date endTime) {
    if(nowTime == null || startTime == null || endTime == null){
        return false;
    }

    if (nowTime.getTime() == startTime.getTime()
            || nowTime.getTime() == endTime.getTime()) {
        return true;
    }

    if (nowTime.after(startTime) && nowTime.before(endTime)) {
        return true;
    } else {
        return false;
    }
}

• 豪华版

<dependency>
    <groupId>cn.hutool</groupId>
    <artifactId>hutool-all</artifactId>
    <version>5.8.25</version>
</dependency>

import cn.hutool.core.date.DateUtil;

DateUtil.isIn(Date date, Date beginDate, Date endDate);

3. 获取一段时间之后或之前的日期

• 老版本

if(null != searchVO.getPayTimeType()){
    Calendar calendar = Calendar.getInstance();
    if(ThirdPartyWarrantyOrderPayTimeTypeEnum.SEVEN_DAY.getKey().equals(searchVO.getPayTimeType())){// 近七天
        paramMap.put("startDate",DateUtil.formatDate(DateUtil.offsetDay(DateUtil.date(), -7)));
        paramMap.put("endDate",DateUtil.today());
    }else if(ThirdPartyWarrantyOrderPayTimeTypeEnum.ONE_MONTH.getKey().equals(searchVO.getPayTimeType())){// 一个月
        calendar.setTime(new Date());
        calendar.add(Calendar.MONTH, -1); //减几就是几个月之前
        paramMap.put("startDate",DateUtil.formatDate(calendar.getTime()));
        paramMap.put("endDate",DateUtil.today());
    }else if(ThirdPartyWarrantyOrderPayTimeTypeEnum.THREE_MONTH.getKey().equals(searchVO.getPayTimeType())){// 三个月
        calendar.setTime(new Date());
        calendar.add(Calendar.MONTH, -3);
        paramMap.put("startDate",DateUtil.formatDate(calendar.getTime()));
        paramMap.put("endDate",DateUtil.today());
    }else if(ThirdPartyWarrantyOrderPayTimeTypeEnum.HALF_YEAR.getKey().equals(searchVO.getPayTimeType())){// 半年
        calendar.setTime(new Date());
        calendar.add(Calendar.MONTH, -6);
        paramMap.put("startDate",DateUtil.formatDate(calendar.getTime()));
        paramMap.put("endDate",DateUtil.today());
    }else if(ThirdPartyWarrantyOrderPayTimeTypeEnum.ONE_YEAR.getKey().equals(searchVO.getPayTimeType())){// 一年
        calendar.setTime(new Date());
        calendar.add(Calendar.YEAR, -1);
        paramMap.put("startDate",DateUtil.formatDate(calendar.getTime()));
        paramMap.put("endDate",DateUtil.today());
    }
}

• 新版本

<dependency>
    <groupId>cn.hutool</groupId>
    <artifactId>hutool-all</artifactId>
    <version>5.8.25</version>
</dependency>

@Test
public void test3(){
    // 获取当前时间后一天的日期
    DateUtil.offsetDay(new Date(),1);

    // 获取当前时间前一天的日期
    DateUtil.offsetDay(new Date(),-1);

    // 获取当前时间后一个月的日期
    DateUtil.offsetMonth(new Date(),1);

    // 获取当前时间前一个月的日期
    DateUtil.offsetMonth(new Date(),-1);

    // 获取当前时间后一周的日期
    DateUtil.offsetWeek(new Date(),1);

    // 获取当前时间前一周的日期
    DateUtil.offsetWeek(new Date(),-1);

    // 以当前时间为准获取一个月中的第几天
    DateUtil.offset(new Date(), DateField.DAY_OF_MONTH,1);

}

4. 计算2个时间相差的天数、小时、分钟、秒

• 老版本

package com.shucha.deveiface.biz.test;
 
import java.text.ParseException;
import java.text.SimpleDateFormat;
 
/**
 * @author tqf
 * @Description
 * @Version 1.0
 * @since 2022-04-18 11:30
 */
public class DateDiff {
 
    /**
     * @return Long
     * @Author hzg
     * @Description // 计算 2 个时间相差的天数、小时、分钟、秒
     * @Date 2024-01-19 10:31
     * @Param [startTime, endTime, format, dateFormatEnum]
     **/
    public static String dateDiff(String startTime, String endTime, String format, DateFormatEnum dateFormatEnum) {
        SimpleDateFormat sd = new SimpleDateFormat(format);
        long nd = 1000 * 24 * 60 * 60;// 一天的毫秒数
        long nh = 1000 * 60 * 60;// 一小时的毫秒数
        long nm = 1000 * 60;// 一分钟的毫秒数
        long ns = 1000;// 一秒钟的毫秒数
        long diff;
        long day = 0;
        long hour = 0;
        long min = 0;
        long second = 0;
        // 获得两个时间的毫秒时间差异
        try {
            diff = sd.parse(endTime).getTime() - sd.parse(startTime).getTime();
            // 计算差多少天
            day = diff / nd;
            // 计算差多少小时
            hour = diff / nh;
            // 计算差多少分钟
            min = diff / nm;
            // 计算差多少秒
            second = diff / ns;
        } catch (ParseException e) {
            e.printStackTrace();
        }
        if (dateFormatEnum.getKey().equalsIgnoreCase(DateFormatEnum.DAY.getKey())) {
            return String.valueOf(day);
        } else if (dateFormatEnum.getKey().equalsIgnoreCase(DateFormatEnum.HOUR.getKey())) {
            return String.valueOf(hour);
        } else if (dateFormatEnum.getKey().equalsIgnoreCase(DateFormatEnum.MIN.getKey())) {
            return String.valueOf(min);
        } else if (dateFormatEnum.getKey().equalsIgnoreCase(DateFormatEnum.SECOND.getKey())) {
            return String.valueOf(second);
        } else if (dateFormatEnum.getKey().equalsIgnoreCase(DateFormatEnum.DAY_HOUR_MIN_SECOND.getKey())) {
            return day + "天" + (hour - day * 24) + "时" + (min - day * 24 * 60) + "分" + second % 60 + "秒";
        } else if (dateFormatEnum.getKey().equalsIgnoreCase(DateFormatEnum.DAY_HOUR_MIN.getKey())) {
            return day + "天" + (hour - day * 24) + "时" + (min - day * 24 * 60) + "分";
        } else if (dateFormatEnum.getKey().equalsIgnoreCase(DateFormatEnum.DAY_HOUR.getKey())) {
            return day + "天" + (hour - day * 24) + "时";
        } else if (dateFormatEnum.getKey().equalsIgnoreCase(DateFormatEnum.MIN_SECOND.getKey())) {
            return (min - day * 24 * 60) + "分" + second % 60 + "秒";
        } else {
            return null;
        }
    }
 
    public static void main(String[] args) {
        System.out.println("相差多少天：" + dateDiff(
                "2022-04-18 11:31:25",
                "2022-04-19 12:31:25",
                "yyyy-MM-dd HH:mm:ss",
                "day"));
        System.out.println("相差多少小时：" + dateDiff(
                "2022-04-18 11:31:25",
                "2022-04-19 12:31:25",
                "yyyy-MM-dd HH:mm:ss",
                "hour"));
        System.out.println("相差多少分钟：" + dateDiff(
                "2022-04-18 11:31:25",
                "2022-04-18 12:31:25",
                "yyyy-MM-dd HH:mm:ss",
                "min"));
        System.out.println("相差多少秒：" + dateDiff(
                "2022-04-18 11:31:25",
                "2022-04-18 12:31:25",
                "yyyy-MM-dd HH:mm:ss",
                "sec"));
    }
}

• 升级版

<dependency>
    <groupId>cn.hutool</groupId>
    <artifactId>hutool-all</artifactId>
    <version>5.8.25</version>
</dependency>

@Test
public void test4(){
    Date beginDate = DateUtil.parse("2024-01-01");
    Date endDate = DateUtil.parse("2024-09-30");
    // isAbs:是否只保留绝对值正数
    System.out.println(DateUtil.between(beginDate, endDate, DateUnit.DAY, true));
}

5. 秒转时分秒

-- 第一种方案：可以自定义格式
/**
  * 秒转时分秒
  * @param second
  * @return
  */
 public static String getFormatTimeBySecond(Integer second) {
     if (second != null) {
         if(second < 60) {//秒
             return 0 + "时"+ 0 + "分" + second+ "秒";
         }
         if(second < 3600) {//分
             return 0 + "时" + second / 60 + "分" + second % 60+ "秒";
         }
         return second/ 60 / 60 + "时" + second/ 60 % 60 + "分" + second% 60+ "秒";
     }
     return "--";
 }

-- 第二种方法方便，但是没法自定义格式
@Test
public void test5(){
    // 秒转时分秒(HH:mm:ss)
    System.out.println(DateUtil.secondToTime(656568));
    // 结果 182:22:48
}

三、Map操作

1. 对象创建时初始化的六种方法

• 使用Collections.singletonMap()初始化

Collections.singletonMap()可以为HashMap初始一个key和value。

import java.util.*;
 
public class Main {
  public static void main(String[] args) {
    Map m1 = Collections.singletonMap("key1", "value1");
    System.out.println(m1);
    System.exit(0); //success
  }
}

• Map.of()

注意：Java 9及以上版本，可以使用Map.of()对HashMap对象进行初始化。最多适用于10个元素。

import java.util.*;
 
public class Main {
  public static void main(String[] args) {
    Map m1 = Map.of(
        "C", "cjavapy",
        "Java", "code"
    );
    System.out.println(m1);
    System.exit(0); //success
  }
}

• Map.ofEntries()

注意：Java 9及以上版本，可以使用Map.ofEntries()对HashMap对象进行初始化。适用于任何数量的元素。

import java.util.*; 
import static java.util.Map.entry;
 
public class Main {
  public static void main(String[] args) {
   Map m2 = Map.ofEntries(
       entry("C", "cjavapy"),
       entry("Java", "code")
   );
    System.out.println(m2);
    System.exit(0); //success
  }
}

相关文档：docs.oracle.com/javase/9/do…

• 使用初始化器

Java 8及以上版本，可以在匿名子类中使用初始化器来实现。

import java.util.*;

public class Main {
  public static void main(String[] args) {
    Map m1 = new HashMap() {{
        put("C", "cjavapy");
        put("Java", "code");
    }};
    System.out.println(m1);
    System.exit(0); //success
  }
}

• ImmutableMap.of()

可以使用ImmutableMap.of()指定初始化的key和value
相关文档：github.com/google/guav…

Map left = ImmutableMap.of("C", 1, "Java", 2, "Python", 3);

• Java 8中 Stream.of()

Java 8中，可以使用Streams/collector来初始化。

import java.util.*;
import static java.util.stream.Collectors.toMap;
import java.util.AbstractMap.SimpleEntry;
import java.util.stream.Stream;
 
public class Main {
  public static void main(String[] args) {
    Map m1 = Stream.of(
         new SimpleEntry<>("key1", "value1"),
         new SimpleEntry<>("key2", "value2"),
         new SimpleEntry<>("key3", "value3"))
        .collect(toMap(SimpleEntry::getKey, SimpleEntry::getValue)); 
    System.out.println(m1);
    System.exit(0); //success
  }
}

2. 相同key将值相加，不同key put进map

@AllArgsConstructor
@Data
public class TestOneClass {
    private String name;
    private Double price;
}

@Test
public void test7() {
    List<TestOneClass> testOneClasses = Arrays.asList(
            new TestOneClass("a", 1.0),
            new TestOneClass("b", 2.0),
            new TestOneClass("a", 5.0)
    );

    Map<String, Double> doubleMap = new HashMap<>();
    testOneClasses.forEach(obj -> {
        doubleMap.merge(obj.getName(), obj.getPrice(), Double::sum);
    });
    System.out.println(doubleMap);// 结果： {a=6.0, b=2.0}
}

3. 循环遍历 Map 的五种方式

• 第一种：通过Map.keySet遍历key和value

@Test
public void test1(){
    Map<String,Object> map = Stream.of(
                    new AbstractMap.SimpleEntry<>("key1", "value1"),
                    new AbstractMap.SimpleEntry<>("key2", "value2"),
                    new AbstractMap.SimpleEntry<>("key3", "value3"))
            .collect(toMap(AbstractMap.SimpleEntry::getKey, AbstractMap.SimpleEntry::getValue));

    map.keySet().forEach(key -> System.out.println("map.get(" + key + ") = " + map.get(key)));
    // 结果：
    // map.get(key1) = value1
    // map.get(key2) = value2
    // map.get(key3) = value3
}

• 第二种：通过Map.entrySet使用Iterator遍历key和value

@Test
public void test2() {
    Map<String, Object> map = Stream.of(
                    new AbstractMap.SimpleEntry<>("key1", "value1"),
                    new AbstractMap.SimpleEntry<>("key2", "value2"),
                    new AbstractMap.SimpleEntry<>("key3", "value3"))
            .collect(toMap(AbstractMap.SimpleEntry::getKey, AbstractMap.SimpleEntry::getValue));
    /************************普通for循环遍历************************************/
    for (Map.Entry<String, Object> entry : map.entrySet()) {
        System.out.println("key:value = " + entry.getKey() + ":" + entry.getValue());
    }
    /************************java8 forEach遍历************************************/
    map.entrySet().iterator().forEachRemaining(item -> System.out.println("key:value=" + item.getKey() + ":" + item.getValue()));
    // 打印结果：
    // key:value=key1:value1
    // key:value=key2:value2
    // key:value=key3:value3
}

• 第三种：通过Map.entrySet遍历key和value（在大容量时推荐使用）

@Test
public void test3() {
    Map<String, Object> map = Stream.of(
                    new AbstractMap.SimpleEntry<>("key1", "value1"),
                    new AbstractMap.SimpleEntry<>("key2", "value2"),
                    new AbstractMap.SimpleEntry<>("key3", "value3"))
            .collect(toMap(AbstractMap.SimpleEntry::getKey, AbstractMap.SimpleEntry::getValue));
    /************************普通for循环遍历************************************/
    for (Map.Entry<String, Object> entry : map.entrySet()) {
        System.out.println("key:value = " + entry.getKey() + ":" + entry.getValue());
    }
    /************************java8 forEach遍历************************************/
    map.forEach((key, value) -> System.out.println("key:value = " + key + ":" + value));
    // 打印结果：
    // key:value = key1:value1
    // key:value = key2:value2
    // key:value = key3:value3
}

• 第四种：通过Map.values()遍历所有的value，但不能遍历key

@Test
public void test4() {
    Map<String, Object> map = Stream.of(
                    new AbstractMap.SimpleEntry<>("key1", "value1"),
                    new AbstractMap.SimpleEntry<>("key2", "value2"),
                    new AbstractMap.SimpleEntry<>("key3", "value3"))
            .collect(toMap(AbstractMap.SimpleEntry::getKey, AbstractMap.SimpleEntry::getValue));
    /************************普通for循环遍历************************************/
    for (Object value : map.values()) {
        System.out.println("map.value = " + value);
    }
    // 打印结果：
    // map.value = value1
    // map.value = value2
    // map.value = value3
    /************************java8 forEach遍历************************************/
    map.values().forEach(System.out::println);
    // 打印结果：
    // value1
    // value2
    // value3
}

• 第五种：通过k,v遍历，Java8独有的

@Test
public void test5() {
    Map<String, Object> map = Stream.of(
                    new AbstractMap.SimpleEntry<>("key1", "value1"),
                    new AbstractMap.SimpleEntry<>("key2", "value2"),
                    new AbstractMap.SimpleEntry<>("key3", "value3"))
            .collect(toMap(AbstractMap.SimpleEntry::getKey, AbstractMap.SimpleEntry::getValue));
    map.forEach((k, v) -> System.out.println("key:value = " + k + ":" + v));
    // 打印结果：
    // key:value = key1:value1
    // key:value = key2:value2
    // key:value = key3:value3
}

4. 默认值的使用

@Test
public void test31() {
    Map<String,Object> map = new HashMap<>();
    map.put("a",1);
    System.out.println(map.getOrDefault("b",2));
    // 2
}

5. 统计集合元素个数

• 第一种方式：

@Test
public void test32(){
    Map<String,Integer> map = new HashMap<>(8);
    List<String> list = Arrays.asList("apple","orange","banana","orange");
    for (String s : list) {
        map.merge(s,1,Integer::sum);
    }
    System.out.println(map);
    // {banana=1, orange=2, apple=1}
}

• 第二种方式：

@Test
public void test34(){
    Map<String,Integer> map = new HashMap<>(8);
    List<String> list = Arrays.asList("apple","orange","banana","orange");
    for (String s : list) {
        map.compute(s,(k,v)->v==null?1:v+1);
    }
    System.out.println(map);
    // {banana=1, orange=2, apple=1}
}

6. 赋值但不能覆盖已存在的key

public void test32(){
    Map<String,Object> map = new HashMap<>();
    map.put("a",1);
    map.putIfAbsent("a",2);
    map.putIfAbsent("b",3);
    System.out.println(map);
    // {a=1, b=3}
}

四、集合操作

1. 创建集合的九种方式

• 第一种：常规方式

@Test
public void test1(){
    List<String> list = new ArrayList<>();
    list.add("1");
    list.add("2");
    list.add("3");
    System.out.println("getList: " + list);
    // getList: [1, 2, 3]
}

• 第二种：Arrays 工具类（不可变）

@Test
public void test2(){
    // 生成的list不可变
    List<String> list = Arrays.asList("1", "2", "3");
    System.out.println("getList: " + list);// getList: [1, 2, 3]
    // 如果要可变需要用ArrayList包装一下
    List<String> numbers = new ArrayList<>(Arrays.asList("1", "2", "3"));
    numbers.add("4");
    System.out.println("getList: " + numbers); // getList: [1, 2, 3, 4]
}

• 第三种：Collections 工具类（不可变）

@Test
public void test3() {
    // 生成的list不可变
    List<String> list = Collections.nCopies(3, "1");
    System.out.println("getList: " + list);// getList: [1, 1, 1]
    // 如果要可变需要用ArrayList包装一下
    List<String> dogs = new ArrayList<>(Collections.nCopies(3, "1"));
    dogs.add("1");
    System.out.println("getList: " + dogs); // getList: [1, 1, 1, 1]
}

• 第四种：Lists 工具类

<dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>33.2.1-jre</version>
</dependency>

@Test
public void test4() {
    // 生成的List可变
    List<String> list = Lists.newArrayList("1", "2", "3");
    list.add("4");
    System.out.println("getList: " + list); // getList: [1, 2, 3, 4]
}

• 第五种：匿名内部类

@Test
public void test5() {
    List<String> list = new ArrayList<String>() {{
        add("1");
        add("2");
        add("3");
    }};
    System.out.println("getList: " + list); // getList: [1, 2, 3]
}

• 第六种：ImmutableList（不可变）

<dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>33.2.1-jre</version>
</dependency>

@Test
public void test6() {
    // 生成的list不可变
    List<String> list = ImmutableList.of("1", "2", "3");
    System.out.println("getList: " + list); // getList: [1, 2, 3]
}

• 第七种：Java8 Stream

@Test
public void test7() {
    // 生成的list可变
    List<String> list = Stream.of("1", "2", "3").collect(Collectors.toList());
    list.add("4");
    System.out.println("getList: " + list); // getList: [1, 2, 3, 4]
}

• 第八种：Java9 List.of

List<String> list = List.of{"1", "2", "3"};

• 第九种：CollUtil/CollectionUtil（Hutool）

<dependency>
    <groupId>cn.hutool</groupId>
    <artifactId>hutool-all</artifactId>
    <version>5.8.25</version>
</dependency>

@Test
public void test8() {
    // 生成的list可变
    List<String> list = CollUtil.newArrayList("1", "2", "3");
    list.add("4");
    System.out.println("getList: " + list); // getList: [1, 2, 3, 4]
}

@Test
public void test9() {
    // 生成的list可变
    List<String> list = CollectionUtil.newArrayList("1", "2", "3");
    list.add("4");
    System.out.println("getList: " + list); // getList: [1, 2, 3, 4]
}

2. 创建空集合的两种方式

• 第一种：原始方法

@Test
public void test10() {
    List<String> list = new ArrayList<>();
}

• 第二种：Collections 工具类

@Test
public void test10() {
    List<String> list1 = Collections.emptyList();
    List list2 = Collections.EMPTY_LIST;
}

3. 统计集合中某个元素的个数

@Test
public void test11() {
    // 统计集合中2的个数
    List<String> list = CollectionUtil.newArrayList("1", "2", "3","1");
    int count = Collections.frequency(list, "1");
    System.out.println("getCount: " + count); // getCount: 2
}

4. 集合去重的 6 种方法

• HashSet 去重

我们知道 HashSet 天生具备“去重”的特性，那我们只需要将 List 集合转换成 HashSet 集合就可以了，实现代码如下：

public class ListDistinctExample {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<Integer>() {{
            add(1);add(3);add(5);add(2);add(1);
            add(3);add(7);add(2);
        }};
        System.out.println("原集合:" + list);
        method_2(list);
    }
    /**
     * 使用 HashSet 去重
     * @param list
     */
    public static void method_2(List<Integer> list) {
        HashSet<Integer> set = new HashSet<>(list);
        System.out.println("去重集合:" + set);
    }
}

以上程序执行的结果：

• TreeSet 去重

除了HashSet集合之外，我们还可以使用 TreeSet 集合来实现去重功能，实现代码如下：、

public class ListDistinctExample {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<Integer>() {{
            add(1);add(3);add(5);add(2);add(1);
            add(3);add(7);add(2);
        }};
        System.out.println("原集合:" + list);
        method_4(list);
    }
    /**
     * 使用 TreeSet 去重(无序)
     * @param list
     */
    public static void method_4(List<Integer> list) {
        TreeSet<Integer> set = new TreeSet<>(list);
        System.out.println("去重集合:" + set);
    }
}

以上程序执行的结果：

• LinkdHashSet 去重

如果上面的Set 不能满足需求，那就使用 LinkedHashSet，它既能去重又能保证集合的顺序，实现代码如下：

public class ListDistinctExample {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<Integer>() {{
            add(1);add(3);add(5);add(2);add(1);
            add(3);add(7);add(2);
        }};
        System.out.println("原集合:" + list);
        method_3(list);
    }
    /**
     * 使用 LinkedHashSet 去重
     * @param list
     */
    public static void method_3(List<Integer> list) {
        LinkedHashSet<Integer> set = new LinkedHashSet<>(list);
        System.out.println("去重集合:" + set);
    }
}

以上程序执行的结果：

• 迭代器去重

public class ListDistinctExample {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<Integer>() {{
            add(1);add(3);add(5);add(2);add(1);
            add(3);add(7);add(2);
        }};
        System.out.println("原集合:" + list);
        method_1(list);
    }
    /**
     * 使用迭代器去重
     * @param list
     */
    public static void method_1(List<Integer> list) {
        Iterator<Integer> iterator = list.iterator();
        while (iterator.hasNext()) {
            // 获取循环的值
            Integer item = iterator.next();
            // 如果存在两个相同的值
            if (list.indexOf(item) != list.lastIndexOf(item)) {
                // 移除最后那个相同的值
                iterator.remove();
            }
        }
        System.out.println("去重集合:" + list);
    }
}

以上程序执行的结果：

• Stream 去重（推荐）

public class ListDistinctExample {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<Integer>() {{
            add(1);add(3);add(5);add(2);add(1);
            add(3);add(7);add(2);
        }};
        System.out.println("原集合:" + list);
        method_5(list);
    }
    /**
     * 使用 Stream 去重
     * @param list
     */
    public static void method_5(List<Integer> list) {
        list = list.stream().distinct().collect(Collectors.toList());
        System.out.println("去重集合:" + list);
    }
}

以上程序执行的结果：

• contains 判断去重

新建一个集合，然后循环原来的集合，每次循环判断原集合中的循环项，如果当前循环的数据，没有在新集合中存在就插入，已经存在了就舍弃，就得到了一个没有重复元素的集合了

public class ListDistinctExample {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<Integer>() {{
            add(1);add(3);add(5);add(2);add(1);
            add(3);add(7);add(2);
        }};
        System.out.println("原集合:" + list);
        method(list);
    }
    /**
     * 自定义去重
     * @param list
     */
    public static void method(List<Integer> list) {
        // 新集合
        List<Integer> newList = new ArrayList<>(list.size());
        list.forEach(i -> {
            if (!newList.contains(i)) { // 如果新集合中不存在则插入
                newList.add(i);
            }
        });
        System.out.println("去重集合:" + newList);
    }
}

五、Hutool

1. 校验格式

Validator
例如：

 // 验证是否为可用邮箱地址
 Validator.isEmail();
 
 // 验证是否为手机号码（中国）
 Validator.isMobile();
 
 // 验证是否为身份证号码（支持18位、15位和港澳台的10位）
 Validator.isCitizenId();
 
 // 验证是否为中国车牌号
 Validator.isCitizenId();
 
 // 验证是否为URL
 Validator.isUrl();
 
 // 是否是有效的统一社会信用代码
 Validator.isCreditCode();
 
 // 验证是否为车架号；别名：行驶证编号 车辆识别代号 车辆识别码
 Validator.isCarVin();
 
 // 验证是否为驾驶证 别名：驾驶证档案编号、行驶证编号 仅限：中国驾驶证档案编号
 Validator.isCarDrivingLicence();

2. 日期格式化

DatePattern:常用日期格式化（DatePattern.NORM_DATETIME_PATTERN）
DateUtils.YYYY_MM_DD_HH_MM_SS

// 日期转指定格式字符串
String dateStr = DateUtil.format(DateUtil.date(), DatePattern.NORM_DATE_PATTERN);
String dateStr = DateUtils.parseDateToStr(DateUtils.YYYY_MM_DD_HH_MM_SS, DateUtil.date());

String format = DateUtil.format(date, "yyyy/MM/dd");// 结果 2017/03/01
String formatDate = DateUtil.formatDate(date);// 常用格式的格式化，结果：2017-03-01
String formatDateTime = DateUtil.formatDateTime(date);// 结果：2017-03-01 00:00:00
String formatTime = DateUtil.formatTime(date);// 结果：00:00:00


// 字符串转日期
String timeStr = "2023-03-03 09:06:08";
Date date = DateUtil.parse(timeStr );// 会照字符串原样转为对应日期 2023-03-03 09:06:08
Date date = DateUtil.parse(timeStr,"yyyy-MM-dd");// 只会转指定格式化部门，剩下补00 2023-03-03 00:00:00


// 常用日期举例
Date date1 = DateUtil.date();// 当前时间：2023-03-16 11:17:04
Date date2 = DateUtil.date(Calendar.getInstance());// 当前时间：2023-03-16 11:18:15

String now = DateUtil.now();// 当前时间字符串：2023-03-16 11:19:12
String today= DateUtil.today();// 当前日期字符串，格式：yyyy-MM-dd：2023-03-16

// 计算时长
DateUtil.formatBetween(bgateVehicleInOutRecordDto.getInTime(), bgatePayOrderDto.getChargeEndTime(), BetweenFormatter.Level.SECOND)

六、对象操作

1. 复制

在 Java 中，当你复制对象时，浅拷贝和深拷贝是两个不同的概念。如果你只是复制对象的引用，而没有复制对象的内容，可能会导致修改一个对象时影响到其他对象。

• 浅拷贝

class Person {
    String name;

    Person(String name) {
        this.name = name;
    }
}

public class Test {
    public static void main(String[] args) {
        Person p1 = new Person("Alice");
        Person p2 = p1;  // 浅拷贝，只复制引用       p2.name = "Bob";       
        System.out.println(p1.name);  // 输出 "Bob"，影响了 p1   
    }
}

如果需要创建独立的副本，使用深拷贝。深拷贝是通过手动复制对象及其引用的对象来实现的。

• 深拷贝

class Person {
    String name;

    Person(String name) {
        this.name = name;
    }   // 实现深拷贝   

    public Person deepCopy() {
        return new Person(new String(this.name));  // 深拷贝   
    }
}

public class Test {
    public static void main(String[] args) {
        Person p1 = new Person("Alice");
        Person p2 = p1.deepCopy();  // 深拷贝       p2.name = "Bob";       
        System.out.println(p1.name);  // 输出 "Alice"，没有影响 p1   
    }
}