Java IO

stream 流是一种抽象概念，它代表了数据的无结构化传递。按照流的方式进行输入输出，数据被当成无结构的字节序或字符序列。从流中取得数据的操作称为提取操作，而向流中添加数据的操作称为插入操作。用来进行输入输出操作的流就称为IO 流。换句话说， IO 流就是以流的方式进行输入输出 ( 读取写入 ) 。

流是一组有顺序的，有起点和终点的字节集合，是对数据传输的总称或抽象。即数据在两设备间的传输称为流，流的本质是数据传输，根据数据传输特性将流抽象为各种类，方便更直观的进行数据操作。

File类使用

java 中我们通过 java.io.File 类实现对文件的基本属性进行操作，包括文件属性读取，文件创建，文件删除，文件添加等等。File 是一个类，那么在使用的时候就需要创建对象，但是 File 类的实例是不可变的，也就是说，一旦创建，由File 对象表示的抽象路径名将永远不会改变 , 也就是说利用构造方法，指定路径名、文件名等来构造File 类的对象，之后调用该对象的 createNewFile() 方法就可以创建出相应的文件。

File 类的对象可以代表一个具体的文件路径，在实际运用种，可以使用绝对路径也可以使用相对路径。

File工具类构造方法

构造方法	说明
new File("d:\test\test.txt")	指定的目录下建立文件，如果路径不存在，则建立虚拟 file 对象
new File("test.txt")	在当前项目根目录下建立文件 test.txt
new File("d:\test")	test 可以是个目录，也可能是个文件
new File("d:\test\","test.dat")	指定目录下，建立指定的文件

File f1=new File("d:\\test\\test.txt"); //指定的目录下建立文件，如果路径不存在，则建立虚拟file对象
File f2=new File("test.txt"); //在当前项目根目录下建立文件 test.txt
File f3=new File("d:\\test");//test可以是个目录，也可能是个文件
File f4=new File("d:\\test\\","test.dat");//指定目录下，建立指定的文件

1. File(String pathname)

通过将给定路径名字符串转换为抽象路径名来创建一个新 File 实例。如果给定字符串是空字符串，那么结果是空抽象路径名。

2. File(File parent, String child)

根据 parent 抽象路径名和 child 路径名字符串创建一个新 File 实例 , 如果 parent 为 null ，则创建一个新的 File 实例，这与调用给定 child 路径名字符串的单参数 File 构造方法的效果一样。否则，parent 抽象路径名用于表示目录， child 路径名字符串用于表示目录或文件。如果 child 路径名字符串是绝对路径名，则用与系统有关的方式将它转换为一个相对路径名。如果 parent 是空抽象路径名，则通过将child 转换为抽象路径名，并根据与系统有关的默认目录解析结果来创建新的 File 实例。否则，将每个路径名字符串转换为一个抽象路径名，并根据父抽象路径名解析子抽象路径名。

3. File(String parent, String child)

parent 指定路径（父目录），可以是 File 类对象也可以是字符串， child 中也可以加入路径层级，但要注意，所用的路径必须存在，不存在的路径不会新建。

静态成员

public static final String pathSeparator; 返回如果当前系统是 windows 返回 \\输出时是一

个 \，如果是Linux系统返回 /

常用方法

方法	说明
File.delete()	删除文件或空目录文件夹目录
File.createNewFile()	创建一个新的空文件
File. mkdir()	创建一个新的空文件夹
File.mkdirs()	批量建立多级目录
File.list()	获取指定目录下的文件和文件夹名称
File.listFiles()	获取指定目录下的文件和文件夹对象
File.exists()	文件或者文件夹是否存在
String getParent()	返回父目录的路径名字符串；如果没有指定父目录，则返回 null
File getParentFile()	返回父目录 File 对象
String getName()	返回文件或文件夹的名称
String getAbsolutePath()	获取绝对路径
String getPath()	返回路径名字符串
long lastModified()	返回文件最后一次被修改的时间
long length()	获取长度 , 字节数
boolean canRead()	判断是否可读
boolean canWrite()	判断是否可写
boolean isHidden()	判断是否隐藏
long getFreeSpace()	返回分区中未分配的字节数
long getTotalSpace()	返回此文件分区大小
long getUsableSpace()	返回占用字节数
int hashCode()	文件哈希码

设置File属性的常用方法

方法	说明
static File[] listRoots()	列出可用的文件系统根
boolean renameTo(File dest)	重命名，剪切粘贴文件，移动文件
boolean setExecutable(boolean executable)	设置执行权限
boolean setExecutable(boolean executable, boolean ownerOnly)	设置其他所有用户的执行权限
boolean setLastModified(long time)	设置最后一次修改时间
boolean setReadable(boolean readable)	设置读权限
boolean setReadable(boolean readable, boolean ownerOnly)	设置其他所有用户的读权限
boolean setWritable(boolean writable)	设置写权限
boolean setWritable(boolean writable, boolean ownerOnly)	设置所有用户的写权限

例

import java.io.File;
public class FileTestDemo{
public static void main(String[] args) throws Exception{
File file = new File("c:\\51gjie.txt");
//返回文件的长度。
System.out.println("length==" + file.length());
//创建文件对象
File file3 = new File("c:\\51gjie", "code");
//判断文件或文件夹是否存在
boolean exists = file3.exists();
if(exists){
file3.delete();//存在就删除
}else{
file3.mkdirs();//不存在就创建
}
//判断该对像是否为一个文件夹。【文件夹必须存在】
boolean isd = file3.isDirectory();
}
}

1. File 类的直接父类是 Object 类。一个 File 类的对象，表示了磁盘上的文件或目录。如果你创建文件或者文件夹忘了写盘符路径，那么，默认在项目根路径下。

2. 在不同的计算机操作系统中，路径分割符号是不同的。 windows 系统的路径分隔符【 \ 】与 Unix 系统的路径分隔符【/ 】不一样

字节流读取

字节流是由字节组成的,字符流是由字符组成的.
Java里字符由两个字节组成.字节流是基本流，主要用在处理二进制数据。
所以字节流是比较常用的，可以可以处理多种不同种类的文件，比如文本文档/音频/视频等等

InputStream抽象类

此抽象类是表示字节输入流的所有类的超类/抽象类,不可创建对象

常用方法：
abstract int read() 从输入流中读取数据的下一个字节
int read(byte[] b) 从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中
int read(byte[] b, int off, int len) 将输入流中最多 len 个数据字节读入 byte 数组,off表示存时的偏移量
void close() 关闭此输入流并释放与该流关联的所有系统资源

FileInputStream子类

直接插在文件上，直接读取文件数据

创建对象
FileInputStream(File file)—直接传文件对象
通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的 File 对象 file 指定FileInputStream(String pathname)—传路径
通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的路径名 name 指定

BufferedInputStream子类

BufferedInputStream 为另一个输入流添加一些功能，在创建BufferedInputStream 时，会创建一个内部缓冲区数组(默认8k大小)。在读取或跳过流中的字节时，可根据需要从包含的输入流再次填充该内部缓冲区，一次填充多个字节。

创建对象
BufferedInputStream(InputStream in)
创建一个 BufferedInputStream 并保存其参数，即输入流 in，以便将来使用。

package cn.tedu.file;import java.io.*;/*本类用于练习字节输入流*/
public class TestIn {public static void main(String[] args) {//method();//字节流的读取method2();//高效字节流的读取}//本方法用于测试高效字节流的读取private static void method2() {//定义一个在本方法中都生效的局部变量in,注意手动初始化，值为nullInputStream in = null;try {//1.创建高效字节输入流对象
//            InputStream in = new BufferedInputStream(
//                    new FileInputStream(new File("E:\\ready\\1.txt")));in = new BufferedInputStream(new FileInputStream("E:\\ready\\1.txt"));//2.使用流进行读取int b;while ((b= in.read())!= -1){System.out.println(b);}} catch (Exception e) {e.printStackTrace();}finally {//关流操作写在finally{}中//3.流用完以后一定要关闭！！！try {in.close();} catch (IOException e) {e.printStackTrace();}}}//本方法用于测试字节流的读取private static void method() {//创建一个在本方法都生效的局部变量注意手动初始化InputStream in = null;try {//1.创建字节输入流对象用于读取//InputStream in = new InputStream();//报错原因：抽象类不可实例化//InputStream in = new FileInputStream(new File("E:\\ready\\1.txt"));in = new FileInputStream("E:\\ready\\1.txt");//2.开始读取/*read()每次调用都会读取一个字节，如果读到了数据的末尾，返回-1*/
//            System.out.println(in.read());
//            System.out.println(in.read());
//            System.out.println(in.read());
//            System.out.println(in.read());//需求：需要循环读取文件中的所有内容，直至读完//定义变量，记录读到的数据int b;while((b=in.read())!= -1){System.out.println(b);}} catch (Exception e) {e.printStackTrace();//打印错误信息/*try-catch结构中的第三个部分：finally{}* 这部分不论是否捕获到异常，是一定会被执行到的代码，常用于关流*/}finally {try {//3.释放资源，流资源用完必须释放！！！in.close();} catch (IOException e) {e.printStackTrace();}}}
}

字符流读取

常用于处理纯文本数据,读写容易出现乱码的现象,在读写时,最好指定编码集为UTF-8

Reader抽象类

用于读取字符流的抽象类。

常用方法：
int read() 读取单个字符
int read(char[] cbuf) 将字符读入数组
abstract int read(char[] cbuf, int off, int len) 将字符读入数组的某一部分
int read(CharBuffer target) 试图将字符读入指定的字符缓冲区
abstract void close() 关闭该流并释放与之关联的所有资源

FileReader子类

用来读取字符文件的便捷类。此类的构造方法假定默认字符编码和默认字节缓冲区大小都是适当的。要自己指定这些值，可以先在 FileInputStream 上构造一个 InputStreamReader。

创建对象
FileReader(String fileName) 在给定从中读取数据的文件名的情况下创建一个新 FileReader
FileReader(File file) 在给定从中读取数据的 File 的情况下创建一个新 FileReader

BufferedReader子类

从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。
可以指定缓冲区的大小，或者可使用默认的大小。大多数情况下，默认值就足够大了。

创建对象
BufferedReader(Reader in) 创建一个使用默认大小输入缓冲区的缓冲字符输入流

package cn.tedu.file;import java.io.*;/*本类用于测试字符流的读取*/
public class TestIn2 {public static void main(String[] args) {//method();//测试普通字符输入流method2();//测试高效字符输入流}//创建一个用于测试高效字符输入流的方法private static void method2() {//1.定义一个在本方法都生效的局部变量，手动初始化值nullReader in=null;try{//1.创建高效字符读取流对象//in = new BufferedReader(new FileReader(new File("E:\\ready\\1.txt")));in = new BufferedReader(new FileReader("E:\\ready\\1.txt"));//2.使用流对象int b;while((b=in.read())!=-1){System.out.println(b);}}catch (Exception e){e.printStackTrace();}finally {//3.关闭流对象try {in.close();} catch (IOException e) {e.printStackTrace();}}}//创建一个用于测试普通字符输入流的方法private static void method() {//1.1创建一个在本方法中都生效的局部变量，注意初始化值nullReader in = null;try {//1.2创建字符输入流对象，注意需要捕获异常//Reader in = new Reader();//报错原因：抽象父级不可实例化//in = new FileReader(new File("E:\\ready\\1.txt"));in = new FileReader("E:\\ready\\1.txt");//2.使用流对象//System.out.println(in.read());//需求：循环读取文件中的所有内容，只要不是-1，就说明还有数据，继续读取//3.1定义变量，记录读取到的数据int b;while((b = in.read())!= -1){System.out.println(b);}} catch (Exception e) {e.printStackTrace();} finally {//3.关流try {in.close();} catch (IOException e) {e.printStackTrace();}}}
}

字节流写出

OutputStream抽象类

此抽象类是表示输出字节流的所有类的超类.输出流接受输出字节并将这些字节发送到某个接收器.

常用方法:
Void close() 关闭此输出流并释放与此流相关的所有系统资源
Void flush() 刷新此输出流并强制写出所有缓冲的输出字节
Void write(byte[ ] b) 将b.length个字节从指定的byte数组写入此输出流
Void write(byte[ ] b,int off ,int len) 将指定byte数组中从偏移量off开始的len个字节写入输出流
Abstract void write(int b) 将指定的字节写入此输出流

FileOutputStream 子类

直接插在文件上,直接写出文件数据

构造方法(创建对象):
FileOutputStream(String name)
创建一个向具有指定名称的文件中写入数据的文件输出流
FileOutStream(File file)
创建一个向指定File对象表示的文件中写入数据的文件输出流
FileOutStream(File file,boolean append)—如果第二个参数为true,表示追加,不覆盖
创建一个向指定File对象表示的文件中写入数据的文件输出流,后面的参数是指是否覆盖原文件内容

BufferedOutputstream 子类

该类实现缓冲的输出流,通过设置这种输出流,应用程序就可以将各个字节写入底层输出流中,而不必每次针对字节写出调用底层系统

构造方法(创建对象):
BufferedOutputStream(OutputStream out)
创建一个新的缓冲输出流,用以将数据写入指定的底层输出流

package cn.tedu.file;import java.io.*;/*本类用于测试字节输出流*/
public class TestOut {public static void main(String[] args) {method();//用于测试普通字节输出流//method2();//用于测试高效字节输出流}//创建一个用于测试高效字节输出流的方法private static void method2() {//1.创建一个在本方法都生效的局部变量，注意手动初始化OutputStream out = null;try{//2.创建高效字节输出流对象
//          out = new BufferedOutputStream(new FileOutputStream(new File("E:\\ready\\2.txt")));out = new BufferedOutputStream(new FileOutputStream("E:\\ready\\2.txt"));//3.使用流对象--进行写出操作out.write(97);out.write(97);out.write(97);}catch (Exception e){e.printStackTrace();}finally {//关流操作要放在finally{}中try {//4.关流out.close();} catch (IOException e) {e.printStackTrace();}}}//创建一个用于测试普通字节输出流的方法private static void method() {//1.创建一个在本方法中都生效的局部变量，注意手动初始化nullOutputStream out = null;//2.创建try-catch-finally结构，因为IO操作可能会产生异常try{//3.创建普通字节输出流对象//out = new FileOutputStream(new File("E:\\ready\\2.txt"));//out = new FileOutputStream("E:\\ready\\2.txt");out = new FileOutputStream("E:\\ready\\2.txt",true);//4.使用流对象--进行写出操作out.write(99);//对应ASCII码表中的aout.write(99);//对应ASCII码表中的bout.write(99);//对应ASCII码表中的c}catch (Exception e){e.printStackTrace();}finally {//如果想要代码一定会执行，需要写在finally中try {//5.关流操作out.close();} catch (IOException e) {e.printStackTrace();}}}
}

字符流写出

Writer 抽象类

写入字符流的抽象类

常用方法:
Abstract void close() 关闭此流,但要先刷新它
Void write(char[ ] cbuf) 写入字符数组
Void write(int c) 写入单个字符
Void write(String str) 写入字符串
Void write(String str,int off,int len) 写入字符串的某一部分
Abstract void write(char[] cbuf,int off,int len)写入字符数组的某一部分

FileWriter 子类

用来写入字符文件的便捷类,此类的构造方法假定默认字符编码和默认字节缓冲区大小都是可接受的.如果需要自己自定义这些值,可以先在FileOutputStream上构造一个OutputStreamWriter.

构造方法(创建对象):
FileWriter(String filename)
根据给定的文件名构造一个FileWriter对象
FileWriter(String filename,boolean append)
根据给定的文件名以及指示是否附加写入数据的boolean值来构造FileWriter

BufferedWriter子类

将文本写入字符输出流,缓冲各个字符,从而提供单个字符,数组和字符串的高效写入.可以指定缓冲区的大小,或者接受默认的大小,在大多数情况下,默认值就足够大了

构造方法(创建对象):
BufferedWriter(Writer out)
创建一个使用默认大小输出缓冲区的缓冲字符输出流

package cn.tedu.file;import java.io.*;/*本类用于测试字符输出流*/
public class TestOut2 {public static void main(String[] args) {//method();//用于测试普通字符输出流method2();//用于测试高效字符输出流}//创建一个用于测试高效字符输出流的方法private static void method2() {//1.创建一个在本方法都生效的局部变量，值为null,注意手动初始化！！！Writer out = null;//2.由于程序可能会抛出异常，所以需要写一个try-catch-finally结构try{//存放可能会抛出异常的代码//3.创建普通字符输出流对象//out = new BufferedWriter(new FileWriter(new File("E:\\ready\\2.txt")));//out = new BufferedWriter(new FileWriter("E:\\ready\\2.txt"));out = new BufferedWriter(new FileWriter("E:\\ready\\2.txt",true));//4.使用流对象out.write(100);out.write(100);out.write(100);out.write(100);out.write(100);}catch (Exception e){//匹配并捕获异常e.printStackTrace();//如果捕获到异常就打印错误信息}finally {//一定会被执行到的代码块，常用于关流try {out.close();} catch (IOException e) {e.printStackTrace();}}}//创建一个用于测试普通字符输出流的方法private static void method() {//1.创建一个在本方法都生效的局部变量，值为null,注意手动初始化！！！Writer out = null;//2.由于程序可能会抛出异常，所以需要写一个try-catch-finally结构try{//存放可能会抛出异常的代码//3.创建普通字符输出流对象//out = new FileWriter(new File("E:\\ready\\2.txt"));//out = new FileWriter("E:\\ready\\2.txt");out = new FileWriter("E:\\ready\\2.txt",true);//4.使用流对象out.write(98);out.write(98);out.write(98);out.write(98);}catch (Exception e){//匹配并捕获异常e.printStackTrace();//如果捕获到异常就打印错误信息}finally {//一定会被执行到的代码块，常用于关流try {out.close();} catch (IOException e) {e.printStackTrace();}}}
}

文件的复制

package cn.tedu.file;import java.io.*;
import java.util.Scanner;/*本类用于练习文件复制综合案例*/
public class TestCopyFile {public static void main(String[] args) {//1.提示并接收用户输入的两个路径System.out.println("请输入源文件路径");//--被复制的那个文件String f = new Scanner(System.in).nextLine();System.out.println("请输入新文件路径：");//--复制好的新文件String t = new Scanner(System.in).nextLine();//2.调用创建好的自定义方法完成文件复制//ZFCopy(f,t);//用字符流完成文件的复制案例ZJCopy(f,t);//用字节流完成文件的复制案例}//利用字节流完成文件复制案例private static void ZJCopy(String f, String t) {//1.定义在整个方法都生效的局部变量，注意手动初始化，引用类型默认值为nullInputStream in = null;OutputStream out = null;//2.由于代码可能会发生异常，所以需要编写try-catch-finally结构try{//3.1创建高效字节输入流对象--FIS的参数是用户传入的源文件路径fin = new BufferedInputStream(new FileInputStream(f));//3.2创建高效字节输出流对象--FOS的参数是用户传入的新文件路径tout = new BufferedOutputStream(new FileOutputStream(t));//4.利用创建好的流对象完成业务//4.1定义变量用来保存读到的数据int b;//4.2循环读取源文件中的数据，只要不是-1，说明还有数据循环继续while((b = in.read()) != -1){//4.3将读到的数据写入到新文件中out.write(b);}System.out.println("恭喜您！文件复制成功！");}catch (Exception e){System.out.println("很抱歉！文件复制失败！");e.printStackTrace();}finally {try {out.close();} catch (IOException e) {e.printStackTrace();}try {in.close();} catch (IOException e) {e.printStackTrace();}}}//利用字符流完成文件复制案例private static void ZFCopy(String f, String t) {//1.定义在整个方法中都生效的局部变量，注意手动初始化，默认值为nullReader in = null;Writer out = null;//2.由于代码可能会发生异常，所以需要编写try-catch-finally结构try{//3.1创建高效字符输入流对象in = new BufferedReader(new FileReader(f));//3.2创建高效字符输出流对象out = new BufferedWriter(new FileWriter(t));//4.拿到流对象以后，就可以使用流对象来完成业务了//4.1定义变量用来保存读到的数据int b;//4.2循环读取源文件，直到返回值为-1，说明没有数据了，再结束循环while ((b=in.read())!=-1) {//4.3将本轮循环中读到的数据写入到新文件中out.write(b);}System.out.println("恭喜您！文件复制成功！");}catch (Exception e){System.out.println("很抱歉！文件复制失败！");e.printStackTrace();}finally {/*关流是有顺序的：如果有多个流，最后创建的流最先关闭* 多条关流语句需要各自try-catch*/try {out.close();} catch (IOException e) {e.printStackTrace();}try {in.close();} catch (IOException e) {e.printStackTrace();}}}
}