一、File类
- 1.1、File常用方法
- 1.2、练习
二、IO流操作
- 2.1、流的分类
- 2.2、四大基本流
- 2.3、操作IO流的模板
三、字节输入流（InputStream）
- 3.1、常用方法
四、字节输出流（OutputStream）
- 4.1、常用方法
五、字符输入流（Reader）
- 5.1、常用方法
六、字符输出流（Writer）
- 6.1、常用方法
七、综合练习
- 7.1、文件拷贝操作
- 7.2、处理异常
八、文件流
- 8.1、文件字节输出流（FileOutputStream）
- 8.2、文件字节输入流（FileInputStream）
- 8.3、文件字符输出流（FileWriter）
- 8.4、文件字符输入流（FileReader）
九、缓冲流
十、字节流和字符流如何选用
十一、对象序列化

一、File类

File课理解为文件和文件夹（目录），用于表示磁盘中某个文件或文件夹的路径。该类包含了文件的创建、删除、重命名、判断是否存在等方法。

只能设置和获取文件本身的信息（文件大小，是否可读），不能设置和获取文件里面的内容。

不同的操作系统对盘符的符号的定义是不同的：

Unix: 严格区分大小写，使用”/”来表示路径分隔符。
Windows: 默认情况下是不区分大小写的，使用”\”来分割目录路径。但是在Java中一个”\”表示转义，所以在Windows系统中就得使用两个”\\”。

1.1、File常用方法

String getName()：获取文件名称
String getPath()：获取文件路径
String getAbsolutePath()：获取绝对路径
File getParentFile()：获取上级目录文件
boolean exists()：判断文件是否存在
boolean isFile() ：是否是文件
boolean isDirectory()：判断是否是目录
boolean delete() ：删除文件
boolean mkdirs()：创建当前目录和上级目录
File[] listFiles() ：列出所有文件对象

public class FileDemo {public static void main(String[] args) throws Exception {File f = new File("C:/test/123.txt");System.out.println(f.getName());//123.txtSystem.out.println(f.getPath());//C:/test/123.txtSystem.out.println(f.getAbsolutePath());//C:/test/123.txtSystem.out.println(f.getParentFile().getName());//testSystem.out.println(f.exists());//trueSystem.out.println(f.isFile());//trueSystem.out.println(f.isDirectory());//false//如果当前文件的父文件夹不存在,则创建if(!f.getParentFile().exists()) {f.getParentFile().mkdirs();}//列出当前文件夹中所有文件File[] fs = f.getParentFile().listFiles();for (File file : fs) {System.out.println(file);}}
}

1.2、练习

列出给定目录中的全部文件的路径，包括给定目录下面的所有子目录。(递归)

public static void list(File file) {if (file.isDirectory()) {// 如果是文件夹，则继续列出File[] fs = file.listFiles();//列出所有文件if (fs != null) {//如果文件不为空，说明里面还有文件夹for (File f : fs) {//遍历文件夹list(f);//递归调用}}}System.out.println(file);//输出文件
}

二、IO流操作

什么是IO，Input和Output，即输入和输出。IO就是一种流。

2.1、流的分类

根据流的不同特性，流的划分是不一样的，一般按照如下情况来考虑：

按流动方向：分为输入流和输出流
按数据传输单位：分为字节流和字符流，即每次传递一个字节（byte）或一个字符（char）
按功能上划分：分为节点流和处理流，节点流功能单一，处理流功能更强

流的流向是相对的，我们一般站在程序的角度：

程序需要数据 → 把数据读进来 → 输入操作（read）：读进来
程序保存数据 → 把数据写出去 → 输出操作（write）：写出去

简而言之：读进来，写出去

2.2、四大基本流

流向	字节流(单位是字节)	字符流(单位是字符)
输入流	InputStream	Reader
输出流	OutputStream	Writer

2.3、操作IO流的模板

1):创建源或者目标对象(挖井).输入操作:   把文件中的数据流向到程序中,此时文件是源,程序是目标.输出操作:   把程序中的数据流向到文件中,此时文件是目标,程序是源.2):创建IO流对象(水管).输入操作:   创建输入流对象.输出操作:   创建输出流对象.3):具体的IO操作.输入操作:   输入流对象的read方法.输出操作:   输出流对象的write方法.4):关闭资源(勿忘). 一旦资源关闭之后,就不能使用流对象了,否则报错.输入操作:   输入流对象.close();输出操作:   输出流对象.close();

注意：

四大抽象流是不能创建对象的，我们会根据需求不同去选择他们的子类，比如操作文件的时候就选择文件流
无论是什么流，到最后都要调用close方法关闭流，释放资源

三、字节输入流（InputStream）

public abstract class InputStream extends Object implements Closeable，表示字节输入流的所有类的超类。

3.1、常用方法

public void close() throws IOException：关闭此输入流并释放与该流关联的所有系统资源。 InputStream 的 close 方法不执行任何操作。
public abstract int read() throws IOException：从输入流中读取一个字节数据并返回该字节数据，如果到达流的末尾，则返回 -1。
public int read(byte[] buff) throws IOException：从输入流中读取多个字节数据，并存储在缓冲区数组 buff 中。返回已读取的字节数量，如果已到达流的末尾，则返回 -1。

package day17_IO.classing;import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Arrays;/*** @author Xiao_Lin* @date 2020/12/22 19:48*/
public class InputStream {public static void main(String[] args) throws IOException {public static void main(String[] args) throws IOException {// 准备File对象  找绝对路径File file = new File("123.txt");// 编译  运行的是字节码文件System.out.println("file.getAbsolutePath() = " + file.getAbsolutePath());// 创建输入流FileInputStream inputStream = new FileInputStream(file);// 方式一:  不可取//当inputStream.read()没有传入参数的时候，返回的是当前读到的值
//        int i = inputStream.read(); // A
//        inputStream.read(); // B
//        inputStream.read(); // C
//        inputStream.read(); // D
//        System.out.println("inputStream.read() = " + inputStream.read());// 方式二: 一般般  没有缓存int i ;while ((i=inputStream.read())!=-1){System.out.println("i = " + (char)i);}// 方式三:  一般般 有缓存,但是缓存需要提前定义好大小 ,可能会浪费//        byte[] b = new byte[1024];
//        while (inputStream.read(b)!=-1) {//            System.out.println("new String(b) = " + new String(b));
//        }// 方式四: 有缓存 用多少缓存,就占用多少byte[] b = new byte[1024];int off = 0;int len ;//当len=inputStream.read(b)中传递了一个数组的时候，返回的是这个数组的长度while ((len=inputStream.read(b)) !=-1){System.out.println("len = " + len);System.out.println("new String(b) = " + new String(b,off,len));}// 关闭资源inputStream.close();}
}

四、字节输出流（OutputStream）

public abstract class OutputStream extends Object implements Closeable, Flushable表示字节输出流的所有类的超类。

4.1、常用方法

public void close() throws IOException：关闭此输出流并释放与此流有关的所有系统资源。
public abstract void write(int b) throws IOException：将指定的一个字节数据b写入到输出流中。
public void write(byte[] buff) throws IOException：把数组buff中所有字节数据写入到输出流中。
public void write(byte[] b, int off,int len) throws IOException：把数组buff中从索引off 开始的len 个字节写入此输出流中。

package day17_IO.classing;import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;/*** @author Xiao_Lin* @date 2020/12/22 20:09*/
public class OutputStream {public static void main(String[] args) throws IOException {// 准备File对象  找绝对路径File file = new File("123.txt");// 创建输出流对象FileOutputStream outputStream = new FileOutputStream(file);// 调用方法往里面写数据  默认false覆盖outputStream.write("ABC".getBytes());// 刷新缓存outputStream.flush();// 关闭资源outputStream.close();}
}

五、字符输入流（Reader）

public abstract class Reader extends Object implements Readable, Closeable表示字符输入流的所有类的超类。

5.1、常用方法

常用方法：

public abstract void close() throws IOException：关闭此输入流并释放与该流关联的所有系统资源。
public int read() throws IOException：从输入流中读取一个字符数据并返回该字符数据，如果到达流的末尾，则返回 -1。
public int read(char[] cbuf) throws IOException：从输入流中读取多个字符，并存储在缓冲区数组 cbuf 中。返回已读取的字符数，如果已到达流的末尾，则返回 -1。

package day17_IO.classing;import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;
import java.io.StringReader;/*** @author Xiao_Lin* @date 2020/12/22 20:15*/
public class ReaderDemo {public static void main(String[] args) throws IOException {// 准备File对象  找绝对路径File file = new File("123.txt");// 创建FileReaderFileReader reader = new FileReader(file);
//        reader.read(); // A
//        reader.read(); // B
//        reader.read(); // C
//        int read = reader.read();
//        System.out.println("read = " + read);char[] bufer = new char[1024];//reader.read(bufer); // 读完了 流中没有数据了,数据都在buferint len = -1;while ((len=reader.read(bufer)) !=-1){String s = new String(bufer,0,len);System.out.println("s = " + s);}// 关闭资源reader.close();}public static void main(String[] args) {Map<String,String> map = new HashMap<>(){{this.put("a","a");this.put("b","b");this.put("c","c");}};Iterator<Map.Entry<String, String>> iterator = map.entrySet().iterator();while (iterator.hasNext()) {//Map.Entry<String, String> next = iterator.next();// System.out.println("next = " + next);if (iterator.next().getKey().equals("a")) {System.out.println("===============");iterator.remove();}}System.out.println( map);}
}

六、字符输出流（Writer）

public abstract class Writer extends Object implements Appendable, Closeable, Flushable表示字符输出流的所有类的超类。

6.1、常用方法

常用方法：

public abstract void flush() throws IOException：刷新此输出流并强制写出所有缓冲的输出字符。
public abstract void close() throws IOException：关闭此输入流并释放与该流关联的所有系统资源。
public void write(int c) throws IOException：将指定的一个字符数据c写入到输出流中。
public void write(char[] cbuf) throws IOException：把数组cbuf中cbuf.length 个字符数据写入到输出流中。
public abstract void write(char[] cbuf, int off,int len) throws IOException：把数组cbuf中从索引off 开始的len 个字符写入此输出流中。
public void write(String str) throws IOException：将str字符串数据写入到输出流中。

package day17_IO.classing;import java.io.File;
import java.io.FileWriter;
import java.io.IOException;/*** @author Xiao_Lin* @date 2020/12/22 20:44*/
public class WriterDemo {public static void main(String[] args) throws IOException {// 准备File对象  找绝对路径File file = new File("123.txt");// 准备字符输出流FileWriter writer = new FileWriter(file);// 调用API 写数据writer.write(49);writer.write("丹丹");writer.write(new char[]{'B','C'});// 刷新writer.flush();// 关闭资源writer.close();}
}

七、综合练习

7.1、文件拷贝操作

private static void copy() throws Exception {//1):创建源或者目标对象File src = new File("file/copy_before.txt");File dest = new File("file/copy_after.txt");//2):创建IO流对象FileReader in = new FileReader(src);FileWriter out = new FileWriter(dest);//3):具体的IO操作int len = -1;//记录以及读取了多个字符char[] buff = new char[1024];//每次可以读取1024个字符len = in.read(buff);//先读取一次while(len > 0) {//边读边写out.write(buff, 0, len);len = in.read(buff);//再继续读取}//4):关闭资源(勿忘)out.close();in.close();
}

7.2、处理异常

private static void copy2() {//1):创建源或者目标对象File src = new File("file/copy_before.txt");File dest = new File("file/copy_after.txt");//把需要关闭的资源，声明在try之外FileReader in = null;FileWriter out = null;try {//可能出现异常的代码//2):创建IO流对象in = new FileReader(src);out = new FileWriter(dest);//3):具体的IO操作int len = -1;//记录以及读取了多个字符char[] buff = new char[1024];//每次可以读取1024个字符len = in.read(buff);//先读取一次while (len > 0) {out.write(buff, 0, len);len = in.read(buff);//再继续读取}} catch (Exception e) {e.printStackTrace();} finally {//4):关闭资源(勿忘)try {if (out != null) {out.close();}} catch (Exception e) {e.printStackTrace();}try {if (in != null) {in.close();}} catch (Exception e) {e.printStackTrace();}}//--------------------------------------------//ctrl+alt+t//Java7的新特性//如果资源对象实现了Closeable接口,那么可以不用手动关闭资源了//开发者只需要指定需要关闭的资源对象即可try (//定义需要关闭的资源对象FileReader reader = new FileReader("files/before.txt");FileWriter writer = new FileWriter("files/after.txt");){//从指定文件中读取数据,立即将读到的数据写到指定的文件中char[] buffer = new char[1024];int len = 0;while((len = reader.read(buffer)) != -1){//将读到的数据(buffer)写到指定的文件中writer.write(buffer, 0, len);}} catch (IOException e) {e.printStackTrace();}
}

八、文件流

当程序需要读取文件中的数据或者把数据保存到文件中去，此时就得使用文件流，但是注意只能操作纯文本文件（txt格式），不要使用Word、Excel。文件流比较常用。

8.1、文件字节输出流（FileOutputStream）

private static void test1() throws Exception {//1):创建源或者目标对象File dest = new File("file/result1.txt");//2):创建IO流对象FileOutputStream out = new FileOutputStream(dest);//3):具体的IO操作out.write(65);//输出Aout.write(66);//输出Bout.write(67);//输出CString str = "to be or not to be";out.write(str.getBytes());//输出str字符串中所有内容//4):关闭资源(勿忘)out.close();
}

8.2、文件字节输入流（FileInputStream）

private static void test2() throws Exception {//1):创建源或者目标对象File src = new File("file/result1.txt");//2):创建IO流对象FileInputStream in = new FileInputStream(src);//3):具体的IO操作System.out.println((char)in.read());//读取A字节System.out.println((char)in.read());//读取B字节System.out.println((char)in.read());//读取C字节byte[] buff = new byte[5];//准备容量为5的缓冲区int len = in.read(buff);//读取5个字节数据,并存储到buff数组中System.out.println(Arrays.toString(buff));//[116, 111, 32, 98, 101]System.out.println(len);//返回读取了几个字节//4):关闭资源(勿忘)in.close();
}

8.3、文件字符输出流（FileWriter）

private static void test3() throws Exception {//1):创建源或者目标对象File dest = new File("file/result2.txt");//2):创建IO流对象FileWriter out = new FileWriter(dest);//3):具体的IO操作out.write('辛');//输出Aout.write('弃');//输出Bout.write('疾');//输出CString str = "众里寻他千百度，蓦然回首，那人却在，灯火阑珊处。";out.write(str.toCharArray());out.write(str);//String的本质就是char[]//4):关闭资源(勿忘)out.close();
}

8.4、文件字符输入流（FileReader）

private static void test4() throws Exception {//1):创建源或者目标对象File src = new File("file/result2.txt");//2):创建IO流对象FileReader in = new FileReader(src);//3):具体的IO操作System.out.println(in.read());//读取辛字符System.out.println(in.read());//读取弃字符System.out.println(in.read());//读取疾字符char[] buff = new char[5];//准备容量为5的缓冲区int len = in.read(buff);//读取5个字符数据,并存储到buff数组中System.out.println(Arrays.toString(buff));//[众, 里, 寻, 他, 千]System.out.println(len);//返回读取了几个字节//4):关闭资源(勿忘)in.close();
}

九、缓冲流

节点流的功能都比较单一，性能较低。处理流，也称之为包装流，相对于节点流更高级，这里存在一个设计模式——装饰设计模式。有了包装流之后，我们只关心包装流的操作即可，比如只需要关闭包装流即可，无需在关闭节点流。

四大基流都有自己的包装流

BufferedInputStream / BufferedOutputStream / BufferedReader / BufferedWriter

缓冲流内置了一个默认大小为8192个字节或字符的缓存区，缓冲区的作用用来减少磁盘的IO操作，拿字节缓冲流举例，比如一次性读取8192个字节到内存中，或者存满8192个字节再输出到磁盘中，操作数据量比较大的流，都建议使用上对应的缓存流。

private static void copy3() throws Exception {//1):创建源或者目标对象File src = new File("file/郭德纲-报菜名.mp3");File dest = new File("file/郭德纲-报菜名2.mp3");//2):创建IO流对象BufferedInputStream bis =
new BufferedInputStream(new FileInputStream(src), 8192);BufferedOutputStream bos =
new BufferedOutputStream(new FileOutputStream(dest), 8192);//3):具体的IO操作int len = -1;//记录以及读取了多个字符byte[] buff = new byte[1024];//每次可以读取1024个字符len = bis.read(buff);//先读取一次while (len > 0) {//边读边写bos.write(buff, 0, len);len = bis.read(buff);//再继续读取}//4):关闭资源(勿忘)bos.close();bis.close();
}

十、字节流和字符流如何选用

使用记事本打开某个文件，如果可以看到内容的就是文本文件，否则可以暂时认为是二进制格式的。

一般的，操作二进制文件（图片、音频、视频等）必须使用字节流。操作文本文件使用字符流，尤其是操作带有中文的文件，使用字符流不容易导致乱码，因为使用字节流可能出现读取半个汉字的尴尬（汉字由两个或三个字节组成）。当然，如果不清楚属于哪一类型文件，都可以使用字节流。

十一、对象序列化

序列化是指把Java堆内存中的对象数据，通过某种方式把对象数据存储到磁盘文件中或者传递给给网络上传输。序列化在分布式系统在应用非常广泛。

相反的也有反序列化：把磁盘文件中的对象的数据或者把网络节点上的对象数据恢复成Java对象的过程。

如果想做序列化的类必须实现序列化接口java.io.Serializable（这是标志接口，里面并没有抽象方法），如果字段使用transient 修饰则不会被序列化。

一文搞定Java IO流√相关推荐

java+输出流++空值_一文搞定Java的输入输出流等常见流
点赞再看,养成习惯,常用流,多看多练准没错!文章较长,建议收藏再看! 1.IO流分析什么是IO? I:Input O:Output 通过IO可以完成对硬盘的读和写. IO流的分类. 有多种分类方式: ...
用几段代码搞定Java文件流
Java文件流 File类篇 1.File类在学习File类之前,需要知道的有以下两点: (1)File类是java.io包下的一个类 (2)应该将File理解成路径而不是文件我们学习File,首 ...
【Java】一文搞定Java反射技术
Java基础之反射一.类加载器 1.类的加载 2.类的加载时机(进入内存) 3.类加载器 4.类加载器的组成二.反射 1.Class类 2.通过反射获取构造方法并使用三.反射练习 1.泛型擦除 ...
一文搞定Java热更新
Java热更新在持续交付的时代,重新部署一个新的版本只需要点击一下按钮.但在有的情况下,重新部署过程可能比较复杂,停机是不被允许的.所以JVM提供了另外一种选择:在不重启应用的前提下进行小幅改动,又 ...
reactor线程模型_面试一文搞定JAVA的网络IO模型
1,最原始的BIO模型该模型的整体思路是有一个独立的Acceptor线程负责监听客户端的链接,它接收到客户端链接请求之后为每个客户端创建一个新的线程进行链路处理,处理完成之后,通过输出流返回应答给客 ...
一文搞定Java集合类，你还在为Java集合类而烦恼吗？
导读:你还在为集合类而烦恼吗?别担心,我花了几天时间整理了一下集合类,文章通俗易懂,看完这篇文章保证让你茅塞顿开.内容很全,所以文章有点长,建议收藏再看. 文章目录 1.什么是集合,要她作甚? 2.集 ...
接收大文件流_一文搞定 Node.js 流（Stream）
stream(流)是一种抽象的数据结构.就像数组或字符串一样,流是数据的集合. 不同的是,流可以每次输出少量数据,而且它不用存在内存中. 比如,对服务器发起 http 请求的 request/resp ...
php带参数单元测试_一文搞定单元测试核心概念
基础概念单元测试(unittesting),是指对软件中的最小可测试单元进行检查和验证,这里的最小可测试单元通常是指函数或者类.单元测试是即所谓的白盒测试,一般由开发人员负责测试,因为开发人员知道被 ...
一文搞定C#关于NPOI类库的使用读写Excel以及io流文件的写出
一文搞定C#关于NPOI类库的使用读写Excel以及io流文件的写出今天我们使用NPOI类库读写xlsx文件, 最终实现的效果如图所示从太平洋官网下载相应的类库,大概4~5MB,不要从github ...

一文搞定Java IO流√

目录