基础复习第二十三天 File类与IO流的使用

创始人

2024-05-29 02:45:48

0次

java.io.File类:

文件或文件目录路径的抽象表现形式，与平台无关。

概述

File能新建、删除、重命名文件或目录，但File不能访问文件内容本身。如果需要访问文件内容本身，则需要使用输入/输出流。

想要在Java程序中表示一个真实存在的文件或目录，那么必须有一个File对象，但是Java程序中的一个File对象，可能没有一个真实存在的文件或目录。

File对象可以作为参数传递给流的构造器。

在API中File的解释是文件和目录路径名的抽象表示形式，即File类是文件或目录的路径，而不是文件本身，因此File类不能直接访问文件内容本身，如果需要访问文件内容本身，则需要使用输入/输出流。

File类代表磁盘或网络中某个文件或目录的路径名称，如：/javase/io/叮咚.jpg
但不能直接通过File对象读取和写入数据，如果要操作数据，需要IO流。File对象好比是到水库的“路线地址”，要“存取”里面的水到你“家里”，需要“管道”。

构造方法

File类的实例化方式:

public File(String pathname):通过将给定的路径名字符串转换为抽象路径名来创建新的 File 实例。

public File(String parent, String child):从父路径名字符串和子路径名字符串创建新的 File 实例。

public File(File parent, String child):从父抽象路径名和子路径名字符串创建新的 File 实例。

 @Testpublic void test1(){//File类的实例化方式://1.public File(String pathname):通过将给定的路径名字符串转换为抽象路径名来创建新的 File 实例。File file1 = new File("D:\\Application\\workspaces1");System.out.println(file1);//2.public File(String parent, String child):从父路径名字符串和子路径名字符串创建新的 File 实例。File file2 = new File("D:\\Application\\workspaces1","\\test\\mo");System.out.println(file2);//3.public File(File parent, String child):从父抽象路径名和子路径名字符串创建新的 File 实例。File file3 = new File(file2,"\\tt\\hh.text");System.out.println(file3);}

File类的获取功能

一个File对象代表硬盘中实际存在的一个文件或者目录。
无论该路径下是否存在文件或者目录，都不影响File对象的创建

File类的获取功能:
File getAbsoluteFile():返回此抽象路径名的绝对形式。等效于 new File（this.getAbsolutePath）。
String getAbsolutePath():返回此抽象路径名的绝对路径名字符串。
long getFreeSpace():返回由此抽象路径名命名的分区中未分配的字节数。
String getName():返回由此抽象路径名表示的文件或目录的名称。
String getParent():返回此抽象路径名的父级的路径名字符串，如果此路径名未命名父目录，则返回 null。
File getParentFile():返回此抽象路径名的父级的抽象路径名，如果此路径名未命名父目录，则返回 null。
String getPath():将此抽象路径名转换为路径名字符串。
long getTotalSpace():返回由此抽象路径名命名的分区的大小。
long getUsableSpace():返回此抽象路径名命名的分区上此虚拟机可用的字节数。
long lastModified():返回此抽象路径名所表示的文件上次修改的时间。
long length():返回由此抽象路径名表示的文件的长度。如果此路径名表示目录，则未指定返回值。
public String[] list():返回一个字符串数组，用于命名此抽象路径名所表示的目录中的文件和目录。
public File[] listFiles():返回一个抽象路径名数组，该数组表示此抽象路径名所表示的目录中的文件。

{//实例化File file1 = new File("D:\\es-windows\\helloworld.txt");//1.public File getAbsoluteFile():返回此抽象路径名的绝对形式。等效于 new File（this.getAbsolutePath）。File absoluteFile = file1.getAbsoluteFile();//2.public String getAbsolutePath():返回此抽象路径名的绝对路径名字符串。String absolutePath = file1.getAbsolutePath();System.out.println(absoluteFile);System.out.println(absolutePath);//3.public long getFreeSpace():返回由此抽象路径名命名的分区中未分配的字节数。System.out.println(file1.getFreeSpace());
//        4.String getName():返回由此抽象路径名表示的文件或目录的名称。
//        5.String getParent():返回此抽象路径名的父级的路径名字符串，如果此路径名未命名父目录，则返回 null。
//        6.File getParentFile():返回此抽象路径名的父级的抽象路径名，如果此路径名未命名父目录，则返回 null。
//        7.String getPath():将此抽象路径名转换为路径名字符串。System.out.println(file1.getName());//helloworld.txtSystem.out.println(file1.getParent());//D:\es-windowsSystem.out.println(file1.getPath());//D:\es-windows\helloworld.txtSystem.out.println(file1.getParentFile());//D:\es-windows/*long getTotalSpace():返回由此抽象路径名命名的分区的大小。即当前文件所在分区的总大小(字节数)long getUsableSpace():返回此抽象路径名命名的分区上此虚拟机可用的字节数。即当前文件所在分区还可用容量大小(字节数)*/System.out.println(file1.getTotalSpace());System.out.println(file1.getUsableSpace());/*long lastModified():返回此抽象路径名所表示的文件上次修改的时间。毫秒数long length():返回由此抽象路径名表示的文件的长度。如果此路径名表示目录，则未指定返回值。字节数*/System.out.println(file1.length());//17long modified = file1.lastModified();System.out.println(modified);//1677578261068System.out.println(new Date(modified));//Tue Feb 28 17:57:41 CST 2023File file2 = new File("D:\\es-windows");/*public String[] list():返回一个字符串数组，用于命名此抽象路径名所表示的目录中的文件和目录。public File[] listFiles():返回一个抽象路径名数组，该数组表示此抽象路径名所表示的目录中的文件。*/System.out.println("=============");String[] list = file2.list();for(String s1:list){System.out.println(s1);}System.out.println("=============");File[] files = file2.listFiles();for(File s2:files){System.out.println(s2);}}

File类的重命名功能

File类的重命名功能:
public boolean renameTo(File dest)：重命名此抽象路径名表示的文件。将当前文件名重新命名为dest文件路径所在的名字
例如:file1.renameTo(file2):
要想保证返回值为true，则必须保证file1在硬盘的对应路径下必须存在，且file2在硬盘的对应路径下不能存在。

  /*** File类的重命名功能:* public boolean renameTo(File dest)：重命名此抽象路径名表示的文件。将当前文件名重新命名为dest文件路径所在的名字* 例如:file1.renameTo(file2):* 要想保证返回值为true，则必须保证file1在硬盘的对应路径下必须存在，且file2在硬盘的对应路径下不能存在。*/@Testpublic void test3(){File file1 = new File("abc.text");File file2 = new File("D:\\es-windows\\helloworld.txt");boolean b = file1.renameTo(file2);System.out.println(b);//true}

File类的判断功能

File类的判断功能:
boolean isDirectory():判断此抽象路径名表示的文件是否为目录。
boolean isFile():判断此抽象路径名表示的文件是否为普通文件。
boolean exists():判断此抽象路径名表示的文件或目录是否存在。
boolean canRead():判断该文件或目录是否为可读。
boolean canWrite():判断该文件或目录是否为可写。
boolean isHidden():判断该文件或目录是否为隐藏文件。

 @Testpublic void test4() {//当该文件是一个普通文件时File file1 = new File("day23.iml");boolean file1Directory = file1.isDirectory();boolean file1File = file1.isFile();boolean exists = file1.exists();boolean canRead = file1.canRead();boolean canWrite = file1.canWrite();boolean file1Hidden = file1.isHidden();System.out.println(file1Directory);//falseSystem.out.println(file1File);//trueSystem.out.println(exists);//trueSystem.out.println(canRead);//trueSystem.out.println(canWrite);//trueSystem.out.println(file1Hidden);//false}@Testpublic void test5() {//当该文件是一个文件目录时File file1 = new File("D:\\Application");boolean file1Directory = file1.isDirectory();boolean file1File = file1.isFile();boolean exists = file1.exists();boolean canRead = file1.canRead();boolean canWrite = file1.canWrite();boolean file1Hidden = file1.isHidden();System.out.println(file1Directory);//trueSystem.out.println(file1File);//falseSystem.out.println(exists);//trueSystem.out.println(canRead);//trueSystem.out.println(canWrite);//trueSystem.out.println(file1Hidden);//false}

File类的创建功能

File类的创建功能:
boolean createNewFile():创建一个新的空文件，当该文件不存在时。如果文件存在则不创建，并且返回false。
boolean mkdir():创建由此抽象路径名命名的目录。如果该目录的上层目录不存在或该目录已存在，则不创建，返回false。
boolean mkdirs():创建由此抽象路径名命名的目录，如果该目录的上层目录不存在，则创建上层目录和该目录；
如果该目录存在返回false。

/*** File类的创建功能:* boolean createNewFile():创建一个新的空文件，当该文件不存在时。如果文件存在则不创建，并且返回false。* boolean mkdir():创建由此抽象路径名命名的目录。如果该目录的上层目录不存在或该目录已存在，则不创建，返回false。* boolean mkdirs():创建由此抽象路径名命名的目录，如果该目录的上层目录不存在，则创建上层目录和该目录；* 如果该目录存在返回false。*/@Testpublic void test6() throws IOException {File renren = new File("renren.text");//判断文件是否存在if (!renren.exists()) {boolean newFile = renren.createNewFile();System.out.println("创建成功");} else {System.out.println("创建失败");}}@Testpublic void test7() throws IOException {/*boolean mkdir():创建由此抽象路径名命名的目录。如果该目录的上层目录不存在或该目录已存在，则不创建，返回false。boolean mkdirs():创建由此抽象路径名命名的目录，如果该目录的上层目录不存在，则创建上层目录和该目录；如果该目录存在返回false。*/File file = new File("D:\\javacode\\abc\\def\\ddd\\bbb", "\\aaa");//假设该目录的上层目录不存在boolean mkdir1 = file.mkdir();System.out.println(mkdir1);//falseboolean mkdir2 = file.mkdirs();System.out.println(mkdir2);//trueSystem.out.println("=======================");File file2 = new File("D:\\javacode\\abc\\def\\ddd\\bbb\\aaa", "\\lll");//假设该目录的上层目录存在,且该目录不存在boolean mkdir3 = file2.mkdir();System.out.println(mkdir3);//true}

注意:如果要创建的文件或目录没有写盘符路径，那么默认在当前module路径下。

File类的删除功能

File类的删除功能:
public boolean delete():删除此抽象路径名表示的文件或目录。如果此路径名表示目录，则该目录必须为空才能删除。

 /*File类的删除功能:public boolean delete():删除此抽象路径名表示的文件或目录。如果此路径名表示目录，则该目录必须为空才能删除。*/@Testpublic void test8() throws IOException {//当前目录不为空File file2 = new File("D:\\javacode\\abc\\def");System.out.println(file2.delete());//false//当前目录为空File file3 = new File("D:\\javacode\\abc\\def\\ddd\\bbb\\aaa\\lll");System.out.println(file3.delete());//true}

IO流

IO概述

什么是IO

生活中，你肯定经历过这样的场景。当你编辑一个文本文件，忘记了ctrl+s ，可能文件就白白编辑了。当你电脑上插入一个U盘，可以把一个视频，拷贝到你的电脑硬盘里。那么数据都是在哪些设备上的呢？键盘、内存、硬盘、外接设备等等。

我们把这种数据的传输，可以看做是一种数据的流动，按照流动的方向，以内存为基准，分为输入input 和输出output ，即流向内存是输入流，流出内存的输出流。

Java中I/O操作主要是指使用java.io包下的内容，进行输入、输出操作。输入也叫做读取数据，输出也叫做作写出数据。

IO的分类

根据数据的流向分为：输入流和输出流。

输入流：把数据从其他设备上读取到内存中的流。

以InputStream,Reader结尾

输出流：把数据从内存中写出到其他设备上的流。

以OutputStream、Writer结尾

根据数据的类型分为：字节流和字符流。

字节流：以字节为单位，读写数据的流。

以InputStream和OutputStream结尾

字符流：以字符为单位，读写数据的流。

以Reader和Writer结尾

根据IO流的角色不同分为：节点流和处理流。

节点流：可以从或向一个特定的地方（节点）读写数据。如FileReader.

处理流：是对一个已存在的流进行连接和封装，通过所封装的流的功能调用实现数据读写。如BufferedReader.处理流的构造方法总是要带一个其他的流对象做参数。一个流对象经过其他流的多次包装，称为流的链接。

这种设计是装饰模式（Decorator Pattern）也称为包装模式（Wrapper Pattern），其使用一种对客户端透明的方式来动态地扩展对象的功能，它是通过继承扩展功能的替代方案之一。在现实生活中你也有很多装饰者的例子，例如：人需要各种各样的衣着，不管你穿着怎样，但是，对于你个人本质来说是不变的，充其量只是在外面加上了一些装饰，有，“遮羞的”、“保暖的”、“好看的”、“防雨的”...

常用的节点流：　

文件 FileInputStream FileOutputStrean FileReader FileWriter 文件进行处理的节点流。

字符串 StringReader StringWriter 对字符串进行处理的节点流。

数组 ByteArrayInputStream ByteArrayOutputStream CharArrayReader CharArrayWriter 对数组进行处理的节点流（对应的不再是文件，而是内存中的一个数组）。

管道 PipedInputStream、PipedOutputStream、PipedReader、PipedWriter对管道进行处理的节点流。

常用处理流：

缓冲流：BufferedInputStream、BufferedOutputStream、BufferedReader、BufferedWriter---增加缓冲功能，避免频繁读写硬盘。

转换流：InputStreamReader、OutputStreamReader---实现字节流和字符流之间的转换。

数据流：DataInputStream、DataOutputStream -提供读写Java基础数据类型功能

对象流：ObjectInputStream、ObjectOutputStream--提供直接读写Java对象功能

4大顶级抽象父类，也称基类

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

流的体系结构:

抽象基类节点流(也称文件流) 缓冲流(处理流的一种)

InputStream FileInputStream BufferedInputStream

OutputStream FileOutputStream BufferedOutputStream

Reader FileReader BufferedReader

Writer FileWriter BufferedWriter

在main方法和测试方法中读取的相同的文件，但是读取到的路径是不同的。

public static void main(String[] args) {//在main方法中file表示当前工程下File file = new File("renren.text");System.out.println(file.getAbsoluteFile());//D:\Application\workspaces1\test\renren.text}@Testpublic void test1() {//在单元测试方法中file表示当前module下File file = new File("renren.text");System.out.println(file.getAbsoluteFile());//D:\Application\workspaces1\test\day23\renren.text}

读取文件的测试代码

 /*** 文件是以字符存储的，图片是以字节存储的* 将day23下的"renren.text"文件内容读取出来，该文件必须存在，否则会报java.io.FileNotFoundException*/@Testpublic void test2() {//1.实例化，指明要操作的文件File file = new File("renren.text");//2.通过具体的流操作文件内容FileReader fileReader = null;try {/*public class FileReader extends InputStreamReader {}InputStreamReader:是从字节流到字符流的桥梁：它读取字节并使用指定的字符集将它们解码为字符。*/fileReader = new FileReader(file);//3.数据的读取int read = fileReader.read();//读取单个字符。字符读取，如果已到达流的末尾，则为 -1//判断文件内容是否读完，如果返回-1，就是文件内容读完了。while (read != -1) {read = fileReader.read();System.out.print((char) read);//转换为字符输出}} catch (IOException e) {throw new RuntimeException(e);} finally {//如果流不用了，必须手动关闭流try {if (fileReader != null) {fileReader.close();}} catch (IOException e) {throw new RuntimeException(e);}}}

/*** read()的重载方法:* int read(char cbuf[]):返回每次读入cbuf数组中的字符个数，如果已到达流的末尾，则返回-1。*/@Testpublic void test3(){//声明一个字符输入流FileReader fileReader = null;try {//1.File类的实例化File file = new File("renren.text");//2.FileReader流的实例化fileReader = new FileReader(file);//3.读取文件数据//int read(char cbuf[]):将字符读入数组,返回每次读入cbuf数组中的字符的个数；如果已到达流的末尾，则为 -1。char[] cbuf = new char[10];int length = fileReader.read(cbuf);System.out.println(length);//判断文件内容是否读完，读取的字符数，//错误的写法:
//            while (length != -1) {
//                //将每次读取到数组中的所有字符遍历出来
//                for (int i = 0; i < cbuf.length; i++) {//这里的循环条件cbuf.length是错误的
//                    System.out.print(cbuf[i]);//abcdefghijklmnopqrstuvwxyzqrst，文件本身内容是26个小写字母，现在输出的与实际不符；
//                    原因是每次读取的字符个数是固定的10个，当第三次读取的字符个数也是10个，但是文件中只有6个，这里的过程:文件中读取的6个字符替换掉第三次读取的前6个字符，后面的6个字符不变。
//                }
//               length = fileReader.read(cbuf);
//
//            }//正确的写法:while (length != -1) {for (int i = 0; i < length; i++) {System.out.print(cbuf[i]);//abcdefghijklmnopqrstuvwxyz}length = fileReader.read(cbuf);}} catch (IOException e) {throw new RuntimeException(e);} finally {//4.关闭流if (fileReader != null) {try {fileReader.close();} catch (IOException e) {throw new RuntimeException(e);}}}}

写出文件的测试代码

 /*从内存中写出数据到硬盘文件中。说明:1.如果硬盘中不存在该文件，并不会报异常。2.File对应的硬盘中的文件如果不存在，在输出的过程中，会自动创建此文件。File对应的硬盘中的文件如果存在:如果流使用的构造器是FileWriter(file, false)/FileWriter(file):对文件实行的是文件的覆盖操作。如果流使用的构造器是FileWriter(file, true):在文件的末尾实行添加操作。*/@Testpublic void test4()  {FileWriter fileWriter=null;try {//1.提供File的实例对象，指明写出的文件File file = new File("Hello.java");//2.创建写出流的对象，并将File实例作为参数传给流对象，指明流要操作的是哪个文件fileWriter = new FileWriter(file,true);//3.流的写出操作fileWriter.write("I have a dream.\n");fileWriter.write("I have 100 yuan.");} catch (IOException e) {throw new RuntimeException(e);}finally {//4.关闭流if (fileWriter!=null) {try {fileWriter.close();} catch (IOException e) {throw new RuntimeException(e);}}}}

文件的复制操作测试代码

   /*文件的复制操作:第一步:将硬盘中的文件1数据读取到内存中第二部:将读取到内存中的数据写出到硬盘的文件2中。*/@Testpublic void test5() {FileReader fileReader = null;FileWriter fileWriter = null;try {//1.创建File类对象，指明要读取的文件和要写出的文件File file1 = new File("Hello.java");File file2 = new File("Hello2.java");//不能使用字符流来处理图片等字节存储的数据
//            File file1 = new File("u=3354826066,550726194&fm=253&fmt=auto&app=138&f=JPEG.jpg");
//            File file2 = new File("EG.jpg");//2.创建输入流和输出流对象fileReader = new FileReader(file1);fileWriter = new FileWriter(file2);//3.数据的读取操作和写出操作char[] cbuf = new char[6];int len = fileReader.read(cbuf);//记录每次读取到cbuf数组中的字符个数while (len != -1) {//每次写出len个字符fileWriter.write(cbuf,0,len);len = fileReader.read(cbuf);}} catch (IOException e) {throw new RuntimeException(e);} finally {//4.输入流和输出流的关闭；流的关闭规则:先开启的后关闭，后开启的先关闭if (fileWriter != null) {try {fileWriter.close();} catch (IOException e) {throw new RuntimeException(e);}}if (fileReader != null) {try {fileReader.close();} catch (IOException e) {throw new RuntimeException(e);}}}}

注意:不能使用字符流来处理图片等字节存储的数据

图片的复制操作测试代码

   /*图片的复制操作:图片是以字节形式存储的第一步:将硬盘中的图片1数据读取到内存中第二部:将读取到内存中的数据写出到硬盘的图片2中。public int read(byte b[]):返回每次读入b数组中的字节个数，如果已到达流的末尾，则为 -1。*/@Testpublic void test1() {FileInputStream inputStream = null;FileOutputStream outputStream = null;try {//1.创建File类对象，指明要读取的图片和写出的图片File file1 = new File("hh.jpg");File file2 = new File("gg.jpg");//2.创建字节输入流和输出流对象，指明要操作的是哪个图片的数据inputStream = new FileInputStream(file1);outputStream = new FileOutputStream(file2);//3.图片的读取操作和写出操作byte[] b = new byte[50];//每次读取的最大字节个数//public int read(byte b[]):返回每次读入b数组中的字节个数，如果已到达流的末尾，则为 -1。int len;//返回每次读入b数组中的字节个数while ((len = inputStream.read(b)) != -1) {//写出操作outputStream.write(b, 0, len);}} catch (IOException e) {throw new RuntimeException(e);} finally {//4.关闭流if (outputStream != null) {try {outputStream.close();} catch (IOException e) {throw new RuntimeException(e);}}if (inputStream != null) {try {inputStream.close();} catch (IOException e) {throw new RuntimeException(e);}}}}

总结:

对于文本文件(.txt,.java,.c),使用字符流处理。

对于非文本文件(.jpg,.mp3,.mp4)，使用字节流处理

流的关闭规则:先开启的后关闭，后开启的先关闭

字节流

一切皆为字节

一切文件数据(文本、图片、视频等)在存储时，都是以二进制数字的形式保存，都一个一个的字节，那么传输时一样如此。所以，字节流可以传输任意文件数据。在操作流的时候，我们要时刻明确，无论使用什么样的流对象，底层传输的始终为二进制数据。

字节输出流【OutputStream】

java.io.OutputStream抽象类是表示字节输出流的所有类的超类，将指定的字节信息写出到目的地。它定义了字节输出流的基本共性功能方法。

public void close() ：关闭此输出流并释放与此流相关联的任何系统资源。

public void flush() ：刷新此输出流并强制任何缓冲的输出字节被写出。

public void write(byte[] b)：将 b.length字节从指定的字节数组写入此输出流。

public void write(byte[] b, int off, int len) ：从指定的字节数组写入 len字节，从偏移量 off开始输出到此输出流。

public abstract void write(int b) ：将指定的字节输出流。

小贴士：
close方法，当完成流的操作时，必须调用此方法，释放系统资源。

FileOutputStream类

OutputStream有很多子类，我们从最简单的一个子类开始。

java.io.FileOutputStream类是文件输出流，用于将数据写出到文件。

构造方法

public FileOutputStream(File file)：创建文件输出流以写入由指定的 File对象表示的文件。

public FileOutputStream(String name)：创建文件输出流以指定的名称写入文件。

当你创建一个流对象时，必须传入一个文件路径。该路径下，如果没有这个文件，会创建该文件。如果有这个文件，会清空这个文件的数据。

构造举例，代码如下：

public class FileOutputStreamConstructor throws IOException {public static void main(String[] args) {// 使用File对象创建流对象File file = new File("a.txt");FileOutputStream fos = new FileOutputStream(file);// 使用文件名称创建流对象FileOutputStream fos = new FileOutputStream("b.txt");}
}

写出字节数据

写出字节：write(int b) 方法，每次可以写出一个字节数据，代码使用演示：

public class FOSWrite {public static void main(String[] args) throws IOException {// 使用文件名称创建流对象FileOutputStream fos = new FileOutputStream("fos.txt");     // 写出数据fos.write(97); // 写出第1个字节fos.write(98); // 写出第2个字节fos.write(99); // 写出第3个字节// 关闭资源fos.close();}
}
输出结果：
abc

小贴士：
虽然参数为int类型四个字节，但是只会保留一个字节的信息写出。
流操作完毕后，必须释放系统资源，调用close方法，千万记得。

写出字节数组：write(byte[] b)，每次可以写出数组中的数据，代码使用演示：

public class FOSWrite {public static void main(String[] args) throws IOException {// 使用文件名称创建流对象FileOutputStream fos = new FileOutputStream("fos.txt");     // 字符串转换为字节数组byte[] b = "尚硅谷".getBytes();// 写出字节数组数据fos.write(b);// 关闭资源fos.close();}
}
输出结果：
尚硅谷

写出指定长度字节数组：write(byte[] b, int off, int len) ,每次写出从off索引开始，len个字节，代码使用演示：

public class FOSWrite {public static void main(String[] args) throws IOException {// 使用文件名称创建流对象FileOutputStream fos = new FileOutputStream("fos.txt");     // 字符串转换为字节数组byte[] b = "abcde".getBytes();// 写出从索引2开始，2个字节。索引2是c，两个字节，也就是cd。fos.write(b,2,2);// 关闭资源fos.close();}
}
输出结果：
cd

数据追加续写

经过以上的演示，每次程序运行，创建输出流对象，都会清空目标文件中的数据。如何保留目标文件中数据，还能继续添加新数据呢？

public FileOutputStream(File file, boolean append)：创建文件输出流以写入由指定的 File对象表示的文件。

public FileOutputStream(String name, boolean append)：创建文件输出流以指定的名称写入文件。

这两个构造方法，参数中都需要传入一个boolean类型的值，true 表示追加数据，false 表示清空原有数据。这样创建的输出流对象，就可以指定是否追加续写了，代码使用演示：

public class FOSWrite {public static void main(String[] args) throws IOException {// 使用文件名称创建流对象FileOutputStream fos = new FileOutputStream("fos.txt"，true);     // 字符串转换为字节数组byte[] b = "abcde".getBytes();// 写出从索引2开始，2个字节。索引2是c，两个字节，也就是cd。fos.write(b);// 关闭资源fos.close();}
}
文件操作前：cd
文件操作后：cdabcde

写出换行

Windows系统里，换行符号是\r\n 。把

以指定是否追加续写了，代码使用演示：

public class FOSWrite {public static void main(String[] args) throws IOException {// 使用文件名称创建流对象FileOutputStream fos = new FileOutputStream("fos.txt");  // 定义字节数组byte[] words = {97,98,99,100,101};// 遍历数组for (int i = 0; i < words.length; i++) {// 写出一个字节fos.write(words[i]);// 写出一个换行, 换行符号转成数组写出fos.write("\r\n".getBytes());}// 关闭资源fos.close();}
}输出结果：
a
b
c
d
e

回车符\r和换行符\n ：
回车符：回到一行的开头（return）。
换行符：下一行（newline）。
系统中的换行：
Windows系统里，每行结尾是回车+换行，即\r\n；
Unix系统里，每行结尾只有换行，即\n；
Mac系统里，每行结尾是回车，即\r。从 Mac OS X开始与Linux统一。

字节输入流【InputStream】

java.io.InputStream抽象类是表示字节输入流的所有类的超类，可以读取字节信息到内存中。它定义了字节输入流的基本共性功能方法。

public void close() ：关闭此输入流并释放与此流相关联的任何系统资源。

public abstract int read()：从输入流读取数据的下一个字节。

public int read(byte[] b)：从输入流中读取一些字节数，并将它们存储到字节数组 b中。

小贴士：
close方法，当完成流的操作时，必须调用此方法，释放系统资源。

FileInputStream类

java.io.FileInputStream类是文件输入流，从文件中读取字节。

构造方法

FileInputStream(File file)：通过打开与实际文件的连接来创建一个 FileInputStream ，该文件由文件系统中的 File对象 file命名。

FileInputStream(String name)：通过打开与实际文件的连接来创建一个 FileInputStream ，该文件由文件系统中的路径名 name命名。

当你创建一个流对象时，必须传入一个文件路径。该路径下，如果没有该文件,会抛出FileNotFoundException 。

构造举例，代码如下：

public class FileInputStreamConstructor throws IOException{public static void main(String[] args) {// 使用File对象创建流对象File file = new File("a.txt");FileInputStream fis = new FileInputStream(file);// 使用文件名称创建流对象FileInputStream fis = new FileInputStream("b.txt");}
}

读取字节数据

读取字节：read方法，每次可以读取一个字节的数据，提升为int类型，读取到文件末尾，返回-1，代码使用演示：

public class FISRead {public static void main(String[] args) throws IOException{// 使用文件名称创建流对象FileInputStream fis = new FileInputStream("read.txt");// 读取数据，返回一个字节int read = fis.read();System.out.println((char) read);read = fis.read();System.out.println((char) read);read = fis.read();System.out.println((char) read);read = fis.read();System.out.println((char) read);read = fis.read();System.out.println((char) read);// 读取到末尾,返回-1read = fis.read();System.out.println( read);// 关闭资源fis.close();}
}
输出结果：
a
b
c
d
e
-1

循环改进读取方式，代码使用演示：

public class FISRead {public static void main(String[] args) throws IOException{// 使用文件名称创建流对象FileInputStream fis = new FileInputStream("read.txt");// 定义变量，保存数据int b ；// 循环读取while ((b = fis.read())!=-1) {System.out.println((char)b);}// 关闭资源fis.close();}
}
输出结果：
a
b
c
d
e

小贴士：
虽然读取了一个字节，但是会自动提升为int类型。
流操作完毕后，必须释放系统资源，调用close方法，千万记得。

使用字节数组读取：read(byte[] b)，每次读取b的长度个字节到数组中，返回读取到的有效字节个数，读取到末尾时，返回-1 ，代码使用演示：

public class FISRead {public static void main(String[] args) throws IOException{// 使用文件名称创建流对象.FileInputStream fis = new FileInputStream("read.txt"); // 文件中为abcde// 定义变量，作为有效个数int len ；// 定义字节数组，作为装字节数据的容器   byte[] b = new byte[2];// 循环读取while (( len= fis.read(b))!=-1) {// 每次读取后,把数组变成字符串打印System.out.println(new String(b));}// 关闭资源fis.close();}
}输出结果：
ab
cd
ed

错误数据d，是由于最后一次读取时，只读取一个字节e，数组中，上次读取的数据没有被完全替换，所以要通过len ，获取有效的字节，代码使用演示：

public class FISRead {public static void main(String[] args) throws IOException{// 使用文件名称创建流对象.FileInputStream fis = new FileInputStream("read.txt"); // 文件中为abcde// 定义变量，作为有效个数int len ；// 定义字节数组，作为装字节数据的容器   byte[] b = new byte[2];// 循环读取while (( len= fis.read(b))!=-1) {// 每次读取后,把数组的有效字节部分，变成字符串打印System.out.println(new String(b，0，len));//  len 每次读取的有效字节个数}// 关闭资源fis.close();}
}输出结果：
ab
cd
e

小贴士：
使用数组读取，每次读取多个字节，减少了系统间的IO操作次数，从而提高了读写的效率，建议开发中使用。

字符流

当使用字节流读取文本文件时，可能会有一个小问题。就是遇到中文字符时，可能不会显示完整的字符，那是因为一个中文字符可能占用多个字节存储。所以Java提供一些字符流类，以字符为单位读写数据，专门用于处理文本文件。

字符输入流【Reader】

java.io.Reader抽象类是表示用于读取字符流的所有类的超类，可以读取字符信息到内存中。它定义了字符输入流的基本共性功能方法。

public void close() ：关闭此流并释放与此流相关联的任何系统资源。

public int read()：从输入流读取一个字符。

public int read(char[] cbuf)：从输入流中读取一些字符，并将它们存储到字符数组 cbuf中。

FileReader类

java.io.FileReader类是读取字符文件的便利类。构造时使用系统默认的字符编码和默认字节缓冲区。

小贴士：
字符编码：字节与字符的对应规则。Windows系统的中文编码默认是GBK编码表。
eclipse中默认GBK，idea中默认UTF-8
字节缓冲区：一个字节数组，用来临时存储字节数据。

构造方法

FileReader(File file)：创建一个新的 FileReader ，给定要读取的File对象。

FileReader(String fileName)：创建一个新的 FileReader ，给定要读取的文件的名称。

当你创建一个流对象时，必须传入一个文件路径。类似于FileInputStream 。

构造举例，代码如下：

public class FileReaderConstructor throws IOException{public static void main(String[] args) {// 使用File对象创建流对象File file = new File("a.txt");FileReader fr = new FileReader(file);// 使用文件名称创建流对象FileReader fr = new FileReader("b.txt");}
}

读取字符数据

读取字符：read方法，每次可以读取一个字符的数据，提升为int类型，读取到文件末尾，返回-1，循环读取，代码使用演示：

public class FRRead {public static void main(String[] args) throws IOException {// 使用文件名称创建流对象FileReader fr = new FileReader("read.txt");// 定义变量，保存数据int b ；// 循环读取while ((b = fr.read())!=-1) {System.out.println((char)b);}// 关闭资源fr.close();}
}
输出结果：
尚
硅
谷

小贴士：虽然读取了一个字符，但是会自动提升为int类型。

使用字符数组读取：read(char[] cbuf)，每次读取b的长度个字符到数组中，返回读取到的有效字符个数，读取到末尾时，返回-1 ，代码使用演示：

public class FRRead {public static void main(String[] args) throws IOException {// 使用文件名称创建流对象FileReader fr = new FileReader("read.txt");// 定义变量，保存有效字符个数int len ；// 定义字符数组，作为装字符数据的容器char[] cbuf = new char[2];// 循环读取while ((len = fr.read(cbuf))!=-1) {System.out.println(new String(cbuf));}// 关闭资源fr.close();}
}
输出结果：
尚硅
谷硅

获取有效的字符改进，代码使用演示：

public class FISRead {public static void main(String[] args) throws IOException {// 使用文件名称创建流对象FileReader fr = new FileReader("read.txt");// 定义变量，保存有效字符个数int len ；// 定义字符数组，作为装字符数据的容器char[] cbuf = new char[2];// 循环读取while ((len = fr.read(cbuf))!=-1) {System.out.println(new String(cbuf,0,len));}// 关闭资源fr.close();}
}输出结果：
尚硅
谷

字符输出流【Writer】

java.io.Writer抽象类是表示用于写出字符流的所有类的超类，将指定的字符信息写出到目的地。它定义了字节输出流的基本共性功能方法。

void write(int c) 写入单个字符。

void write(char[] cbuf)写入字符数组。

abstract void write(char[] cbuf, int off, int len)写入字符数组的某一部分,off数组的开始索引,len写的字符个数。

void write(String str)写入字符串。

void write(String str, int off, int len) 写入字符串的某一部分,off字符串的开始索引,len写的字符个数。

void flush()刷新该流的缓冲。

void close() 关闭此流，但要先刷新它。

FileWriter类

java.io.FileWriter类是写出字符到文件的便利类。构造时使用系统默认的字符编码和默认字节缓冲区。

构造方法

FileWriter(File file)：创建一个新的 FileWriter，给定要读取的File对象。

FileWriter(String fileName)：创建一个新的 FileWriter，给定要读取的文件的名称。

当你创建一个流对象时，必须传入一个文件路径，类似于FileOutputStream。

构造举例，代码如下：

public class FileWriterConstructor {public static void main(String[] args) throws IOException {// 使用File对象创建流对象File file = new File("a.txt");FileWriter fw = new FileWriter(file);// 使用文件名称创建流对象FileWriter fw = new FileWriter("b.txt");}
}

本写出数据

写出字符：write(int b) 方法，每次可以写出一个字符数据，代码使用演示：

public class FWWrite {public static void main(String[] args) throws IOException {// 使用文件名称创建流对象FileWriter fw = new FileWriter("fw.txt");     // 写出数据fw.write(97); // 写出第1个字符fw.write('b'); // 写出第2个字符fw.write('C'); // 写出第3个字符fw.write(30000); // 写出第4个字符，中文编码表中30000对应一个汉字。/*【注意】关闭资源时,与FileOutputStream不同。如果不关闭,数据只是保存到缓冲区，并未保存到文件。*/// fw.close();}
}
输出结果：
abC田

小贴士：
虽然参数为int类型四个字节，但是只会保留一个字符的信息写出。
未调用close方法，数据只是保存到了缓冲区，并未写出到文件中。

关闭和刷新

因为内置缓冲区的原因，如果不关闭输出流，无法写出字符到文件中。但是关闭的流对象，是无法继续写出数据的。如果我们既想写出数据，又想继续使用流，就需要flush 方法了。

flush ：刷新缓冲区，流对象可以继续使用。

close:先刷新缓冲区，然后通知系统释放资源。流对象不可以再被使用了。

代码使用演示：

public class FWWrite {public static void main(String[] args) throws IOException {// 使用文件名称创建流对象FileWriter fw = new FileWriter("fw.txt");// 写出数据，通过flushfw.write('刷'); // 写出第1个字符fw.flush();fw.write('新'); // 继续写出第2个字符，写出成功fw.flush();// 写出数据，通过closefw.write('关'); // 写出第1个字符fw.close();fw.write('闭'); // 继续写出第2个字符,【报错】java.io.IOException: Stream closedfw.close();}
}

小贴士：即便是flush方法写出了数据，操作的最后还是要调用close方法，释放系统资源。

写出其他数据

写出字符数组：write(char[] cbuf) 和 write(char[] cbuf, int off, int len) ，每次可以写出字符数组中的数据，用法类似FileOutputStream，代码使用演示：

public class FWWrite {public static void main(String[] args) throws IOException {// 使用文件名称创建流对象FileWriter fw = new FileWriter("fw.txt");     // 字符串转换为字节数组char[] chars = "尚硅谷".toCharArray();// 写出字符数组fw.write(chars); // 尚硅谷// 写出从索引1开始，2个字节。索引1是'硅'，两个字节，也就是'硅谷'。fw.write(b,1,2); // 硅谷// 关闭资源fos.close();}
}

写出字符串：write(String str) 和 write(String str, int off, int len) ，每次可以写出字符串中的数据，更为方便，代码使用演示：

public class FWWrite {public static void main(String[] args) throws IOException {// 使用文件名称创建流对象FileWriter fw = new FileWriter("fw.txt");     // 字符串String msg = "尚硅谷";// 写出字符数组fw.write(msg); //尚硅谷// 写出从索引1开始，2个字节。索引1是'硅'，两个字节，也就是'硅谷'。fw.write(msg,1,2);    // 尚硅谷// 关闭资源fos.close();}
}

续写和换行：操作类似于FileOutputStream。

public class FWWrite {public static void main(String[] args) throws IOException {// 使用文件名称创建流对象，可以续写数据FileWriter fw = new FileWriter("fw.txt"，true);     // 写出字符串fw.write("尚");// 写出换行fw.write("\r\n");// 写出字符串fw.write("硅谷");// 关闭资源fw.close();}
}
输出结果:
尚
硅谷

小贴士：字符流，只能操作文本文件，不能操作图片，视频等非文本文件。
当我们单纯读或者写文本文件时使用字符流其他情况使用字节流

缓冲流

缓冲流,也叫高效流，按照数据类型分类：

字节缓冲流：BufferedInputStream，BufferedOutputStream

字符缓冲流：BufferedReader，BufferedWriter

缓冲流的基本原理，是在创建流对象时，会创建一个内置的默认大小的缓冲区数组，通过缓冲区读写，减少系统IO次数，从而提高读写的效率。

字节缓冲流

构造方法

public BufferedInputStream(InputStream in) ：创建一个新的缓冲输入流。

public BufferedOutputStream(OutputStream out)：创建一个新的缓冲输出流。

构造举例，代码如下：

// 创建字节缓冲输入流
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("bis.txt"));
// 创建字节缓冲输出流
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("bos.txt"));

效率测试

查询API，缓冲流读写方法与基本的流是一致的，我们通过复制大文件（375MB），测试它的效率。

基本流，代码如下：

public class BufferedDemo {public static void main(String[] args) throws IOException {// 记录开始时间long start = System.currentTimeMillis();// 创建流对象FileInputStream fis = new FileInputStream("jdk9.exe");FileOutputStream fos = new FileOutputStream("copy.exe");// 读写数据int b;while ((b = fis.read()) != -1) {fos.write(b);}fos.close();fis.close();// 记录结束时间long end = System.currentTimeMillis();System.out.println("普通流复制时间:"+(end - start)+" 毫秒");}
}十几分钟过去了...

缓冲流，代码如下：

public class BufferedDemo {public static void main(String[] args) throws IOException {// 记录开始时间long start = System.currentTimeMillis();// 创建流对象BufferedInputStream bis = new BufferedInputStream(new FileInputStream("jdk9.exe"));BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("copy.exe"));// 读写数据int b;while ((b = bis.read()) != -1) {bos.write(b);}bos.close();bis.close();// 记录结束时间long end = System.currentTimeMillis();System.out.println("缓冲流复制时间:"+(end - start)+" 毫秒");}
}缓冲流复制时间:8016 毫秒

如何更快呢？

使用数组的方式，代码如下：

public class BufferedDemo {public static void main(String[] args) throws IOException {// 记录开始时间long start = System.currentTimeMillis();// 创建流对象BufferedInputStream bis = new BufferedInputStream(new FileInputStream("jdk9.exe"));BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("copy.exe"));// 读写数据int len;byte[] bytes = new byte[8*1024];while ((len = bis.read(bytes)) != -1) {bos.write(bytes, 0 , len);}bos.close();bis.close();// 记录结束时间long end = System.currentTimeMillis();System.out.println("缓冲流使用数组复制时间:"+(end - start)+" 毫秒");}
}
缓冲流使用数组复制时间:666 毫秒

字符缓冲流

构造方法

public BufferedReader(Reader in) ：创建一个新的缓冲输入流。

public BufferedWriter(Writer out)：创建一个新的缓冲输出流。

构造举例，代码如下：

// 创建字符缓冲输入流
BufferedReader br = new BufferedReader(new FileReader("br.txt"));
// 创建字符缓冲输出流
BufferedWriter bw = new BufferedWriter(new FileWriter("bw.txt"));

特有方法

字符缓冲流的基本方法与普通字符流调用方式一致，不再阐述，我们来看它们具备的特有方法。

BufferedReader：public String readLine(): 读一行文字。

BufferedWriter：public void newLine(): 写一行行分隔符,由系统属性定义符号。

readLine方法演示，代码如下：

public class BufferedReaderDemo {public static void main(String[] args) throws IOException {// 创建流对象BufferedReader br = new BufferedReader(new FileReader("in.txt"));// 定义字符串,保存读取的一行文字String line  = null;// 循环读取,读取到最后返回nullwhile ((line = br.readLine())!=null) {System.out.print(line);System.out.println("------");}// 释放资源br.close();}
}

newLine方法演示，代码如下：

public class BufferedWriterDemo throws IOException {public static void main(String[] args) throws IOException  {// 创建流对象BufferedWriter bw = new BufferedWriter(new FileWriter("out.txt"));// 写出数据bw.write("尚");// 写出换行bw.newLine();bw.write("硅");bw.newLine();bw.write("谷");bw.newLine();// 释放资源bw.close();}
}
输出效果:
尚
硅
谷

转换流

字符编码和字符集

字符编码

计算机中储存的信息都是用二进制数表示的，而我们在屏幕上看到的数字、英文、标点符号、汉字等字符是二进制数转换之后的结果。按照某种规则，将字符存储到计算机中，称为编码。反之，将存储在计算机中的二进制数按照某种规则解析显示出来，称为解码。比如说，按照A规则存储，同样按照A规则解析，那么就能显示正确的文本符号。反之，按照A规则存储，再按照B规则解析，就会导致乱码现象。

编码:字符(能看懂的)--字节(看不懂的)

解码:字节(看不懂的)-->字符(能看懂的)

字符编码Character Encoding : 就是一套自然语言的字符与二进制数之间的对应规则。

编码表:生活中文字和计算机中二进制的对应规则

字符集

字符集 Charset：也叫编码表。是一个系统支持的所有字符的集合，包括各国家文字、标点符号、图形符号、数字等。

计算机要准确的存储和识别各种字符集符号，需要进行字符编码，一套字符集必然至少有一套字符编码。常见字符集有ASCII字符集、GBK字符集、Unicode字符集等。

可见，当指定了编码，它所对应的字符集自然就指定了，所以编码才是我们最终要关心的。

ASCII字符集：

ASCII（American Standard Code for Information Interchange，美国信息交换标准代码）是基于拉丁字母的一套电脑编码系统，用于显示现代英语，主要包括控制字符（回车键、退格、换行键等）和可显示字符（英文大小写字符、阿拉伯数字和西文符号）。

基本的ASCII字符集，使用7位（bits）表示一个字符，共128字符。

ASCII的扩展字符集使用8位（bits）表示一个字符，共256字符，方便支持欧洲常用字符。

ISO-8859-1字符集：

拉丁码表，别名Latin-1，用于显示欧洲使用的语言，包括荷兰、丹麦、德语、意大利语、西班牙语等。

ISO-8859-1使用单字节编码，兼容ASCII编码。

GBxxx字符集：

GB就是国标的意思，是为了显示中文而设计的一套字符集。

GB2312：简体中文码表。一个小于127的字符的意义与原来相同。但两个大于127的字符连在一起时，就表示一个汉字，这样大约可以组合了包含7000多个简体汉字，此外数学符号、罗马希腊的字母、日文的假名们都编进去了，连在ASCII里本来就有的数字、标点、字母都统统重新编了两个字节长的编码，这就是常说的"全角"字符，而原来在127号以下的那些就叫"半角"字符了。

GBK：最常用的中文码表。是在GB2312标准基础上的扩展规范，使用了双字节编码方案，共收录了21003个汉字，完全兼容GB2312标准，同时支持繁体汉字以及日韩汉字等。

GB18030：最新的中文码表。收录汉字70244个，采用多字节编码，每个字可以由1个、2个或4个字节组成。支持中国国内少数民族的文字，同时支持繁体汉字以及日韩汉字等。

Unicode字符集：

Unicode编码系统为表达任意语言的任意字符而设计，是业界的一种标准，也称为统一码、标准万国码。

它最多使用4个字节的数字来表达每个字母、符号，或者文字。有三种编码方案，UTF-8、UTF-16和UTF-32。最为常用的UTF-8编码。

UTF-8编码，可以用来表示Unicode标准中任何字符，它是电子邮件、网页及其他存储或传送文字的应用中，优先采用的编码。互联网工程工作小组（IETF）要求所有互联网协议都必须支持UTF-8编码。所以，我们开发Web应用，也要使用UTF-8编码。它使用一至四个字节为每个字符编码，编码规则：

128个US-ASCII字符，只需一个字节编码。

拉丁文等字符，需要二个字节编码。

大部分常用字（含中文），使用三个字节编码。

其他极少使用的Unicode辅助字符，使用四字节编码。

编码引出的问题

在Eclipse中，使用FileReader 读取项目中的文本文件。由于Eclipse的设置UTF-8编码但是，当读取Windows系统中创建的文本文件时，由于Windows系统的默认是GBK编码，就会出现乱码。

public class ReaderDemo {public static void main(String[] args) throws IOException {FileReader fileReader = new FileReader("E:\\File_GBK.txt");int read;while ((read = fileReader.read()) != -1) {System.out.print((char)read);}fileReader.close();}
}
输出结果：
���

那么如何读取GBK编码的文件呢？

InputStreamReader类

转换流java.io.InputStreamReader，是Reader的子类，是从字节流到字符流的桥梁。它读取字节，并使用指定的字符集将其解码为字符。它的字符集可以由名称指定，也可以接受平台的默认字符集。

构造方法

InputStreamReader(InputStream in): 创建一个使用默认字符集的字符流。

InputStreamReader(InputStream in, String charsetName): 创建一个指定字符集的字符流。

构造举例，代码如下：

InputStreamReader isr = new InputStreamReader(new FileInputStream("in.txt"));
InputStreamReader isr2 = new InputStreamReader(new FileInputStream("in.txt") , "GBK");

指定编码读取

public class ReaderDemo2 {public static void main(String[] args) throws IOException {// 定义文件路径,文件为gbk编码String FileName = "E:\\file_gbk.txt";// 创建流对象,默认UTF8编码InputStreamReader isr = new InputStreamReader(new FileInputStream(FileName));// 创建流对象,指定GBK编码InputStreamReader isr2 = new InputStreamReader(new FileInputStream(FileName) , "GBK");// 定义变量,保存字符int read;// 使用默认编码字符流读取,乱码while ((read = isr.read()) != -1) {System.out.print((char)read); // ��Һ�}isr.close();// 使用指定编码字符流读取,正常解析while ((read = isr2.read()) != -1) {System.out.print((char)read);// 大家好}isr2.close();}
}

OutputStreamWriter类

转换流java.io.OutputStreamWriter ，是Writer的子类，是从字符流到字节流的桥梁。使用指定的字符集将字符编码为字节。它的字符集可以由名称指定，也可以接受平台的默认字符集。

构造方法

OutputStreamWriter(OutputStream in): 创建一个使用默认字符集的字符流。

OutputStreamWriter(OutputStream in, String charsetName): 创建一个指定字符集的字符流。

构造举例，代码如下：

OutputStreamWriter isr = new OutputStreamWriter(new FileOutputStream("out.txt"));
OutputStreamWriter isr2 = new OutputStreamWriter(new FileOutputStream("out.txt") , "GBK");

指定编码写出

public class OutputDemo {public static void main(String[] args) throws IOException {// 定义文件路径String FileName = "E:\\out.txt";// 创建流对象,默认UTF8编码OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(FileName));// 写出数据osw.write("你好"); // 保存为6个字节osw.close();// 定义文件路径String FileName2 = "E:\\out2.txt";// 创建流对象,指定GBK编码OutputStreamWriter osw2 = new OutputStreamWriter(new FileOutputStream(FileName2),"GBK");// 写出数据osw2.write("你好");// 保存为4个字节osw2.close();}
}

转换流理解图解

转换流是字节与字符间的桥梁！

转换文件编码

将GBK编码的文本文件，转换为UTF-8编码的文本文件。

案例分析

指定GBK编码的转换流，读取文本文件。

使用UTF-8编码的转换流，写出文本文件。

案例实现

public class TransDemo {public static void main(String[] args) {      // 1.定义文件路径String srcFile = "file_gbk.txt";String destFile = "file_utf8.txt";// 2.创建流对象// 2.1 转换输入流,指定GBK编码InputStreamReader isr = new InputStreamReader(new FileInputStream(srcFile) , "GBK");// 2.2 转换输出流,默认utf8编码OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(destFile));// 3.读写数据// 3.1 定义数组char[] cbuf = new char[1024];// 3.2 定义长度int len;// 3.3 循环读取while ((len = isr.read(cbuf))!=-1) {// 循环写出osw.write(cbuf,0,len);}// 4.释放资源osw.close();isr.close();}
}

数据流

前面学习的IO流，在程序代码中，要么将数据直接按照字节处理，要么按照字符处理。那么，如果要在程序中直接处理Java的基础数据类型，怎么办呢？

String name = “巫师”;
int age = 300;
char gender = ‘男’;
int energy = 5000;
double price = 75.5;
boolean relive = true;

完成这个需求，可以使用DataOutputStream进行写，随后用DataInputStream进行读取，而且顺序要一致。

示例代码

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;public class TestData {public void save() throws IOException{String name = "巫师";int age = 300;char gender = '男';int energy = 5000;double price = 75.5;boolean relive = true;DataOutputStream dos = new DataOutputStream(new FileOutputStream("game.dat"));dos.writeUTF(name);dos.writeInt(age);dos.writeChar(gender);dos.writeInt(energy);dos.writeDouble(price);dos.writeBoolean(relive);dos.close();}    public void reload()throws IOException{DataInputStream dis = new DataInputStream(new FileInputStream("game.dat"));String name = dis.readUTF();int age = dis.readInt();char gender = dis.readChar();int energy = dis.readInt();double price = dis.readDouble();boolean relive = dis.readBoolean();System.out.println(name+"," + age + "," + gender + "," + energy + "," + price + "," + relive);dis.close();}
}

重新认识PrintStream和Scanner、System.in和out

PrintStream类

平时我们在控制台打印输出，是调用print方法和println方法完成的，这两个方法都来自于java.io.PrintStream类，该类能够方便地打印各种数据类型的值，是一种便捷的输出方式。

构造方法

public PrintStream(String fileName)：使用指定的文件名创建一个新的打印流。

构造举例，代码如下：

PrintStream ps = new PrintStream("ps.txt")；

改变打印流向

System.out就是PrintStream类型的，只不过它的流向是系统规定的，打印在控制台上。不过，既然是流对象，我们就可以玩一个"小把戏"，改变它的流向

public class PrintDemo {public static void main(String[] args) throws IOException {// 调用系统的打印流,控制台直接输出97System.out.println(97);// 创建打印流,指定文件的名称PrintStream ps = new PrintStream("ps.txt");// 设置系统的打印流流向,输出到ps.txtSystem.setOut(ps);// 调用系统的打印流,ps.txt中输出97System.out.println(97);}
}

Scanner类

构造方法

Scanner(File source) ：构造一个新的 Scanner，它生成的值是从指定文件扫描的。

Scanner(File source, String charsetName) ：构造一个新的 Scanner，它生成的值是从指定文件扫描的。

Scanner(InputStream source) ：构造一个新的 Scanner，它生成的值是从指定的输入流扫描的。

Scanner(InputStream source, String charsetName) ：构造一个新的 Scanner，它生成的值是从指定的输入流扫描的。

常用方法：

boolean hasNextXxx()：如果通过使用nextXxx()方法，此扫描器输入信息中的下一个标记可以解释为默认基数中的一个 Xxx 值，则返回 true。

Xxx nextXxx()：将输入信息的下一个标记扫描为一个Xxx

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Scanner;import org.junit.Test;public class TestFile {@Testpublic void test1() throws IOException {Scanner input = new Scanner(System.in);ArrayList list = new ArrayList<>();while(true){System.out.print("请输入一个单词：");String str = input.nextLine();if("stop".equals(str)){break;}list.add(str);}System.out.println(list);input.close();}@Testpublic void test2() throws IOException {Scanner input = new Scanner(new File("1.txt"));while(input.hasNextLine()){String str = input.nextLine();System.out.println(str);}input.close();}@Testpublic void test3() throws FileNotFoundException{System.setIn(new FileInputStream("1.txt"));Scanner input = new Scanner(System.in);while(input.hasNextLine()){String str = input.nextLine();System.out.println(str);}input.close();}
}

序列化

概述

Java 提供了一种对象序列化的机制。用一个字节序列可以表示一个对象，该字节序列包含该对象的类型和对象中存储的属性等信息。字节序列写出到文件之后，相当于文件中持久保存了一个对象的信息。

反之，该字节序列还可以从文件中读取回来，重构对象，对它进行反序列化。对象的数据、对象的类型和对象中存储的数据信息，都可以用来在内存中创建对象。看图理解序列化：

ObjectOutputStream类

java.io.ObjectOutputStream 类，将Java对象的原始数据类型写出到文件,实现对象的持久存储。

构造方法

public ObjectOutputStream(OutputStream out)：创建一个指定OutputStream的ObjectOutputStream。

构造举例，代码如下：

FileOutputStream fileOut = new FileOutputStream("employee.txt");
ObjectOutputStream out = new ObjectOutputStream(fileOut);

序列化操作

该类必须实现java.io.Serializable 接口，Serializable 是一个标记接口，不实现此接口的类将不会使任何状态序列化或反序列化，会抛出NotSerializableException 。

如果对象的某个属性也是引用数据类型，那么如果该属性也要序列化的话，也要实现Serializable 接口

该类的所有属性必须是可序列化的。如果有一个属性不需要可序列化的，则该属性必须注明是瞬态的，使用transient 关键字修饰。

静态变量的值不会序列化

public class Employee implements java.io.Serializable {public static String company = "尚硅谷";public String name;public String address;public transient int age; // transient瞬态修饰成员,不会被序列化public void addressCheck() {System.out.println("Address  check : " + name + " -- " + address);}
}

写出对象方法

public final void writeObject (Object obj) : 将指定的对象写出。

public class SerializeDemo{public static void main(String [] args)   {Employee e = new Employee();e.name = "zhangsan";e.address = "beiqinglu";e.age = 20; try {// 创建序列化流对象ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("employee.txt"));// 写出对象out.writeObject(e);// 释放资源out.close();fileOut.close();System.out.println("Serialized data is saved"); // 姓名，地址被序列化，年龄没有被序列化。} catch(IOException i)   {i.printStackTrace();}}
}
输出结果：
Serialized data is saved

ObjectInputStream类

ObjectInputStream反序列化流，将之前使用ObjectOutputStream序列化的原始数据恢复为对象。

构造方法

public ObjectInputStream(InputStream in)：创建一个指定InputStream的ObjectInputStream。

反序列化操作1

如果能找到一个对象的class文件，我们可以进行反序列化操作，调用ObjectInputStream读取对象的方法：

public final Object readObject () : 读取一个对象。

public class DeserializeDemo {public static void main(String [] args)   {Employee e = null;try {        // 创建反序列化流FileInputStream fileIn = new FileInputStream("employee.txt");ObjectInputStream in = new ObjectInputStream(fileIn);// 读取一个对象e = (Employee) in.readObject();// 释放资源in.close();fileIn.close();}catch(IOException i) {// 捕获其他异常i.printStackTrace();return;}catch(ClassNotFoundException c)  {// 捕获类找不到异常System.out.println("Employee class not found");c.printStackTrace();return;}// 无异常,直接打印输出System.out.println("Name: " + e.name);    // zhangsanSystem.out.println("Address: " + e.address); // beiqingluSystem.out.println("age: " + e.age); // 0}
}

对于JVM可以反序列化对象，它必须是能够找到class文件的类。如果找不到该类的class文件，则抛出一个 ClassNotFoundException 异常。

反序列化操作2

另外，当JVM反序列化对象时，能找到class文件，但是class文件在序列化对象之后发生了修改，那么反序列化操作也会失败，抛出一个InvalidClassException异常。发生这个异常的原因如下：

该类的序列版本号与从流中读取的类描述符的版本号不匹配

该类包含未知数据类型

Serializable 接口给需要序列化的类，提供了一个序列版本号。serialVersionUID 该版本号的目的在于验证序列化的对象和对应类是否版本匹配。

public class Employee implements java.io.Serializable {// 加入序列版本号private static final long serialVersionUID = 1L;public String name;public String address;// 添加新的属性 ,重新编译, 可以反序列化,该属性赋为默认值.public int eid; public void addressCheck() {System.out.println("Address  check : " + name + " -- " + address);}
}

序列化集合

将存有多个自定义对象的集合序列化操作，保存到list.txt文件中。

反序列化list.txt ，并遍历集合，打印对象信息。

案例分析

把若干学生对象，保存到集合中。

把集合序列化。

反序列化读取时，只需要读取一次，转换为集合类型。

遍历集合，可以打印所有的学生信息

案例实现

public class SerTest {public static void main(String[] args) throws Exception {// 创建 学生对象Student student = new Student("老王", "laow");Student student2 = new Student("老张", "laoz");Student student3 = new Student("老李", "laol");ArrayList arrayList = new ArrayList<>();arrayList.add(student);arrayList.add(student2);arrayList.add(student3);// 序列化操作// serializ(arrayList);// 反序列化  ObjectInputStream ois  = new ObjectInputStream(new FileInputStream("list.txt"));// 读取对象,强转为ArrayList类型ArrayList list  = (ArrayList)ois.readObject();for (int i = 0; i < list.size(); i++ ){Student s = list.get(i);System.out.println(s.getName()+"--"+ s.getPwd());}}private static void serializ(ArrayList arrayList) throws Exception {// 创建 序列化流 ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("list.txt"));// 写出对象oos.writeObject(arrayList);// 释放资源oos.close();}
}

java.io.Externalizable接口

除了Serializable接口之外，还可以实现java.io.Externalizable接口，但是要求重写：

void readExternal(ObjectInput in) void writeExternal(ObjectOutput out)

关于哪些属性序列化和反序列化，由程序员自己定。虽然可以自己决定任意属性的输出和读取，但是还是建议不要输出静态的和transient属性。

学生类：

import java.io.Externalizable;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;public class Student implements Externalizable{private static String school = "atguigu";private String name;private transient int age;private int score;public Student(String name, int age, int score) {super();this.name = name;this.age = age;this.score = score;}public Student() {super();}public static String getSchool() {return school;}public static void setSchool(String school) {Student.school = school;}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;}public int getScore() {return score;}public void setScore(int score) {this.score = score;}@Overridepublic String toString() {return "Student [name=" + name +",age =" +age + ", score=" + score +",schoool = " + school+ "]";}//一下两个方法不是程序员手动调用，而是在对象被序列化和反序列时，IO流自动调用@Overridepublic void writeExternal(ObjectOutput out) throws IOException {//在这个方法中，程序员自己定，哪些属性需要序列化，及其顺序out.writeUTF(school);out.writeUTF(name);out.writeInt(score);out.writeInt(age);}@Overridepublic void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {//读取的顺序要与写的顺序一致school = in.readUTF();name = in.readUTF();score = in.readInt();age = in.readInt();}}

测试类

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;import org.junit.Test;/** 类通过实现 java.io.Serializable 接口以启用其序列化功能。未实现此接口的类将无法使其任何状态序列化或反序列化。*         序列化接口没有方法或字段，仅用于标识可序列化的语义。* * java.io.Externalizable 实例类的唯一特性是可以被写入序列化流中，该类负责保存和恢复实例内容。 *         则它要实现 Externalizable 接口的 writeExternal 和 readExternal 方法。* *  void readExternal(ObjectInput in) *  void writeExternal(ObjectOutput out)  *  *  虽然可以自己决定任意属性的输出和读取，但是还是建议不要输出静态的和transient属性*/
public class TestExternalizable {@Testpublic void in()throws IOException, ClassNotFoundException{FileInputStream fis = new FileInputStream("stu.dat");ObjectInputStream ois = new ObjectInputStream(fis);Object obj = ois.readObject();System.out.println(obj);ois.close();fis.close();}@Testpublic void out()throws IOException{Student student = new Student("张三", 23, 89);Student.setSchool("尚硅谷");FileOutputStream fos = new FileOutputStream("stu.dat");ObjectOutputStream oos = new ObjectOutputStream(fos);oos.writeObject(student);oos.close();fos.close();}
}

NIO:非阻塞IO

词库加载错误:未能找到文件“E:\highferrum_mysql\Configuration\Dict_Stopwords.txt”。

上一篇：训练CV模型常用的方法与技巧

下一篇：汇编基础语法和指令总结+案例（用32位汇编实现插入排序）