编码技巧——时间工具类

最新推荐文章于 2022-08-24 16:34:28 发布
最新推荐文章于 2022-08-24 16:34:28 发布
阅读量411 收藏
点赞数
分类专栏： 代码技巧 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/minghao0508/article/details/123972598
版权

时间工具类，包括JDK8的时间相关的API包装、Date类与新的JDK8实践类的转换、打印格式、判断条件等；

import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.*;
import java.time.temporal.ChronoUnit;
import java.util.Calendar;
import java.util.Date;

/**
 * @Description 日期工具类
 */
public class DateUtil {

    private static final Logger LOGGER = LoggerFactory.getLogger(DateUtil.class);

    public static final String DATE_FORMAT_1 = "yyyy-MM-dd";

    public static final String DATE_FORMAT_2 = "yyyyMMdd";

    public static final String DATE_FORMAT_3 = "yyyy年MM月dd日";

    public static final String DATE_FORMAT_4 = "yyyy/MM/dd";

    public static final String DATE_FORMAT_5 = "yyyy.MM.dd";

    public static final String DATE_FORMAT_6 = "yyyy年MM月";

    public static final String DATE_FORMAT_7 = "yyyy.M.d";

    public static final String DATETIME_FORMAT_1 = "yyyy-MM-dd HH:mm:ss";

    public static final String DATETIME_FORMAT_3 = "yyyy-MM-dd HH-mm-ss";

    public static final String DATETIME_FORMAT_2 = "yyyyMMddHHmmss";

    public static final String DATETIME_FORMAT_4 = "yyyy/MM/dd HH:mm:ss";

    public static final String DATETIME_FORMAT_5 = "yyyy-MM-dd HH:mm";

    public static final String MONTH_FORMAT_1 = "M月d日";

    public static final String MONTH_FORMAT_2 = "MM-dd";

    public static final String MONTH_FORMAT_3 = "M月d日 HH点";

    public static final String MONTH_FORMAT_4 = "M月d日 HH:mm";

    public static final int DIFFER_IN_SECOND = 0;

    public static final int DIFFER_IN_MINUTE = 1;

    public static final int DIFFER_IN_HOUR = 2;

    public static final int DIFFER_IN_DAY = 3;

    public static final String DEF_DATE_FORMAT = DATETIME_FORMAT_1;

    public static final String DEF_DATE_FORMAT_SHORT = DATE_FORMAT_1;

    private DateUtil() {
        throw new IllegalStateException("Utility class");
    }

    public static Date toDate(String str) {
        try {
            if (StringUtils.isNotEmpty(str) && str.indexOf(' ') == -1) {
                str += " 00:00:00";
            }
            SimpleDateFormat sdf = new SimpleDateFormat(DEF_DATE_FORMAT);
            return sdf.parse(str);
        } catch (Exception e) {
            return null;
        }
    }

    public static String toString(Date date) {
        SimpleDateFormat sdf = new SimpleDateFormat(DEF_DATE_FORMAT);
        return sdf.format(date);
    }

    public static String toShortString(Date date) {
        return toStringByFormat(date, DEF_DATE_FORMAT_SHORT);
    }

    public static String toStringByFormat(Date date, String format) {
        SimpleDateFormat sdf = new SimpleDateFormat(format);
        return sdf.format(date);
    }

    public static Date getDate(int addDay) {
        Calendar calendar = Calendar.getInstance();
        calendar.add(Calendar.DAY_OF_YEAR, addDay);
        return calendar.getTime();
    }

    public static Date getToday(String format) {
        SimpleDateFormat sdf = getDateFormat(format);
        try {
            return sdf.parse(sdf.format(new Date()));
        } catch (ParseException e) {
            LOGGER.error("获取当天日期异常", e);
        }
        return new Date();
    }

    public static Date getDate(Date date, int addDay) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        calendar.add(Calendar.DAY_OF_YEAR, addDay);
        return calendar.getTime();
    }

    public static Date getDate(int type, int add) {
        Calendar calendar = Calendar.getInstance();
        calendar.add(type, add);
        return calendar.getTime();
    }

    public static Integer leftDay(Date pEndDate) {
        Calendar startDate = Calendar.getInstance();
        Calendar endDate = Calendar.getInstance();
        if (pEndDate != null) {
            endDate.setTime(pEndDate);
        }
        return betweenDay(startDate, endDate);
    }

    public static Integer betweenDay(Date startDate, Date endDate) {
        Calendar start = Calendar.getInstance();
        start.setTime(startDate);
        Calendar end = Calendar.getInstance();
        end.setTime(endDate);
        return betweenDay(start, end);
    }

    public static Integer betweenDay(Calendar startDate, Calendar endDate) {
        Calendar start = (Calendar) startDate.clone();
        Calendar end = (Calendar) endDate.clone();
        Integer daysBetween = 0;
        start.set(Calendar.HOUR_OF_DAY, 0);
        start.set(Calendar.MINUTE, 0);
        start.set(Calendar.SECOND, 0);
        start.set(Calendar.MILLISECOND, 0);
        end.set(Calendar.HOUR_OF_DAY, 0);
        end.set(Calendar.MINUTE, 0);
        end.set(Calendar.SECOND, 0);
        end.set(Calendar.MILLISECOND, 0);
        if (start.before(end)) {
            while (start.before(end)) {
                start.add(Calendar.DAY_OF_MONTH, 1);
                daysBetween++;
            }
        } else {
            while (start.after(end)) {
                start.add(Calendar.DAY_OF_MONTH, -1);
                daysBetween--;
            }
        }
        return daysBetween;
    }

    /**
     * Description: 将日期转为字符串 <br>
     *
     * @param date   <br>
     * @param format 转换格式，DateUtil中有 <br>
     * @return <br>
     */
    public static String date2String(Date date, String format) {
        if (date == null) {
            return "";
        }
        SimpleDateFormat sdf = getDateFormat(format);
        return sdf.format(date);
    }

    /**
     * Description: 根据日期格式化字符串生成日期格式化对象 <br>
     *
     * @param format
     * @return <br>
     */
    public static SimpleDateFormat getDateFormat(String format) {
        return new SimpleDateFormat(format);
    }

    /**
     * Description: 将字符串转为日期对象，自动判断几种常见的日期格式 <br>
     *
     * @param date
     * @return <br>
     */
    public static Date string2Date(String date) {
        Date ret = null;
        if (date == null || date.length() == 0) {
            return ret;
        }
        if (date.length() > 11) {
            if (date.indexOf('-') > -1) {
                if (date.indexOf(':') > -1) {
                    ret = string2Date(date, DATETIME_FORMAT_1);
                } else {
                    ret = string2Date(date, DATETIME_FORMAT_3);
                }
            } else if (date.indexOf('/') > -1) {
                ret = string2Date(date, DATETIME_FORMAT_4);
            } else {
                ret = string2Date(date, DATETIME_FORMAT_2);
            }
        } else {
            if (date.indexOf('-') > -1) {
                ret = string2Date(date, DATE_FORMAT_1);
            } else if (date.indexOf('/') > -1) {
                ret = string2Date(date, DATE_FORMAT_4);
            } else if (date.length() == 8) {
                if (date.endsWith("d")) {
                    ret = string2Date(date, DATE_FORMAT_2);
                } else {
                    ret = string2Date(date, DATE_FORMAT_6);
                }
            } else {
                ret = string2Date(date, DATE_FORMAT_3);
            }
        }
        return ret;
    }

    /**
     * Description: 将字符串转为日期对象，需要输入转换格式 <br>
     *
     * @param date
     * @param format
     * @return <br>
     */
    public static Date string2Date(String date, String format) {
        if (StringUtils.isEmpty(date)) {
            return null;
        }
        if (!ValidateUtil.validateNotEmpty(format)) {
            throw new IllegalArgumentException("日期格式化字符串为空");
        }
        SimpleDateFormat sdf = getDateFormat(format);
        if (!ValidateUtil.validateNotNull(sdf)) {
            throw new IllegalArgumentException("日期格式化字符串不能匹配到日期格式化对象，请检查格式是否正确");
        }
        try {
            return sdf.parse(date);
        } catch (ParseException e) {
            throw new IllegalArgumentException("日期字符串 " + date + " 和日期格式化字符串不匹配  " + format, e);
        }
    }

    /**
     * Description: 获取N秒偏移后的时间，不考虑夏时令 <br>
     *
     * @param date
     * @param seconds
     * @return <br>
     */
    public static Date offsetSecond(Date date, long seconds) {
        if (date == null) {
            return null;
        }
        long time = date.getTime();
        long time2 = time + (seconds * 1000);
        Date date2 = new Date(time2);
        return date2;
    }

    /**
     * Description: 获取N分钟偏移后的时间 <br>
     *
     * @param date
     * @param minutes
     * @return <br>
     */
    public static Date offsetMinute(Date date, long minutes) {
        return offsetSecond(date, 60 * minutes);
    }

    /**
     * Description: 获取N小时偏移后的时间 <br>
     *
     * @param date
     * @param hours
     * @return <br>
     */
    public static Date offsetHour(Date date, long hours) {
        return offsetMinute(date, 60 * hours);
    }

    /**
     * @param date
     * @param days
     * @return <br>
     * @Description: 获取N天偏移后的时间 <br>
     */
    public static Date offsetDay(Date date, int days) {
        return offsetHour(date, 24L * days);
    }

    /**
     * @param date
     * @param weeks
     * @return <br>
     * @Description: 获取N周偏移后的时间 <br>
     */
    public static Date offsetWeek(Date date, int weeks) {
        return offsetDay(date, 7 * weeks);
    }

    /**
     * @param date1
     * @param ，months
     * @return <br>
     * @Description: 获取N月偏移后的时间 <br>
     */
    public static Date offsetMonth(Date date1, int months) {
        if (date1 == null) {
            return null;
        }

        Date date = new Date(date1.getTime());
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);

        int curDay = calendar.get(Calendar.DAY_OF_MONTH);
        int maxDay = calendar.getActualMaximum(Calendar.DAY_OF_MONTH);
        calendar.set(Calendar.DAY_OF_MONTH, 1);
        calendar.add(Calendar.MONTH, months);

        int newMaxDay = calendar.getActualMaximum(Calendar.DAY_OF_MONTH);
        if (curDay == maxDay) {
            calendar.set(Calendar.DAY_OF_MONTH, newMaxDay);

        } else {
            if (curDay > newMaxDay) {
                calendar.set(Calendar.DAY_OF_MONTH, newMaxDay);
            } else {
                calendar.set(Calendar.DAY_OF_MONTH, curDay);
            }
        }
        date.setTime(calendar.getTimeInMillis());
        return date;
    }

    /**
     * Description: 获取N年偏移后的时间 <br>
     *
     * @param date
     * @param years
     * @return <br>
     */
    public static Date offsetYear(Date date, int years) {
        if (date == null) {
            return null;
        }
        Date newdate = (Date) date.clone();
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(newdate);
        calendar.add(Calendar.YEAR, years);
        newdate.setTime(calendar.getTimeInMillis());
        return newdate;
    }

    /**
     * Description: 当天的最后一秒 <br>
     *
     * @param date
     * @return <br>
     */
    public static Date getLastSecondOfDate(Date date) {
        Date newdate = (Date) date.clone();
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(newdate);
        calendar.set(Calendar.HOUR_OF_DAY, 23);
        calendar.set(Calendar.MINUTE, 59);
        calendar.set(Calendar.SECOND, 59);
        newdate.setTime(calendar.getTimeInMillis());
        return newdate;
    }

    /**
     * Description: 当天的第一秒 <br>
     *
     * @param date
     * @return <br>
     */
    public static Date getFirstSecondOfDate(Date date) {
        Date newdate = (Date) date.clone();
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(newdate);
        calendar.set(Calendar.HOUR_OF_DAY, 0);
        calendar.set(Calendar.MINUTE, 0);
        calendar.set(Calendar.SECOND, 0);
        calendar.set(Calendar.MILLISECOND, 0);
        newdate.setTime(calendar.getTimeInMillis());
        return newdate;
    }

    /**
     * Description: 当星期的最后一秒<br>
     *
     * @param date
     * @return <br>
     * @author chenhaitong<br>
     */
    public static Date getLastSecondOfWeek(Date date) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        calendar.setFirstDayOfWeek(Calendar.MONDAY);
        calendar.set(Calendar.HOUR_OF_DAY, 23);
        calendar.set(Calendar.MINUTE, 59);
        calendar.set(Calendar.SECOND, 59);
        calendar.set(Calendar.MILLISECOND, 999);
        calendar.set(Calendar.DAY_OF_WEEK, Calendar.SUNDAY);
        Date tmp = new Date();
        tmp.setTime(calendar.getTimeInMillis());
        return tmp;
    }

    public static Date getFirstSecondOfWeek(Date date) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        calendar.setFirstDayOfWeek(Calendar.MONDAY);
        calendar.set(Calendar.HOUR_OF_DAY, 0);
        calendar.set(Calendar.MINUTE, 0);
        calendar.set(Calendar.SECOND, 0);
        calendar.set(Calendar.MILLISECOND, 0);
        calendar.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);
        Date tmp = new Date();
        tmp.setTime(calendar.getTimeInMillis());
        return tmp;
    }

    /**
     * Description: 比较两个时间之间的差值 <br>
     *
     * @param beginDate
     * @param endDate
     * @param returnType 返回的类型 0：秒 1：分钟 2：小时 3：天
     * @return
     */
    public static long differDateInDays(Date beginDate, Date endDate, int returnType) {
        long begin = beginDate.getTime();
        long end = endDate.getTime();
        long surplus = begin - end;

        Calendar calendarBeginDate = Calendar.getInstance();
        calendarBeginDate.setTime(beginDate);

        Calendar calendarEndDate = Calendar.getInstance();
        calendarEndDate.setTime(endDate);

        long ret = 0;
        switch (returnType) {
            case DIFFER_IN_SECOND:
                ret = surplus / 1000;
                break;
            case DIFFER_IN_MINUTE:
                ret = surplus / 1000 / 60;
                break;
            case DIFFER_IN_HOUR:
                ret = surplus / 1000 / 60 / 60;
                break;
            case DIFFER_IN_DAY:
                ret = surplus / 1000 / 60 / 60 / 24;
                break;
            default:
                ret = surplus;// 增加毫秒级计算结果
                break;
        }

        return ret;
    }

    /**
     * Description: 检测某个时间是否在一个时间段范围内，参数为日期类型 <br>
     *
     * @param date
     * @param beginDate
     * @param endDate
     * @return <br>
     */
    public static boolean isInRange(Date date, Date beginDate, Date endDate) {
        long time = date.getTime();
        long beginTime = beginDate.getTime();
        long endTime = endDate.getTime();

        if (time >= beginTime && time <= endTime) {
            return true;
        } else {
            return false;
        }
    }

    public static Boolean isToday(Date when) {
        Calendar calendar = Calendar.getInstance();
        calendar.set(Calendar.HOUR_OF_DAY, 0);
        calendar.set(Calendar.MINUTE, 0);
        calendar.set(Calendar.SECOND, 0);
        if (calendar.before(when)) {
            calendar.set(Calendar.HOUR_OF_DAY, 23);
            calendar.set(Calendar.MINUTE, 59);
            calendar.set(Calendar.SECOND, 59);
            if (calendar.after(when)) {
                return true;
            }
        }
        return false;
    }

    /**
     * Description:比较两个时间大小 <br>
     *
     * @param firstStr
     * @param secondStr
     * @return true:开始时间小于结束时间 false:开始时间小于等于结束时间 <br>
     */
    private static boolean isAsc(String firstStr, String secondStr) {
        return firstStr.compareTo(secondStr) < 0;
    }

    public static boolean isSameDay(Date source, Date target) {
        return isInRange(target, getFirstSecondOfDate(source), getLastSecondOfDate(source));
    }

    public static boolean isBeforeNow(Date date) {
        if (date == null) {
            return false;
        }
        Date now = new Date();
        return date.before(now);
    }

    public static LocalDateTime asLocalDateTime(Date date) {
        return Instant.ofEpochMilli(date.getTime()).atZone(ZoneId.systemDefault()).toLocalDateTime();
    }

    public static LocalDate asLocalDate(Date date) {
        return Instant.ofEpochMilli(date.getTime()).atZone(ZoneId.systemDefault()).toLocalDate();
    }

    public static long getRemainSecondsOfDay() {
        LocalDateTime now = LocalDateTime.now();
        LocalDateTime midnight = now.plusDays(1).withHour(0).withMinute(0).withSecond(0).withNano(0);
        long seconds = ChronoUnit.SECONDS.between(now, midnight);
        return seconds;
    }

    public static Date getOffsetDay(int offset) {
        LocalDate offsetDay = LocalDate.now().plusDays(offset);
        return Date.from(offsetDay.atStartOfDay(ZoneId.systemDefault()).toInstant());
    }

    public static Date getOffsetDay(LocalDate base, int offset) {
        LocalDate offsetDay = base.plusDays(offset);
        return Date.from(offsetDay.atStartOfDay().atZone(ZoneId.systemDefault()).toInstant());
    }

    public static Date getEndTimeOfYesterday(LocalDate base) {
        Instant instant = base.atStartOfDay(ZoneId.systemDefault()).toInstant().minusSeconds(1L);
        return Date.from(instant);
    }

    public static boolean isTheSameDay(Date a, Date b) {
        LocalDateTime aLocalDateTime = asLocalDateTime(a);
        LocalDateTime bLocalDateTime = asLocalDateTime(b);
        if (aLocalDateTime.toLocalDate().toEpochDay() == bLocalDateTime.toLocalDate().toEpochDay()) {
            return true;
        }
        return false;
    }

    /**
     * Date to LocalDate
     *
     * @param date
     * @return
     */
    public static LocalDate toLocalDate(Date date) {
        return date.toInstant().atZone(ZoneId.systemDefault()).toLocalDate();
    }

    public static Date localDate2Date(LocalDate localDate) {
        if (null == localDate) {
            return null;
        }
        ZonedDateTime zonedDateTime = localDate.atStartOfDay(ZoneId.systemDefault());
        return Date.from(zonedDateTime.toInstant());
    }

    /**
     * Date时间戳转成MySQL的DATE类型
     *
     * @param timestamp
     * @return
     */
    public static java.sql.Date toSQLDate(Date timestamp) {
        if (timestamp != null) {
            return new java.sql.Date(timestamp.getTime());
        }
        return null;
    }
}

七海健人
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
独家 | 将时间信息编码用于机器学习模型的三种编码时间信息作为特征的三种方法...
数据派THU
03-21 2127
作者：Eryk Lewinson 翻译：汪桉旭 校对：zrx 本文约4400字，建议阅读5分钟 本文研究了三种使用日期相关的信息如何创造有意义特征的方法。标签：时间帧，机器学习，Pyt...
DirectShow中的时间戳的简单讲解
kathywp
11-04 4465
时间编码一、概念这里我们要说明一下媒体流处理中的一个重要概念－时间编码。时间编码是一个为了视频和音频流的一种辅助的数据。它包含在视频和音频文件中，我们可以理解为时间戳。SMPTE timecode 是一个SMPTE 时间和控制码的总和，它是一视频和音频流中的连续数字地址桢，标志和附加数据。它被定义在ANSI/SMPTE12-1986。它的目的就是提供一个可用计算机处理的视频和音频地
时间编号
weixin_42601615的博客
06-17 507
时间编号 开发工具与关键技术：java 作者：彭浩达 撰写时间：2019年 6月 17日 function run() { var currentDate = new Date(); var year = currentDate.getFullYear(); //获取年份 var month = currentDate....
各种时间日期格式代码
流水账
07-30 3700
<br />Console.WriteLine("------------------------标准及自定义时间格式字符串---------------------------"); 128 DateTime date = new DateTime(2010, 4, 5, 18, 8, 8, 16); 129 130 //d 短日期 131 Console.WriteLine("d 短日期"
求本周，上周，下周所有日期时间
crazy_Sxk的博客
07-18 488
//求本周，周一，时间 public static Date getThisWeekMonday(Date date) { Calendar cal = Calendar.getInstance(); cal.setTime(date); // 获得当前日期是一个星期的第几天 int dayWeek = cal.get(Calendar.DAY_OF_WEEK); if (1 ...
商品分类——家用电器类
12-21
在商品管理领域，家用电器类商品的分类是一个关键环节，它直接影响着消费者的购物体验和超市的运营...这份“商品分类——家用电器类”文档无疑是对此主题的深入探讨，值得下载学习，以获取更多实用的管理策略和技巧。
微信小程序——[小工具类]二维码生成器（截图+源码）.zip
04-17
本压缩包提供的内容是关于一个“小工具类”的二维码生成器，包括了截图和源代码，这将对理解微信小程序开发，特别是涉及到二维码功能的实现，提供宝贵的学习资料。 二维码生成器是用于将各种信息编码成二维码的工具...
预测类赛题——Logistic模型.rar
07-31
《预测类赛题——Logistic模型详解》 在数据分析与机器学习领域，预测类赛题是一种常见的挑战，而Logistic模型则是解决这类问题的重要工具。本文将深入探讨Logistic回归模型的理论基础、应用场景以及实战技巧，帮助...
ASP.NET源码——文件编码转换器源码.zip
10-10
总之，"ASP.NET源码——文件编码转换器源码.zip"提供了一个实用的工具，可以帮助开发者理解和实现文件编码转换功能。通过分析源码，不仅可以学习到ASP.NET的基础知识，还能掌握文件操作和编码处理的高级技巧，这对于...
ProSpring——Spring专业开发指南
05-24
Spring的核心特性之一是依赖注入，它允许对象之间的关系在运行时被外部定义，而不是硬编码在类内部。通过依赖注入，我们可以实现松耦合，使代码更易于测试和维护。 2. **面向切面编程（Aspect-Oriented ...
时间编码（Time Zone Code）列表
kgojiwong的博客
12-19 6082
(GMT+10:00) Canberra, Melbourne, Sydney (Commonwealth Games 2006); 256 (GMT-04:00) Georgetown, La Paz, Manaus, San Juan; 55 (GMT) Greenwich Mean Time : Dublin, Edinburgh, Lisbon, London; 85 (GMT+06:00...
【commons】时间日期工具类——commons-lang3-time
weixin_30417487的博客
09-09 449
推荐参考：http://www.cnblogs.com/java-class/p/4845962.html 　　　　　　https://blog.csdn.net/yihaoawang/article/details/50638199 转载于:https://www.cnblogs.com/jiangbei/p/9613407.html
日期编码
qq_25043489的博客
07-04 1218
按日期自动追加编码，例：20180704001，不足之处在于删除中间编码后，不能再补上.编码数据存在XML文档中。public bool check()//检查行数是否为0        {            DataTable dt = dataxml.ReadFromXml(Application.StartupPath + "//data.xml"); // 读取xml数据       ...
独家 | 时间信息编码为机器学习模型特征的三种方法（附链接）
数据派THU
04-24 3744
作者：Eryk Lewinson 翻译：张睿毅 校对：张睿毅 本文约4200字，建议阅读10分钟本文我们主要使用非常知名的Python包，以及依赖于一个相对不为人知的scikit-lego包。标签：数据帧，精选， 机器学习， Python， 技术演练设置和数据在本文中，我们主要使用非常知名的Python包，以及依赖于一个相对不为人知的scikit-lego包，这是一...
文本编码时间操作命令
java火推阳光的博客
06-17 474
文本编码 在计算机中，所有的数据在存储和运算时都要使用二进制数表示（计算机用商电平和 低电平分别表示1和0) 。例如：像a、b、c、d这样的52个字母（包括大小写）以及0、1、 2等数字还有一些常用的符号（*.#、@等）在计算机中存储时也要使用二进制数来表示， 而只体用哪些二进制数字表示哪个符号，当然每个人都可以约定自己的规定（这就叫编 码），而相互之间即要互相通信又不造成混乱，那么就必...
干货 ：时间信息编码为机器学习模型特征的三种方法（附链接）
数据分析
04-27 1284
作者：Eryk Lewinson 翻译：张睿毅 校对：张睿毅本文约4200字，建议阅读10分钟本文我们主要使用非常知名的Python包，以及依赖于一个相对不为人知的scikit-lego包。设置和数据在本文中，我们主要使用非常知名的Python包，以及依赖于一个相对不为人知的scikit-lego包，这是一个包含许多有用功能的库，这些功能正在扩展scikit-le...
打印时间工具类
sdojqy1122的专栏
01-19 232
自己写的工具类，方便调试方法运行时间，代码如下： package com.example.log; /** * User: Jimmy * Date: 2020/1/19 * Desc: */ import com.google.common.collect.Maps; import org.apache.commons.lang3.StringUtils; import org...
Linux C 时间 及 文件IO编程
TheBlob的博客
08-24 354
本篇是IO编程第二篇文章，主要讲述 IO编程中的时间编程基础以及文件IO编程基础。涉及到时间编程和文件IO的函数。文章中基本每个函数都举了一些简单的例子，希望能帮助大家理解。
Excel导出工具类
qq_41973154的博客
06-28 307
我们在导出报表的时候会遇到在 controller层 写重复的响应（IO）方法，做的重复的工作。其实就是CV的活，这时可以考虑把相同的抽取出来写作一个工具类。 1、正常的操作 @Api(value = "检修缺陷工单管理", description = "检修缺陷工单管理") @RestController @RequestMapping(value = "/overhaul/defect-order") public class exportControlle{ @ApiOperation("缺陷列表
实用数据清洗——19个必备技巧.pdf
最新发布
02-03
"实用数据清洗——19个必备技巧.pdf" 数据清洗是数据分析过程中的关键步骤，对于确保数据质量、提高分析结果的准确性至关重要。在这个由李贝克编写的指南中，作者强调了在数据驱动的世界里，不论是面对海量的大数据...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值