java IO流

最新推荐文章于 2023-05-30 15:57:30 发布
最新推荐文章于 2023-05-30 15:57:30 发布
阅读量132 收藏
点赞数
分类专栏： java 文章标签： java jvm 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_62414347/article/details/129136996
版权

文章目录

IO

字符集：

常见字符集：ASCll 包括了数字，英文，符号。

ASCll使用一个字节存储字符，一个字节是八位，总共可以表示128个字符

GBK:用来存储中文字符，window系统默认的字符

Unicode码表：统一全球的编码，万国码。UTF-8,UTF-16…。技术UTF_8人员都应该使用UTF_8，编码前和解码后必须要一致，不然会乱码。

字符的编码有多种方案，一个英文字符在ASCII码、Unicode码、UTF-8编码中，分别占用一个、两个、一个字节的空间；一个汉字字符在ASCII码、Unicode码、UTF-8编码中，分别占用两个、两个、三个字节的空间

结论：计算机底层可以表示十进制编号。计算机可以给人类符号进行编号存储，即字符集

IO流概述：

按方向分类：分为输入流，输出流

输入流：是数据从硬盘文件，读入到内存的过程

输出流：是内存程序的数据从内存写出到硬盘文件的过程，称之为输出，负责写。

按流中的数据最小单位分为：字节流，字符流。

  • 字节输入流：以内存为基准，来自磁盘中的文件/网络中的数据以字节的形式读入到内存中，称为字节输入流

  • 字节输出流：以内存为基准，来自内存的数据以字节的形式读入到磁盘中的文件/网络中，称为字节输出流

    • InputStream,OutputStream

  • 字符输入流：以内存为基准，来自磁盘中的文件/网络中的数据以字符的形式读入到内存中，称为字符输入流

  • 字符输出流：以内存为基准，来自内存的数据以字符的形式读入到磁盘中的文件/网络中，称为字符输出流

    • Reader , Writer
//文件字节输入流，api
public int read();
//每次读取一个字节返回，如果没有字节返回-1；

读取一个字节存在什么问题：

  • 性能较慢
  • 读取中文字符，容易出现乱码问题。

文件字节输入流：FileInputStream

文件字节输出流：FileOutputStream

//以字节的形式将数据读取到内存中去
public int read();
public int read(byte[] buffer);

控制台=内存，磁盘，网络文件

外：磁盘，网络文件

内：内存，控制台

字节流读取：

常用API:

write();

read();

根据参数不同选择不同

int,char[],String,off,set如下代码：

package com.pan.Stream;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;

public class FileStream {
    public static void main(String[] args) throws Exception {
        File f= new File("FileTest/src/test.txt");
        InputStream is = new FileInputStream(f);
       /* int b1 = is.read();
        System.out.println(b1);

        int b4 = is.read();
        System.out.println(b4);
        int b3 = is.read();
        System.out.println(b3);
        int b2 = is.read();
        System.out.println(b2);
        */
       //依然无法避免乱码，会把中文截断，一个中文字符栈用三个字节,一个英文字符占一个字节
        /*byte[] bytes = new byte[3];
        int len;
        while((len = is.read(bytes)) != -1){
            System.out.println(new String(bytes,0,len));
        }*/


        /*System.out.println("读取了几个字节"+len);
        String rs = new String(bytes,1,2);
        System.out.println(rs);*/

        //将文件所有的字符一次性接收
       /* byte[] buffer = new byte[(int) f.length()];
        int len = is.read(buffer);
        System.out.println("长度为："+len);
        System.out.println("长度为："+f.length());
        System.out.println(new String(buffer));*/

      // byte[] buffer = is.readALLBByte();
    }
}

字符流读取：

package com.pan.Stream;

/*
*由于字节流读取文件会出现乱码
* 使用字符流读取和写入，最小单位是按照字符开始的
* Reader(抽象)--->FileReader(实现类)
* */

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.Reader;

public class FileInputStringStream {

    public static void main(String[] args) throws Exception {
        //目标：每次读取一个字符
        //1。创建一个字符输入流管道与原文件接通
        Reader reader = new FileReader("FileTest/src/dataCode.txt");
        //2.读取一个字符
        int count = reader.read();
        System.out.println((char)count);

        int code ;
        while((code = reader.read()) != -1){
            System.out.print((char)code);
        }
        //不能重复读，上面的循环完后，下面的循环输出为空；必须注释掉上面
        char[] characters = new char[1024];
       // int count1 = reader.read(characters,0,3);
        //记录读取字符的个数
        int len;
        System.out.println("=========================================================================");
        while((len = reader.read(characters)) != -1){
            String rs = new String(characters,0,len);
            System.out.print(rs);
        }
        //System.out.println((char)count1);
    }

}

输出流

package com.pan.Stream;

/*
* 写入外部文件，以字符为基础
* 写到磁盘文件
* Writer(抽象类)---->FileWriter(实现类）
* */

import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;

public class FileOutStringStream {

    //1.创建一个文件输出流
    public static void main(String[] args) throws IOException {
        Writer writer = new FileWriter("FileTest/src/data字符.txt",true);
        //2.常用API
        writer.write(99);
        writer.write("年后就");
        writer.write('a');
        //换行
        writer.write("\r\n");
        char[] chars = "我似乎好像是输出流".toCharArray();
        writer.write(chars);
        writer.write("\r\n");
        writer.write("我是中国人",0,2);
        //刷新
        writer.flush();//刷新后，流可以继续使用
        //关闭流
        writer.close();//关闭包含刷新，关闭后流不可以使用
    }

}

字节 缓冲流

package com.pan.StreamAreasBuffer;

import java.io.*;
/*
* Buffer高级流，性能更好
* */

public class ByteBufferDemo {

    public static void main(String[] args) {

//            InputStream inputStream = null;
//            OutputStream outputStream = null;
            //创建一个字节输入流管道与视屏文件接通
            try(
                    //try()中会自动关闭流。
                    InputStream inputStream = new FileInputStream("E:\\图库\\OIP-C.jpg");
                    //2.创建一个字节输出流管道与目标文件接通
                    //把原始的字节输入流包装成高级的缓冲输入流
                    InputStream bis = new BufferedInputStream(inputStream);
                    //文件的速度慢于内存，outputStream 不在内存中非常慢
                    OutputStream outputStream = new FileOutputStream("FileTest/src/image01.png");
                    //把字节输出流包装在高级的缓冲字节输出流管道，8kb的缓冲池，存储空间小，查找快，读取快
                    OutputStream outputStream1 = new BufferedOutputStream(outputStream);
            ) {

                byte[] buffer = new byte[1024];
                int len ;
                while((len = bis.read(buffer) ) != -1){
                    outputStream1.write(buffer,0,len);
                }
                System.out.println("赋值完成了");
            } catch (IOException e) {
                e.printStackTrace();
            }
            finally {
                System.out.println("=====================finally=================");
            }
        }

    }

文件复制案例与性能对比

package com.pan.StreamAreasBuffer;

import java.io.*;
import java.nio.Buffer;
import java.util.Collections;

public class CompareTimeBuffer {

    public static void main(String[] args) {
        copyBufferStreamTime();
        copyOldStreamTime();
        copyBufferStreamTimeBit();
        copyOldStreamTimeBit();
    }

    public static void copyOldStreamTime(){
        long startTime = System.currentTimeMillis();
//            InputStream inputStream = null;
//            OutputStream outputStream = null;
            //创建一个字节输入流管道与视屏文件接通
            try(
                    InputStream inputStream = new FileInputStream("E:\\图库\\2019年下半年软件设计师下午真题及答案解析.word");
                    //2.创建一个字节输出流管道与目标文件接通
                    OutputStream outputStream = new FileOutputStream("FileTest/src/papers01.pdf");
            ) {

                byte[] buffer = new byte[1024];
                int len ;
                while((len = inputStream.read(buffer) ) != -1){
                    outputStream.write(buffer,0,len);
                }
                System.out.println("赋值完成了");
            } catch (IOException e) {
                e.printStackTrace();
            }
            finally {
                System.out.println("=====================finally=================");
            }
            long endTime = System.currentTimeMillis();
            System.out.println("使用--原始的--字节流（一个数组）的形式复制文件"+(endTime - startTime)/1000.0 + "s");
    }

    public static void copyBufferStreamTime(){
        long startTime = System.currentTimeMillis();
//            InputStream inputStream = null;
//            OutputStream outputStream = null;
        //创建一个字节输入流管道与视屏文件接通
        try(
                InputStream inputStream = new FileInputStream("E:\\图库\\2019年下半年软件设计师下午真题及答案解析.word");
                InputStream inputStream1 = new BufferedInputStream(inputStream);
                //2.创建一个字节输出流管道与目标文件接通
                OutputStream outputStream = new FileOutputStream("FileTest/src/papers02.pdf");
                OutputStream outputStream1 = new BufferedOutputStream(outputStream);
        ) {

            byte[] buffer = new byte[1024];
            int len ;
            while((len = inputStream1.read(buffer) ) != -1){
                outputStream1.write(buffer,0,len);
            }
            System.out.println("赋值完成了");
        } catch (IOException e) {
            e.printStackTrace();
        }
        finally {
            System.out.println("=====================finally=================");
        }
        long endTime = System.currentTimeMillis();
        System.out.println("使用--缓冲--字节流（一个数组）形式复制文件"+(endTime - startTime)/1000.0 + "s");
    }

    public static void copyOldStreamTimeBit(){
        long startTime = System.currentTimeMillis();
//            InputStream inputStream = null;
//            OutputStream outputStream = null;
        //创建一个字节输入流管道与视屏文件接通
        try(
                InputStream inputStream = new FileInputStream("E:\\图库\\2019年下半年软件设计师下午真题及答案解析.word");
                //2.创建一个字节输出流管道与目标文件接通
                OutputStream outputStream = new FileOutputStream("FileTest/src/papers03.pdf");
        ) {
           //一个一个字节输出
            int len ;
            while((len = inputStream.read() ) != -1){
                outputStream.write(len);
            }
            System.out.println("赋值完成了");
        } catch (IOException e) {
            e.printStackTrace();
        }
        finally {
            System.out.println("=====================finally=================");
        }
        long endTime = System.currentTimeMillis();
        System.out.println("使用--原始的--字节流（一个一个字节）的形式复制文件"+(endTime - startTime)/1000.0 + "s");
    }

    public static void copyBufferStreamTimeBit(){
        long startTime = System.currentTimeMillis();
//            InputStream inputStream = null;
//            OutputStream outputStream = null;
        //创建一个字节输入流管道与视屏文件接通
        try(
                InputStream inputStream = new FileInputStream("E:\\图库\\2019年下半年软件设计师下午真题及答案解析.word");
                InputStream inputStream1 = new BufferedInputStream(inputStream);
                //2.创建一个字节输出流管道与目标文件接通
                OutputStream outputStream = new FileOutputStream("FileTest/src/papers04.pdf");
                OutputStream outputStream1 = new BufferedOutputStream(outputStream);
        ) {

            int len ;
            while((len = inputStream1.read() ) != -1){
                outputStream1.write(len);
            }
            System.out.println("赋值完成了");
        } catch (IOException e) {
            e.printStackTrace();
        }
        finally {
            System.out.println("=====================finally=================");
        }
        long endTime = System.currentTimeMillis();
        System.out.println("使用--缓冲--字节流（一个一个字节）的形式复制文件"+(endTime - startTime)/1000.0 + "s");
    }


}

结果如下：

赋值完成了
=====finally=
使用–缓冲–字节流（一个数组）形式复制文件0.014s
赋值完成了
=====finally=
使用–原始的–字节流（一个数组）的形式复制文件0.026s
赋值完成了
=====finally=
使用–缓冲–字节流（一个一个字节）的形式复制文件0.046s
赋值完成了
=====finally=
使用–原始的–字节流（一个一个字节）的形式复制文件10.532s

Process finished with exit code 0

字符缓冲流

BufferedRead

package com.pan.StreamAreasBuffer;

/*
* 目标：学会使用字符缓冲输入流/输出流提高自己的性能(8k空间)
* 并学习新增的方法(readLine())优先使用
* Reader---->BufferedReader(继承)
* 经典代码：字符流，行读，不需要字符流桶，桶读会截断。
* */

import java.io.*;

public class BufferReaderDemo01 {
    public static void main(String[] args) throws Exception {
        try ( //1.创建一个Reader的字符流与原文件接通
              Reader reader = new FileReader("FileTest/src/data1.txt");
              BufferedReader bufferedReader = new BufferedReader(reader);
        ) {
            //2.用循环，将文件读取出来
//            char[] chars = new char[1024];
//            int len ;
//            while((len = reader.read(chars)) != -1){
//                String s = new String(chars,0,len);
//                System.out.println(s);
//            }
            String line;
            while((line = bufferedReader.readLine())!= null){
                System.out.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}

输出

package com.pan.StreamAreasBuffer;

/*
 * 目标：学会使用字符缓冲输出流/输出流提高自己的性能(8k空间)
 * 并学习新增的方法()优先使用
 * Writer---->BufferedWriter(继承)
 * */


import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;

public class BufferWriterDemo01 {

    //1.创建一个文件输出流
    public static void main(String[] args) throws IOException {
        Writer fw = new FileWriter("FileTest/src/data字符.txt",true);
        BufferedWriter bufferedWriter = new BufferedWriter(fw);
        //2.常用API
        bufferedWriter.write(99);
        bufferedWriter.write("年后就========================================================");
        bufferedWriter.write('a');
        //换行
        bufferedWriter.write("\r\n");
        char[] chars = "我似乎好像是输出流".toCharArray();
        bufferedWriter.write(chars);
        bufferedWriter.write("\r\n");
        bufferedWriter.write("我是中国人",0,2);
        //刷新
        bufferedWriter.flush();//刷新后，流可以继续使用
        //关闭流
        bufferedWriter.close();//关闭包含刷新，关闭后流不可以使用
    }
java

}

案例：

乱序的出师表恢复

package com.pan.items;

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.Reader;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

/*
* 拷贝一个出师表
* */
public class TeacherForm {

    public static void main(String[] args) {
        try( //1.创建一个Buffered输入流
             Reader reader = new FileReader("FileTest/src/出师表.txt");
             BufferedReader bufferedReader = new BufferedReader(reader);) {
            //2.创建一个list数组存放行字符，list可以默认排序
            List<String> data = new ArrayList<>();
            //按行读取字符，并添加到数组里
            String Line;
            while((Line = bufferedReader.readLine()) != null){
                data.add(Line);
            }
            System.out.println(data);
            //排序
            Collections.sort(data);
            System.out.println(data);

            //自定义排序规则
            List<String> size = new ArrayList<>();
            Collections.addAll(size,"一","二","三","四","五","六","七","八","九");
            Collections.sort(data, new Comparator<String>() {
                @Override
                public int compare(String o1, String o2) {

                    return size.indexOf(o1.substring(0,o1.indexOf("\\.")))- size.indexOf(o2.substring(0,o2.indexOf("\\.")));
                }
            });
            System.out.println(data);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

读取乱码问题(代码与文件编码不一致)

读写编码格式设置

使用以下两个流

InputStreamReader: 有多种构造器

package com.pan.problemsolve;

/*
* 当文件编码格式与代码编码格式不一致时解决办法
* 使用 Reader ----> InputStreamReader(input,charset);
* */

import java.io.*;

public class ConfuseCode {

    public static void main(String[] args) throws Exception {
        try ( //1.创建一个Reader的字符流与原文件接通,文档编码不一致，一个是GBK 一个是UTF-8,由于对中文编码字节数数不一致的
//              Reader reader = new FileReader("E:/文档/data.txt");，这是原本的文件读取方式，会出现乱码，由于编码的不一致
//              BufferedReader bufferedReader = new BufferedReader(reader);
              InputStream inputStream = new FileInputStream("E:/文档/data01.txt");
              //BufferedInputStream bufferedInputStream = new BufferedInputStream(inputStream);
              //2.通过字符流的子实现类的构造方式去确定流的读取编码方式。得到流数据
              Reader reader = new InputStreamReader(inputStream,"GBK");
              //3.设置缓冲区流，将流反倒缓冲区
              BufferedReader bufferedReader = new BufferedReader(reader);
        ) {
            //当然也可以让直接字节容器读取，但要确定文件大小才行
           /* byte[] bytes = new byte[10];
            int line;

            while((line = bufferedInputStream.read(bytes))!= -1){
                String s = new String(bytes,0,line);
                System.out.println(s);*/
           //4.读取到控制台，按行读取。
           String Line;
           while((Line = bufferedReader.readLine() ) != null){
               System.out.println(Line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }


}

OutStreamWriter: 有多种构造器

package com.pan.problemsolve;

/*
*
* */

import java.io.*;

public class ConfuseCodeOut {
    public static void main(String[] args) {
        //1.定义一个字节输出流
        OutputStream outputStream = null;
        try {
            outputStream = new FileOutputStream("FileTest/src/datacodetest.txt");
            //低级流,并指定编码。idea默认为UTF-8
            Writer writer = new OutputStreamWriter(outputStream,"GBK");
            //高级流
            BufferedWriter bufferedWriter = new BufferedWriter(writer);
            bufferedWriter.write("我爱你中国~~~~~~~~~");
            bufferedWriter.close();
        } catch (Exception e) {
            e.printStackTrace();
        }



    }
}

对象序列

小小白胜志
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java IO流
qq_49690983的博客
06-06 117
IO流 1. IO流概述 1.1 什么是IO流 I：Input O：Output 通过IO可以完成硬盘文件的读写 1.2 IO流的分类 分类方式 按照流的方向进行分类 以内存作为参照物 输入流： 往内存中去叫做输入（Input ）或读（Read） 输出流： 从内存中取出浇输出（Output）或写（Write） 按照读取数据的方式不同分类 字节流： 按照字节的方式读取数据，一次读一个字节（byte）即8个二进制位 这种流是万能的，可以读取任何文件（文本文件，图片，声音等）
JAVA IO流详解
qqw666666的博客
03-24 561
java.io 包下提供了各种“流”类的接口，用以获取不同种类的数据，并通过标准的方法输入或输出数据，而流的本质是一种有序的数据集合，有数据源和目的地。对于计算机来说，数据都是以二进制形式读出或写入的，如何将数据从数据源送到目的地的操作就是流操作过程类是专门对文件进行操作的类，只能对文件本身进行操作，不能对文件内容进行操作。类是文件和目录路径名的抽象表示，主要用于文件和目录的创建、查找和删除等操作。注：1.File跟流无关，File类不能对文件进行读和写也就是输入和输出！
Java之IO流
weixin_57111105的博客
03-18 108
注意：JDK 7 以及 JDK 9的()中只能放置资源对象，否则报错，什么是资源呢？读取的性能得到了提升，读取中文字符输出无法避免乱码问题。一般不用read() 方法读取单个字节，性能慢，使用读取字节数组方法，性能较快。字节缓冲输出流自带了8KB缓冲池，数据就直接写入到缓冲池中去，写数据性能极高了。字节缓冲输入流自带了8KB缓冲池，直接从缓冲池读取数据，所以性能较好。文件字节输出流（FileOutputStream）写数据出去的API。1,字节流适合做一切文件数据的拷贝（音视频，文本）
Java基础之IO流
m0_51014049的博客
05-22 81
Java基础之IO流
Java基础 IO流
qq_46589966的博客
04-23 100
使用处理流可以提供更方便和高效的 I/O 操作，尤其是在处理大量数据或需要复杂数据转换的情况下。节点流和处理流可以根据具体需求进行组合和嵌套使用，以满足不同的 I/O 操作需求。什么是文件，文件对于我们并不陌生，文件就是保存数据的地方，比如大家经常使用的word文档，txt文件，excel文件...都是文件。Java I/O（输入/输出）操作可以通过节点流和处理流来进行。功能：提供了对基本类型或对象类型的序列化和反序列化的方法。文件流：文件在程序中是以流的形式来操作的。文件的拷贝 此处是照片。
java-IO流
LQalive的博客
04-19 72
序列化流（对象操作输出流）：可以把java中的对象写到本地文件中 属于字节流子类。流的方向： IO流：输入流-读取文件内容到程序 输出流-程序写出到文件。操作文件类型： IO流分为字节流（所有类型的文件）和字符流（纯文本文件）readObject() 把序列化到本地文件中的对象，读取到程序中来。反序列化流：将序列化到本地文件中大的对象，读取到程序中来。一个中文占两个字节，二进制高位字节的第一位是1。字节打印流：字节打印流 printStream。2.特有的写方法可以实现，数据原样写出。
java IO流详细笔记
07-12
Java IO流详解
Java IO流和文件操作实现过程解析
08-25
Java IO流和文件操作实现过程解析 Java IO流和文件操作实现过程解析是Java语言中的一种基本操作，IO流是Java中处理输入输出的基础。Java中的IO流主要包括两种类型：字节流和字符流。字节流用于处理二进制数据，而...
javaIO流javaIO流javaIO流
最新发布
07-02
Java IO流是Java平台中用于处理输入输出操作的核心机制，它允许程序与各种数据源（如文件、设备、网络）进行交互。Java IO流体系结构是基于“流”的概念，流是一组有序的数据序列，可以是字节流或字符流。Java IO库...
JAVA IO流技术
09-19
4. Java中流的概念细分 流的方向： 输入流：数据源到程序(InputStream、Reader读进来) 输出流：程序到目的地(OutPutStream、Writer写出去) 处理数据单元： 字节流：按照字节读取数据(InputStream、OutputStream) 字符流：按照字符读取数据(Reader、Writer) 功能不同： 节点流：可以直接从数据源或目的地读写数据。 处理流：不直接连接到数据源或目的地，是处理流的流。通过对其他流的处理提高程序的性能。 节点流和处理流的关系： 节点流处于io操作的第一线，所有操作必须通过他们进行；处理流可以对节点流 进行包装，提高性能或提高程序的灵活性。
java IO流方式上传下载文件，源代码
10-16
java IO流方式上传下载文件源代码，2个JSP程序都经过测试通过，并在真实项目中使用。
java IO流文件的读写具体实例
09-04
Java IO流是Java平台中用于处理输入输出的重要机制，它允许程序与各种数据源和目的地进行交互，包括文件、网络连接、系统硬件等。在Java中，IO流分为四个主要类别，分别是字节流（处理二进制数据）、字符流（处理...
Java IO流 文件传输基础
09-02
Java IO流是Java平台中用于处理输入输出的重要机制，它涉及到数据从源到目标的传输。文件传输基础是Java IO流应用的一个核心场景，通过IO流可以实现对文件的读写操作，包括创建、打开、修改和删除文件。在本文中，...
Java IO流文档
03-31
彻底明白Java的IO流
JavaIO流
qq_29575635的博客
05-30 305
IO流是指用于输入输出操作的数据流，通常在计算机程序中用来读取或写入数据。它是一种将数据从一个地方传递到另一个地方的方法。在Java中，IO流被分为输入流（InputStream）和输出流（OutputStream），它们用于读取和写入数据。输入流通常用来从文件、网络或其他数据源中读取数据，而输出流通常用来将数据写入文件、网络或其他数据存储位置。在Java中，IO流通常是面向字节的，即字节流，也可以使用字符流。
java IO流详解
weixin_62275996的博客
08-17 811
🌈🌈😄😄 欢迎来到茶色岛独家岛屿，本期将为大家揭晓JavaIO流详解，做好准备了么，那么开始吧 🌲🌲🐴🐴
io java io 流
01-11
java io 的例子有利于对io的熟悉的了解深入，希望对大家有帮助
Java IO流详解：InputStream核心方法
此外，还概述了Java IO流的分类，如字节流、字符流、输入流、输出流，以及节点流和包装流的概念。" 在Java的IO系统中，InputStream是所有字节输入流的基类，它提供了读取字节数据的基本方法。以下是对这些方法的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值