Java中IO流详细整合(含案例)

最新推荐文章于 2022-05-30 22:20:07 发布
最新推荐文章于 2022-05-30 22:20:07 发布
阅读量2.7k 收藏 5
点赞数
CC 4.0 BY-SA版权
分类专栏： JavaSE基础 文章标签： 后端 经验分享 javase iostream 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Hunny_java/article/details/122432333

本章主要详细讲解IO流

目录

文件/目录的基本操作

IO流基本知识

输入输出流原理

  • 从程序的角度来讲，从 计算机读取到的原始数据肯定都是010101这种形式的，一个字节一个字节地往外读，如果你觉得这样的方法不合适，你再在这根管道的外面再包一层比较强大的管道，这个管道可以帮你把 010101转换成字符串。这样你使用程序读取数据时读到的就不再是010101这种形式的数据了，而 是一些可以看得懂的字符串了。
ioprinciple

输入输出流分类

  • 按数据流的方向不同可以分为输入流和输出流
  • 按照处理数据单位不同可以分为字节流和字符流
    • 字节流：最原始的一个流，读出来的数据就是010101这种最底层的数据表示形式，只不过它是按照字节来读的
    • 字符流：字符流是一个字符一个字符地往外读取数据
  • 按照功能不同可以分为节点流和处理流
    • 节点流：可以从一个特定的数据源(节点)读取数据
    • 处理流：“连接”在已存在的流(节点流或处理流)之上，通过对数据的处理为程序提供更强大的读写能力
iostream

节点流类型

截屏2022-01-08 下午9.45.12

处理流类型

截屏2022-01-08 下午9.45.28

FileInputStream

FileInputStream的基本方法

//读取一个字节并以整数的形式返回(0~255) //如果返回-1就说明已经到了输入流的末尾 
int read() throws IOException
//读取一系列字节并存储到一个数组buffer //返回实际读取的字节数，如果读取前已到输入流的末尾，则返回-1 
int read(byte[] buffer) throws IOException
//读取length个字节
//并存储到一个字节数组buffer，从length位置开始 //返回实际读取的字节数，如果读取前以到输入流的末尾返回-1.
int read(byte[] buffer,int offset,int length) throws IOException
//关闭流释放内存资源
void close() throws IOException
//跳过n个字节不读，返回实际跳过的字节数 
long skip(long n) throws IOException

FileInputStream的案例

"/Users/test/iotest.txt"
Hello World

public class FileInputTest {
    public static void main(String[] args) {
        int count =0;
        byte[] buf=new byte[8];
        FileInputStream ips=null;
        try{
            ips=new FileInputStream("/Users/test/iotest.txt");
            //使用FileInputStream流来读取有中文的内容时，读出来的是乱码，因为使用
            //InputStream流里面的read()方法读取内容时是一个字节一个字节地读取的，而一个汉字是占用两个字节的，所以读取出来的汉字无法正确显示。

            //int read() throws IOException
            //ReadNoPra(count,ips); 
            //输出：
            //Hello World

            //int read(byte[] buffer) throws IOException
            //ReadBuf(buf,count,ips);
            //输出：
            //Hello Wo
            //rld

            //int read(byte[] buffer,int offset,int length) throws IOException
            //long skip(long n) throws IOException
            ReadBufLen(buf,count,ips);
            //输出：
            //1
            //ell
        } catch (Exception e) {
            System.out.println("读取失败");
        } finally {
            try {
                if (ips!=null){
                	ips.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    static void ReadBufLen(byte[] buf,int count,FileInputStream ips) throws IOException {
        //跳过一个字节不读
        System.out.println(ips.skip(1));

        if ((count=ips.read(buf,0,3))!=-1) {
            System.out.println(new String(buf, 0, count));
        }
    }
    static void ReadBuf(byte[] buf,int count,FileInputStream ips) throws IOException {
        while ((count=ips.read(buf))!=-1){
            System.out.println(new String(buf,0,count));
        }
    }
    static void ReadNoPra(int count,FileInputStream ips) throws IOException {
        while ((count=ips.read())!=-1){
            System.out.printf("%c",(char) count);
        }
    }
}

FileOutputStream

FileOutputStream的基本方法

//向输出流中写入一个字节数据，该字节数据为参数b的低8位 
void write(int b) throws IOException
//将一个字节类型的数组中的数据写入输出流
void write(byte[] b) throws IOException
//将一个字节类型的数组中的从指定位置(off)开始的len个字节写入到输出流 
void write(byte[] b,int off,int len) throws IOException
//关闭流释放内存资源
void close() throws IOException
//将输出流中缓冲的数据全部写出到目的地 void flush() throws IOException

FileOutputStream的基本方法的案例

"/Users/test/iotest.txt"
Hello
  
public class FileOutputTest {
    public static void main(String[] args) {
        int count =0;
        byte[] buf=new byte[8];
        FileOutputStream ops=null;
        try{
            //若没有这个文件，会自动创建文件并写入数据
            //如果添加true，那新写入的数据不会覆盖原先数据而是追加在后面
            ops=new FileOutputStream("/Users/test/iotest.txt",true);
            //void write(int b) throws IOException
            ops.write(' ');
            //void write(byte[] b) throws IOException
            String str="World";
            ops.write(str.getBytes());
            //void write(byte[] b,int off,int len) throws IOException
            ops.write(' ');
            String str2="Love China";
            ops.write(str2.getBytes(),0,4);
        } catch (Exception e) {
            System.out.println("写入失败");
        } finally {
            try {
                if (ops!=null){
                	ops.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
}
//输出结果：
"/Users/test/iotest.txt"
Hello World Love

文件拷贝

"/Users/test"
boji.jpeg
  
public class FileCopy {
    public static void main(String[] args) {
        int count=0;
        FileInputStream ips=null;
        FileOutputStream ops=null;
        byte[] buf=new byte[1024];
        try{
            ips=new FileInputStream("/Users/test/boji.jpeg");
            ops=new FileOutputStream("/Users/test/boji2.jpeg");
            while ((count=ips.read(buf))!=-1){
                ops.write(buf,0,count);
            }
            System.out.println("success");
        } catch (Exception e) {
            System.out.println("fail");
        } finally {
            try{
                if (ips!=null){
                    ips.close();
                }
                if (ops!=null){
                    ops.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}
//输出结果：
"/Users/test"
boji.jpeg
boji2.jpeg

FileReader的案例

"/Users/test/iotest.txt"
Hello World
你好，世界

public class FileReaderTest {
    public static void main(String[] args) {
        ReadOne();
        System.out.println();
        System.out.println("-------");
        ReadMore();
    }
    //一个字符为单位读
    static void ReadOne(){
        int count=0;
        FileReader fr=null;
        try{
            fr=new FileReader("/Users/test/iotest.txt");
            while ((count=fr.read())!=-1){
                System.out.print((char)count);
            }
        } catch (Exception e) {
            System.out.println("读取失败");
        }finally {
            try {
                if (fr!=null){
                    fr.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    //字符数组为单位读
    static void ReadMore(){
        int count=0;
        FileReader fr=null;
        char[] chars=new char[8];
        try{
            fr=new FileReader("/Users/test/iotest.txt");
            while ((count=fr.read(chars))!=-1){
                System.out.print(new String(chars,0,count));
            }
        } catch (Exception e) {
            System.out.println("读取失败");
        }finally {
            try {
                if (fr!=null){
                    fr.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}
//输出结果：
Hello World
你好，世界
-------
Hello World
你好，世界

FileWriter的案例

  • 注意，FileWriter使用后，必须关闭(close)或刷新(flush)，否则写入不到指定文件。
"/Users/test/iotest.txt"
Hello
  
public class FileWriterTest {
    public static void main(String[] args) {
        int count=0;
        FileWriter fw=null;
        char[] chars={'a','b','c'};
        try{
            //后面没有true，表示覆盖
            fw=new FileWriter("/Users/test/iotest.txt");
            //写入单个字符
            fw.write('H');
            //写入字符数组
            fw.write(chars);
            //写入指定字符数组的指定长度
            fw.write("你好呀".toCharArray(),0,2);
            //写入字符串
            fw.write("很高兴认识你");
            //写入字符串指定部分
            fw.write("杭州北京",0,2);
        } catch (Exception e) {
            System.out.println("写入失败");
        }finally {
            try {
                if (fw!=null){
                    fw.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}
//输出结果：
"/Users/test/iotest.txt"
Habc你好很高兴认识你杭州

处理流讲解

缓冲流

BufferedInputStream/BufferedOutputStream的案例

  • 可以通过上述流操作二进制文件[图片、声音、视频、doc、pdf]
"/Users/test/iotest.txt"

public class BufInputTest {
    public static void main(String[] args) {
        FileInputStream ips=null;
        FileOutputStream ops=null;
        BufferedInputStream bis=null;
        BufferedOutputStream bos=null;
        try{
            ops= new FileOutputStream("/Users/test/iotest.txt");
            bos=new BufferedOutputStream(ops);
            bos.write("Hello World".getBytes());
            bos.flush();

            ips= new FileInputStream("/Users/test/iotest.txt");
            bis=new BufferedInputStream(ips);
            int count=0;
            System.out.println((char) bis.read());
            //public void mark(int readlimit)
            //readlimit 参数告知此输入流在标记位置无效之前允许读取的字节数
            bis.mark(3);
            for (int i=0;i<=10&&(count=bis.read())!=-1;i++){
                System.out.print((char) count);
            }
            System.out.println();
            bis.reset();
            for (int i=0;i<=10&&(count=bis.read())!=-1;i++){
                System.out.print((char) count);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (bos!=null){
                    bos.close();
                }
                if (bis!=null){
                    bis.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}
//输出结果：
H
ello World
ello World

BufferedReader/BufferedWriter的案例

  • 如果通过上述流操作二进制文件[图片、声音、视频、doc、pdf]，可能会造成文件损坏
"/Users/test/iotest.txt"

public class BufReaderTest {
    public static void main(String[] args) {
        BufferedWriter bw=null;
        BufferedReader br=null;
        try{
            bw=new BufferedWriter(new FileWriter("/Users/test/iotest.txt"));
            String s=null;
            Random random = new Random();
            for (int i=0;i<3;i++){
                //随机生成数字
                s=String.valueOf(random.nextInt(10));
                bw.write(s);
                bw.newLine();
            }
            bw.flush();

            br=new BufferedReader(new FileReader("/Users/test/iotest.txt"));
            while ((s=br.readLine())!=null){
                System.out.println(s);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (bw!=null){
                    bw.close();
                }
                if (br!=null){
                    br.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }

        }
    }
}
//输出结果：
7
4
9

对象流

序列化和反序列化

  • 序列化就是在保存数据时，保存数据的值和数据类型
  • 反序列化就是在恢复数据时，恢复数据的值和数据类型
  • 需要让某个对象支持序列化机制，则必须让其类是可序列化的，为了让某个类是可序列化的，该类必须实现如下两个接口之一：
    • Serializable 这是一个标记接口，里面没有方法，推荐使用
    • Externalizable 该接口有方法需要实现

ObjectOutputStream的案例

public class ObjOutTest {
    public static void main(String[] args) {
        ObjectOutputStream oos=null;
        try{
            oos=new ObjectOutputStream(new FileOutputStream("/Users/test/iotest.txt"));
            //序列化数据到iotest.txt
            oos.writeInt(100);//自动装箱 int -> Integer (实现了Serializable)
            oos.writeBoolean(true);
            oos.writeChar('a');
            oos.writeDouble(3.14);
            oos.writeUTF("Love Java");
            //保存一个dog对象
            Dog dog=new Dog(6,"小花");
            oos.writeObject(dog);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try{
                if (oos!=null){
                    oos.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}
class Dog implements Serializable{
    private int age;
    private String name;

    public Dog(int age, String name) {
        this.age = age;
        this.name = name;
    }
    @Override
    public String toString() {
        return "Dog{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}

ObjectInputStream的案例

public class ObjInputTest {
    public static void main(String[] args) {
        ObjectInputStream ois=null;
        try{
            ois=new ObjectInputStream(new FileInputStream("/Users/test/iotest.txt"));
            System.out.println(ois.readInt());
            System.out.println(ois.readBoolean());
            System.out.println(ois.readChar());
            System.out.println(ois.readDouble());
            System.out.println(ois.readUTF());
            Dog dog= (Dog)ois.readObject();
            System.out.println(dog);
            System.out.println(dog.getClass());
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try{
                if (ois!=null){
                    ois.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}
//输出结果：
100
true
a
3.14
Love Java
Dog{age=6, name='小花'}
class javabase.javaio.Dog

对象流处理事项

  • 读取顺序要一致
  • 要求序列化或反序列化对象，需要实现Serializable
  • 序列化的类中建议添加SerialVersionUID，为了提高版本的兼容性
  • 序列化对象时，默认将里面所有的属性都进行序列化，但出了static或transient修饰的成员
  • 序列化对象时，要求里面属性的类型也需要实现序列化接口
  • 序列化具备可继承性，也就是说如果某类已经实现了序列化，则它的所有子类也已经默认实现了序列化

数据流

DataInputStream/DataOutputStream的案例

  • DataOutputStream数据输出流允许应用程序将基本Java数据类型写到基础输出流中
  • DataInputStream数据输入流允许应用程序以机器无关的方式从底层输入流中读取基本的Java类型
//例子1
public class DataStreamTest {
    public static void main(String[] args) throws IOException {
        ByteArrayOutputStream boutput = new ByteArrayOutputStream();
        DataOutputStream dop=new DataOutputStream(boutput);
        Random random=new Random();
        dop.writeByte('a');
        dop.writeByte('b');
        dop.writeByte('c');
        dop.writeByte('d');
        byte[] b= boutput.toByteArray();
        System.out.println("Print the content");
        for(int x= 0;x<b.length;x++) {
            //打印字符
            System.out.print((char)b[x]  + " ");
        }
        System.out.println();
        int count;
        ByteArrayInputStream binput = new ByteArrayInputStream(b);
        DataInputStream dip=new DataInputStream(binput);
        System.out.println("Converting characters to Upper case " );
        while((count= dip.read())!= -1) {
            System.out.print(Character.toUpperCase((char)count)+" ");
        }
    }
}
//输出结果：
Print the content
a b c d 
Converting characters to Upper case 
A B C D 

//例子2
public class DataStreamTest {
    public static void main(String[] args) throws IOException {
        DataOutputStream dos = new DataOutputStream(new FileOutputStream("/Users/test/iotest.txt"));
        dos.writeUTF("Love Java");
        dos.writeInt(3);
        dos.writeBoolean(true);
        dos.writeShort((short)123);
        dos.writeLong((long)456);
        dos.writeDouble(3.14);
        DataInputStream dis = new DataInputStream(new FileInputStream("/Users/test/iotest.txt"));
        System.out.println(dis.readUTF());
        System.out.println(dis.readInt());
        System.out.println(dis.readBoolean());
        System.out.println(dis.readShort());
        System.out.println(dis.readLong());
        System.out.println(dis.readDouble());
        dis.close();
        dos.close();
    }
}
//输出结果：
Love Java
3
true
123
456
3.14

转换流

  • 转换流非常的有用，它可以把一个字节流转换成一个字符流

InputStreamReader的案例

"/Users/test/iotest.txt"
Hello World

public class ISReaderTest {
    public static void main(String[] args) throws IOException {
        BufferedReader br=new BufferedReader(new InputStreamReader(new FileInputStream("/Users/test/iotest.txt"),"utf-8"));
        String s=br.readLine();
        System.out.println(s);
        br.close();
    }
}
//输出结果：
Hello World

OutputStreamWriter的案例

"/Users/test/iotest.txt"

public class OSWriterTest {
    public static void main(String[] args) throws IOException {
        BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(new FileOutputStream("/Users/test/iotest.txt"),"utf-8"));
        bw.write("你好，世界！");
        bw.close();
    }
}
//输出结果：
"/Users/test/iotest.txt"
你好，世界！

标准输入输出流

System.in/System.out的案例

public class InAndOutTest {
    public static void main(String[] args) {
        //System.in 编译类型 InputStream
        //System.in 运行类型 BufferedInputStream
        System.out.println(System.in.getClass());
        //System.out 编译类型 PrintStream
        //System.out 运行类型 PrintStream
        System.out.println(System.out.getClass());
    }
}
//输出结果：
class java.io.BufferedInputStream
class java.io.PrintStream

打印流

  • 打印流只有输出流没有输入流

PrintStream的案例

"/Users/test/iotest.txt"

public class PrintStreamTest {
    public static void main(String[] args) throws IOException {
        PrintStream pr=new PrintStream(System.out);
        pr.println("Love Java");
        pr.write("Love Java".getBytes());
        pr.close();
        System.setOut(new PrintStream("/Users/test/iotest.txt"));
        System.out.println("这里没有东西");
    }
}
//输出结果：
Love Java
Love Java

"/Users/test/iotest.txt"
这里没有东西

PrintWriter的案例

"/Users/test/iotest.txt"

public class PrintWriterTest {
    public static void main(String[] args) throws FileNotFoundException {
        PrintWriter pw=new PrintWriter("/Users/test/iotest.txt");
        pw.println("你好，世界！");
        pw.write("你好，世界！");
        pw.close();
    }
}
//输出结果：
"/Users/test/iotest.txt"
你好，世界！
你好，世界！

Hi, welcome to JasperのBlog！

Java IO流：NIO 介绍及使用
栗筝i的博客
08-16 404
NIO 也叫 Non-Blocking IO 是同步非阻塞的 IO 模型。线程发起 IO 请求后，立即返回。同步指的是必须等待 IO 缓冲区内的数据就绪，而非阻塞指的是，用户线程不原地等待 IO 缓冲区，可以先做一些其他操作，但是要定时轮询检查 IO 缓冲区数据是否就绪。Java 中的 NIO 是 new IO的意思。其实是 NIO 加上 IO 多路复用技术。
IO系列(一) -一文带你读懂 java 中的IO流！
程序员志哥的博客
05-13 1169
说到 IO，相信大家都不陌生，英文全称：Input/Output，即输入/输出，通常指数据在内部存储器和外部存储器或其他周边设备之间的输入和输出。
java中IO流例子
10-16
java IO流 例子 源程序 字节流，字符流。
Java IO流实例
ZHI_YUE的博客
05-30 494
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言一、IO是什么？二、类库分析File类OutputStream类InputStreamWriter类Reader类Serializable接口三、io类结构图流io 前言 浅浅收录一下Java路上第一个坎 一、IO是什么？ I/O是Input/Output的缩写， I/O技术是非常实用的技术，用于处理设备之间的数据传输。如读/写文件，网络通讯等。 IO流也是Java重要的一个构成部分，在Java中I/O操作主要是指使用Jav.
java中io流案例_IO流相关案例
weixin_30990821的博客
02-27 171
1.1 复制文本文件的5种方式A:利用基本流一次读写一个字符B:利用基本流一次读写一个字符数组C:利用缓冲流一次读写一个字符D:利用缓冲流一次读写一个字符数组E:利用缓冲流的特有方法一次读写一个字符串1.1.1 案例代码十二:packagecom.itheima_06;importjava.io.BufferedReader;importjava.io.BufferedWriter;impo...
java IO流案例详解
Code-lover's Learning Notes
09-18 3648
流的概念和作用 学习Java IO，不得不提到的就是JavaIO流。 流是一组有顺序的，有起点和终点的字节集合，是对数据传输的总称或抽象。即数据在两设备间的传输称为流，流的本质是数据传输，根据数据传输特性将流抽象为各种类，方便更直观的进行数据操作。 IO流的分类 根据处理数据类型的不同分为：字符流和字节流 根据数据流向不同分为：输入流和输出流 字符流和字节流
Java：IO流综合案例（大礼包）
weixin_44918667的博客
05-04 1954
1.第一个简单的IO流 当程序需要读取数据源的数据时，就会通过 IO 流对象开启一个通向数据源的流，通过这个 IO 流对象的相关方法可以顺序读取数据源中的数据。
java io案例
10-11
Java IO（输入/输出）是Java...通过对`整合练习2`中的代码进行详细分析，我们可以深入了解Java IO流的实际运用，提升我们的编程技能。同时，也可以学习到如何优化代码，避免资源泄露，以及如何处理可能出现的异常情况。
Java IO流案例及代码解析
标签"io"强调了Java中输入输出流的重要性。IO操作是软件开发中不可或缺的一部分，它使得程序能够和外界（文件系统、网络等）进行数据交换。 #### 压缩包子文件的文件名称列表：整合练习2 这里提到的“整合练习2”...
IO流案例
最新发布
03-25
好的，用户需要关于Java IO流的示例代码或案例解析。首先，我应该回忆Java IO流的基本分类，包括字节流和字符流，以及它们的常用类。 用户提供的引用中有三个示例，分别涉及字节流的FileInputStream、循环读取改进...
java之io流实例
09-28
java之io流实例应用。
java io流的实践案例大全
03-06
一套非常齐全，难得的java io流知识案例大全，让你一看就懂，一学就会，代码齐全，注释明了
java IO流实例，包括文件的读写、上传和下载
08-13
java IO流操作，包括文件的读取，写入，上传和下载，支持文本数据和音频等文件
java io流 案例
11-11
关于 java io 流 方面的的引用，主要用一个例子说明！
集合到文件数据排序改进版
Leon_Jinhai_Sun的博客
09-13 213
案例需求 键盘录入5个学生信息(姓名,语文成绩,数学成绩,英语成绩)。要求按照成绩总分从高到低写入文本文件 格式：姓名,语文成绩,数学成绩,英语成绩 举例：林青霞,98,99,100 分析步骤 定义学生类 创建TreeSet集合，通过比较器排序进行排序 键盘录入学生数据 创建学生对象，把键盘录入的数据对应赋值给学生对象的成员变量 把学生对象添加到TreeSet集合 创建字符缓冲输出流对象 遍历集合，得到每一个学生对象
JAVA IO流示例
昝昝的博客
07-20 382
以字符流的方式读取文件public class JavaIOTest { /** * 读取txt文件的内容 * @param file 想要读取的文件对象 * @return 返回文件内容 */ public static String txt2String(File file){ StringBuilder result =
java io例子_java中io操作小例子
weixin_36079903的博客
02-16 156
//示例1,file基本操作import java.io.File;import java.io.IOException;class FileDemo{public static void main(String args[]){try{File file=new File("file1.txt");System.out.println("文件是否存在: "+file.exists());Syst...
IO流的介绍（一）
Xun_independent的博客
03-14 2091
IO流的介绍（一） 什么是IO流 对任何程序设计语言而言，输入输出（Input/Output）系统都是非常核心的功能。 输入(Input)：就是将外部的数据读取到程序当中（以程序为基准，核心含义是“读”）；如读取硬盘的文件到程序；读取网络上某个位置内容到程序；读取数据库系统的数据到程序；读取某些硬件系统到程序。 输出(Output)：在处理数据时，需要将数据写到外部（以程序为基准，核心含义是“写”）；如将数据写到硬盘中；将数据写到数据库系统中；将数据写到某些硬件系统中。 java.io包为我
java io流详解_IO流的实例详解
weixin_33542801的博客
02-19 194
IO流:I:input,输入,读取到内存O:Output,输出,写入文件流:数据流(字符,字节)分类:流向:输入:字节输入流(FileInputStream),字符输入流(FileReader)输出:字节输出流(FileOutputStream),字符输入流(FileWriter)种类:字符,字节java.io.OutputStream:字节输出流,是所有字节输出流的父类公共的成员方法:abstr...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值