Java带你去看流浪世界！（十七）

《File IO》

学习阶段存储方式的演变：

临时存储：变量—>数组—>对象—>对象数组—>集合【最常用的程序内临时存储的顶级存储方式】

持久化存储：文件

文件的概念：相关记录或者放在一起的数据的集合。它是需要存储在“长期存储”的设备上的，有了它我们就可以实现持久化存储。

一、使用File类操作文件或目录的属性

File类是java.io包下，可以实现对文件/文件夹（目录directory）的操作。

构建一个File对象

main(){
    File file = new file("d:/xx/test.txt");
    //文件
    String path = "d:/test.txt";
    //文件夹
    String path = "d:/aaa";
    File file = new File(path);
}

File的构造方法：

1.File(String pathname)直接根据字符串类型地址获取对象的文件对象

2.File(String parent,String child)根据字符串类型的父路径和子路径获取对应的文件对象

3.File(File parent,String child)根据文件类型的父路径和字符串的子路径获取对应的文件对象

main{
    /*1.File(String pathname)
    File file = new File("d:\\a.txt");*/
    
    /*2.File(String parent父路径,String child子路径)
    //通常应用于：你已经获取到了某个文件的父路径，然后只需要通过本构造即可实现路径自动拼接
    File file = new File("d:","a.txt");*/
    
    /*3.File(File parent,String child)
    //通常应用于：你已经后去到了某个文件的父路径（File对象型的）...
    File parent = new File("d:");
    File file = new File(parent,"a.txt");*/
    syso(file.length());
}

File常用的API:

1.boolean.exists()--->查找文件是否存在，有true，没有false

2.boolean.isFile()--->用于判断是否是文件

3.boolean.isDirectory()--->用于判断是否是目录，有true，没有false

4.String.getPath()---->获得相对路径

5.String.getAbsolutePathD()--->获得绝对路径

6.String.getName()--->获得文件名

7.delete()---->删除文件/空的文件夹

8.boolean.createNewFlie()---->创建空文件，不创键文件夹

9.long.length()----->查看文件大小

10.boolean.mkdir()/ mkdirs()--->新建文件和文件夹

11.File[] listFiles()--->获取文件夹下的所有子目录/文件

展示各种方法：文件类的操作

class{
    //创建文件
    public void create(File file){
        if(!file.exists()){
            try{
               file.createNewFile();
                syso("文件已创建");
            }catch(IOException){
                e.printStackTrace();
            }
        }
    }
 	//查看文件相关信息
    public void showFileInfo(File file){
        if(file.exists()){
             //如果文件存在，则查看其信息
            if（file.isFile()){
            	syso(file.getName());//查看文件名
           		syso(file.getPath());//查看相对路径：类似于../demo1/testConstructor.java
            	syso(file.getAbsolutePath());//查看绝对路径:一个固定的地址，可以根据这个地址找到文件 d:/a.text
               	syso(file.length());//查看文件大小
            }
            if(file.isDirectory()){
                syso("此文件是目录")
            }
        }else{
            syso("文件不存在！")
        }
    }
    //删除文件
    public void delete(File flie){
        if(file.exists()){
            file.delete();
            syso("文件已删除")
        }
    }
    main{
        FileDemo fileDemo = new FileDemo();
        File file = new File("d:/chengxuan/test.txt");
        fileDemo.create(file);
    }

二、流（Stream）：OutputStream/inputStream

1.流的概念

流是指：一串字节以先进先出的方式发送和接受数据的通道

1.流动性：根据方向的不同，进行先进先出如同流水一样的动性。

2.方向性：相对于程序为参照物，流是有读取和写入操作，是有方向的。

2.流的分类

1.根据流向分为：

	输入流：读	InputStream

	输出流：写	OutputStream

2.根据数据处理单元分为：

	1.字节流：可以用来传输一切内容。音频，视频，图片，文本....	根据美国ASCII码进行通信传输的

		字节输入流 InputStream	字节输出流  OutputStream

	2.字符流：可以用来传输文本内容	根据不同国家进行了相应文字转换（它是基于字节流产生的）

		字符输入流 Reader	字符输出流 Writer

3.Reader和Writer的区别

Reader： 字符输入流，继承自Reader的流都是用于向程序中输入数据的。

Writer ：字符输出流，继承Writer的流都是向程序中输出的。

基类是抽象类无法创建对象，所以需要寻找对应的子类。

4.InputStream和OutputSteam的区别

InputStream 字节输入流：继承自InputStream的流都是用于向程序中输入数据的。

OutputStream 字节输出流 ：继承自OutputStream的流是程序用于向外输出数据的。

5.流的方向是以内存为参照物

三、字节流(byte表示字节)

1.FileInputStream / FileOutputStream

FileInputStream:

	1.int.read()--->读取一个字节数据

	2.int read(byte[] b)--->读取一个字节数组长度的字节数据，返回世界速去到的字节数量

	3.int read(byte[] b, off, int len)--->读取输入流中从指定索引开始，指定长度的字节数据到字节数组中

	4.int close();--->关流

//从输入流中指定位置开始，读取指定长度的字节数据到字节数组中
//p1:字节数组p2:起始索引p3:长度
//read（byte b[], int off(offs), int len)
FileInputStream fis = new FileInputStream("d:/test.txt");
//方法
byte[] b = new byte[1024];
int read = fis.read();
int read = fis.read(b,0,7);
//关流
try{
    
}catch(异常){
    
}finally{
    if(fis != null){
        fis.close();
    }
}

FileOutputStream:

1.void write(int b)--->输出一个字节

2.void write(byte[] b)--->输出一个字节数组的内容

3.void write(byte[] b, off, int len)--->输出一个字节数组中的指定范围的内容

4.void close();--->关流

main{
    FileOutputStream fos = null;
    try{
        //1.根据File对象来构建输出流对象
    	/*File file = new File("d:/b.txt");
    	FileOutputStream fos = new FileOutputStream(file);*/
       //2.根据文件路径来构建输出流对象 
        /*FileOutputStream fos = new FileOutputStream("d;/b.txt");*/
        //3.想指定文件追加数据p1:文件地址/File对象 p2:是否追加数据
        /*FileOutputStream fos = new FileOutputStream("d;/b.txt",true);*/
    }catch(Exception e){
        e.printStackTrace();
    }finally{
        //关流
        if(fos != null){
            fos.close();
        }
    }
}
//2.API方法
/*write(int b) 输出一个字节ASCII码
fos.write(97);*/
/*write(byte b[])输出一个字节数组的内容
String str = "hello whord";
fos.write(str.getBytes());*/
/*write(byte b[], int off, int len)输出一个字节数组内指定索引开始，指定长度结束
String str = "hello whord";
fos.write(str.getBytes(), 13,6);*/

2.文件复制（任意文件）

//将一个文件，复制到一个文件夹下
FileInputStream fis = new FileInputStream("d:/test.txt");
fos = new FileOutputStream("c:/a.txt")
//用数组来存储
byte[] bs = new byte[3];
while(fis.read(bs) > 0){
    syso(xxxx有数据);
}
int n = fis.read();//读第一个字符
n = fis.read();//读下一个字符
syso(n);
//关流
fis.close();

四、字符流

字符流的基类：

Reader

Writer

1.FileReader/FileWriter

构造：

**输入流**

FileReader(File file);

FileReader(String pathname);

**输出流**

FileWrite(File file);

FileWriter(String pathname);

FileWriter(String/File pathname, boolean append);追加数据

常用方法：

**输入流**

int read(char[] buffer);读取数据到字符数组中，返回读取的字符数

int read(char[] buffer, int offset, int len);读取指定长度的字符数据到数组中，返回读取的字符数

**输出流**

void write(String str);输出一个字符串

void write(String str, int offset, int len);输出一个字符串的一部分

void write(char[] buffer);输出一个字符数组

void write(char[] buffer, int offset, in len);输出一个字符数的一部分

关流方法：void close();在try-catch中可以通过try()形式自动关流，但是关流的时候是程序结束时自动关流。

.flush();清空缓冲区内容。BufferedWrite会清空两个缓冲区（一个是它自带的，一个是字符流的）

关流就是在清空缓冲区。

2.BufferedWriter / BufferedReader

构造：

**输入流**

BufferedReader(Reader re);

**输出流**

BufferedWrite(write wr);

常用方法：

**输入流**

String readLine();读取一行数据

其他同普通字符输入流，但是比之更加高效。

**输出流**

方法基本和普通字符输出流一样，但是比之更加高效（都是重新重写自Writer类的相关方法）

1.自带缓冲区更高效

2.对换行符做了处理，可以readLine() / newLine()

3.是对FileReader、FileWriter的封装

3.读写文本文件

五、读写二进制文件

1.将内存中的基本数据已二进制的形式写入文件或者读取出来

2.DataInputStream / DataOutputStream

3.peadLong() / readByte() / readUTF() / readChar()

4.写入同上

六、序列化和反序列化

1.序列化就是将对象的状态存储到特定介质中的过程，反之就叫反序列化

2.序列化又叫串行化，这样使得对象数据可以创术或者永久保存在文件中，且与平台无关

3.DataInputStream也可以实现序列化效果，将数据一个一个写入

4.实现了java.io.Serializable接口的类对象才能被序列化，即可序列化接口

5.ObjectOutputStream / O

bjectInputStream一次可以写入一个对象