java初学总结（十一）

一、IO介绍

        IO技术：把程序中的数据最终输出到持久设备上，或者从持久设备读取已经存在的数据，最后给我们读取到程序中。

        IO：input  输入    读操作

               output  输出   写操作

二、file类介绍

        需要把数据持久的保存起来，最终都要以文件的形式存储在持久设备上。如果持久设备上文件太多如何管理？就会使用文件夹来管理文件或者文件夹。

        在学习IO技术之前，需要了解java是如何针对文件和文件夹这类事物做封装的。

        在Java中使用File  这个类来描述持久设备上的文件或者文件夹。

        文件：是用来保存真实的数据的

        文件夹：管理文件和文件夹

        File类常用的构造方法有两个，构造方法可以把对应的文件和文件夹来封装成一个File对象

        File没有空参数的构造方法。

        常用的构造方法：

        1、File(String pathname)

        把一个字符串描述的文件或者文件夹封装成File对象。File类的构造方法会把指定的内容封装成File对象

        2、File(String parent,String child)

        可以把一个文件或者文件夹的父目录单独分离出来，然后再结合当前的子目录一起封装成File对象

三、file常用方法

方法名称	说明
boolean exists()	判断文件或者目录是否存在
boolean isFile()	判断是否是文件
boolean isDirectory()	判断是否是文件夹(目录）
String getPath()	获取此对象表示的相对路径名
String getAbsolutePath()	获取此对象表示的绝对路径名
String getName()	获取此对象表示的文件或文件夹的名称
boolean delete()	删除此对象指定的文件或文件夹
boolean createNewFile()	创建名称的空文件，不创建文件夹
long length()	返回文件的长度，单位为字节，如果文件不存在，则返回0L

四、字节流

        File类是描述文件和文件夹的，并且其中定义的方法都是围绕文件和文件夹的操作展开的。

        但是File类有缺陷，它无法去获取一个文件中的数据

        如果我们再程序中要读取文件中存放的具体的数据，或者给文件中写数据，这时必须使用Java中提供的另外一套机制来读取

        这套机制就是IO流技术。 I：InputStream      O：OutputStream

        流的分类：

        按找处理数据单元划分:

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

        1、InputStream

        fileInputStream是inputStream常用子类

        fileInputStream流被称为文件字节输入流，意思指对文件数据以字节的形式进行读取操作

        常用的构造方法有：FileInputStream(File file)；FileInputStream(String path)

        常用的方法有：

        int read()：这个方法被调用一次，它运行一次，会从底层读取一个字节数据，当把这个字节读取完成之后，在文件中的隐式光标自动的移动到第一个字节和第二个字节之间。返回的数据是这个字节数据转成int值，当读取到文件的末位时，会返回-1；因此在使用read方法读取数据的时候，通过判断读取的数据是否是-1来判断是否把文件中的数据已经完全读取完成。

        int read(byte[] b)：这个方法没执行一次，就会从底层读取多个字节数据，把读取到的字节数据存储在byte数组中。返回的int值，是表示当前从底层读取了几个字节数据。即就是给byte数组中存储了几个字节数据。如果读取到文件末位会返回-1.

        int read(byte[] b,int off,int len)：off从哪里开始，读len长度

        void close()：关闭流，在使用完成之后一定要关闭流

        2、字节读取文件模板

        一次读取一个字节的模板代码

//1、先创建流对象和文件进行关联
FileInputStream fis = new FileInputStream("文件名");
//2、定义变量，用来记录从底层文件中读取到的那个字节数据
int ch = 0;
//3、定义循环开始从文件中读取数据
whlie((ch = fis.read())!=-1){
    //处理读取到的数据，数据存储在ch空间   
}
//4、关闭流对象
fis.close();

        一次读取多个字节数据模板代码

//1、先创建流对象和文件进行关联
FileInputStream fis = new FileInputStream("文件");
//2、定义数组，用来存储从底层读取的多个字节数据，一般是1024的整数倍
byte[] buf = new byte[1024];
//3、定义变量，用来记录到底从底层读取了多个字节数据
int len = 0;
//4、使用循环从底层开始读取数据
while((len = fis.read(buf))!=-1){
    //处理读取到的数据，数据存储在buf数组中，buf中共计存储了len个字节数据，并不一定把buf存满
}
//5、关闭流对象
fis.close();

        3、OutputStream

        数据在持久设备上都以二进制保存，字节数据，因此Java给我们提供了专门操作持久设备上的流对象，字节流。

        OutputStream：专门用来操作字节数据的字节输出流对象。是所有字节输出流的超类，并且是个抽象类，不能直接创建对象。

        写的方法：

        write(int b)：把字节数据直接写到持久设备上

        write(byte[] buf)：把字节数组中的数据写到持久设备上。

        write(byte[] buf,int off,int len)：把buf字节数组中的数据从off下标开始共计写出len个字节数据

        close()：关闭java程序和外围设备直接的连接通道。

        在OutputStream类下有直接的子类FileOutputStream：

        FileOutputStream(File file)在创建输出流对象的时候，指定一个文件对象，用于把数据写到指定的这个文件中

        FileOutputStream(String pathName)在创建输出流对象的时候，把这个字符串当前一个具体的文件位置，然后把数据写到这个文件中

        在使用输出流的时候，如果指定的文件不存在，会自动创建这个文件对象，如果文件存在，会创建一个新的把原来的文件覆盖掉。

        子类FileOutputStream常用的构造方法：FileOutputStream(File file)，FileOutputStream(String name)，FileOutputStream(String name,boolean append)

        注意：

        前面两个构造方法如果指定的文件不存在，会自动创建这个文件对象，如果文件存在，会创建一个新的把原来的文件覆盖掉。以前的数据都消失了；

        第三个构造方法写数据时，当文件不存在同样会创建一个文件，如果文件存在了，第二个参数表示是否追加，false表示不追加（默认），和其他的两个构造方法结果一致，为true时，表示追加，在原来内容的基础上新增新的内容。

五、字符流

        java给我们提供专门用于操作字符数据的流对象

        字符输入流：Reader

        字符输出流：Writer       

        1、Reader

        用于读取字符流的抽象类。子类必须实现的方法只有read(char[] ,int ,int)和close()。

        多数子类将重写此处定义的一些方法，以提供更高的效率和其他功能。

        int read()：执行一次，会得到一个字符数据，如果读取到文件末尾，返回的-1

        int read(char[] c)：执行一次，会从底层读取多个字符数据，存储在字符数组中，返回本次读取的字符数据个数，如果读取到文件末位，返回-1

        read(char[] c,int off,int len)：将读取到的数据存储在数组中，从off开始，到len结束

        void close()

        子类InputStreamReader常用的构造方法，它又称为转换流

        InputStreamReader(InputStream in)

        InputStreamReader(InputStream in,String charsetName)

        FileReader类是InputStreamReader的子类

        FileReader(File file)

        FileReader(String name)

        2、字符读取文件模板

        一次读取一个字符数据模板代码

//定义字符输入流对象和文件进行关联
FileReader fr = new FileReader("文件");
//定义变量，存储读取到的字符数据
int ch = 0;
//使用循环读取数据
while((ch = fr.read())!=-1){
    //处理读取到的单个字符数据，数据在ch中保存
}
//关闭流对象
fr.close();

        一次读取多个字符数据

//定义字符输入流对象和文件进行关联
FileReader fr = new FileReader("文件");
//定义字符数组，用来存储一次读取到的多个字符数据
char[] buf = new char[1024];
//定义变量，记录每次读取到字符个数
int len = 0;
//使用循环读取数据
while((len = fr.read(buf))!=-1){
    //处理读取到的数据，数据保存在buf中，buf中共计保存了len个字符数据  
}
//关闭流对象
fr.close();

        3、BufferedReader

        BufferedReader提高字符流读取文本文件，有一个独立的方法readLine()，又称高效流，带有缓冲区的流。

        当所有文件信息都获取完成的时候，readLine()方法将返回null

        注意：文档中有空行，读取的时候不是null，而是空内容

        BufferedReader常用的构造方法

        BufferedReader(Reader in)：需要接受一个字符流

        如果读取文件中出现中文乱码问题时，可以考虑指定编码，原则如下：

FileInputStream fis = new FileInputStream("c:\\myDoc\\hello.txt");
//使用InputStreamReader并设置编码格式
InputStreamReader fr = new InputSreamReader(fis,"UTF-8");
BufferedReader br = new BufferedReader(fr);

        4、writer

        Writer类常用方法：

        write(String str)：写一个字符串

        write(String str,int off,int len)：把str中的字符数据从off开始，共计写len个

        void close()：关闭流

        void flush()：刷新

        子类OutputStreamWriter常用的构造方法

        OutputStreamWriter(OutputStream out)

        OutputStreamWriter(OutputStream out,String charsetName)

        FileWriter类是OutputStreamWriter的子类

        FileWriter(File file)

        FileWriter(String name)

        注意：

        用字符输出流写出数据的时候：

        1、其实数据不是直接写到文件中，而是把字节数据存储在缓冲区中。如果这时字符输出流的缓冲区没有写满，或者我们没有调用flush方法，或没有关闭流对象，在程序结束之前，数据依然在缓冲区，不会被写到文件中。所以要求，在关闭流之前一定要刷新操作

        2、字符输出流（FileWriter）关联的文件如果不存在，会在指定的位置创建，如果文件存在，在创建流对象的谁会，没有指定的true值，这时会创建新的文件覆盖原来的文件。

        flush和close什么区别：

        flush是把缓冲区的数据刷出到文件中，没有关闭流和文件之间的关联，在刷新之后，依然可以使用流对象继续给文件中写数据。

        close方法在关闭流之前会先调用flush把缓冲区中的数据写底层文件中，然后把流和文件的关联关系断开

        一旦调用了close方法，流就已经被关闭了，就无法再使用当前这个流对象写数据。

5、BufferedWriter

       使用FileWriter类与BufferedWriter类可以提高字符流写文本文件的效率

        BufferedWriter常用的构造方法

        BufferedWriter(Writer out)

6、流的总结

        字节输入流：

        InputStream：它是字节输入流的超类，它只定义字节流的基本操作方法：

        close();

        read()：一次读取一个字节数据

        read(byte[] buf)：一次读取多个字节数据，存储在buf中，然后给buf中读取的字节个数

        FileInputStream：专门用来读取文件中的字节数据的文件字节输入流对象

        创建这个类的对象，读取文件中的数据

        模板代码：

        1、一次读取一个字节

FileInputStream fis = new FileInputStream("文件");
int ch = 0;
while((ch = fis.read())!=-1){
    //处理读取到的数据，数据在ch中
}
fis.close();

        2、一次读取多个字节数据

        

FileInputStream fis = new FileInputStream("文件");
byte[] buf = new byte[1024];
int len = 0;
while((len = fis.read(buf))!=-1){
    //处理数据，数据在buf中，共计有len个
}
fis.close();

        字节输出流

        OutputStream：字节输出流的超类，它中定义的基本的输出字节数据的操作

        close()：

        write(int b)：写出一个字节数据，注意只能把这个int数据中的最低1个字节数据写出去

        write(byte[] buf)：把字节数组中的所有数据写到文件中

        write(byte[] buf, int off,int len)：把字节数组中的数据从off开始，共计写len个

        FileOutputStream：它是专门用来给文件中写字节数据的流对象。使用输出流写数据的时候，如果对应的文件不存在会创建一个文件，如果文件存在，在创建对象的时候，没有指定true值，就会继续创建新的文件，覆盖原来的文件。

        一般会在读的while循环中使用写的功能，往外把读取到的数据写出去。

字符流：2类

        字符输入流：

        Reader：是所有字符输入流的超类。

        close()：

        read()：一次读取一个字符数据，但返回的是字符数据的编码值

        read(char[] buf)：一次读取多个字符数据，把数据存储在buf中，返回读取的字符个数

        FileReader()：专门用于读取字符文件字符输入流对象，它内部使用本地默认的编码表（GBK）

        字符输出流：

        Writer：是所有字符输出流的超类

        close()：

        write(int b)：写出一个字符数据                write('a')这里会把a转换成97，再写进去

        字符数据和int数据再一定范围内可以互相赋值

        write(char[] buf)：把buf数组中的数据全部写出去

        weite(char[] buf , int off , int len)把buf中的数据从off开始共计写len个

        write(String s)：把一个字符串写出去

        FileWriter：专门用于给字符文件中写字符数据的便捷类，它的底层使用的默认的编码表和默认的缓冲区。

7、DataInputStream

        在IO包中提供了两个与平台无关的数据操作流

        数据输出流：DataOutputStream

        数据输入流：DataInputStream

        其使用方法和字节流类似

        DataInputStream类是FilterInputStream的子类，与FileInputStream类结合使用读取二进制文件

        构造方法：DataInputStream(InputStream in)

        DataOutputStream类是FilterOutputStream的子类，与FileOutputStream类结合使用写二进制文件

        构造方法：DataOutputStream(OutputStream out)

8、序列化和反序列化

        序列化是一个用于将对象状态转换为字节流的过程，需要使用对象输出流ObjectOutputStream。对象------>文件-------->写的过程

        反序列化则是从特定的流中湖区数据重新构建对象的过程，需要使用对象输入流ObjectInputStream。文件----->内存----->读的过程

        对象的序列化主要有两种用途：

        1）把对象的字节序列永久地保存到硬盘上，通常存放在一个文件中；

        2）在网络上传送对象的字节序列

注意：

        1、序列化和反序列化都是基于二进制流的，也就是说，在信息转化为二进制存储在文件中之后，用文本编辑器打开查看的话，肯定是会出现乱码的，只有通过反序列化才能将存储的二进制读取出来，然后正常显示在控制台上。

        2、如果一个对象要实现序列化的话，则这个类必须要实现一个序列化的接口

实现序列化：序列化是写的过程

        实现Serializable接口--->创建对象输出流--->调用writeObject()方法将对象写入文件--->关闭对象输出流

实现反序列化：反序列化是读的过程

        实现Serializable接口--->创建对象输入流--->调用readObject()方法读取对象--->关闭对象输入流