计算两个日期之间的工作日（去掉周末和节假日）

最新推荐文章于 2023-11-24 14:40:14 发布
最新推荐文章于 2023-11-24 14:40:14 发布
阅读量7.5k 收藏 11
点赞数 3
分类专栏： java 基础 文章标签： elementui java 前端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Im_Shuang/article/details/61196555
版权

一个贴吧上找到的，整理一下

package com.uphone.commons;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.Iterator;
import java.util.List;

import org.springframework.stereotype.Component;
/**
 * 获取工作日
 * <br>创建日期：2016年7月21日
 * <br><b>Copyright 2016 UTOUU All Rights Reserved</b>
 * @author zhushuangshuang
 * @since 1.0
 * @version 1.0
 */
@Component
public class GetWorkDay {
    /**
    * 获取两个时间之内的工作日时间（只去掉两个日期之间的周末时间，法定节假日未去掉）
    *
    * @param start
    * -起始时间，共有3个重载方法，可以传入long型，Long型，与Date型
    * @param end
    * -结束时间，共有3个重载方法，可以传入long型，Long型，与Date型
    * @return Long型时间差对象
    */
    /*public static void main(String[] args) {
        GetWorkDay g=new GetWorkDay();
        List<Date> initHoliday;
        try {
            initHoliday = g.initHoliday();
            double days = g.getWorkdayTimeInMillisExcWeekendHolidays("2016-06-30 17-12-53","2016-08-30 11-27-50","yyyy-MM-dd HH-mm-ss",initHoliday);
            double formateToDay = g.formateToDay(days);
            String formatDuring = g.formatDuring(days);
             System.out.println(formateToDay);
            System.out.println(formatDuring);
        } catch (ParseException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    } */
    
    private double getWorkdayTimeInMillis(long start, long end,
        List<Date> listHolidays) {
    
        // 如果起始时间大于结束时间，将二者交换
        if (start > end) {
            long temp = start;
            start = end;
            end = temp;
        }
        // 根据参数获取起始时间与结束时间的日历类型对象
        Calendar sdate = Calendar.getInstance();
        Calendar edate = Calendar.getInstance();
    
        sdate.setTimeInMillis(start);
        edate.setTimeInMillis(end);
    
        // 计算指定时间段内法定节假日天数的毫秒数
        long holidays = 0;
        if (listHolidays != null) {
            holidays = getHolidaysInMillis(start, end, listHolidays);
            listHolidays.clear();
        }
    
        // 如果两个时间在同一周并且都不是周末日期，则直接返回时间差，增加执行效率
        if ((sdate.get(Calendar.YEAR) == edate.get(Calendar.YEAR))
        && (sdate.get(Calendar.WEEK_OF_YEAR) == edate
        .get(Calendar.WEEK_OF_YEAR))
        && (sdate.get(Calendar.DAY_OF_WEEK) != 1 && sdate
        .get(Calendar.DAY_OF_WEEK) != 7)
        && (edate.get(Calendar.DAY_OF_WEEK) != 1 && edate
        .get(Calendar.DAY_OF_WEEK) != 7)) {
        return new Long(end - start - holidays);
        }
        // 如果两个时间在同一周并且都是周末日期，则直接返回0
        if ((sdate.get(Calendar.YEAR) == edate.get(Calendar.YEAR))
        && (sdate.get(Calendar.WEEK_OF_YEAR) == edate
        .get(Calendar.WEEK_OF_YEAR)-1)
        && (sdate.get(Calendar.DAY_OF_WEEK) == 1
        || sdate.get(Calendar.DAY_OF_WEEK) == 7)
        &&
        (edate.get(Calendar.DAY_OF_WEEK) == 1
        || edate.get(Calendar.DAY_OF_WEEK) == 7)) {
        start=validateStartTime(sdate);
        end=validateEndTime(edate);
        long result=end - start - holidays;
        return new Long(result>0?result:0);
        }
    
        start=validateStartTime(sdate);
        end=validateEndTime(edate);
    
        // 首先取得起始日期与结束日期的下个周一的日期
        Calendar snextM = getNextMonday(sdate);
        Calendar enextM = getNextMonday(edate);
    
        // 获取这两个周一之间的实际天数
        int days = getDaysBetween(snextM, enextM);
    
        // 获取这两个周一之间的工作日数(两个周一之间的天数肯定能被7整除，并且工作日数量占其中的5/7)
        int workdays = days / 7 * 5;
    
        // 计算最终结果，具体为：workdays加上开始时间的时间偏移量，减去结束时间的时间偏移量
        double a=(double)workdays*24*3600000;
        double result = (a + calcWorkdayTimeInMillis(sdate, edate, start, end) - holidays);
       return result > 0 ? result : 0;
    }
    /***
    * 验证开始日期是否合法,如果不合法,并返回修复后的正确日期毫秒数
    * @param sdate
    * @return
    */
    private long validateStartTime(Calendar sdate){
        if(sdate.get(Calendar.DAY_OF_WEEK) == 1)//开始日期从周日开始,如果开始时间为周末，自动修复为下周的9：00开始
        {
            sdate.add(Calendar.DATE,1);
            sdate.setTimeInMillis(sdate.getTime().getTime()- //从9点开始
            (((sdate.get(Calendar.HOUR_OF_DAY)-9) * 3600000)+ (sdate.get(Calendar.MINUTE) * 60000)+ (sdate.get(Calendar.SECOND) * 1000)));
        }else if(sdate.get(Calendar.DAY_OF_WEEK) == 7){//开始日期从周六开始
                sdate.add(Calendar.DATE,2);
                sdate.setTimeInMillis(
                sdate.getTime().getTime()- //从9点开始,如果开始时间为周末，自动修复为下周的9：00开始
                (((sdate.get(Calendar.HOUR_OF_DAY)-9) * 3600000)
               + (sdate.get(Calendar.MINUTE) * 60000)
               + (sdate.get(Calendar.SECOND) * 1000)));
        }
            return sdate.getTimeInMillis();
    }


    /***
    * 验证结束日期是否合法,如果不合法,并返回修复后的正确日期毫秒数
    * @param sdate
    * @return
    */
    private long validateEndTime(Calendar edate)
    {
        if(edate.get(Calendar.DAY_OF_WEEK) == 1)//结束日期是周日,如果结束日期是周六、周末自动修复为这周五18:00
        {
        edate.add(Calendar.DATE,-2);
        edate.setTimeInMillis(
        edate.getTime().getTime()+
        (18*3600000-((edate.get(Calendar.HOUR_OF_DAY) * 3600000)
        + (edate.get(Calendar.MINUTE) * 60000)
        + (edate.get(Calendar.SECOND) * 1000))));
        }else if(edate.get(Calendar.DAY_OF_WEEK) == 7){//结束日期是周六,如果结束日期是周六、周末自动修复为这周五18:00
            edate.add(Calendar.DATE,-1);
            edate.setTimeInMillis(
            edate.getTime().getTime()+
        (18*3600000-((edate.get(Calendar.HOUR_OF_DAY) * 3600000)
        + (edate.get(Calendar.MINUTE) * 60000)
        + (edate.get(Calendar.SECOND) * 1000))));}
        return edate.getTimeInMillis();
    }
    /***
    * 计算两个日期间的工作日天数，除周六日
    *
    * @param sdate
    * @param edate
    * @return
    */
    private long calcWorkdayTimeInMillis(Calendar sdate, Calendar edate,long start, long end) {
        // 获取开始时间的偏移量
        long scharge = 0;
        if (sdate.get(Calendar.DAY_OF_WEEK) != 1
        && sdate.get(Calendar.DAY_OF_WEEK) != 7) {
        // 只有在开始时间为非周末的时候才计算偏移量
        scharge += (sdate.get(Calendar.HOUR_OF_DAY) * 3600000);
        scharge += (sdate.get(Calendar.MINUTE) * 60000);
        scharge += (sdate.get(Calendar.SECOND) * 1000);
        scharge = ((24 * 3600000) - scharge);
    
        scharge += ((sdate.getTime().getTime() - start) - (3 * 24 * 3600000));
        }
        // (24*3600000=86400000)-((9*3600000+1800000)=34200000)+(3*24*3600000=259200000)-(2*24*3600000)=
        // 86400000-34200000=52200000
        // 获取结束时间的偏移量
        long echarge = 0;
        if (edate.get(Calendar.DAY_OF_WEEK) != 1
        && edate.get(Calendar.DAY_OF_WEEK) != (7)) {
        // 只有在结束时间为非周末的时候才计算偏移量
        echarge += (edate.get(Calendar.HOUR_OF_DAY) * 3600000);
        echarge += (edate.get(Calendar.MINUTE) * 60000);
        echarge += (edate.get(Calendar.SECOND) * 1000);
        echarge = ((24 * 3600000) - echarge);
        echarge += (edate.getTime().getTime() - end) - (24 * 3600000);
        echarge -= (2 * 24 * 3600000);
        }
        // (24*3600000=86400000)-(18*3600000=64800000)+(24*3=259200000)
        if (scharge < 0 || echarge < 0)
        scharge = echarge = 0;
        return scharge - echarge;
    }
    
    /**
    * 获取两个时间之内的工作日时间（只去掉两个日期之间的周末时间，法定节假日未去掉）
    *
    * @param start
    * -起始时间，共有3个重载方法，可以传入long型，Long型，与Date型
    * @param end
    * -结束时间，共有3个重载方法，可以传入long型，Long型，与Date型
    * @return Long型时间差对象
    */
    public double getWorkdayTimeInMillisExcWeekend(long start, long end) {
        return getWorkdayTimeInMillis(start, end);
    }

    /***
    * 获取两个时间之内的工作日时间（去掉两个日期之间的周末时间，法定节假日时间）
    *
    * @param start
    * @param end
    * @return
    */
    public double getWorkdayTimeInMillisExcWeekendHolidays(String start,String end, String format, List<Date> listHolidays) {
        SimpleDateFormat sdf = new SimpleDateFormat(format);
        Date sdate;
        Date edate;
        try {
            sdate = sdf.parse(start);
            edate = sdf.parse(end);
            return getWorkdayTimeInMillis(sdate.getTime(), edate.getTime(),
            listHolidays);
            } catch (ParseException e) {
            e.printStackTrace();
            return new Long(0);
        }
    }
    
    public double getWorkdayTimeInMillis(Long start, Long end) {
        return getWorkdayTimeInMillis(start.longValue(), end.longValue(), null);
        }

        public double getWorkdayTimeInMillis(Date start, Date end) {
        return getWorkdayTimeInMillis(start.getTime(), end.getTime(), null);
        }

        public double getWorkdayTimeInMillis(String start, String end, String format) {
            SimpleDateFormat sdf = new SimpleDateFormat(format);
            Date sdate;
            Date edate;
            try {
                sdate = sdf.parse(start);
                edate = sdf.parse(end);
                return getWorkdayTimeInMillis(sdate, edate);
            } catch (ParseException e) {
                e.printStackTrace();
                return new Long(0);
            }
            }
    
            private long getHolidaysInMillis(long start, long end,
                List<Date> listHolidays) {
                Calendar scalendar = Calendar.getInstance();
                Calendar ecalendar = Calendar.getInstance();
                int daysofH = 0;
                try {
        
                scalendar.setTimeInMillis(start);
                ecalendar.setTimeInMillis(end);
        
                if (listHolidays == null)
                return new Long(0);
                Iterator<Date> iterator = listHolidays.iterator();
                while (iterator.hasNext()) {
                Calendar ca = Calendar.getInstance();
                Date hdate = iterator.next();
                ca.setTime(hdate);
                if (ca.after(scalendar) && ca.before(ecalendar)) {
                    daysofH = daysofH + 1;
                } else if (ca.getTimeInMillis() == scalendar.getTimeInMillis()) {
                    daysofH = daysofH + 1;
                } else if (ca.getTimeInMillis() == ecalendar.getTimeInMillis()) {
                    daysofH = daysofH + 1;
                }
                }
        
                } catch (Exception e) {
                    e.printStackTrace();
                    return new Long(0);
                }
                   return daysofH * 24 * 3600000;
         }
        
        
        private Calendar getNextMonday(Calendar cal) {
                int addnum = 9 - cal.get(Calendar.DAY_OF_WEEK);
                if (addnum == 8)
                addnum = 1;// 周日的情况
                cal.add(Calendar.DATE, addnum);
                return cal;
        }

            /**
            *
            * @param mss 
            * @param 要转换的毫秒数
            * @return 该毫秒数转换为 * days * hours * minutes * seconds 后的格式
            */
        public String formatDuring(double mss) {
            long days = (long) (mss / (1000 * 60 * 60 * 24));
            long hours = (long) ((mss % (1000 * 60 * 60 * 24)) / (1000 * 60 * 60));
            long minutes = (long) ((mss % (1000 * 60 * 60)) / (1000 * 60));
            long seconds = (long) ((mss % (1000 * 60)) / 1000);
            return days + " days " + hours + " hours " + minutes + " minutes "
            + seconds + " seconds ";
            }
            
            /**
            * 获取两个日期之间的实际天数，支持跨年
            * @param start 
            * @param end 
            *  
            */
        /**
         * 获得两个日期之间的工作日
         * @since 1.0 
         * @param mss
         * @return
         * <br><b>作者： @author zhushunagshuang</b>
         * <br>创建时间：2016年7月21日 下午3:12:23
         */
        public double formateToDay(double mss){
            double days = mss / (1000 * 60 * 60 * 24);
            return days;
        }
        
        public int getDaysBetween(Calendar start, Calendar end) {
            if (start.after(end)) {
            Calendar swap = start;
            start = end;
            end = swap;
            }

            int days = end.get(Calendar.DAY_OF_YEAR)- start.get(Calendar.DAY_OF_YEAR);
            int y2 = end.get(Calendar.YEAR);
            if (start.get(Calendar.YEAR) != y2) {
                start = (Calendar) start.clone();
                do {
                    days += start.getActualMaximum(Calendar.DAY_OF_YEAR);
                    start.add(Calendar.YEAR, 1);
                } while (start.get(Calendar.YEAR) != y2);
                
            }
            return days;
        }
        /**
         * 手动维护2016年的节假日
         * @since 1.0 
         * @return
         * @throws ParseException
         * <br><b>作者： @author zhushunagshuang</b>
         * <br>创建时间：2016年7月21日 下午5:12:08
         */
        public List<Date> initHoliday() throws ParseException{                
            List<Date> holidays = new ArrayList<Date>();
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
            //元旦
            holidays.add(sdf.parse("2016-01-01"));
            holidays.add(sdf.parse("2016-01-02"));
            holidays.add(sdf.parse("2016-01-03"));
            //春节
            holidays.add(sdf.parse("2016-02-07"));
            holidays.add(sdf.parse("2016-02-08"));
            holidays.add(sdf.parse("2016-02-09"));
            holidays.add(sdf.parse("2016-02-10"));
            holidays.add(sdf.parse("2016-02-11"));
            holidays.add(sdf.parse("2016-02-12"));
            holidays.add(sdf.parse("2016-02-13"));
            //清明节
            holidays.add(sdf.parse("2016-04-02"));
            holidays.add(sdf.parse("2016-04-03"));
            holidays.add(sdf.parse("2016-04-04"));
            //劳动节
            holidays.add(sdf.parse("2016-04-30"));
            holidays.add(sdf.parse("2016-05-01"));
            holidays.add(sdf.parse("2016-05-02"));
            //端午节
            holidays.add(sdf.parse("2016-06-09"));
            holidays.add(sdf.parse("2016-06-10"));
            holidays.add(sdf.parse("2016-06-11"));
            //中秋节
            holidays.add(sdf.parse("2016-09-15"));
            holidays.add(sdf.parse("2016-09-16"));
            holidays.add(sdf.parse("2016-09-17"));
            //国庆节
            holidays.add(sdf.parse("2016-10-01"));
            holidays.add(sdf.parse("2016-10-02"));
            holidays.add(sdf.parse("2016-10-03"));
            holidays.add(sdf.parse("2016-10-04"));
            holidays.add(sdf.parse("2016-10-05"));
            holidays.add(sdf.parse("2016-10-06"));
            holidays.add(sdf.parse("2016-10-07"));
            return holidays;
        }
        
}

乌龙柚子
关注
专栏目录
计算两个日期之间工作日天数(c#实现)
chenbinqq164的专栏
12-12 2894
public void getDays()    {        DateTime dt1 = new DateTime(2010, 01, 01);//初始化一个日期        DateTime dt2 = DateTime.Now;//获取今天日期        TimeSpan ts1 = dt1.Subtract(dt2);//TimeSpan得到dt1和dt2的时间间隔      
[原创]JS端计算一段时间内工作日的天数，排除周末和法定节假日，同时考虑到调休日...
alna13051的博客
02-10 1143
公司项目最近有个需求，要统计人员有多少天没使用工作系统。 原本只是简单地将当前时间与最后使用时间相减，得到的天数做为未使用的天数。 结果，领导说这样不行，需要计算得精确些，于是上网搜到不少解决方案，不是通过循环解决，就是都不符合我们的实际情况，便自己写一个。 项目是jQuery的，所以循环语句也需要自己改一下。希望对同样需求的兄弟姐妹们有所帮助，也希望大家多多拍砖，提点意见哈！ ...
记录一次计算两个日期间的工作日天数，排除节假日、周末等
lmq199517的博客
10-21 1229
1.数据库存储节假日、补班日期 数据库结构如下，0代表节日，1代表补班日期，需要每年更新 2.代码 （1）计算相差天数 @Override public Long getWorkDay(String startDate, String endDate) { try { //获取所有节假日 List<String> holidayList = dateDao.getMnHoliday(0L); //获取补班日期 List<String> workdayL
C# 获取一段日期内的工作日
dengqiu2187的博客
03-21 751
/// <summary> /// 根据指定时间段计算工作日天数 /// </summary> /// <param name="firstDay"></param> /// <param name="lastDay"></p...
计算两个日期之间周末的天数和工作日天数
10-19
本人编写，通过自己定义的函数计算两个日期之间周末的天数和工作日天数，经过测试，非常好用
计算2个日期相差天数、去除节假日周末
06-14
在编程领域，尤其是在数据分析、日程管理或者时间序列分析中，计算两个日期之间的差异并考虑工作日排除节假日和周末是一项常见的任务。C++作为一种强大的系统级编程语言，提供了丰富的库来处理日期和时间操作。本篇...
oracle 节假日天数,强大的PLSQL - 计算两个日期之间的工作日天数-除去(周末和公共假日...
weixin_42519772的博客
04-03 1261
用php写了一个函数,实现的功能是 计算两个日期之间的工作日天数-除去(周末和公共假日)写了 300多行的代码,实现公共假日从文件中读取, 或者从数据库提取,然后传入两个日期,就能返回想要的结果, 无奈之下想到了PLSQL, 同事几分钟后给我一段简短的代码. 着实让我吃了一惊..下面是代码:CREATE OR REPLACE FUNCTION calcDates(START_DATE IN ...
js计算两个日期之间工作日，去除周末
weixin_43709908的博客
11-16 1883
<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>6.计算工作日</title> </head> <body> </body> <script> function getWeekday(first, last) { //计算工作日方法：遍历这两个日期区间的
C#获取两个时间的时间差并去除周末（取工作日）的方法
09-03
本文将详细解析如何使用C#获取两个日期之间的工作日时间差，并去除周末的影响。 首先，我们需要理解基础的日期和时间操作。在C#中，DateTime结构用于表示日期和时间，而TimeSpan结构则用于表示两个日期或时间之间的...
SqlServer计算2个时间的间隔时间(工作日时间)，不包括法定节假日和周末
toString的博客
07-22 5664
最近在统计计算的时候，有一个需求是计算关闭时间-开始时间的小时数，但是如果中间有周末或者法定节假日不能包括在内，只计算工作日的小时数 在网上查询了很多资料后发现，有2种做法 第1种是使用存储过程的方式，另1种方法是需要一张法定节假日的表，然后关联一下，进行计算和查询。网上可以下载的到 例如2020年法定节假日和周末数据：https://download.csdn.net/download/u014508939/12650095 这是我上传的资源 下面我可以把数据提供出来： 如果导入失...
计算俩个日期之间的工作日(用C#)
weixin_30905133的博客
06-17 196
根据公司项目的需求要计算俩个日期之间的工作日天数,写了一个方法来处理,如下 1usingSystem;2usingSystem.Collections.Generic;3usingSystem.Text;45namespaceConsoleApplication16{7classProgram8{9staticvoidMai...
给一个开始时间，和间隔时间计算结束时间，排除中间的节假日
ID_liuliu的博客
11-24 612
方法比较简单使用一个递归函数就可以实现，具体思路：从开始时间算，判断他的后一天是不是非工作日，遇到工作日就让间隔数-1，非工作日则间隔数不变，循环调用函数直到间隔数为0。调用startTime.add(1, 'd')后会改变原来的日期，递归调用时如果直接使用startTime._i会陷入死循环。chinese-workday中还有很多方法，可以根据自己的需要去选择对应的API。简单分享一下最近遇到的一个需求: 只编辑开始时间，根据间隔时间来计算结束时间，中间不包含节假日和周末。项目是vue2的版本。
Java 根据开始日期和结束日期，获取日期之间的工作日，去除了周末和法定节假日
weixin_52825089的博客
07-20 1848
输出结果： public static void main(String[] args) { String sd = “2021-02-01”; String ed = “2021-02-28”; List list = getWorkDays(sd,ed); for (String date: list) { System.out.println(date); } } /** * 此方法计算两个日期的真实工作日(除周末和法定节假日) * @param startDate(起始日期),EndDate
获取某天到某天相隔的时间段的工作日期（包含周末上班时间）和非工作日（包括调休、国家法定节假日）
qq_43244730的博客
03-02 751
在这 ## **获取某天到某天相隔的时间段的工作日期（包含周末上班时间）和非工作日（包括调休、国家法定节假日）** Date.prototype.format = function() { 　　　　　var s = ''; var mouth = (this.getMonth() + 1)>=10?(this.getMonth() + 1):('0'+(this.getMonth()...
判断两个日期之间除去周末和规定节假日剩余的天数(精确度为半天)
qq915697213的专栏
11-06 3056
这两天在写一个项目，考勤系统，写到请假的一块，需要判断请假的天数，
Java实现计算两个日期之间的工作日天数
m0_52861211的博客
09-16 1514
计算当前日期与数据库内保存的日期数据之间相隔的工作日数目。
两个日期相减得到天数
qq_31426651的博客
08-16 2023
public static int getDaySub(String beginDateStr,String endDateStr)     {         int day=0;         java.text.SimpleDateFormat format = new java.text.SimpleDateFormat("yyyy-MM-dd");             java.u...
java计算两个日期间的工作日
gongwenshuai的博客
09-18 1177
public int calLeaveDays(Date startTime, Date endTime){ SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd"); int leaveDays = 0; Date flag = startTime;//设置循环开始日期 Calendar cal = Calendar.getInstance(); while(.
sqlserver计算两个日期之前的工作日天数，需要排除周末和法定节假日
最新发布
09-12
在SQL Server中，计算两个日期之间的工作日天数通常涉及到自定义函数或者使用存储过程，因为SQL本身的日期函数并不直接提供这样的功能。你需要创建一个逻辑来处理周末和非工作假期。这里是一个简单的示例，假设你有一个包含所有法定假日的表`HolidayCalendar`： ```sql CREATE FUNCTION [dbo].[WorkDays] (@StartDate DATE, @EndDate DATE) RETURNS INT AS BEGIN DECLARE @WorkingDays INT = DATEDIFF(day, @StartDate, @EndDate) + 1; -- 总天数包括结束当天 SET @StartDate = DATEADD(day, -1, @StartDate); -- 将开始日期减1 WHILE @StartDate < @EndDate BEGIN IF NOT EXISTS (SELECT 1 FROM HolidayCalendar WHERE HolidayDate = @StartDate) -- 非周末且非法定假日 SET @WorkingDays -= 1; SET @StartDate = DATEADD(day, 1, @StartDate); END RETURN @WorkingDays; END ``` 你可以通过调用这个函数来获取两个日期之间的工作日天数： ```sql SELECT dbo.WorkDays('2023-01-01', '2023-02-01') AS WorkDaysBetweenDates; ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值