Java基础学习—— IO流

已于 2022-02-20 00:19:07 修改
阅读量154 收藏 1
点赞数
分类专栏： java笔记 文章标签： java 学习 开发语言
于 2022-02-19 23:55:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43954793/article/details/123025951
版权

Java基础学习—— IO流

1 文件

1.1 文件的创建

public void create01() {
        String filePath = "e:\\news1.txt";
        File file = new File(filePath);

        try {
            file.createNewFile();
            System.out.println("文件创建成功");
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

1.2 文件常用的方法

  • getName：获取文件名
  • getAbsolutePath：获取文件绝对路径
  • getParent：获取父级目录
  • getlength：文件大小(字节)
  • exists：文件是否存在
  • isFile： 是不是文件
  • isDirectory：是不是目录
  • delet：删除文件
  • mkdir：创建目录
  • mdirs：创建多级目录

2 IO流

抽象基类字节流字符流
输入流InputStreamReader
输出流OutputStreamWriter

这四个类是抽象类，其他IO流对象都是以这四个类派生出来

  • 节点流：直接和数据源相接（File,String,Pipe等)
  • 处理流：封装一个节点流，使用了模拟器模式(BufferedReader,BufferedWriter等)

2.1 FileInputStream

  1. 从文件读取单个字节
public void readFile01() {
        String filePath = "e:\\hello.txt";
        int readData = 0;
        FileInputStream fileInputStream = null;
        try {
            //创建 FileInputStream 对象，用于读取 文件
            fileInputStream = new FileInputStream(filePath);
            //从该输入流读取一个字节的数据。 如果没有输入可用，此方法将阻止。
            //如果返回-1 , 表示读取完毕
            while ((readData = fileInputStream.read()) != -1) {
                System.out.print((char)readData);//转成char显示
            }

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //关闭文件流，释放资源.
            try {
                fileInputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
  1. 用数组读取文件
public void readFile02() {
        String filePath = "e:\\hello.txt";
        //字节数组
        byte[] buf = new byte[8]; //一次读取8个字节.
        int readLen = 0;
        FileInputStream fileInputStream = null;
        try {
            //创建 FileInputStream 对象，用于读取 文件
            fileInputStream = new FileInputStream(filePath);
            //从该输入流读取最多b.length字节的数据到字节数组。 此方法将阻塞，直到某些输入可用。
            //如果返回-1 , 表示读取完毕
            //如果读取正常, 返回实际读取的字节数
            while ((readLen = fileInputStream.read(buf)) != -1) {
                System.out.print(new String(buf, 0, readLen));//显示
            }

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //关闭文件流，释放资源.
            try {
                fileInputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }

2.2 FileOutputStream

  1. new FileOutputStream(filePath) 创建方式，当写入内容是，会覆盖原来的内容
  2. new FileOutputStream(filePath, true) 创建方式，当写入内容是，是追加到文件后面
public void writeFile() {

        //创建 FileOutputStream对象
        String filePath = "e:\\a.txt";
        FileOutputStream fileOutputStream = null;
        try {
            //得到 FileOutputStream对象 对象
            //1. new FileOutputStream(filePath) 创建方式，当写入内容是，会覆盖原来的内容
            //2. new FileOutputStream(filePath, true) 创建方式，当写入内容是，是追加到文件后面
            fileOutputStream = new FileOutputStream(filePath);
            //写入一个字节
            //fileOutputStream.write('H');//
            //写入字符串
            String str = "hello,world!";
            //str.getBytes() 可以把 字符串-> 字节数组
            //fileOutputStream.write(str.getBytes());
            /*
            write(byte[] b, int off, int len) 将 len字节从位于偏移量 off的指定字节数组写入此文件输出流
             */
            fileOutputStream.write(str.getBytes());

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

2.3 文件的拷贝

  1. 创建文件的输入流 , 将文件读入到程序
  2. 创建文件的输出流， 将读取到的文件数据，写入到指定的文件.
public static void main(String[] args) {
        
        
        String srcFilePath = "e:\\Koala.jpg";
        String destFilePath = "e:\\Koala3.jpg";
        FileInputStream fileInputStream = null;
        FileOutputStream fileOutputStream = null;

        try {

            fileInputStream = new FileInputStream(srcFilePath);
            fileOutputStream = new FileOutputStream(destFilePath);
            //定义一个字节数组,提高读取效果
            byte[] buf = new byte[1024];
            int readLen = 0;
            while ((readLen = fileInputStream.read(buf)) != -1) {
                //读取到后，就写入到文件 通过 fileOutputStream
                //即，是一边读，一边写
                fileOutputStream.write(buf, 0, readLen);//一定要使用这个方法

            }
            System.out.println("拷贝ok~");


        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                //关闭输入流和输出流，释放资源
                if (fileInputStream != null) {
                    fileInputStream.close();
                }
                if (fileOutputStream != null) {
                    fileOutputStream.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }


    }

2.4 FileReader

FileReader以字符为单位读取文件

java中的char

java里的char类型无论何时都是2字节的，字母’A’也不例外，只是在流中就不一定了，因为不同的编码方式有不同的规则。 unicode第一Plane总共有65536个空位，是16位的，占两个字节，因为java仅使用了unicode的第一个Plane，所以也是16位的。 从字符流中以某种字符编码读取读取字符时，会将流中的字节以某种字符编码的机内码规则进行解码，并转换为unicode的值存储到char类型变量中；向字符流以某种字符编码写入字符时，会将char类型的unicode码代表的字符以某种的字符编码的机内码规则进行编码，然后将编码后的字节写入到目标流中。

/**
     * 单个字符读取文件
     */
    @Test
    public void readFile01() {
        String filePath = "e:\\story.txt";
        FileReader fileReader = null;
        int data = 0;
        //1. 创建FileReader对象
        try {
            fileReader = new FileReader(filePath);
            //循环读取 使用read, 单个字符读取
            while ((data = fileReader.read()) != -1) {
                System.out.print((char) data);
            }

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

    /**
     * 字符数组读取文件
     */
    @Test
    public void readFile02() {
        System.out.println("~~~readFile02 ~~~");
        String filePath = "e:\\story.txt";
        FileReader fileReader = null;

        int readLen = 0;
        char[] buf = new char[8];
        //1. 创建FileReader对象
        try {
            fileReader = new FileReader(filePath);
            //循环读取 使用read(buf), 返回的是实际读取到的字符数
            //如果返回-1, 说明到文件结束
            while ((readLen = fileReader.read(buf)) != -1) {
                System.out.print(new String(buf, 0, readLen));
            }

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

2.5 FileWriter

String filePath = "e:\\note.txt";
        //创建FileWriter对象
        FileWriter fileWriter = null;
        char[] chars = {'a', 'b', 'c'};
        try {
            fileWriter = new FileWriter(filePath);//默认是覆盖写入
//            3) write(int):写入单个字符
            fileWriter.write('C');
//            4) write(char[]):写入指定数组
            fileWriter.write(chars);
//            5) write(char[],off,len):写入指定数组的指定部分
            fileWriter.write("Curry".toCharArray(), 0, 3);
//            6) write（string）：写入整个字符串
            fileWriter.write(" 你好哦");
            fileWriter.write("君子慎独");
//            7) write(string,off,len):写入字符串的指定部分
            fileWriter.write("上海天津", 0, 2);
            //在数据量大的情况下，可以使用循环操作.


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

            //对应FileWriter , 一定要关闭流，或者flush才能真正的把数据写入到文件
        
            try {
                //fileWriter.flush();
                //关闭文件流，等价 flush() + 关闭
                fileWriter.close();
            } catch (IOException e) {
                e.printStackTrace();
            }

        }

        System.out.println("程序结束...");

2.6 BufferedReader

对字节操作使用BufferedInputStream

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

        String filePath = "f:\\hello.txt";
        //创建bufferedReader
        BufferedReader bufferedReader = new BufferedReader(new FileReader(filePath));
        //读取
        String line; //按行读取, 效率高
        //说明
        //1. bufferedReader.readLine() 是按行读取文件
        //2. 当返回null 时，表示文件读取完毕
        while ((line = bufferedReader.readLine()) != null) {
            System.out.println(line);
        }

        //关闭流, 这里注意，只需要关闭 BufferedReader ，因为底层会自动的去关闭 节点流

        bufferedReader.close();

    }

2.7 BufferedWriter

对字节操作使用BufferedOutputStream

public static void main(String[] args) throws IOException {
        String filePath = "f:\\ok.txt";
        //创建BufferedWriter
        //说明:
        //1. new FileWriter(filePath, true) 表示以追加的方式写入
        //2. new FileWriter(filePath) , 表示以覆盖的方式写入
        BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(filePath));
        bufferedWriter.write("你一定能够成为你想要成为的人");
        bufferedWriter.newLine();//插入一个和系统相关的换行
        bufferedWriter.write("你一定能够成为你想要成为的人");
        bufferedWriter.newLine();
        bufferedWriter.write("你一定能够成为你想要成为的人");
        bufferedWriter.newLine();

        //说明：关闭外层流即可 ， 传入的 new FileWriter(filePath) ,会在底层关闭
        bufferedWriter.close();

    }

2.9 ObjectOutputStream

序列化：在保存数据时，保存数据的值和数据类型，要实现可序列化，必须实现Serializable或者Externalizable接口。一般使用Serializable接口（标记化的，里面没有方法）

反序列化：恢复数据时，恢复数据的值和数据类型

对象处理流能够将数据序列化和反序列化

public static void main(String[] args) throws Exception {
        //序列化后，保存的文件格式，不是纯文本，而是按照他的格式来保存
        String filePath = "f:\\data.dat";

        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(filePath));

        //序列化数据到 e:\data.dat
        oos.writeInt(100);// int -> Integer (实现了 Serializable)
        oos.writeBoolean(true);// boolean -> Boolean (实现了 Serializable)
        oos.writeChar('a');// char -> Character (实现了 Serializable)
        oos.writeDouble(9.5);// double -> Double (实现了 Serializable)
        oos.writeUTF("你一定可以成为你想要成为的人");//String
        oos.close();
        System.out.println("数据保存完毕(序列化形式)");


    }

2.10 ObjectInputStream

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

    //指定反序列化的文件
    String filePath = "f:\\data.dat";

    ObjectInputStream ois = new ObjectInputStream(new FileInputStream(filePath));

    //读取
    //1. 读取(反序列化)的顺序需要和你保存数据(序列化)的顺序一致
    //2. 否则会出现异常

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


    //关闭流, 关闭外层流即可，底层会关闭 FileInputStream 流
    ois.close();


}

对象处理流的注意事项

  1. 读写顺序要一致
  2. 类中添加serialVersionUID 序列化的版本号，可以提高兼容性
  3. 序列化对象时，默认将所有的属性都序列化，除了static或transient修饰的成员
  4. 序列化具有可继承性，其子类默认实现可序列化
  5. 对象序列化时，对象的属性必须要可序列化

2.11 InputStreamReader

将字节流转为字符流，用InputStreamReader可以指定编码格式，解决乱码的问题

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

        String filePath = "f:\\a.txt";

        //1. 把 FileInputStream 转成 InputStreamReader
        //2. 指定编码 gbk
        //InputStreamReader isr = new InputStreamReader(new FileInputStream(filePath), "gbk");
        //3. 把 InputStreamReader 传入 BufferedReader
        //BufferedReader br = new BufferedReader(isr);

        //将2 和 3 合在一起
        BufferedReader br = new BufferedReader(new InputStreamReader(
                                                    new FileInputStream(filePath), "gbk"));

        //4. 读取
        String s = br.readLine();
        System.out.println("读取内容=" + s);
        //5. 关闭外层流
        br.close();

    }

2.12 OutputStreamReader

public static void main(String[] args) throws IOException {
        String filePath = "f:\\hello.txt";
        String charSet = "utf-8";
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(filePath), charSet);
        osw.write("你好啊，笨蛋");
        osw.close();
        System.out.println("按照 " + charSet + " 保存文件成功~");


    }
南北有东西
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
JAVA-FileInputStream之read方法
weixin_30568591的博客
08-26 1895
　　今天一个友询问FileInputStrem方法的read()和read(byte b) 方法为什么都用-1来判断读文件结束的问题，在此和大家一起学习下。 　　关于FileInputStream 　　　　它用于读取本地文件中的字节数据，继承自InputStream类，由于所有的文件都是以字节为向导，因此它适用于操作于任何形式的文件。 关于其最重要的两个方法Read()和...
Java基础——IO详解
qq_45821255的博客
03-21 2477
本文介绍了IO流的具体内容，包括总结了常用的IO流，把它们做成了体系图。根据体系图分别介绍了它们的使用场景...
java IO技术
weixin_44722237的博客
10-24 152
package Demo; import javax.sql.rowset.FilteredRowSet; import java.io.*; public class Demo10 { public static void main(String[] args) throws Exception { //字符输出 (字节打印流) 与PrintWriter效果基本相同，但是进行字符输出时还是使用后者 PrintStream ps = new PrintStr.
面试|详细了解Java中的字符流
星空下的程序猿
07-30 441
上一篇博客讲了IO流中的字节流，分别介绍输入字节流和输出字节流的类结构图； 主要介绍字节流的读取方式和输出方式，分表对应着read()方法和write()方法；然后介绍不同形式的来源有不同的读取方式，同时根据输出的目的地不同有不同的输出方式。具体的内容可以看这里，这里我们介绍IO流中的字符流。 1 输入字符流 输入字符流的父类是抽象类Reader，它除了实现Closeable接口，还需要实现Rea...
Java实现文件写入——IO流（输入输出流详解）
热门推荐
张博在读
09-09 14万+
输入输出的重要性：      输入和输出功能是Java对程序处理数据能力的提高，Java以流的形式处理数据。流是一组有序的数据序列，根据操作的类型，分为输入流和输出流。      程序从输入流读取数据，向输出流写入数据。Java是面向对象的程序语言，每一个数据流都是一个对象，它们提供了各种支持“...
Java学习12.15——Io流
MODXc的博客
12-15 1334
IO IO是输入输出流 两个对应一个桥梁 分为字节流和字符流 Java的IO主要包含三个部分 流式部分——Io的主体部分 非流式部分——主要包含一些辅助流式部分的类 文件读取部分的与安全相关的类以及与本地操作系统相关的文件系统的类 Java中的流操作分为两种 基于字节流（Inputstream读取，Outputstream写入） 基于字符流（Reader读取，Writer写入） 两个对应一个桥梁 两个对应：字节流与字符流的对应，输入流和输出流的对应 一个桥梁：字节流到字符流的桥梁
Java模块学习——IO流
weixin_46050314的博客
12-28 216
java模块学习-关于IO流
Java基础——IO
qq_52519008的博客
10-01 2342
流（Stream），是一个抽象的概念，是指一连串的数据（字符或字节），是以先进先出的方式发送信息的通道。当程序需要读取数据的时候，就会开启一个通向数据源的流，这个数据源可以是文件，内存，或是网络连接。类似的，当程序需要写入数据的时候，就会开启一个通向目的地的流。这时候你就可以想象数据好像在这其中“流”动一样。
Java学习笔记——IO流
Lutra的博客
07-02 169
Java——IO流基础
qq_44331253的博客
02-11 5986
目录IO流IO的概述IO的分类体系图字节流字节输出流【OutputStream】OutputStream类的概述OutputStream类的常用方法FileOutputStream类FileOutputStream类的概述FileOutputStream类的构造方法文件是否存在FileOutputStream类的写出数据数据追加续写写出换行字节输入流【InputStream】InputStream类的概述InputStream类的常用方法FileInputStream类FileInputStream类的概述
java——IO流技术.pdf
04-03
javaIO流
浅谈java IO流——四大抽象类
08-26
java IO流——四大抽象类 ...java IO流——四大抽象类是java语言中输入输出操作的基础，它们提供了基本的输入输出操作，例如读取、写入、关闭等。理解这四大抽象类的作用和使用方法是java编程的基础。
java基础——IO流及File-RandomAccessFile对象.docx
01-02
java基础——IO流及File-RandomAccessFile对象.docx
java IO流学习笔记——(1)文件字节流
12-21
java IO流学习笔记——(1) IO流总述 • 输入流：数据源到程序(InputStream、Reader读进来) • 输出流：程序到目的地(OutputStream、Writer写出去) 流分类 : • 节点流：可以直接从数据源或目的地读写数据 • 处理...
Java基础 学习笔记 Markdownr版
06-27
本学习笔记主要涵盖了Java的基础知识，包括面向对象、集合、IO流、多线程、反射与动态代理以及Java 8的新特性等方面，旨在帮助初学者或有经验的开发者巩固和提升Java编程技能。 1. 面向对象（OOP）：Java的核心是...
redis+spring面试题
github_36510643的博客
07-21 155
redis+spring面试题
Java-Lambda
最新发布
lizhiwei21的博客
07-21 145
lambda表达式可以理解为对匿名内部类的一种简化 , 但是本质是有区别的面向对象思想 :强调的是用对象去完成某些功能函数式编程思想 :强调的是结果 , 而不是怎么去做。
Promise 详解（原理篇）
山重水复疑无路，柳暗花明又一村。
07-20 486
Promise 是一种异步编程的解决方案。在异步操作中，callback 会导致回调地狱的问题，Promise 解决了这个问题。一个 Promise对象有以下三种状态:pending：初始状态，既不是成功，也不是失败状态。：意味着操作成功完成。rejected：意味着操作失败。当 new Promise() 被实例化后，即表示 Promise 进入 pending 初始化状态，准备就绪，等待运行。
接口防刷！利用redisson快速实现自定义限流注解
架构师小吴的博客
07-18 1133
如登录接口，当用户使用手机号+验证码登录时，一般我们会生成6位数的随机验证码，并将验证码有效期设置为1-3分钟，如果对登录接口不加以限制，理论上，通过技术手段，快速重试100000次，即可将验证码穷举出来。解决思路：对登录接口加上限流操作，如限制一分钟内最多登录5次，登录次数过多，就返回失败提示，或者将账号锁定一段时间。在日常开发中，一些重要的对外接口，需要加上访问频率限制，以免造成资��损失。ok，通过以上两步，即可完成我们的限流注解了，下面通过一个接口验证下效果。
JVM-垃圾回收与内存分配
m0_50846237的博客
07-19 1122
JVM-垃圾回收与内存分配

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

南北有东西

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值