Java——18个Demo带你玩转Java中的I/O流

Posted 张起灵-小哥

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Java——18个Demo带你玩转Java中的I/O流相关的知识,希望对你有一定的参考价值。

文章目录:

写在前面

1.Demo 1(FileInputStream)

2.Demo 2(FileInputStream)

3.Demo 3(FileInputStream)

4.Demo 4(FileOutputStream)

5.Demo 5(FileInputStream & FileOutputStream完成文件的拷贝)

6.Demo 6(FileReader)

7.Demo 7(FileWriter)

8.Demo 8(FileReader & FileWriter 完成对文件的拷贝)

9.Demo 9(BufferedReader)

10.Demo 10(BufferedReader)

11.Demo 11(BufferedWriter)

12.Demo 12(DataOuputStream)

13.Demo 13(DataInputStream)

14.Demo 14(PrintStream)

15.Demo 15(I/O流联合Properties属性类使用)

16.Demo 16(File)

17.Demo 17(File)

18.Demo 18(ObjectInputStream & ObjectOutputStream)

写在结尾


写在前面

java.io包下需要掌握的流有16个:
    
    文件专属:
        java.io.FileInputStream
        java.io.FileOutputStream
        java.io.FileReader
        java.io.FileWriter

    转换流:(将字节流转换成字符流)
        java.io.InputStreamReader
        java.io.OutputStreamWriter

    缓冲流专属:
        java.io.BufferedReader
        java.io.BufferedWriter
        java.io.BufferedInputStream
        java.io.BufferedOutputStream

    数据流专属:
        java.io.DataInputStream
        java.io.DataOutputStream

    标准输出流:
        java.io.PrintWriter
        java.io.PrintStream

    对象专属流:
        java.io.ObjectInputStream
        java.io.ObjectOutputStream

这篇文章非常非常的长!!!因为我总结了Java中I/O常用的流的相关读写操作,希望我写的有一点点用吧!!!😄😄😄

1.Demo 1(FileInputStream)

package com.szh.io;

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

/**
 * java.io.FileInputStream
 *      1) 文件字节输入流、万能的、任何类型的文件都可以采用这个流来读
 *      2) 字节的方式,完成输入(读)的操作(磁盘 ---> 内存)
 *      public int read() throws IOException
 *      该方法缺点:一次读取一个字节byte,这样内存和硬盘交互太频繁,时间都耗费在交互上面了
 */
public class FileInputStreamTest01 {

    public static void main(String[] args) {
        FileInputStream fis=null;
        try {
            //创建文件字节输入流对象
            fis=new FileInputStream("F:/temp.txt");
            //开始读
            int readData=0;
            while ((readData = fis.read()) != -1) {
                System.out.println(readData);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //在finally语句块中确保流一定关闭
            if (fis != null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

2.Demo 2(FileInputStream)

package com.szh.io;

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

/**
 * public int read(byte[] b) throws IOException
 * 该方法一次最多读取 b.length 个字节
 * 减少内存和硬盘之间的交互,提高程序的执行效率
 */
public class FileInputStreamTest02 {

    public static void main(String[] args) {
        FileInputStream fis=null;
        try {
            //创建文件字节输入流对象
            fis=new FileInputStream("F:/temp.txt");
            //开始读,采用byte数组
            byte[] bytes=new byte[4];
            int readCount=0;
            while ((readCount = fis.read(bytes)) != -1) {
                System.out.print(new String(bytes,0,readCount));
            }
        }catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fis != null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

3.Demo 3(FileInputStream)

package com.szh.io;

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

/**
 * public int available() throws IOException
 * 返回此输入流中可以读取(或跳过)的剩余字节数量
 *
 * public long skip(long n) throws IOException
 * 跳过输入流中的n个字节的数据不读
 */
public class FileInputStreamTest03 {

    public static void main(String[] args) {
        FileInputStream fis=null;
        try {
            //创建文件字节输入流对象
            fis=new FileInputStream("F:/temp.txt");
            //available()方法 获取该文件中的总字节数量(此时还未读文件,所以数量为全部字节数),存入byte数组中
            //该方式不是读大文件,因为byte数组不能太大
            byte[] bytes=new byte[fis.available()];
            System.out.println("读之前文件中还可以读取的字节数量: " + fis.available());
            int readCount=fis.read(bytes);
            System.out.println(new String(bytes));
            System.out.println("读之后文件中还可以读取的字节数量: " + fis.available());

            //skip(long n)方法 跳过几个字节不读
//            fis.skip(3);
//            System.out.println(fis.read());
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fis != null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

4.Demo 4(FileOutputStream)

package com.szh.io;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

/**
 * java.io.FileOuputStream
 *      1) 文件字节输出流,负责写
 *      2) 从内存 ---> 硬盘
 */
public class FileOutputStreamTest01 {

    public static void main(String[] args) {
        FileOutputStream fos=null;
        try {
            //创建文件字节输出流对象,文件不存在时会自动新建
            //该方法会先将原文件清空,然后重新写入,谨慎使用!!!
            //fos=new FileOutputStream("F:/myfile.txt");
            //下面这种方法在文件末尾追加写入,不会清空原文件内容
            fos=new FileOutputStream("F:/myfile.txt",true);
            //开始写
            byte[] bytes={97,98,99,100};
            fos.write(bytes);
            //写完之后,最后一定记得刷新
            fos.flush();
        }catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fos != null) {
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

5.Demo 5(FileInputStream & FileOutputStream完成文件的拷贝)

package com.szh.io;

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

/**
 * 使用 FileInputStream 和 FileOutputStream 完成对文件的复制
 */
public class CopyTest01 {

    public static void main(String[] args) {
        FileInputStream fis=null;
        FileOutputStream fos=null;
        try {
            //创建一个文件输入流对象
            fis=new FileInputStream("F:/myfile.txt");
            //创建一个文件输出流对象
            fos=new FileOutputStream("E:/myfile.txt");
            //核心:一边读,一边写
            byte[] bytes=new byte[1024]; //1024B=1KB (一次最多读1KB)
            int readCount=0;
            while ((readCount = fis.read(bytes)) != -1) {
                fos.write(bytes,0,readCount);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fis == null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (fos == null) {
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

6.Demo 6(FileReader)

package com.szh.io;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

/**
 * java.io.FileReader
 *      文件字符输入流,只能读取普通文本
 *      读取普通文本时,比较方便快捷
 * 能用记事本编辑的都是普通文本文件
 */
public class FileReaderTest {

    public static void main(String[] args) {
        FileReader reader=null;
        try {
            //创建文件字符输入流对象
            reader=new FileReader("F:/temp.txt");
            //开始读,字节对应的是byte数组,字符对应的是char数组
            char[] chars=new char[4]; //一次读取4个字符
            int readCount=0;
            while ((readCount = reader.read(chars)) != -1) {
                System.out.print(new String(chars,0,readCount));
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (reader != null) {
                try {
                    reader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

7.Demo 7(FileWriter)

package com.szh.io;

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

/**
 * java.io.FileWriter
 *      文件字符输出流,负责写
 *      只能输出普通文本
 * 能用记事本编辑的都是普通文本文件
 */
public class FileWriterTest {

    public static void main(String[] args) {
        FileWriter writer=null;
        try {
            //创建文件字符输出流对象
            writer=new FileWriter("F:/temp.txt");
            //开始写
            char[] chars={'我','是','中','国','人'};
            writer.write(chars);
            writer.write(chars,2,3);
            writer.write("Java");
            //刷新
            writer.flush();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (writer != null) {
                try {
                    writer.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

8.Demo 8(FileReader & FileWriter 完成对文件的拷贝)

package com.szh.io;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

/**
 * 使用 FileReader 和 FileWriter 完成对文件的复制,只能拷贝普通文本文件
 * 能用记事本编辑的都是普通文本文件
 */
public class CopyTest02 {

    public static void main(String[] args) {
        FileReader reader=null;
        FileWriter writer=null;
        try {
            //读
            reader=new FileReader("F:/temp.txt");
            //写
            writer=new FileWriter("E:/temp.txt");
            //一边读一边写
            char[] chars=new char[512]; //一次读取512字节(0.5KB)
            int readCount=0;
            while ((readCount = reader.read(chars)) != -1) {
                writer.write(chars,0,readCount);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (reader != null) {
                try {
                    reader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (writer != null) {
                try {
                    writer.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}

9.Demo 9(BufferedReader)

package com.szh.io;

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

/**
 * java.io.BufferedReader
 *      带有缓冲区的字符输入流
 *      使用带缓冲区的流的时候不需要自定义byte数组、char数组
 */
public class BufferedReaderTest01 {

    public static void main(String[] args) {
        BufferedReader br=null;
        try {
            //当一个流的构造方法中需要另一个流的时候,内部被传进来的流叫做 节点流
            //外部负责包装的流叫做 包装流
            //也就是说此时,FileReader是节点流,BufferedReader是包装流
            br=new BufferedReader(new FileReader("F:/Test.java"));
            //循环读,一次读一行
            String s=null;
            while ((s = br.readLine()) != null) {
                System.out.println(s);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //关闭的时候只需要关闭包装流即可,而里面的节点流会自动关闭(详情见源代码)
            if (br != null) {
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

10.Demo 10(BufferedReader)

package com.szh.io;

import java.io.*;

/**
 *
 */
public class BufferedReaderTest02 {

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

        //最内部是 一个文件字节 输入流
        //中间的是 一个字节流转字符流 的输入流
        //最外部是 一个缓冲字符 输入流 (也就是实现了字节流 ---> 字符流)
        BufferedReader br=new BufferedReader(new InputStreamReader(new FileInputStream("F:/Test.java")));
        //开始读
        String line=null;
        while ((line = br.readLine()) != null) {
            System.out.println(line);
        }
        //只需关闭最外部的包装流即可
        br.close();
    }
}

11.Demo 11(BufferedWriter)

package com.szh.io;

import java.io.*;

/**
 *
 */
public class BufferedWriterTest01 {

    public static void main(String[] args) throws IOException {
        //创建一个缓冲字符输出流
        //BufferedWriter bw=new BufferedWriter(new FileWriter("E:/a.txt"));
        BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(new FileOutputStream("E:/a.txt",true)));
        //开始写
        bw.write("Hello World!!!");
        bw.write("\\n");
        bw.write("Java I/O流");
        bw.write("\\n");
        //刷新
        bw.flush();
        //关闭最外部的包装流
        bw.close();
    }
}

12.Demo 12(DataOuputStream)

package com.szh.io;

import java.io.DataOutputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

/**
 * java.io.DataOutputStream 数据专属的字节输出流
 * 这个流可以将数据连同数据的类型一并写入文件(该文件不是普通的文本文件,无法用记事本打开)
 */
public class DataOutputStreamTest {

    public static void main(String[] args) throws IOException {
        //创建数据专属的字节输出流
        DataOutputStream dos=new DataOutputStream(new FileOutputStream("E:/data"));
        //写数据
        byte b=100;
        short s=200;
        int i=300;
        long j=400;
        float f=0.5F;
        double d=3.14;
        boolean flag=false;
        char a='我';
        dos.writeByte(b);
        dos.writeShort(s);
        dos.writeInt(i);
        dos.writeLong(j);
        dos.writeFloat(f);
        dos.writeDouble(d);
        dos.writeBoolean(flag);
        dos.writeChar(a);
        //刷新
        dos.flush();
        //关闭
        dos.close();
    }
}

13.Demo 13(DataInputStream)

package com.szh.io;

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

/**
 * java.io.DataInputStream 数据专属的字节输入流
 * DataOutputStream 写的文件只能使用 DataInputStream 来读,同时读的顺序必须和写的顺序一样
 */
public class DataInputStreamTest {

    public static void main(String[] args) throws IOException {
        //创建数据专属的字节输入流
        DataInputStream dis=new DataInputStream(new FileInputStream("E:/data"));
        //开始读
        byte b=dis.readByte();
        short s=dis.readShort();
        int i=dis.readInt();
        long j=dis.readLong();
        float f=dis.readFloat();
        double d=dis.readDouble();
        boolean flag=dis.readBoolean();
        char a=dis.readChar();

        System.out.println(b);
        System.out.println(s);
        System.out.println(i);
        System.out.println(j);
        System.out.println(f);
        System.out.println(d);
        System.out.println(flag);
        System.out.println(a);

        //关闭
        dis.close();
    }
}

14.Demo 14(PrintStream)

package com.szh.io;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.PrintStream;

/**
 * java.io.PrintStream
 * 标准字节输出流,默认直接输出到控制台
 */
public class PrintStreamTest {

    public static void main(String[] args) throws FileNotFoundException {
        System.out.println("Hello World!!!");

        //创建一个标准字节输出流对象
        PrintStream ps=System.out;
        ps.println("Java I/O流");
        ps.println("Java 666");
        ps.println(123);

        //标准输出流不需要手动调用close方法关闭

        //修改标准字节输出流的输出方向,输出到 log 文件
        PrintStream printStream=new PrintStream(new FileOutputStream("E:/log"));
        System.setOut(printStream);
        //再次输出,将不会输出到控制台
        System.out.println("Java I/O流");
        System.out.println("Java 666");
        System.out.println(999);
    }
}

15.Demo 15(I/O流联合Properties属性类使用)

package com.szh.io;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.Properties;

/**
 * I/O流和Properties的联合使用
 * 设计理念:以后经常改变的数据,可以单独写道一个文件中,使用程序动态读取
 *         将来只需要修改这个文件的内容,Java代码不需要修改,不需要重新编译,服务器也不需要重启,就可以拿到动态的数据
 *
 * 类似于以上机制的文件被称为配置文件,其中的格式为
 *         key1=value1
 *         key2=value2 (key重复的情况下,value会自动覆盖)
 * 的时候,我们把这种配置文件称为属性配置文件,例如:jdbc.properties
 * Java中有规范要求,属性配置文件需要以 .properties 结尾,但这不是必须的
 * Properties类是Java中专门存放属性配置文件的一个类
 */
public class IoPropertiesTest {

    public static void main(String[] args) throws IOException {
        //Properties是一个Map集合,继承了Hashtable,其key和value都是String类型
        //这里打算将一个文件中的数据加载到Properties对象中
        //新建一个文件字符输入流对象
        FileReader reader=new FileReader("E:/userinfo.txt");
        //创建一个Properties集合
        Properties properties=new Properties();
        //调用Properties对象的load方法,将文件中的数据加载到Properties集合中
        properties.load(reader);
        //通过文件中的key获取对应的value
        String username=properties.getProperty("username");
        String password=properties.getProperty("password");
        System.out.println(username);
        System.out.println(password);
    }
}

16.Demo 16(File)

package com.szh.io;

import java.io.File;

/**
 *
 */
public class FileTest02 {

    public static void main(String[] args) {
        File file=new File("E:/");
        //获取当前目录下的所有子文件
        File[] files=file.listFiles();
        for (File file1 : files) {
            //获取所有子文件的绝对路径
            //System.out.println(file1.getAbsolutePath());
            //获取所有子文件的文件名
            System.out.println(file1.getName());
        }
    }
}

17.Demo 17(File)

package com.szh.io;

import java.io.File;

/**
 *
 */
public class FileTest02 {

    public static void main(String[] args) {
        File file=new File("E:/");
        //获取当前目录下的所有子文件
        File[] files=file.listFiles();
        for (File file1 : files) {
            //获取所有子文件的绝对路径
            //System.out.println(file1.getAbsolutePath());
            //获取所有子文件的文件名
            System.out.println(file1.getName());
        }
    }
}

18.Demo 18(ObjectInputStream & ObjectOutputStream)

这两个流呢,我在这里就不再举例了,它们两个联合起来主要是实现Java中的序列化和反序列化操作。

在我的这篇文章中有相关的实例:https://blog.csdn.net/weixin_43823808/article/details/116885510

写在结尾

I/O流这块其实就是读读写写的操作,把大体的框架搭建出来,该new对象new对象,该调方法就调方法,遇到什么异常要用什么方法解决(throws直接上抛、还是try/catch捕获),最后记得关闭流、如果是输出流记得刷新。

以上是关于Java——18个Demo带你玩转Java中的I/O流的主要内容,如果未能解决你的问题,请参考以下文章

七个方面带你玩转Java线程池

接入指南一个Demo带你玩转华为帐号服务

jdk都出到16了8还没掌握吗?挽周带你玩转java8新特性(建议收藏)

七分钟带你玩转Java基本语法——安装Eclipse

明晚直播丨带你玩转PaddleOCR Java部署

18 | 眼前一亮:带你玩转GUI自动化的测试报告