java IO流二：字节流 FileInputStream & FileOutputstream

最新推荐文章于 2025-04-11 18:05:37 发布

原创最新推荐文章于 2025-04-11 18:05:37 发布 · 300 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java #IO流 #FileInputStream #FileOutputstream

Java 专栏收录该内容

47 篇文章

订阅专栏

本文深入讲解Java中的FileInputStream和FileOutputStream，包括它们的基本用法、读写操作、字节流的复制，以及如何处理异常。通过实例演示了如何读取和写入文件，展示了高效的字节读取和文件复制技巧。

在这里插入图片描述

FileInputStream：文件字节输入流

package com.company01.IO;
/*
    java.io.InputStream;
        java.io.FileInputStream; 文件字节输入流

        按照字节方式读取文件
*/
import java.io.*;
public class FileInputStreamTest01 {
    public static void main(String[] args) {

        FileInputStream fis = null;

        try{
            // 1.要读取某文件，先与这个文件创建一个“输入流”
            // 文件路径
            //String filePath = "test.txt";  // 相对路径&绝对路径  绝对路径注意由于转义字符的存在，采用双斜杠"\\"
            // 在IDEA中与相对路径起始位置默认是在Moudel文件下，与src文件夹同一级别。
            String filePath = "E:\\mydemo\\Java\\IDEA\\test\\day02\\src\\com\\company01\\IO\\test.txt";
            // 由于在windows路径中 / 和 \ 是一样的，并且 \ 也能规避转义字符，所以也能写成下面这样
            //String filePath = "E:/mydemo/Java/IDEA/test/day02/src/com/company01/IO/test.txt";

            fis = new FileInputStream(filePath);

            // 2.开始读
            int i1 = fis.read(); // 以字节的方式读取，一个字母占一个字节，一个汉字占两个字节，每次读取一半
            int i2 = fis.read();
            int i3 = fis.read();

            int i4 = fis.read();
            int i5 = fis.read();

            int i6 = fis.read();  // 文件中只有“abc我”

            System.out.println(i1);  // 输出a的ASIIC码 97
            System.out.println(i2);  // 98
            System.out.println(i3);  // 99

            System.out.println(i4);  // 206
            System.out.println(i5);  // 210

            System.out.println(i6);  // -1  // 如果已经读取到文件的末尾。就会返回-1

        }catch(FileNotFoundException e){
            e.printStackTrace();
        }catch(IOException e){   // IOException比FileNotFoundException 更加宽泛，必须写在后面
            e.printStackTrace();
        }finally{

            //为了保证流一定会释放，所以在finally语句块中执行
            if(fis != null){
                try{
                    fis.close();
                }catch(IOException e){
                    e.printStackTrace();
                }
            }

        }
    }
}

package com.company01.IO;

import java.io.FileInputStream;

public class FileInputStreamTest02 {
    public static void main(String[] args) throws Exception {

        // 1.创建流
        FileInputStream fis = new FileInputStream("test01");

        // 2.开始读
        /*
        while(true){
            int temp = fis.read();
            if(temp == -1) break;

            System.out.println(temp);
        }
        */
        // 升级循环
        int temp = 0;
        while((temp = fis.read()) != -1){
            System.out.println(temp);
        }

        // 3.关闭流
        fis.close();
    }
}

package com.company01.IO;

import java.io.FileInputStream;

/*
    int read(byte[] bytes);
    读取之前在内存中准备一个byte数组，每次读取多个字节存储到byte数组中。
    一次读取多个字节，不是单字节读取了。

    效率高
*/
public class FileInputStreamTest03 {
    public static void main(String[] args) throws Exception{

        // 1.创建输入流

        FileInputStream fis = new FileInputStream("test01");

        // 2.开始读
        // 准备一个byte数组
        byte[] bytes = new byte[3];  // 每次最多读取3个字节

        // int read(byte[] bytes);  该方法返回的int类型的值代表的是：这次读取了多少个字节
        int i1 = fis.read(bytes);   // 3

        // 将byte数组转换成字符串
        System.out.println(new String(bytes));  // abc

        int i2 = fis.read(bytes);   // 3

        System.out.println(new String(bytes));  // def

        int i3 = fis.read(bytes);   // 1

        System.out.println(new String(bytes));  // gef   新读取到的就一个g，只会对d进行覆盖，bytes数组剩余的2个位置元素不变
        // 如果只想要获得g
        System.out.println(new String(bytes, 0, i3));  // g

        int i4 = fis.read(bytes);  // -1 已经到达文件的末尾，返回-1

        System.out.println(i1);
        System.out.println(i2);
        System.out.println(i3);
        System.out.println(i4);
        // 关闭
        fis.close();

    }
}

package com.company01.IO;

import java.io.FileInputStream;

/*
    循环读取
*/
public class FileInputStreamTest04 {
    public static void main(String[] args) throws Exception {

        FileInputStream fis = new FileInputStream("test01");

        // 循环取出
        byte[] bytes = new byte[1024];  //每次读取1KB

        /*
        while(true){
            int temp = fis.read(bytes);

            if(temp==-1) break;

            // 将数组中的有效数据转换成字符串
            System.out.print(new String(bytes, 0, temp));
        }

        */


        // 升级循环
        int temp = 0;
        while(((temp=fis.read(bytes)))!= -1){
            System.out.print(new String(bytes, 0, temp));
        }
        fis.close();
    }
}

package com.company01.IO;

import java.io.*;

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


        FileInputStream fis = new FileInputStream("test01");

        System.out.println(fis.available());  // 7
        System.out.println(fis.read()); // 97

        // int available(); 返回流中剩余的估计字节数。
        System.out.println(fis.available());  // 6  读取一个之后减一了

        // 跳过2个字节
        fis.skip(2);
        System.out.println(fis.available());  // 4

        fis.close();
    }
}

FileOutputStream：文件字节输出流

package com.company01.IO;

import java.io.FileOutputStream;

/*
    java.io.OutputStream;
        java.io.FileOutputStream;  文件字节输出流

        将计算机内存中的数据写入硬盘文件中
*/
public class FileOutputStreamTest01 {
    public static void main(String[] args) {

        FileOutputStream fos = null;
        //String str = "E:/mydemo/Java/IDEA/test/day02/src/com/company01/IO/test.txt";

        try{
            // 1.创建文件字节输出流
            // fos = new FileOutputStream("test01");  //改文件不存在则自动创建  【注】这种方式不是在后面添加，而是覆盖重写

            // 【注】以追加的方式写入
            fos = new FileOutputStream("test01", true);  // 在后面追加

            // 2.开始写
            String msg = "Hello World! ";

            // 将String转换成byte数组
            byte[] bytes = msg.getBytes();

            // 将byte数组中所有的数据全部写入
            fos.write(bytes);

            // 将byte数组中的部分数据写入
            fos.write(bytes, 0,3);   // 0表示起始位置，3表示长度

            // 推荐最后的时候为了保证数据完全写入硬盘，所以要刷新
            fos.flush();  // 强制写入

        }catch(Exception e){
            e.printStackTrace();
        }finally{

            // 关闭
            if(fos!=null){
                try{
                   fos.close();
                }catch(Exception e){
                    e.printStackTrace();
                }
            }
        }

    }
}

使用FileInputStream & FileOutputStream 实现文件复制

注：FileInputStream & FileOutputStream 实现文件复制，该文件只能是文本文件。

package com.company01.IO;
/*
    关于文件复制粘贴
*/
import java.io.*;

public class CopyTest01 {
    public static void main(String[] args) throws Exception{

        // 创建输入流
        FileInputStream fis = new FileInputStream("test01");

        // 创建输入流
        FileOutputStream fos = new FileOutputStream("test02");

        // 一边读，一边写
        byte[] bytes = new byte[1024];  // 1KB
        int temp = 0;
        while((temp = fis.read(bytes)) != -1){

            // 将byte数组中内容直接写入
            fos.write(bytes, 0 , temp);
        }
        // 刷新
        fos.flush();

        // 关闭流
        fis.close();
        fos.close();
    }
}