javase-io-210508-02

白光一

墨衍会员 · AI 创作全网分发码龄9年

关注

原创最新推荐文章于 2026-11-12 09:52:22 发布 133 阅读 AI 写同款· GEO 优化 ›

【干货攻略】Oracle报错篇 ORA-01378 磁盘扇区大小不兼容问题本期将为大家分享“ORA-01378 磁盘扇区大小不兼容”报错的问题解决方案。阅读详情

javase-io-210508-02

FileInputStream
FileOutputStream
文件拷贝

FileInputStream

read方法示意图

Demo01.java

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

/*
    java.io.FileInputStream:
        文件字节输入流，万能流
        字节方式，完成输入的操作，完成读的操作（硬盘--->内存）
 */
/*
	当前文本内容为  ab
*/

public class Demo01 {
    public static void main(String[] args) {

        FileInputStream fis = null;
        try {

            // ./test 根路径
            fis = new FileInputStream("./test");

            // 开始读
            int readData = fis.read();
            System.out.println(readData);   // 97

            readData = fis.read();
            System.out.println(readData);   // 98

            // 读到文件末尾，再读的时候读取不到任何数据，返回-1
            readData = fis.read();
            System.out.println(readData);       // -1

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 关闭输入流
            if (fis != null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}

Demo02.java

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

public class Demo02 {
    public static void main(String[] args) {
        FileInputStream fis = null;
        try {

            fis = new FileInputStream("./test");

//            // 方法一
//            while (true){
//                int readData = fis.read();
//                if (readData == -1) {
//                    break;
//                }
//                System.out.println(readData);
//            }

            // 方法二
            int readData01 = 0;
            while ((readData01 = fis.read()) != -1){
                System.out.println(readData01);
            }

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
}

Demo04.java

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

public class Demo04 {
    public static void main(String[] args) {
        FileInputStream fis = null;
        try {
            fis = new FileInputStream("test");

            // 一次最多读取四个字节，，，最多读  数组.length() 个字节
            byte[] bytes = new byte[4];

            // 这个方法的返回值是：读取到的字节数量。（不是字节本身）
            int readCount = fis.read(bytes);
            System.out.println(readCount);          // 第一次读到4个字节，，输出4
//            System.out.println(new String(bytes));  // abcd
            // 不应该全部都转换，应该是读取了多少个字节，转换多少个
            System.out.println(new String(bytes,0,readCount));  // abcd

            readCount = fis.read(bytes);
            System.out.println(readCount);          // 第二次读到3个字节，，输出3
//            System.out.println(new String(bytes));  // efgd
            // 不应该全部都转换，应该是读取了多少个字节，转换多少个
            System.out.println(new String(bytes,0,readCount));  // efg

            readCount = fis.read(bytes);            // 第三次没读到字节
            System.out.println(readCount);          // -1

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fis != null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

Demo05.java

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

public class Demo05 {
    public static void main(String[] args){
        FileInputStream fis = null;
        try {
            fis = new FileInputStream("test");
            byte[] bytes = new byte[4];

            // 方法1
//            while (true) {
//                int readCount = fis.read(bytes);
//                if (readCount == -1) {
//                    break;
//                }
//                // 把byte数组转换成字符串，读到多少个，转换多少个
//                System.out.println(new String(bytes,0,readCount));
//            }

            // 方法2
            int readCount = 0;
            while ((readCount = fis.read(bytes)) != -1){
                // 把byte数组转换成字符串，读到多少个，转换多少个
                System.out.println(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();
                }
            }
        }

    }
}

Demo06.java

/*
    FileInputStream类其他方法
        int available()         返回流当中剩余的没有读到的字节数量
        long skip(long n)       跳过几个字节不读
 */

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

public class Demo06 {
    public static void main(String[] args) {
        FileInputStream fis = null;
        try {
            fis = new FileInputStream("test");

            System.out.println("总字节数量："+fis.available());

            // 现在读一个字节
            int readByte = fis.read();
            System.out.println("还剩字节数量："+fis.available());

            // 使用这个方法，不需要循环了，直接读一次就行
            // 使用这个方法，不需要循环了，直接读一次就行
            // 使用这个方法，不需要循环了，直接读一次就行
            byte[] bytes = new byte[fis.available()];
            int readCount = fis.read(bytes);
            System.out.println(new String(bytes));      //bcdefg

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Demo07.java

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

/*
    FileInputStream类其他方法
        int available()         返回流当中剩余的没有读到的字节数量
        long skip(long n)       跳过几个字节不读
 */
public class Demo07 {
    public static void main(String[] args) {
        FileInputStream fis = null;
        try {
            fis = new FileInputStream("test");

            System.out.println("总字节数量："+fis.available());

            // 目前跳过两个字节不读
            fis.skip(2);
            System.out.println((char)fis.read());     // c

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

test

abcdefg

FileOutputStream

Demo01.java

/*
    FileOutputStream
        文件字节输出流，负责写
        从内存到硬盘
 */
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class Demo01 {
    public static void main(String[] args) {
        FileOutputStream fos = null;

        try {
            /*
                fos = new FileOutputStream("myfile");
                fos = new FileOutputStream("myfile",true);
                这两种方式，如果文件不存在，会自动创建，然后写入
                
                fos = new FileOutputStream("myfile");
                这种方法会将原文件清空，然后重新写入
                
                fos = new FileOutputStream("myfile",true);
                这种方法不会将原文件清空，会在原文件的基础上追加，追加，追加，追加
             */
            fos = new FileOutputStream("myfile",true);

            // 开始写
            byte[] bytes = {97,98,99,100};
            // 将byte数组全部写出
            // abcd
            fos.write(bytes);

            // 写出一部分
            // ab
            fos.write(bytes,0,2);

            // 写完之后，刷新
            fos.flush();

            String s = "白光一";
            byte[] bs = s.getBytes();
            fos.write(bs);

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fos != null) {
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

文件拷贝

/*
    这个拷贝方式适合所有文件类型
 */

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

public class FileCopy {
    public static void main(String[] args) {
        FileInputStream fis = null;
        FileOutputStream fos = null;

        try {
            fis = new FileInputStream("myfile");
            fos = new FileOutputStream("copymyfile");

            // 定义一个数组
            byte[] bytes = new byte[4];

            // 读取到的字节数
            int readCount = 0;

            // fis.read(bytes)  把数据读取到数组里面，，，bytes这个数组就是一个载体（我的理解）
            while ((readCount = fis.read(bytes)) != -1){
                // 读取几个，写入几个
                fos.write(bytes,0,readCount);
            }

            // 刷新通道
            fos.flush();

        } 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();
                }
            }
        }
    }
}