Day 60

最新推荐文章于 2024-08-11 20:00:32 发布
最新推荐文章于 2024-08-11 20:00:32 发布
阅读量233 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ALVIS_108/article/details/124301229
版权

字符流读数据的两种方式

  1. 方法名说明
    int read()一次读一个字符数据
    int read(char[] cbuf)一次读一个字符数组数据
  2. package demo14;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;

public class _IO_Stream_Demo_03 {
    public static void main(String[] args) {
        /*
        int read()                一次读一个字符数据
        int read(char[] cbuf)     一次读一个字符数组数据
         */

        InputStreamReader isr = null;
        try {
            isr = new InputStreamReader(new FileInputStream("C:\\Users\\Alvord\\Desktop\\markdown学习\\code\\studyProject\\src\\demo14\\book_01.txt"));
            if (isr != null) {
                int ch;
                /*
                // int read()     一次读一个字符数据
                while ((ch = isr.read()) != -1) {
                    System.out.print((char) ch);
                }
                 */
                // int read(char[] cbuf)     一次读一个字符数组数据
                char[] arr = new char[1024];
                while ((ch = isr.read(arr)) != -1) {
                    /*
                    public String(char[] value, int offset,  int count)
                    分配一个新的String ，其中包含字符数组参数的子阵列中的字符。
                    offset参数是子阵列的第一个字符的索引， count参数指定子阵列的长度。
                    副本的内容被复制; 字符数组的后续修改不会影响新创建的字符串
                     */
                    System.out.print(new String(arr,0,ch));
                }
            }

        } catch (IOException e) {
            e.printStackTrace();
        }
        finally {
            try {
                isr.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
}
==============================================
声表面波（SAW，Surface Acoustic Wave）是沿物体表面传播的一种弹性波。
声表面波是英国物理学家瑞利（Rayleigh）在19世纪80 年代研究地震波的过程中偶尔发现的一种能量集中于地表面传播的声波。
1965年，美国的怀特（R.M.White）和沃尔特默（F.W.Voltmer）发表题为“一种新型声表面波声——电转化器”的论文，
取得了声表面波技术的关键性突破，能在压电材料表面激励声表面波的金属叉指换能器 IDT的发明，大大加速了声表面波技术的发展，
使这门年轻的学科逐步发展成为一门新兴的、声学和电子学相结合的边缘学科。
Process finished with exit code 0

_字符流复制Java文件改进版

  1. 分析：
    • 转换流的名字比较长，而我们常见的操作都是按照本地默认编码实现的，所以，为了简化书写，转换流提供了对应的子类
    • FileReader：用于读取字符文件的便捷类：FileReader(String fileNme)
    • FileWriter：用于写入字符文件的便捷类：FileWriter(String fileNme)

_字符缓冲流

  1. BufferedWriter：将文本写入字符输出流，缓冲字符，以提供单个字符，数组和字符串的高效写入，可以指定缓冲区的大小，或者是可以接受默认大小。默认值足够大，可用于大多数用途
  2. BufferedReader：从字符输入流读取文本，缓冲字符，以提供字符，数组和行的搞笑读取，可以指定缓冲区的大小，或者是可以使用默认大小。默认值足够大，可用于大多数用途

_字符缓冲流复制Java文件

  1. 思路：

    • 根据数据源创建字符缓冲流输入对象
    • 根据目的地创建字符缓冲输出流对象
    • 读写数据，复制文件
    • 释放资源
  2. package demo14;

import java.io.*;

public class _IO_Stream_Demo_04 {
    public static void main(String[] args) {
        /*
        需求： 字符缓冲流复制Java文件

        思路：
            - 根据数据源创建字符缓冲流输入对象
            - 根据目的地创建字符缓冲输出流对象
            - 读写数据，复制文件
            - 释放资源
         */

        BufferedReader br = null;
        BufferedWriter bw = null;
        try {
            br = new BufferedReader(new FileReader("C:\\Users\\Alvord\\Desktop\\markdown学习\\code\\studyProject\\src\\demo13\\_IO_Buffered_02.java"));
            bw = new BufferedWriter(new FileWriter("C:\\Users\\Alvord\\Desktop\\markdown学习\\code\\studyProject\\src\\demo14\\_IO_Buffered_02.java"));
            if (br != null) {
                char[] ch = new char[1024];
                int len;
                while ((len = br.read(ch)) != -1) {
                    bw.write(ch,0,len);
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        finally {
            try {
                br.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                bw.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}
==========================================

Process finished with exit code 0
******************************************
    package demo13;

import java.io.*;

public class _IO_Buffered_02 {
    public static void main(String[] args) {
        /*
        需求：用4种方法把一个视频文件复制到当前的模块下，比较程序运行的时间

         思路 ：
           - 根据数据源创建字节输入流对象
           - 根据目的地创建字节流入流对象
           - 读写数据，复制视频
           - 释放资源

         基本字节流一次读写一个字节：       程序运行耗时：59099毫秒
         基本字节流一次读写一个字节数组：    程序运行耗时：101毫秒
         字节缓冲流一次读写一个字节：       程序运行耗时：258毫秒
         字节缓冲流一次读写一个字节数组：    程序运行耗时：37毫秒
         */

        // 记录开始时间
        long startTime = System.currentTimeMillis();
//        run_01();     //  程序运行耗时：59099毫秒
//        run_02();     //  程序运行耗时：101毫秒
//        run_03();     //  程序运行耗时：258毫秒
        run_04();     //  程序运行耗时：37毫秒



        // 记录程序结束时间
        long endTime = System.currentTimeMillis();
        System.out.println("程序运行耗时："+(endTime-startTime)+"毫秒");
    }

    // 单独使用FileOut/InStream，一次读取一个字节
    public static void run_01() {
        FileOutputStream fos = null;
        FileInputStream fis = null;
        try {
            fis = new FileInputStream("C:\\Users\\Alvord\\Desktop\\markdown学习\\截图\\一斗.mp4");
            fos = new FileOutputStream("C:\\Users\\Alvord\\Desktop\\markdown学习\\code\\studyProject\\src\\demo13\\一斗.mp4");
            if (fis != null) {
                int read;
                while ((read = fis.read()) != -1) {
                    fos.write(read);
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

        finally {
            try {
                fos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    // 单独使用FileOut/InStream，一次读取byte[1024]
    public static void run_02() {
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            fis = new FileInputStream("C:\\Users\\Alvord\\Desktop\\markdown学习\\截图\\一斗.mp4");
            fos = new FileOutputStream("C:\\Users\\Alvord\\Desktop\\markdown学习\\code\\studyProject\\src\\demo13\\一斗.mp4");
            if (fis != null) {
                int len;
                byte[] bytes = new byte[1024];
                while ((len = fis.read(bytes)) != -1) {
                    fos.write(bytes,0,len);
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        finally {
            try {
                fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                fos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    // 使用字节缓冲流复制视频，但一次只读取一个字节
    public static void run_03() {
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;
        try {
            FileInputStream fis = new FileInputStream("C:\\Users\\Alvord\\Desktop\\markdown学习\\截图\\一斗.mp4");
            FileOutputStream fos = new FileOutputStream("C:\\Users\\Alvord\\Desktop\\markdown学习\\code\\studyProject\\src\\demo13\\一斗.mp4");
            bis = new BufferedInputStream(fis);
            bos = new BufferedOutputStream(fos);

            if (bis != null) {
                int read;
                while ((read = bis.read()) != -1) {
                    bos.write(read);
                }
            }

        } catch (IOException e) {
            e.printStackTrace();
        }
        finally {
            try {
                bis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                bos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    // 使用字节缓冲流复制视频，一次读取byte[1024]
    public static void run_04() {
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;
        try {
            FileInputStream fis = new FileInputStream("C:\\Users\\Alvord\\Desktop\\markdown学习\\截图\\一斗.mp4");
            FileOutputStream fos = new FileOutputStream("C:\\Users\\Alvord\\Desktop\\markdown学习\\code\\studyProject\\src\\demo13\\一斗.mp4");
            bis = new BufferedInputStream(fis);
            bos = new BufferedOutputStream(fos);

            if (bis != null) {
                int len;
                byte[] bytes = new byte[1024];
                while ((len = bis.read(bytes)) != -1) {
                    bos.write(bytes,0,len);
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        finally {
            try {
                bis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                bos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}
*****************************************
package demo13;

import java.io.*;

public class _IO_Buffered_02 {
    public static void main(String[] args) {
        /*
        需求：用4种方法把一个视频文件复制到当前的模块下，比较程序运行的时间

         思路 ：
           - 根据数据源创建字节输入流对象
           - 根据目的地创建字节流入流对象
           - 读写数据，复制视频
           - 释放资源

         基本字节流一次读写一个字节：       程序运行耗时：59099毫秒
         基本字节流一次读写一个字节数组：    程序运行耗时：101毫秒
         字节缓冲流一次读写一个字节：       程序运行耗时：258毫秒
         字节缓冲流一次读写一个字节数组：    程序运行耗时：37毫秒
         */

        // 记录开始时间
        long startTime = System.currentTimeMillis();
//        run_01();     //  程序运行耗时：59099毫秒
//        run_02();     //  程序运行耗时：101毫秒
//        run_03();     //  程序运行耗时：258毫秒
        run_04();     //  程序运行耗时：37毫秒



        // 记录程序结束时间
        long endTime = System.currentTimeMillis();
        System.out.println("程序运行耗时："+(endTime-startTime)+"毫秒");
    }

    // 单独使用FileOut/InStream，一次读取一个字节
    public static void run_01() {
        FileOutputStream fos = null;
        FileInputStream fis = null;
        try {
            fis = new FileInputStream("C:\\Users\\Alvord\\Desktop\\markdown学习\\截图\\一斗.mp4");
            fos = new FileOutputStream("C:\\Users\\Alvord\\Desktop\\markdown学习\\code\\studyProject\\src\\demo13\\一斗.mp4");
            if (fis != null) {
                int read;
                while ((read = fis.read()) != -1) {
                    fos.write(read);
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

        finally {
            try {
                fos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    // 单独使用FileOut/InStream，一次读取byte[1024]
    public static void run_02() {
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            fis = new FileInputStream("C:\\Users\\Alvord\\Desktop\\markdown学习\\截图\\一斗.mp4");
            fos = new FileOutputStream("C:\\Users\\Alvord\\Desktop\\markdown学习\\code\\studyProject\\src\\demo13\\一斗.mp4");
            if (fis != null) {
                int len;
                byte[] bytes = new byte[1024];
                while ((len = fis.read(bytes)) != -1) {
                    fos.write(bytes,0,len);
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        finally {
            try {
                fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                fos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    // 使用字节缓冲流复制视频，但一次只读取一个字节
    public static void run_03() {
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;
        try {
            FileInputStream fis = new FileInputStream("C:\\Users\\Alvord\\Desktop\\markdown学习\\截图\\一斗.mp4");
            FileOutputStream fos = new FileOutputStream("C:\\Users\\Alvord\\Desktop\\markdown学习\\code\\studyProject\\src\\demo13\\一斗.mp4");
            bis = new BufferedInputStream(fis);
            bos = new BufferedOutputStream(fos);

            if (bis != null) {
                int read;
                while ((read = bis.read()) != -1) {
                    bos.write(read);
                }
            }

        } catch (IOException e) {
            e.printStackTrace();
        }
        finally {
            try {
                bis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                bos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    // 使用字节缓冲流复制视频，一次读取byte[1024]
    public static void run_04() {
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;
        try {
            FileInputStream fis = new FileInputStream("C:\\Users\\Alvord\\Desktop\\markdown学习\\截图\\一斗.mp4");
            FileOutputStream fos = new FileOutputStream("C:\\Users\\Alvord\\Desktop\\markdown学习\\code\\studyProject\\src\\demo13\\一斗.mp4");
            bis = new BufferedInputStream(fis);
            bos = new BufferedOutputStream(fos);

            if (bis != null) {
                int len;
                byte[] bytes = new byte[1024];
                while ((len = bis.read(bytes)) != -1) {
                    bos.write(bytes,0,len);
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        finally {
            try {
                bis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                bos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}
bos = null;
        try {
            FileInputStream fis = new FileInputStream("C:\\Users\\Alvord\\Desktop\\markdown学习\\截图\\一斗.mp4");
            FileOutputStream fos = new FileOutputStream("C:\\Users\\Alvord\\Desktop\\markdown学习\\code\\studyProject\\src\\demo13\\一斗.mp4");
            bis = new BufferedInputStream(fis);
            bos = new BufferedOutputStream(fos);

            if (bis != null) {
                int len;
                byte[] bytes = new byte[1024];
                while ((len = bis.read(bytes)) != -1) {
                    bos.write(bytes,0,len);
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        finally {
            try {
                bis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                bos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }

_字符缓冲流的特有功能

  1. BufferedWriter:

    • void newLine() ：写一行行分隔符，行分隔符字符由系统属性定义

  2. BufferedReader:

    • public String readLine() ：读一行文字。结果包含的内容的字符串，不包括任何终止字符，如果流的结尾已经到达，则为null
  3. package demo14;

import java.io.*;

public class _IO_Stream_Demo_05 {
    public static void main(String[] args) {
        /*
        需求：用字符流的特有功能复制JAVA文件

        思路：
             1. BufferedWriter:
                - void newLine() ：写一行行分隔符，行分隔符字符由系统属性定义
             2. BufferedReader:
                - public String readLine() ：读一行文字。结果包含的内容的字符串，不包括任何终止字符，如果流的结尾已经到达，则为null
         */

        BufferedWriter bw = null;
        BufferedReader br = null;
        try {
            bw = new BufferedWriter(new FileWriter("C:\\Users\\Alvord\\Desktop\\markdown学习\\code\\studyProject\\src\\demo14\\_Copy_IO_Buffered_02.java"));
            br = new BufferedReader(new FileReader("C:\\Users\\Alvord\\Desktop\\markdown学习\\code\\studyProject\\src\\demo13\\_IO_Buffered_02.java"));

            if (br != null) {
                String len;
                while ((len = br.readLine()) != null) {
                    bw.write(len);
                    bw.newLine();
                    bw.flush();
                }
            }

        } catch (IOException e) {
            e.printStackTrace();
        }
        finally {
            try {
                bw.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                br.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
}
=================================

Process finished with exit code 0
团子たまこ
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
代码随想录day60 | 动态规划P17 | ● 647. ● 516.● 动态规划总结篇
FhilMs的博客
05-07 972
● 647. 回文子串 ● 516.最长回文子序列 ● 动态规划总结篇
java读取通达信day_通达信，获得当前日期(示例代码)
weixin_29188759的博客
02-17 1509
DRAWTEXT(ISNEWDAY, P_OBV, VAR2STR(DATE+19000000-20170000, 0) );函数名 简称 详解 用法PERIOD 周期 取得周期类型. 结果从0到11,依次分别是1/5/15/30/60分钟,日/周/月,多分钟,多日,季,年.DATE 日期 取得该周期从1900以来的的年月日. DATE例如函数返回1000101,表示2000年1月1日,DATE...
sqlite julianday
chisong4176的博客
06-16 1195
sqlite中做两个时间的差时让我纠结好久 select (julianday(datetime('now','localtime'))-julianday(datetime('2014-12-31 21:00:00'))) 这句话计算出来的结果是天数，如果要算相差的小时数 就*24...
1-2day基本操作
qq_59778168的博客
06-24 2007
python初入
详解谷歌VR平台Daydream：有手柄就是不一样
程序达人
01-23 1781
谷歌Cardboard头戴设备很有趣，这是一款简单又便宜的产品。许多人通过这款产品尝试了虚拟现实。不过，Cardboard没有太多的控制功能，因此体验受到了限制。 在上周的I/O开发者大会上，谷歌推出了新设备Daydream。借助这款设备，人们可以做的不仅仅是坐在沙发上看YouTube视频。 谷歌虚拟现实业务负责人克莱·巴沃尔(Clay Bavor)在上周三的主题演讲中表示，Daydr
Python 全栈 60 天精通之路
GitChat
02-11 2951
传统的 Python 教程 我见过很多的 Python 讲解教程和书籍，它们大都这样讲 Python： 先从 Python 的发展历史开始，介绍 Python 的基本语法规则，Python 的 list, dict, tuple 等数据结构，然后再介绍字符串处理和正则表达式，介绍文件等 IO 操作，再介绍异常处理， 就这样一章一章的。 很多都是枯燥的讲理论，越看越累，越累越不想看。 那么，有没有比...
mysql获取60天以前数据_mysql如何获得60天前unix时间呢？
weixin_33842051的博客
01-19 1877
摘要：下文讲述mysql数据库中获取unix指定时间的方法分享，如下所示；实现思路:1.借助now获取当天日期及时间2.借助ADDDATE函数向前减去指定天数3.使用unix_timestamp()方法转换时间类型例:mysql> select unix_timestamp(adddate(now(),interval -60 day));+-------------------------...
Calendar类要点、易错点&Calendar中的DATE 和 DAY_OF_MONTH 和 DAY_OF_YEAR
qq_43842093的博客
08-20 2296
用于日期的计算。是一个抽象类，得用它的静态方法getInstance()获取（它的子类）实例。（会根据地区的不同创建当地使用的日历）将年月日等都存在了它的一个private数组里：fields[]。年在该数组的下标存在了public static字段YEAR里，以此类推。
【JAVA-Day43】Java常用类Calendar解析
热门推荐
沉淀、分享、成长，让自己和他人都能有所收获！
10-16 2万+
作为博主，我将带您深入探讨Java中的日期处理神器 -。我们将一探这个强大的类库，学会如何处理日期、时区、重复事件、甚至是国际假期。而且，在文章中我会用丰富的表情和Java代码案例来让您轻松掌握这些知识。无论您是初学者还是经验丰富的开发者，本文都将为您提供深刻的见解。通过本文，您已经深入了解了类以及如何在Java中进行高级日期处理。我们讨论了其基本用法、日期操作、时区处理、格式化、重复事件、国际假期、最佳实践以及与新日期时间API的比较。
[CISCN2019 华北赛区 Day2 Web1]Hack World
pakho_C的博客
02-12 1837
web第31题 [CISCN2019 华北赛区 Day2 Web1]Hack World 打开靶场： 提示了flag表中有flag列，我们只能提交id 提交1 地址栏中无参数，说明是post方式传参 提交2 3以及后面的就没有了，说明只有2条数据 尝试1’ 说明类型是数字 手动测试一下有无过滤，试了常规的猜解字段等方式，发现有过滤 FUZZ跑一下 相应为482的都是被过滤的字符 例如空格，or，order，union以及报错注入的相关字符都被过滤了 但是select和from没有被过滤 这时我
day60 安装MySql数据库
03-11
在本教程中，我们将深入探讨如何在您的计算机上安装MySQL 8.0数据库。MySQL是一种广泛使用的开源关系型数据库管理系统（RDBMS），它以其高效、稳定和易于管理的特性而受到开发者的青睐。让我们逐步了解如何进行安装...
day60_Shiro.docx
04-13
Apache Shiro 是一个轻量级的Java安全框架，主要用于实现身份认证、授权、加密和会话管理等功能。作为Java框架的一员，Shiro以其简洁易用的API和灵活的架构受到开发者的欢迎。与Spring Security相比，Shiro更适合...
python60day
02-18
python60day
day60vedio.part6.rar
06-01
day60vedio.part6.rar
day60vedio.part5.rar
06-01
day60vedio.part5.rar
【Spring Boot】高效配置管理: 易用性与灵活性并重
weixin_68020300的博客
08-07 1285
本文探讨了Spring Boot中多样化的配置读取方法及其应用场景，强调了配置管理的重要性，并展示了Spring Boot如何通过灵活多变的配置选项简化这一过程。此外，文章还展望了配置管理领域未来的技术趋势和发展方向。对于任何希望深入了解Spring Boot配置管理的开发者来说，这是一篇不容错过的好文。
伐木工 (100%用例)D卷 (Java&&Python&&C++&&Node.js&&C语言)
荆赫同艺的博客
08-07 292
一根 4米长的树木，伐木工不需要切割为 2*2，省去切割成本，直接整根树木交易，为 4*1，收益最大为 4。方式二: 3,2,2,3，但方式二，伐木工多切割一次，增加了切割成本却卖了一样的价格，因此并不是最优收益。一根 2 米长的树木，伐木工不切割，为2*1，收益最大为 2。一根5 米长的树木，伐木工切割为 2*3,收益最大为 6。输出最优收益时的各个树木长度，以空格分隔，按升序排列。一根 10 米长的树木，伐木工可以切割。方式一:3,4,4，也可以切割为。
（javaweb）请求响应postman
2301_79144798的博客
08-08 471
1.Tomcat又称为servlet容器前端浏览器发起请求携带http请求数据，web服务器负责请求协议的解析，Tomcat接收请求数据，并对请求数据进行解析。Tomcat将解析后所有的信息封装到一个对象当中：HttpServletRequest（请求对象）---应用程序从中获取请求数据。HttpServletResponse--通过这个对象设置要响应的数据 --响应信息给浏览器浏览器--服务器：：BS架构（通过浏览器能访问到的网站：京东 淘宝 天猫 唯品会都是BS架构）
SpringBoot快速入门（手动创建）
最新发布
m0_74124657的博客
08-11 250
代码如下//引导类项目的入口//注解添加导入进来你可以浏览器中查看自己编写的代码，看是否正确localhost：你命名的端口号（默认是8080。后面你也可以在配置文件修改）
day_between
03-07
3. 将时间差转换为天数，即将秒数除以24*60*60（一天的秒数）。 以下是一个示例代码： ```python import datetime def day_between(date1, date2): # 将日期字符串转换为datetime对象 date1 = datetime....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值