IO流

IO流

I（input）O（output）。

流的分类：

按照读写方向，分为输入流和输出流。（在程序角度分析）
按照读写内容单位而言，分为字节流和字符流
按照流的功能不同，分为节点流和处理流
- 字节流：直接连接在文件上
- 处理流：嵌套在其它流上

流的家族体系

-	输入	输出
字节流	InputStream	OutputStream
字符流	Reader	Writer

上面四个都是抽象类

对应文件流：

文件字节输入流 FileInputStream

文本字节输出流FileOutputStream

字符输入流：FileReader

字符输入流：FileWriter

File类

表示操作系统中的文件或者文件夹。

文件路径
- 绝对路径
- 相对路径

文件/文件夹基础操作

package eg01_file;

import java.io.File;

import java.io.IOException;

public class Test1 {

    public static void main(String[] args) {

        boolean result = false;

        File file = new File("test01.txt"); // 该文件可有可无

        try {

            result = file.createNewFile();//create a file. create file not folder

            System.out.println("文件创建"+ (result ?"成功":"失败"));

            System.out.println(file.getParent());// 拿到上一级文件夹路径

            System.out.println(file.getParentFile());//拿到上一级文件夹的文件对象

            file.mkdir();//创建单个文件夹。

            file.mkdirs();//支持同时创建多级目录

            result  = file.renameTo(new File("test01_change.txt"));

            System.out.println("文件修改名称"+ (result ?"成功":"失败"));

            //查看相关

            System.out.println(file.exists());//文件是否存在

            System.out.println(file.isAbsolute());//是否是绝对路径

            System.out.println(file.isDirectory());//是否是文件夹

            System.out.println(file.isFile());//是否是文件夹

            System.out.println(file.length());//查看文件大小

        } catch (IOException e) {

            e.printStackTrace();//查看文件是否存在

        }

    }

}

创建文件的完整步骤

package eg01_file;

import java.io.File;

public class Test2 {

    public static void main(String[] args) {

    try{

        File file = new File("abc/test2.txt");

        //判断上层文件夹是否存在

        File parentFile = file.getParentFile();

        if(!parentFile.exists()){

            //上层文件夹不存在，先创建

            parentFile.mkdirs();

        }

        //创建文件

        file.createNewFile();

    }catch (Exception e){

        e.printStackTrace();

    }

    }

}

IO流 - 节点流

读入文件一个字节（一个字节）

不能读取中文。中文是2个字节一个字

package eg02_io;

import java.io.FileInputStream;

import java.io.InputStream;

public class TestFileInputStream {

  public static void main(String[] args) {

    //创建流

    try {

      InputStream fis = new FileInputStream("test01.txt");

      //----------------------------------------------

      int result = fis.read();//读出来的是字符ASCII码

      System.out.println((char) result);//强制转换

      //----------------------------------------------

    } catch (Exception e) {

      e.printStackTrace();

    }

  }

}

[FileInputStream]字节数组的方式读取(读取全部内容)

package eg02_io;

import java.io.FileInputStream;

import java.io.InputStream;

public class TestFileInputStream {

  public static void main(String[] args) {

    //创建流

    try {

      InputStream fis = new FileInputStream("test01.txt");

      byte[] bs = new byte[1024];//一次读kb

      int len = fis.read(bs);//读出来的是字节数组。返回值为读取的字节数量。

      System.out.println(new String(bs, 0, len));//字节数组转为字符

    } catch (Exception e) {

      e.printStackTrace();

    }

  }

}

[FileInputStream]读取文件最重要的一套写法

package eg02_io;

import java.io.FileInputStream;

import java.io.InputStream;

public class TestFileInputStream {

  public static void main(String[] args) {

    //创建流

    try {

      InputStream fis = new FileInputStream("test01.txt");

      byte[] bs = new byte[1024];//一次读kb

      int len = 0;

      while ((len = fis.read(bs)) != -1) {// 不等于-1表示没读完，便继续读取。

        //该写法仅限于IO流使用，其他地方不要用。

        String s = new String(bs, 0, len);

        System.out.println(s);

      }

      //关流

      fis.close();

    } catch (Exception e) {

      e.printStackTrace();

    }

  }

}

[FileoutputStream]向文件写入内容

package eg02_io;

import java.io.File;

import java.io.FileOutputStream;

public class TestFileOutputStream {

  public static void main(String[] args) {

    try {

      FileOutputStream fos = new FileOutputStream(new File("test01.txt"), true);//true追加。则不会清空原有数据

      fos.write("牛啊牛啊，醉酒的向日狼".getBytes());

      fos.flush();

      fos.close();

    } catch (Exception e) {

      e.printStackTrace();

    }

  }

}

[FileReader]读入文件一个字符（两个字节）

package eg02_io;

import java.io.File;

import java.io.FileReader;

public class TestFileReader {

  public static void main(String[] args) {

    try {

      FileReader fr = new FileReader(new File("test01.txt"));

      int i = fr.read();//以字符为单位。

      System.out.println((char) i);

    } catch (Exception e) {

      e.printStackTrace();

    }

  }

}

[FileReader]读入文件所有字符

package eg02_io;

import java.io.File;

import java.io.FileReader;

public class TestFileReader {

  public static void main(String[] args) {

    try {

      FileReader fr = new FileReader(new File("test01.txt"));

      char[] cs = new char[1024];

      int len = fr.read(cs);

      System.out.println(new String(cs, 0, len));

    } catch (Exception e) {

      e.printStackTrace();

    }

  }

}

对于存在大量内容需要读取时的写法

package eg02_io;

import java.io.File;

import java.io.FileReader;

public class TestFileReader {

  public static void main(String[] args) {

    try {

      FileReader fr = new FileReader(new File("test01.txt"));

      char[] cs = new char[1024];

      int len = 0;

      while ((len = fr.read(cs)) != -1) {

        System.out.println(new String(cs, 0, len));

      }

      fr.close();

    } catch (Exception e) {

      e.printStackTrace();

    }

  }

}

[FileWriter]向文件写入内容

package eg02_io;

import java.io.File;

import java.io.FileWriter;

public class TestFileWriter {

  public static void main(String[] args) {

    try {

      FileWriter fw = new FileWriter(new File("test01.txt"), true);//追写则true

      fw.write("刑啊，太刑了。");

      fw.flush();

      fw.close();

    } catch (Exception e) {

      e.printStackTrace();

    }

  }

}

如何选择流？

字节流：常用于读取非文本文件

字符流：常用于读取文件中的文字信息

IO流练习：复制图片操作

选择的流：字节流

package eg03_copypic;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.IOException;

public class test3 {

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

        FileInputStream fis = new FileInputStream(new File("1.jpg"));

        FileOutputStream fos = new FileOutputStream(new File("2.jpg"),true);

        byte[] bs = new byte[1024];

        int len = 0;

        while ((len = fis.read(bs))!=-1){

            fos.write(bs,0,len);

        }

        fis.close();

        fos.flush();

        fos.close();

    }

}

如果不是复制，而是剪切

package eg03_copypic;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.IOException;

public class test3 {

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

        File file = new File("2.jpg");

        FileInputStream fis = new FileInputStream(file);

        FileOutputStream fos = new FileOutputStream(new File("3.jpg"),true);

        byte[] bs = new byte[1024];

        int len = 0;

        while ((len = fis.read(bs))!=-1){

            fos.write(bs,0,len);

        }

        fis.close();

        fos.flush();

        fos.close();

        file.delete();

    }

}

IO流 - 处理流

缓冲流

缓冲流：带有缓冲区的数据流

重点是BufferedReader ，这是读取文本文件最好的方式

BufferedInputStream
BufferedOutputStream
BufferedReader
BufferedWirter

package eg04.buffer;

import java.io.*;

public class test04 {

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

       // BufferedInputStream bis = new BufferedInputStream(new FileInputStream(new File("test01.txt"))); //一般不用

        BufferedReader br = new BufferedReader(new FileReader(new File("test01.txt")));

//        System.out.println(br.readLine()); //读取文本文件最好用的方法。

//        System.out.println(br.readLine());

        String str = "";

        while ((str= br.readLine())!=null){

            //读取内容

            System.out.println(str);

        }

        br.close();

    }

}

转换流

字节流 ==> 字符流：

[输入] InputStreamReader
[输出] OutputStreamWriter

package eg05_convert;

import java.io.IOException;

import java.io.OutputStreamWriter;

import java.io.Writer;

public class test_out {

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

//        System.out.println();

        Writer writer = new OutputStreamWriter(System.out);

        writer.write("abc路人甲");

        writer.flush();

        //writer.close();//有时候流不可以关，如果这里关了，后面的 System.out.println(); 也不会输出。

        System.out.println("关闭了流");

    }

}

对象流

ObjectInputStream
ObjectOutputStream

[对象] Person.java

package eg06_obj;

public class Person {

    private int id;

    private String name;

    private int age;

    public Person(int id, String name, int age) {

        this.id = id;

        this.name = name;

        this.age = age;

    }

    public int getId() {

        return id;

    }

    public void setId(int id) {

        this.id = id;

    }

    public String getName() {

        return name;

    }

    public void setName(String name) {

        this.name = name;

    }

    public int getAge() {

        return age;

    }

    public void setAge(int age) {

        this.age = age;

    }

}

[测试] test06.java

package eg06_obj;

import java.io.*;

public class test06 {

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

        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(new File("person.data")));

        Person p = new Person(1,"萌狼蓝天",18);

        oos.writeObject(p);

        oos.flush();

        oos.close();

    }

}

[运行结果]报错

序列化：把一个对象转化为字节的过程

反序列化：把字节转化成对象

解决方案：在Java中只需要给类添加一个实现，Serialable。这样这个类就可以被序列化了。过程是全自动的。(实质：让数据可以进行序列化)

更改 Person.java

package eg06_obj;

import java.io.Serializable;

public class Person implements Serializable {

    private int id;

    private String name;

    private int age;

    public Person(int id, String name, int age) {

        this.id = id;

        this.name = name;

        this.age = age;

    }

    public int getId() {

        return id;

    }

    public void setId(int id) {

        this.id = id;

    }

    public String getName() {

        return name;

    }

    public void setName(String name) {

        this.name = name;

    }

    public int getAge() {

        return age;

    }

    public void setAge(int age) {

        this.age = age;

    }

}

此时运行，便不会报错。

那么如何读取呢？(反序列化)

package eg06_obj;

import java.io.*;

public class Test07 {

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

        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(new File("person.data")));

        Object obj =  ois.readObject();

        Person p = (Person) obj;

        System.out.println(p.getName());

    }

}

文件修改操作

思路：偷梁换柱。逐行读取文件内容，将内容进行替换，将替换结果记录在一个新文件中，直到数据写入完毕，把源文件删除。

把新文件的名字改成源文件的名字

代码如下

package eg07_update;

import java.io.*;

import java.nio.Buffer;

public class test7 {

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

        File res  = new File("test.txt");

        //没有test.txt需要先手动创建，内容如下

        /**

         * 记录生活的博客：萌狼蓝天の小世界 - 萌狼蓝天 (mllt.cc)

         *

         * 记录学习笔记的博客：萌狼蓝天 - 博客园 (cnblogs.com)

         *

         * 分享信息技术相关内容的哔哩哔哩账号：萌狼蓝天的个人空间_哔哩哔哩_bilibili

         *

         * 分享个人生活的哔哩哔哩账号：醉酒的向日狼的个人空间_哔哩哔哩_bilibili

         *

         * 这四个网站是我主要活跃的网站

         *

         * 其中，mllt.cc这个网站是搭建在我自己服务器的，也许我会因为续费不起服务器而在2023年的时候关闭这个网站。

         *

         * 如果你想获取我的学习笔记，应该去看我的博客园

         *

         * 如果你想观看我录制的计算机相关知识视频，应该去看萌狼蓝天的个人空间_哔哩哔哩_bilibili

         */

        File new_res  = new File("副本_test.txt");

        BufferedReader br = new BufferedReader(new FileReader(res));

        BufferedWriter bw = new BufferedWriter(new FileWriter(new_res));

        String line = "";

        while((line = br.readLine())!=null){

            line = line.replace("萌狼蓝天","易水千");

            bw.write(line);

            bw.newLine();//另起一行（换行）

        }

        br.close();

        bw.flush();

        bw.close();

        //删除源文件

        res.delete();

        //重命名新文件

        new_res.renameTo(res);

    }

}

[运行结果]

【Java高级编程】IO流学习笔记的更多相关文章

JAVA.IO流学习笔记
一.java.io 的描述通过数据流.序列化和文件系统提供系统输入和输出.IO流用来处理设备之间的数据传输二.流流是一个很形象的概念,当程序需要读取数据的时候,就会开启一个通向数据源的流,这个数 ...
Java中的io流学习（了解四大基类和基本步骤）
Java中io流四大基类及io流操作四大基本步骤 io流:(input/output)即输入输出流.面向对象的思想之一是面向接口编程,面向父类编程,也就是多态.所以学好基类(父类)很重要. 分类按处 ...
IO流学习笔记（二）之BufferedWriter与BufferedReader及实例Demo
在之前的学习笔记(http://blog.csdn.net/megustas_jjc/article/details/72853059)中,FileWriter与FileReader的Demo使用的中 ...
Java基础之IO流学习总结
Java流操作有关的类或接口: Java流类图结构: 流的概念和作用流是一组有顺序的,有起点和终点的字节集合,是对数据传输的总称或抽象.即数据在两设备间的传输称为流,流的本质是数据传输,根据数据传输 ...
关于java读取文件IO流学习总结（一）
IO流的分类: 1.根据流的数据对象来分: 高端流:所有的内存中的流都是高端流,比如:InputStreamReader 低端流:所有的外界设备中的流都是低端流,比如InputStream,Outpu ...
java高级之Io流
1.1,什么是io流? 流是一组有顺序的,有起点和终点的字节集合,是对数据传输的总称或抽象.即数据在两设备间的传输称为流,流的本质是数据传输,根据数据传输特性将流抽象为各种类,方便更直观的进行数据操作 ...
IO流学习笔记（一）之FileWriter与FileReader
IO流用来处理设备之间的数据传输 Java对数据的操作是通过流的方式 Java用于操作流的对象都在IO包中流按照操作数据分为两种:字节流和字符流流按流向分为:输入流和输出流输入流和输出流是相对于 ...
《Java并发编程实战》学习笔记线程安全、共享对象和组合对象
Java Concurrency in Practice,一本完美的Java并发参考手册. 查看豆瓣读书推荐:InfoQ迷你书<Java并发编程的艺术> 第一章介绍线程的优势:充分利 ...
java中File IO流的笔记
1.File文件的属性和操作 boolean exists( ) 判断文件或目录是否存在boolean isFile( ) 判断是否是文件boolean isDirectory( ) 判断是否是目 ...
《Java并发编程实战》学习笔记
第2章线程安全性正确性: 某个类的行为与其规范完全一致. 2.1线程安全: 当多个线程访问某个类时,不管运行时环境采用何种调度方式或者这些线程将如何交替执行,并且在主调代码中不需要任何额外的同步或 ...

随机推荐

axios 常见状态码
'100': 'Continue', '101': 'SwitchingProtocols', '102': 'Processing', '103': 'EarlyHints', '200': 'Ok ...
document.write 和 innerHTML 的区别
a document.write 是整个页面的内容,会重写页面b innerHTML 是某个元素的内容,只有给body的innerHTML设置内容才会重写页面
小程序的三大API
小程序的API有宿主环境提供的 : ps:浏览器的定义对象是 window 而微信中的顶级对象是wx :都是不用声明就能调用 : 1. 事件监听以on开头,监听事件的触发 eg:onWindowRe ...
Android复习(三)清单文件中的元素——> activity
转自: https://developer.android.google.cn/guide/topics/manifest/activity-element <activity> 语法: ...
在 Kubernetes Pod 中如何获取客户端的真实 IP
Kubernetes 依靠 kube-proxy 组件实现 Service 的通信与负载均衡.在这个过程中,由于使用了 SNAT 对源地址进行了转换,导致 Pod 中的服务拿不到真实的客户端 IP 地 ...
云原生周刊：Istio 1.19 发布｜ 2023.9.11
开源项目推荐 Timoni Timoni 是 Kubernetes 的软件包管理器,由 CUE 提供支持,灵感来自 Helm. Timoni 项目致力于改善编写 Kubernetes 配置的用户体验. ...
华为云-容器引擎CCE-基本概念
云容器引擎(Cloud Container Engine,简称CCE)提供高度可扩展的.高性能的企业级Kubernetes集群,支持运行Docker容器.借助云容器引擎,您可以在华为云上轻松部署.管理 ...
vue搜索历史记录缓存实现
思路: 1.浏览器缓存永久保存搜索历史数据. 2.页面初始化将数据保存到页面变量中. 3.对搜索历史记录的怎加和删除,要同步到缓存中. ----------------直接看代码----------- ...
管中窥豹----从String Intern中观察.NET Core到.NET 8 托管堆的变迁
简介 https://www.cnblogs.com/lmy5215006/p/18494483 在此文中,研究.NET String底层结构时,我所观察到的情况与<.NET Core底层入门& ...
IDEA 2024.2.2 最新安装教程（附激活-2099年~）
访问 IDEA 官网下载 IDEA 2024.2.2 版本的安装包. 下载补丁https://pan.quark.cn/s/fcc23ab8cadf 检查进入 IDEA 中后,点击菜单 Help ...

【Java高级编程】IO流学习笔记

IO流