IO流（三）

最新推荐文章于 2024-08-02 15:39:40 发布
最新推荐文章于 2024-08-02 15:39:40 发布
阅读量161 收藏
点赞数
分类专栏： java 文章标签： io流 File类 Properties 深度遍历 递归
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/promiseend/article/details/78544828
版权

File对象

File类用于将文件或者文件夹封装成对象，方便对文件和文件夹的属性信息进行操作。File类对象可以作为参数传递给流的构造函数。

构造函数

四种构造函数的代码示例：

public class FileDemo {

    public static void main(String[] args) {

        constructorDemo();

    }

    public static void constructorDemo() {
        ///可以将一个已存在的或者不存在的文件或者目录封装成file对象。
        File f1 =new File("c:\\a.txt");

        File f2 =new File("c:\\","a.txt");

        File f=new File("c:\\");
        File f3=new File(f,"a.txt");

//      File f4=new File("c:"+System.getProperty("file.separator")+"a.txt");
        File f4=new File("c:"+File.separator+"a.txt");
    }
}

常见方法

File对象的常见方法有
1.获取、创建、删除、判断以及重命名。

public class FileMethodDemo {

    public static void main(String[] args) throws IOException {
/*      
        File对象的常见方法
            1.获取                                     getDemo()
                获取文件名称
                获取文件路径
                获取文件大小
                获取文件修改时间

            2.创建与删除   boolean           createAndDeleteDemo()

            3.判断                        isDemo() 

            4.重命名                       renameToDemo()

*/
//      getDemo();
//      createAndDeleteDemo();

//      isDemo();
        renameToDemo();
    }

    public static void renameToDemo() {

        File f1=new File("c:\\0.mp3");

        File f2=new File("d:\\9.mp3");

        boolean b=f1.renameTo(f2);
        System.out.println("rename:"+b);

    }

    public static void isDemo() throws IOException {

        File f=new File("a.txt");
        boolean b=f.exists();
/*      
        //带.txt的不一定是文件，不带后缀名的也不一定是目录
        File f1=new File("aaa.txt");
        f1.mkdir();
        File f2=new File("aaa");
        f2.createNewFile();
        */

        System.out.println("is exists:"+b);
        //最好先判断是否存在，在判断是否目录。文件等
        System.out.println(f.isFile());
        System.out.println(f.isDirectory());
        System.out.println(f.isHidden());
        System.out.println(f.isAbsolute());
    }

    public static void createAndDeleteDemo() throws IOException {

        File dir=new File("abc");
        boolean d=dir.mkdir();//make directory
        System.out.println("create dir:"+d);

        System.out.println("delete dir:"+dir.delete());//如果目录里面有内容，则删除不了，因为Windows只能从里往外删除

        File dirs=new File("abc\\a\\b\\c\\d\\e");//创建多级目录
        boolean d1=dir.mkdirs();//make directorys
        System.out.println("create dirs:"+d1);
        System.out.println("delete dirs:"+dirs.delete());//删除的的目录e,前面都是父目录


//      文件的创建与删除
        File file=new File("file.txt");
        /*      
         和输出流不一样，如果文件不存在，则创建，如果存在则不创建

        */  
        boolean b=file.createNewFile();
        System.out.println("create:"+b);

        boolean b1=file.delete();
        System.out.println("delete:"+b1);

        }

    public static void getDemo(){

//      File file=new File("D:\MyEclipse Professional 2014\day22e\a.txt");
        File file=new File("a.txt");


        String name=file.getName();
        String path=file.getAbsolutePath();
        String path1=file.getPath();
        long len=file.length();
        long time=file.lastModified();

        Date date=new Date(time);
        DateFormat dateFormat=DateFormat.getDateTimeInstance(DateFormat.LONG,DateFormat.LONG);
        String str_time=dateFormat.format(date);

        System.out.println("name:"+name);
        System.out.println("absPath:"+path);
        System.out.println("path:"+path1);
        System.out.println("len:"+len);
        System.out.println("time:"+time);
        System.out.println("str_time:"+str_time);

        System.out.println("parent path:"+file.getParent());//当实例化时参数为相对目录时返回空，为绝对目录时返回父目录。
    }

}

2.获取系统根目录和容量

public class FileMethodDemo {

    public static void main(String[] args) throws IOException {

        listRootsDemo();
    }

    public static void listRootsDemo() {

        File[] files=File.listRoots();
        for(File file:files){
            System.out.println(file);
        }

        File f=new File("d:\\");
        System.out.println("FreeSpace:"+f.getFreeSpace());
        System.out.println("TotalSpace:"+f.getTotalSpace());
        System.out.println("UsableSpace:"+f.getUsableSpace());
    }
}

输出：
C:\
D:\
E:\
F:\
G:\
FreeSpace:241087184896
TotalSpace:371055390720
UsableSpace:241087184896

3.获取目录内容
调用list方法的File对象中封装的必须是目录，否则会发生NullPointerException。
如果访问的是系统级目录，也会发生空指针异常。
如果目录存在但是没有内容，会返回一个数组，但是长度为0。

public class FileMethodListDemo {

    public static void main(String[] args) {

        listDemo();

    }

    public static void listDemo() {

        File file=new File("c:\\");
        /*
        函数功能：当前目录下的文件以及文件夹的名称，包含隐藏文件
        */
        String[] names=file.list();

        for(String name:names){
            System.out.println(name);
        }
    }
}

4.过滤器
通过过滤器可以只获取那些带有固定特征的文件或者目录，例如获取后缀为”.java”的文件，或者隐藏文件。

后缀名为”.java”的过滤器：

public class FilterByJava implements FilenameFilter {

    @Override
    public boolean accept(File dir, String name) {

        return name.endsWith(".java");
    }

}

将后缀名作为参数的过滤器：

public class SuffixFilter implements FilenameFilter {

    private String suffix;

    public SuffixFilter(String suffix) {
        super();
        this.suffix = suffix;
    }

    @Override
    public boolean accept(File dir, String name) {

        return name.endsWith(suffix);
    }
}

隐藏文件的过滤器：

public class FilterByHidden implements FileFilter {

    @Override
    public boolean accept(File pathname) {

        return !pathname.isHidden();
    }

}

使用以上过滤器的实例：

public class FileMethodListDemo {

    public static void main(String[] args) {

        listDemo_2();
        listDemo_3();

    }

    public static void listDemo_3() {

        File dir=new File("c:\\");

        File[] files=dir.listFiles(new FilterByHidden());

        for(File file:files){
            System.out.println(file);
        }
    }

    public static void listDemo_2() {

        File dir=new File("c:\\");
//      String[] names=dir.list(new FilterByJava());
        String[] names=dir.list(new SuffixFilter(".java"));

        for(String name:names){
            System.out.println(name);
        }
    }
}

深度遍历

需求一：对指定目录进行所有内容的列出（包含子目录的内容）
即进行深度遍历。

public class FileTest {

    public static void main(String[] args) {

        File dir=new File("E:\\javawork");
        listAll(dir,0);

    }

    public static void listAll(File dir,int level) {
//      System.out.println("dir:"+dir.getAbsolutePath());
        System.out.println(getSpace(level)+dir.getName());
        level++;
        //获取指定目录下当前的所有文件夹或者文件对象
        File[] files=dir.listFiles();
        //
        for(int x=0;x<files.length;x++){
            if(files[x].isDirectory()){

                listAll(files[x],level);
            }
            else
                System.out.println(getSpace(level)+files[x].getName());
        }

    }

    private static String getSpace(int level) {

        StringBuilder sb=new StringBuilder();

        sb.append("|--");
        for(int x=0;x<level;x++){
            sb.insert(0,"|  ");
        }

        return sb.toString();
    }

}

递归
函数自身直接或间接地调用到自身就是递归。
一个功能在被重复使用，并每次使用时，参与运算的结果和上一次调用有关，这时可以用递归来解决问题。
注意：
1.递归一定要明确条件，否则容易栈溢出。
2.注意递归的次数。

需求二：删除一个带内容的目录。
原理：必须要从最里面往外删，需要进行深度遍历。

public class RemoveDirTest {

    public static void main(String[] args) {


        File dir=new File("e:\\demodir");
        removeDir(dir);
    }

    public static void removeDir(File dir) {

        File[] files=dir.listFiles();

        for(File file:files){

            if(file.isDirectory()){

                removeDir(file);
            }
            else{
                System.out.println(file+":"+file.delete());file.delete();
            }

        }
        System.out.println(dir+":"+dir.delete());
    }

}

Properties集合

Properties集合是Hashtable集合下的一个子类：
Map–>Hashtable->Properties

Properties表示一个持久的属性集，该集合用于操作以键值对形式存在的配置文件。

Properties集合的特点：
1. 可以保存在流中或者从流中加载。
2. 属性列表中每个键及其对应值都是一个字符串。

Properties集合的常见使用：

public class PropertiesDemo {

    public static void main(String[] args) throws IOException {

//      propertiesDemo();

//      methodDemo_2();
//      methodDemo_3();
//      methodDemo_4();

//      myLoad();
        test();
    }

    //对已有的配置文件中的信息进行修改
    /*
    读取这个文件
    并将这个文件中的键值数据存储到集合中
    再通过集合对数据进行修改
    再通过流将修改后的数据存储到文件中

    */

    public static void test() throws IOException{
        //读取这个文件
        File file=new File("info.txt");
        if(!file.exists()){
            file.createNewFile();
        }

        FileReader fr=new FileReader(file);//流与数据相关联
//      FileWriter fw=new FileWriter(file);//不能写在这里，因为这样是新创建了一个一个文件，原文件的数据被覆盖了，里面没数据

        //创建集合存储配置信息
        Properties prop =new Properties();

        //将流中的信息存储到集合中
        prop.load(fr);

//      prop.list(System.out);

//      通过集合对数据进行修改
        prop.setProperty("marry", "21");

//      prop.list(System.out);

//      通过流将修改后的数据存储到文件中
        FileWriter fw=new FileWriter(file);

        prop.store(fw,"info");

        fw.close();
        fr.close();
    }

//  模拟load方法
    public static void myLoad() throws IOException{

        Properties prop=new Properties();
        BufferedReader bufr=new BufferedReader(new FileReader("info.txt"));

        String line=null;

        while((line=bufr.readLine())!=null){

            if(line.startsWith("#"))
                continue;

            String[] arr=line.split("=");

//          System.out.println(arr[0]+"::"+arr[1]);
            prop.setProperty(arr[0], arr[1]);

        }

        prop.list(System.out);

        bufr.close();
    }

    public static void methodDemo_4() throws IOException {

        Properties prop=new Properties();
        /*
        集合中的数据来自一个文件
        注意：必须保证该文件的数据是键值对
        需要使用到读取流
        */
        FileInputStream fis=new FileInputStream("info.txt");

        //使用load方法
        prop.load(fis);

        prop.list(System.out);

    }

    public static void methodDemo_3() throws IOException {

        Properties prop=new Properties();

        //存储元素
        prop.setProperty("marry", "28");
        prop.setProperty("tom", "14");
        prop.setProperty("jerry", "12");
        prop.setProperty("lisa", "24");

        /*
         * 想要将这些集合中的字符串键值信息持久化存储到文件中
         * 需要关联输出流
         * 
         * */

        FileOutputStream fos=new FileOutputStream("info.txt");
        //将集合中的数据存储到文件中，使用store方法
        prop.store(fos, "name+age");

        fos.close();

    }

    /*
    演示Properties集合和流对象相结合的功能
    */
    public static void methodDemo_2(){

        Properties prop=new Properties();

        //存储元素
        prop.setProperty("marry", "28");
        prop.setProperty("tom", "14");
        prop.setProperty("jerry", "12");
        prop.setProperty("lisa", "24");

        //public void list(PrintStream out):将属性列表输出到指定的输出流
        prop.list(System.out);//集合中的数据输出到输出流控制台上。调试用，开发用得少

        Properties prop1=System.getProperties();
        prop1.list(System.out);
    }

    /*
    Properties集合的存和取
    */
    public static void propertiesDemo(){

        //创建一个Properties集合
        Properties prop=new Properties();

        //存储元素
        prop.setProperty("marry", "28");
        prop.setProperty("tom", "14");
        prop.setProperty("jerry", "12");
        prop.setProperty("lisa", "24");

        //修改元素
        prop.setProperty("marry", "18");

        //取出所有元素
        Set<String> names=prop.stringPropertyNames();

        for(String name:names)
        {
            String value=prop.getProperty(name);
            System.out.println(name+":"+value);
        }
    }
}

Properties集合练习
需求：定义功能，获取一个应用程序运行的次数，如果超过5次，给出使用次数已到请注册的提示，并且不要再运行程序。
思路：
1.应该有计数器；
每次程序启动都需要计数一次，并且是在原有的次数上进行计数。
2.计数器就是一个变量，程序启动时进行计数，计数器必须存在于内存中并进行运算。
但是程序一旦结束，计数器消失了，再次启动该程序的时候，计数器又重新被初始化了。

然而我们需要多次启动同一个应用程序，使用的是同一个计数器。
这就需要计数器的生命周期变长，从内存存储到硬盘文件中。

3.如何使用这个计数器：
首先，程序启动时，应该先读取这个用于记录计数器信息的配置文件。
获取上一次计数器次数，并进行试用次数的判断。
其次，对该次数进行自增，并将自增后的次数重新存储到配置文件中。

4.文件中的信息该如何进行存储并体现：
直接存储此数值可以，但是不明确该数据的含义，所以应该起一个名字。
（简单数据可以这么体现，用键值对。但是复杂数据不可以，要想进行更贴切的描述，应该用xml文件。）
这就有了名字和值的对应，所以可以使用键值对。
可以应用有映射关系的map集合搞定，又需要读取硬盘上的数据，所以map+io=Properties。

public class PropertiesTest {

    public static void main(String[] args) throws IOException {
        getAppCount();

    }


    public static void getAppCount() throws IOException{

        //将配置文件封装成File对象
//      .ini在Windows或者常见应用软件里比较常用，对于java制作的软件的键值对的配置信息用.properties作为扩展名
        File confile=new File("count.ini");

        if(!confile.exists()){
            confile.createNewFile();
        }

        FileInputStream fis=new FileInputStream(confile);

        Properties prop=new Properties();

        prop.load(fis);

        //从集合中通过键获取次数
        String value=prop.getProperty("time");

        //定义计数器，记录获取到的次数
        int count=0;
        if(value!=null){
            count =Integer.parseInt(value);
            if(count>=5){
//              System.out.println("使用次数已到,请注册");
//              return;
                throw new RuntimeException("使用次数已到,请注册");
            }
        }
        count++;

        //将改变后的次数重新存储到集合中
        prop.setProperty("time", count+"");

        FileOutputStream fos=new FileOutputStream(confile);

        prop.store(fos,"");

        fos.close();
        fis.close();

    }
}

综合练习

需求：获取指定目录下，指定扩展名的文件（包含子目录中的）这些文件的绝对路径写入到一个文本文件中。简单说，就是建立一个指定扩展名的文件的列表。

思路：
1.必须进行深度遍历；
2.要在遍历的过程中进行过滤，将符合条件的内容都存储到容器中；
3.对容器中的内容进行遍历并将绝对路径写入到文件中。

public class Test {

    public static void main(String[] args) throws IOException {

        File dir=new File("e:\\javawork");
        FilenameFilter filter=new FilenameFilter(){


            @Override
            public boolean accept(File dir, String name) {

                return name.endsWith(".java");
            }

        };

        List<File> list=new ArrayList<File>();

        getFiles(dir,filter,list);
        File destFile=new File(dir,"javalist.txt");

        write2File(list,destFile);
    }
/**
 * 对指定目录中的内容进行深度遍历，并按照指定的过滤器进行过滤，将过滤后的内容存储到指定容器list中
 * @param dir
 * @param filter
 * @param list
 */
    public static void getFiles(File dir,FilenameFilter filter,List<File> list){

        File[] files=dir.listFiles();

        for(File file:files){
            if(file.isDirectory()){
                //递归
                getFiles(file,filter,list);
            }else{
                //对遍历到的文件文件进行过滤器的过滤，将符合条件的File对象，存储到List集合中。
                if(filter.accept(dir, file.getName())){
                    list.add(file);
                }
            }
        }
    }

    public static void write2File(List<File> list,File destFile) throws IOException{

        BufferedWriter bufw=null;
        try {
            bufw=new BufferedWriter(new FileWriter(destFile));

            for(File file:list){
                bufw.write(file.getAbsolutePath());
                bufw.newLine();
                bufw.flush();
            }

        } /*catch (IOException e) {//catch或者抛出
            throw new RuntimeException("写入失败");
        }*/finally{
            if(bufw!=null)
                try{
                    bufw.close();

                }catch(IOException e){
                    throw new RuntimeException("关闭失败");
                }
        }

    }
}
promiseend
关注
专栏目录
java 图片io流_关于JavaIO流的图片读取
weixin_32757449的博客
02-16 1091
关于JavaIO流的图片读取自我介绍一下大家好，新的一年,新的一个学期…我是一个大二的学生，我姓林。最近Java刚刚学到IO流这一板块知识。在此，发表一下关于IO流的图片读取总结的心得还有思路…简单介绍一下IO板块中有输出流还有输入流，后面还有缓冲流等等 ，现在简单介绍输出流还有输入流在Java的IO这一板块中,有输入流InPutStream(当然，这是输入流的父类也是抽象类)它的子类是FileI...
第1章 File类
weixin_34216107的博客
04-16 122
1.1 File概述打开API，搜索File类。阅读其描述：File文件和目录路径名的抽象表示形式。即，Java中把文件或者目录（文件夹）都封装成File对象。也就是说如果我们要去操作硬盘上的文件，或者文件夹只要找到File这个类即可,那么我们就要研究研究File这个类中都有那些功能可以操作文件或者文件夹呢1.2 File类的构造函数File(String pathname) :将一个字符串路径封...
【Java基础-3】吃透Java IO：字节流、字符流、缓冲流
热门推荐
云深不知处
09-23 15万+
什么是Java-IO？字符流和字节流的区别与适用场景是什么？缓冲流到底实现了什么？如何高效地读写文件？ 本文用大量的示例图和实例，带你吃透Java IO。
IO流的分类
小白学编程
05-11 1万+
IO流的分类可以分为以下三种： 第一种：输入流和输出流 按照流的流向来分，可以分为输入流和输出流。输入，输出都是从程序运行所在内存的角度来划分的。 输入流：只能从中读取数据，而不能向其写入数据，由InputStream和Reader作为基类。 输出流：只能向其写入数据，而不能从中读取数据。由OutputStream和Writer作为基类 第二种：字节流和字符流 字节流和字符流的用法几乎完全一样，区...
Java IO流的种类
程序员
02-20 3357
Java IO流的种类
JavaIO流详解
itqcyyl的博客
08-09 2万+
转载：https://www.cnblogs.com/LittleHann/p/3678685.html Java输入、输入、IO流 类层次关系梳理 本文主要关注在Java编程中涉及到的IO相关的类库、方法。以及对各个层次(抽线、接口继承)的流之间的关系进行梳理   相关学习资料 http://baike.baidu.com/view/1007958.htm?noadapt=1 h...
java IO流
D大调奏鸣曲_第七序章_de博客
11-11 8万+
目录 序 一、IO流开篇 1、概念 2、流的分类 3、IO流的作用 4、IO流的使用场景 二、字节流 1、字节流抽象基类 2、字节流写数据 （1）基本步骤 （2）三种方式 （3）两个问题 （4）异常处理 3、字节缓冲流 （1）基本分类&概述 （2）构造方法 （3）代码演示 三、字符流 1、概念 2、分类 （1）字符流体系图 （2）字符输入流（Reader） （3）字符输出流（Writer） 3、字符缓冲流 （1）概念 （2）构造方法 （3）...
Java io流 详解
m0_68987535的博客
06-11 4833
"IO流"（Input/Output stream）指的是Java中用于处理输入输出（I/O）数据的机制。在Java中，所有的输入和输出都被抽象为“流”对象，并通过输入流读取数据、输出流写入数据。Java的I/O包提供了丰富的类和方法来支持不同类型的流，输入流和输出流之间可以自由地进行转换。它们分别主要包括字节流和字符流两种类型。其中，字节流是操作二进制数据的流，可以处理任何类型的数据，常见的例如InputStream和OutputStream；
Java IO流 详细版
最新发布
Heyi3416的博客
08-02 2148
BufferedWriter：将文本写入字符输出流，缓冲字符，以提供单个字符，数组和字符串的高效写入，可以指定缓冲区大小，或者可以接受默认大小。BufferedReader：从字符输入流读取文本，缓冲字符，以提供字符，数组和行的高效读取，可以指定缓冲区大小，或者可以使用默认大小。用字节流复制文本文件时，文本文件也会有中文，但是没有问题，原因是最终底层操作会自动进行字节拼接成中文，如何识别是中文的呢？这种机制就是使用一个字节序列表示一个对象，该字节序列包含：对象的类型、对象的数据和对象中存储的属性等信息。
（Java笔记）IO流的六类16种流方式
张松的博客
04-26 3592
IO流的四大类16种流方式
IO流三种流方式的文本文件的复制
07-27
在Java编程语言中，IO流（Input/Output流）是用来处理数据输入与输出的重要工具。在文本文件的复制过程中，通常会用到三种主要的流类型：字节流（Byte Stream）、字符流（Character Stream）以及缓冲流（Buffered ...
Java-Io流，练习
07-06
Java的IO流是Java编程语言中的重要组成部分，它主要用于数据的输入和输出操作。在Java中，IO流被设计为处理任何类型的数据，包括字符、字节甚至对象。本练习旨在帮助初学者理解和掌握Java IO流的基础知识。 一、IO...
Java基础篇：IO流.pdf
05-19
Java IO流是Java编程语言中用于处理输入输出操作的一个重要概念。它允许程序读取数据源或向数据目的地写入数据。Java中的IO流主要分为输入流和输出流两大类，每类又可以根据数据处理方式的不同细分为多种具体实现。...
java基础之IO流
06-18
### Java IO流基础知识点 #### 一、IO流概述 - **定义**：在Java中，IO流（Input/Output Streams）是用来处理输入输出的基本工具。流是一种有序的数据集合，通常涉及从源到目的地的数据传输过程。源可以是文件、...
IO流、Xml解析
08-26
在IT领域，IO流（Input/Output Stream）和XML解析是两个重要的概念，它们在数据处理和信息交换中起着核心作用。 IO流是Java编程语言中的一个关键特性，用于处理程序与外部设备（如硬盘、网络、内存等）之间的数据...
数组常见算法比较
promiseend的博客
09-21 7910
1.选择排序基本思想： 选择排序的基本思想是将指定排序位置与其他数组元素分别对比，如果满足条件则交换元素。 算法示例： 如图，先将下标为0的数组元素分别与其他元素相比，23<45,不交换（从小到大排序），再比较23与6，交换……这样将23与其他元素比较后，下标为0的元素变成了6。再将下标为1的元素与下标为2，3，4，5的元素进行比较，经过5轮这样的比较后，就可完成排
进制转换与查表法
promiseend的博客
09-22 851
原理： 引例：获取一个十进制整数的16进制表示。 分析：在Java程序中，int类型在内存中占用4个字节，即32位。由于一位16进制可以由4位二进制来表示，因此，最大的int类型的整数可以用32/4=8位十六进制数来表示。 当十进制数x在{1，2，…,9}范围内时，与16进制表示一致，在{10，11，12,13,14,15}范围内时，在十六进制中表示为{A,B,C,D,E,F}
Java类包
promiseend的博客
10-12 656
概述Java类包是Java管理类文件的一种机制，可以解决类名冲突的问题。 Java类包的特性： 1.对类文件进行分类管理 2.给类提供多层命名（名称）空间 3.写在程序文件的第一行 4.类名的全称是 包名.类名 5.包也是一种封装形式使用不同包中的类常犯的错误： 1，类名写错：在不同的包中调用类时要明确其包的所属，正确格式是包名.类名
JDBC技术对数据库的操作
promiseend的博客
09-18 621
1.连接数据库要访问数据库，首先要加载数据库的驱动程序（只需要在第一次访问数据库时加载一次），然后每次访问数据是创建一个Connection对象，接着执行操作数据库的SQL语句，最后在完成数据库操作后销毁前面创建的Connection对象，释放与数据库的连接。 两个步骤： 1.加载驱动程序： Class.forName(‘com.mysql.jdbc.Driver”); (ps:需导入mys
Java IO流基础与实战示例
Java IO流是Java编程语言中的基础组件，它允许程序与外部数据源（如文件、网络连接等）进行数据交换。本文档将详细介绍Java中IO流的运用，包括文件操作和上传，通过实例来深入理解其工作原理。 首先，我们来看关于`...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值