Hutoolcore笔记

返回上一级

克隆

    @Test
    public void fileTest(){
        try {
            Cat1 cat1 = new Cat1().clone();
            System.out.println(cat1.name);
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        Cat2 cat2 = new Cat2().clone();
        System.out.println(cat2.name);
        Cat3 cat3 = new Cat3().clone();
        System.out.println(cat3.list);

        // 深克隆，必须实现序列化接口，引用类型是新的，浅克隆两个对象使用同一个引用类型
        Cat3 cat31 = ObjectUtil.cloneByStream(new Cat3());
        System.out.println(cat31.list);
    }

    //使用jdk原生接口，没有强制实现克隆方法，要使用，调用方需要捕获异常
    public static class  Cat1 implements java.lang.Cloneable{
        private String name="cat1";

        @Override
        protected Cat1 clone() throws CloneNotSupportedException {
            return (Cat1) super.clone();
        }
    }

    //Hutool提供克隆接口，定义了一个方法，必须实现
    public static class Cat2 implements Cloneable<Cat2> {
        private String name="cat2";
        @Override
        public Cat2 clone() {
            try {
                return (Cat2) super.clone();
            } catch (CloneNotSupportedException e) {
                e.printStackTrace();
                throw new CloneRuntimeException(e);
            }
        }
    }

    // 提供继承类，可以不实现方法，父类直接实现好，但是必须是类没有继承其他类
    public static class Cat3 extends CloneSupport<Cat3> implements Serializable {
        private String name="cat3";
        private List<String> list= Arrays.asList("11","22");
    }

类型转换

    /**
     * 常用数据类型转换
     */
    @Test
    public void convertTest01(){
        // 类型转换
        Convert.toStr(1);
        // 数组转换
        String[] b = { "1", "2", "3", "4" };
        String str = Convert.toStr(b);
        Integer[] intArray = Convert.toIntArray(b);
        // 转日期
        String a = "2021-04-06";
        Date value = Convert.toDate(a);
        // 转集合
        Object[] c = {"a", "你", "好", "", 1};
        List<?> list = Convert.toList(c);
        // 转指定泛型集合,其他类型元素都会转成指定泛型
        Object[] d = { "a", "你", "好", "", 1 };
        List<String> strings = Convert.toList(String.class, d);
    }

    // 字符串 16进制互相转换
    @Test
    public void convertTest02(){
        // 转换必须传入编码格式
        String a="侯";
        String hex = Convert.toHex(a, CharsetUtil.CHARSET_UTF_8);
        System.out.println(hex);
        String raw = Convert.hexToStr(hex, CharsetUtil.CHARSET_UTF_8);
        System.out.println(raw);
    }

    // Unicode 字符串互相转换
    @Test
    public void convertTest03(){
        String a = "平安";
        String unicode = Convert.strToUnicode(a);
        System.out.println(unicode);// \u5e73\u5b89
        String raw = Convert.unicodeToStr(unicode);
    }

    @Test
    public void convertTest04(){
        // 编码转换
        String a = "我不是乱码";
        //转换后result为乱码, 从UTF_8转为ISO_8859_1
        String result = Convert.convertCharset(a, CharsetUtil.UTF_8, CharsetUtil.ISO_8859_1);
        String raw = Convert.convertCharset(result, CharsetUtil.ISO_8859_1, "UTF-8");
        System.out.println(raw);
    }

    @Test
    public void convertTest05(){
        // 时间单位转换，年月日时分秒换算等
        long a = 4535345;
        //秒->分
        long minutes = Convert.convertTime(a, TimeUnit.MILLISECONDS, TimeUnit.MINUTES);
    }

    @Test
    public void convertTest06(){
        // 金额大小写转换,只能转到分，再后面小数会被忽略
        double a = 67556.32;
        //陆万柒仟伍佰伍拾陆元叁角贰分
        String digitUppercase = Convert.digitToChinese(a);// 默认是繁体
        // 是否使用繁体字
        String numberToChinese = Convert.numberToChinese(a, false);
        // 六万七千五百五十六点三二
        System.out.println(numberToChinese);
    }

    /**
     * 半角符号和全角符号转换
     * 全角：占两个标注字符的位置
     * 半角：占一个标注字符的位置
     * 简单说：全角看起来有空格，半角没有
     */
    @Test
    public void convertTest07(){
        // 半角->全角
        String a = "1,2.3456789";
        String sbc = Convert.toSBC(a);
        System.out.println(sbc);
        // 全角->半角
        String b = "１２３４５６７８９";
        String dbc = Convert.toDBC(b);
        System.out.println(dbc);
    }

日期工具类

    // 日期转换
    @Test
    public void dateUtilTest01(){
        //获取当前时间三种方式
        Date date = DateUtil.date();
        Date date2 = DateUtil.date(Calendar.getInstance());
        Date date3 = DateUtil.date(System.currentTimeMillis());
        //当前时间字符串，格式：yyyy-MM-dd HH:mm:ss
        String now = DateUtil.now();
        //当前日期字符串，格式：yyyy-MM-dd
        String today= DateUtil.today();

        // 字符串转日期
        String dateStr = "2017-03-01";
        Date date4 = DateUtil.parse(dateStr, "yyyy-MM-dd");
        // 日期转字符串
        //结果 2017/03/01
        String format = DateUtil.format(date4, "yyyy/MM/dd");

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


    @Test
    public void dateUtilTest02(){
        // 获取日期某个部分
        Date date = DateUtil.date();
        //获得年的部分
        DateUtil.year(date);
        //获得月份，从0开始计数
        DateUtil.month(date);
        //获得月份枚举
        DateUtil.monthEnum(date);
        // 获取开始时间和结束时间
        String dateStr = "2017-03-01 22:33:23";
        Date date1 = DateUtil.parse(dateStr);

        //一天的开始，结果：2017-03-01 00:00:00
        Date beginOfDay = DateUtil.beginOfDay(date);

        //一天的结束，结果：2017-03-01 23:59:59
        Date endOfDay = DateUtil.endOfDay(date);
    }

    @Test
    public void dateUtilTest03(){
        // 时间偏移
        String dateStr = "2017-03-01 22:33:23";
        Date date = DateUtil.parse(dateStr);

        //结果：2017-03-03 22:33:23
        Date newDate = DateUtil.offset(date, DateField.DAY_OF_MONTH, 2);

        //常用偏移，结果：2017-03-04 22:33:23
        DateTime newDate2 = DateUtil.offsetDay(date, 3);

        //常用偏移，结果：2017-03-01 19:33:23
        DateTime newDate3 = DateUtil.offsetHour(date, -3);
        //当前时间简化API偏移
        //昨天
        DateUtil.yesterday();
        //明天
        DateUtil.tomorrow();
        //上周
        DateUtil.lastWeek();
        //下周
        DateUtil.nextWeek();
        //上个月
        DateUtil.lastMonth();
        //下个月
        DateUtil.nextMonth();

        // 时间差
        String dateStr1 = "2017-03-01 22:33:23";
        Date date1 = DateUtil.parse(dateStr1);
        String dateStr2 = "2017-04-01 23:36:55";
        Date date2 = DateUtil.parse(dateStr2);
        // 时间差： 单位  输出：31
        long betweenDay = DateUtil.between(date1, date2, DateUnit.DAY);
        System.out.println(betweenDay);
        // 格式化输出时间差
        //Level表示精确单位，如果为0 则不显示：
        String formatBetween = DateUtil.formatBetween(date1, date2, BetweenFormater.Level.SECOND);
        //输出：31天1小时3分32秒
        Console.log(formatBetween);
    }

    @Test
    public void dateUtilTest04(){
        // 计时器
        TimeInterval timer = DateUtil.timer();

        //-------这是执行过程

        timer.interval();//花费毫秒数
        timer.intervalRestart();//返回花费时间，并重置开始时间
        long minute = timer.intervalMinute();//花费分钟数

        // 星座和属相，年龄
        // 1月19 是 "摩羯座"
        String zodiac = DateUtil.getZodiac(Month.JANUARY.getValue(), 19);
        // "狗"
        String chineseZodiac = DateUtil.getChineseZodiac(1994);
        //年龄
        DateUtil.ageOfNow("1990-01-30");
        //是否闰年
        DateUtil.isLeapYear(2017);
    }

日期对象

/**
 * DateTime类继承于java.util.Date类，覆盖了toString()方法，
 * 返回yyyy-MM-dd HH:mm:ss形式的字符串，提供了众多便捷的方法对日期对象操作
 * 这些方法多是DateUtil静态方法的对象表现形式，使用DateTime对象可以完全替代开发中Date对象
 */
public class DateTimeTest {

    @Test
    public void test01(){
        // 构造器
        //new方式创建
        DateTime time = new DateTime(new Date());
        // 指定格式
        DateTime dateTime = new DateTime("2017-01-05 12:34:23", DatePattern.NORM_DATETIME_FORMAT);
        Console.log(time);
        //of方式创建
        DateTime now = DateTime.now();
        DateTime dt = DateTime.of(DateUtil.yesterday());
    }

    @Test
    public void test02(){
        DateTime dateTime = new DateTime("2021-01-05 12:34:23", DatePattern.NORM_DATETIME_FORMAT);

        //年，结果：2021
        int year = dateTime.year();

        //月份，结果：Month.JANUARY
        Month month = dateTime.monthEnum();

        //日，结果：5
        int day = dateTime.dayOfMonth();
    }

    @Test
    public void test03(){
        // DateTime对象默认是可变对象（调用offset、setField、setTime方法默认变更自身，还是原来的对象），
        // 可以调用setMutable(false)方法使其变为不可变对象。
        // 在不可变模式下，offset、setField方法返回一个新对象，setTime方法抛出异常。

        DateTime dateTime = new DateTime("2017-01-05 12:34:23", DatePattern.NORM_DATETIME_FORMAT);

        //默认情况下DateTime为可变对象，此时offset == dateTime
        DateTime offset = dateTime.offset(DateField.YEAR, 1);
        // 此时dateTime已经被改变，offset=dateTime
        System.out.println(dateTime);

        //设置为不可变对象后变动将返回新对象，此时offset != dateTime
        dateTime.setMutable(false);
        offset = dateTime.offset(DateField.YEAR, 0);
    }
}

中国日期

    @Test
    public void test01(){
        // 构造器
        //通过农历日期构建
        ChineseDate chineseDate = new ChineseDate(1992,12,14);
        //通过公历构建
        ChineseDate chineseDate1 = new ChineseDate(DateUtil.parseDate("1993-01-06"));
    }

    @Test
    public void test02(){
        //通过公历构建
        ChineseDate date = new ChineseDate(DateUtil.parseDate("2020-01-25"));
        // 一月
        date.getChineseMonth();
        // 正月
        date.getChineseMonthName();
        // 初一
        date.getChineseDay();
        // 庚子
        date.getCyclical();
        // 生肖：鼠
        date.getChineseZodiac();
        // 传统节日（部分支持，逗号分隔）：春节
        date.getFestivals();
        // 庚子鼠年 正月初一
        date.toString();
        // 获取天干地支： 庚子年甲申月癸卯日
         date.getCyclicalYMD();
    }