当前位置 博文首页 > 文章内容

    Java学习笔记--文件IO

    作者:adminmttt 栏目:未分类 时间:2020-07-30 18:01:40

    简介

    对于任何程序设计语言,输入和输出(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