Java学习笔记--文件IO

简介

对于任何程序设计语言，输入和输出(Input\Output)都是系统非常核心的功能，程序运行需要数据，而数据的获取往往需要跟外部系统进行通信，外部系统可能是文件、数据库、其他程序、网络、IO设备等等，外部系统比较复杂多变，那么我们有必要通过某种手段进行抽象、屏蔽外部的差异，从而实现更加便捷的编程。

1.输入：指的是可以让程序从外部系统取得数据，常见的应用有：

• 读取硬盘上的文件内容到程序
• 读取网络上某个位置内容到程序
• 读取数据库系统的数据到程序
• 读取某些硬件系统的数据到程序

2.输出：指的是程序输出数据给外部系统从而可以操作外部系统，常见的应用有：

• 将数据写到硬盘中
• 将数据写到数据库系统中
• 将数据写到某些硬件系统中

Java中流(Stream)的概念

当程序需要读取数据源的数据时，就会通过IO流对象开启一个通向数据源的流，通过这个IO流对象的相关方法可以顺序读取数据源中的数据。 流对象使用完，必须关闭！不然，总占用系统资源，最终会造成系统崩溃！

import java.io.*;
public class TestIO {
    public static void main(String[] args){
        FileInputStream fis = null;
        try {
            fis = new FileInputStream("路径");
            StringBuilder sb = new StringBuilder();
            int temp =0;
            while((temp = fis.read())!=-1){
                sb.append((char)temp);
            }
            System.out.println(sb);
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try {
                if(fis!=null){
                    fis.close();
                }
            }catch (IOException e){
                e.printStackTrace();
            }
        }
    }
}

四大抽象IO类

InputStream/OutputStream和Reader/writer类是所有IO流类的抽象父类，我们有必要简单了解一下这个四个抽象类的作用。然后，通过它们具体的子类熟悉相关的用法。

·InputStream

此抽象类是表示字节输入流的所有类的父类。InputSteam是一个抽象类，它不可以实例化。 数据的读取需要由它的子类来实现。根据节点的不同，它派生了不同的节点流子类 。

继承自InputSteam的流都是用于向程序中输入数据，且数据的单位为字节(8 bit)。

      常用方法：

int read()：读取一个字节的数据，并将字节的值作为int类型返回(0-255之间的一个值)。如果未读出字节则返回-1(返回值为-1表示读取结束)。

void close()：关闭输入流对象，释放相关系统资源。

· OutputStream

此抽象类是表示字节输出流的所有类的父类。输出流接收输出字节并将这些字节发送到某个目的地。

常用方法：

void write(int n)：向目的地中写入一个字节。

void close()：关闭输出流对象，释放相关系统资源。

· Reader

Reader用于读取的字符流抽象类，数据单位为字符。

int read(): 读取一个字符的数据，并将字符的值作为int类型返回(0-65535之间的一个值，即Unicode值)。如果未读出字符则返回-1(返回值为-1表示读取结束)。

void close() ： 关闭流对象，释放相关系统资源。

· Writer

Writer用于写入的字符流抽象类，数据单位为字符。

void write(int n)： 向输出流中写入一个字符。

void close() ： 关闭输出流对象，释放相关系统资源。

 

文件操作

关于文件类的操作。数据存在变量，数组和对象中，但是这些都是临时的，当程序中断了，这些数据都会消失，为了永久的存储这些在程序中创造的数据，你需要将这些数据存在一个文件里面，然后将这些文件放在磁盘或者CD上，文件可以传递，同时这些文件可以被后来的程序所访问。

每个文件都是直接放在文件系统中的，绝对文件名包含了文件的名称和全部路径名，这些都可以在操作系统的层面上看到。从某种角度来看，其实Java的虚拟机也可以看做是某种操作系统。

文件类 File Class

method : +File(pathname: String), +File(parent: String, Child: String), +File(parent: File, Child: String)

+exists(): boolean +canRead():boolean +canRead():boolean +canWrite():boolean

　文件的输入和输出

　　File对象封装了文件的内容或者文件的路径，但是没有包含创建文件的方法，也么有从文件里面读或者写，为了实现输入和输出，你必须要创建对象，然后使用Java IO的类，这些对象包含了对文件读写方法。

　　使用PrintWriter写数据

　　Java.io.printWriter 类可以使用来创建文件，并且对文件写入数据，首先创建PrintWriter对象

　　

PrintWriter output = new PrintWriter(filename);

然后你可以使用print ,println和printf的方法。

WriteData.java
public class WriteData {
public static void main(String[] args) throws Exception {
java.io.File file = new java.io.File("scores.txt");
if (file.exists()) {
System.out.println("File already exists");
System.exit(0);
}
 // Create a file java.io.PrintWriter output = new java.io.PrintWriter(file);
/ Write formatted output to the file
output.print("John T Smith ");
output.println(90);
output.print("Eric K Jones ");
output.println(85);
// Close the file
output.close();
}

通过Scanner类读取数据：Java.util.Scanner类用于读字符串和最初的值--“从控制台读输入”，

　　从键盘读入时候的语法 : Scanner input = new Scanner(System.in);

　　从文件中读入时的语法 : Scanner input = new Scanner(new File(filename));

注意到 new Scanner(string) 创建了一个Scanner来赋予String，为了使得Scanner 能够从文件里面读取数据，你要使用Java.io.File类来创建一个File实例，使用如下的创建方法，new File(filename)，然后使用 Scanner（File）来创建一个Scanner用于文件。

序列化和反序列化

当两个进程之间进行通信时，彼此可以发送各种类型的数据，无论是何种类型的数据，都会以二进制序列的形式进行传送，例如http协议发送字符串信息，也可以支架发送Java对象，发送方需要将这个Java对象转换成字节序列，才能在网络上进行传送，接收方则需要把字符串序列再恢复成Java对象才能正常读取。把Java对象转换为字节序列的的过程称为对象的序列化，把字节序列恢复为Java对象的过程称为对象的反序列化，对象的序列化有如下两种作用：

• 持久化：把对象的字节序列永久地保留在硬盘上，通常存放在一个文件中，比如：休眠的实现，以后服务器session管理，hibernate将对象持久化实现。
• 网络通信：在网络上传送对象的字节序列。例如：服务器时间的数据通信、对象传递。

ObjectOutputStream代表对象输出流，它的writeObject(Object obj)方法可对参数指定的obj对象进行序列化，把得到的字节序列写到一个目标输出流中。

ObjectInputStream代表兑现输入流，它的readObject(Object obj)方法从一个源输入流中读取字节序列，再把他们反序列化为一个对象，并将其返回

只有实现了Serializable接口的类的对象才能被序列化。Serializable接口是一个空接口，只起到标记作用

import java.io.*;
public class SerializableDemo {
    public static void main(String[] args) {
        FileOutputStream fos = null;
        FileInputStream fis = null;
        ObjectInputStream ois = null;
        ObjectOutputStream oos = null;

        try {
            PersonDemo pd = new PersonDemo(18,true,"Ling");
            System.out.println("--------------pd-----------");
            System.out.println(pd);
            fos = new FileOutputStream("d:/fos.txt");
            oos = new ObjectOutputStream(fos);
            oos.writeObject(pd);
            oos.flush();

            fis = new FileInputStream("d:/fos.txt");
            ois = new ObjectInputStream(fis);
            PersonDemo pd2 = (PersonDemo) ois.readObject();
            System.out.println("--------------pd-----------");
            System.out.println(pd2);
        }catch (ClassNotFoundException e){
            e.printStackTrace();
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            if(oos!=null){
                try {
                    oos.close();
                }catch (Exception e){
                    e.printStackTrace();
                }
            }

            if(fos!=null){
                try {
                    fos.close();
                }catch (IOException e){
                    e.printStackTrace();
                }
            }

            if(fis!=null){
                try {
                    fis.close();
                }catch (IOException e){
                    e.printStackTrace();
                }
            }

            if(ois!=null){
                try {
                    ois.close();
                }catch (IOException e){
                    e.printStackTrace();
                }
            }
        }
    }
}

• static属性不参与序列化
• 对象中的某些属性如果不想被序列化，不能使用static，而是使用transient修饰
• 为了防止读和写的序列化ID不一致，一般指定一个固定的序列化ID