java-IO系统

1.概念：IO（输入/输出）指的是计算机与外部世界，或者一个程序与计算机的其余部分的接口。

2.流(stream)的概念：当程序需要写入数据的时候，就会开启一个通向目的地设备的流。

(1).流的特性：含有流质(数据)；具有方向(读或写)。

3.IO操作的步骤：建立流、操作流、关闭流

4.文件类

(1).File构造器

 public File(String pathname)
 public File(String parent,String child)
 public File(File parent,String child)
  public File(URL uri)

(2).File对象类似于一个字符串，只代表一个文件或一个目录的路径名，所以，即使指定的文件或目录不存在，这些构造器也能成功执行。

       // 创建File对象
        File file = new File("E:exercise_bak.txt");

        // 能否读
        System.out.println("能否读：" + file.canRead());

        // 删除
        System.out.println("删除成功：" + file.delete());

        // 重新创建文件对象
        file = new File("E:\jg\exercise_bak.txt");

        // 判断文件是否存在
        System.out.println("是否存在：" + file.exists());

        // 目录或文件名称
        System.out.println("名称：" + file.getName());

        // 是否目录、文件
        System.out.println("是否目录：" + file.isDirectory());
        System.out.println("是否文件：" + file.isFile());

        // 最后一次修改时间
        System.out.println("最后一次修改时间：" + new Date(file.lastModified()));

        // 文件大小
        System.out.println("文件大小：" + file.length());

        // 重新创建File对象
        file = new File("E:\jg");

        System.out.println("文件目录列表：");
        // 返回一个字符串数组，这些字符串指定此抽象路径名表示的目录中的文件和目录
        String[] list = file.list();
        for (String string : list) {
            System.out.println(string);
        }
        System.out.println("*******************************");

        // 返回一个抽象路径名数组，这些路径名表示此抽象路径名表示的目录中的文件对象
        File[] files = file.listFiles();
        for (File item : files) {
            if (item.isDirectory()) { // 当前File对象为目录，则遍历该目录下所有子目录与文件
                System.out.println(item.getName() + " 目录下子目录与文件：");
                String[] it = item.list();
                for (String i : it) {
                    System.out.println(i);
                }
                continue;
            }

            System.out.println(item.getName() + "  文件");
        }

        // 重新创建File对象
        file = new File("E:\jg\test\demo\test.txt");
        if (!file.exists()) { // 文件不存在
            // 获取文件路径
            File dir = file.getParentFile();
            if (!dir.exists()) { // 目录不存在，则创建路径中所有不存在的目录
                dir.mkdirs();
            }try {
                // 创建空文件
                System.out.println("文件是否创建成功：" + file.createNewFile());
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

5.流的分类

(1).区分高级流与低级流：查看该类的构造器。如果类的构造器带有一个已存在的流作为参数，那么就是高级流，反之则为低级流。

(2).按流的方向分：输入流。io包中的输入流都继承自抽象类InputStream或Reader。数据源读取数据到程序中

                         输出流。io包中的输出流都继承自抽象类OutputStream或Writer。将数据从程序写入数据目的地

(3).按流的处理数据的最小单位的不同：字节流(用于处理二进制文件)。byte为最小单位，io包中的字节流都继承自抽象类InputStream或OutputStream。

                                                  字符流(用于处理文本文件)。char为最小单位，io包中的输入流都继承自抽象类Reader或Writer。

(4).按流的功能分：节点流(效率低)。

                         处理流。

(5).字节流：低级字节流-FileInputStream或FileOutputStream...

                高级字节流-BufferedInputStream或BufferedOutputStream(缓冲流);DataInputStream或DataOutputStream(数据流)...

(6).字符流：低级字符流-FileReader或FileWriter...

                 高级字符流-BufferedReader或BufferdWriter(缓冲流);InputStreamReader或OutputStreamWriter(转换流)...

package com.lovo;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Reader;
import java.io.Writer;

/**
 * 字符输入输出流测试
 * 
 * @author 
 *
 */
public class IOTest2 {

    public static void main(String[] args) {
        StringBuffer buffer = new StringBuffer();

        /* 输入流 */
        Reader reader = null;

        try {
            // 1. 打开流
            reader = new FileReader("E:\jg\exercise.txt");
            // 2. 读取
            char[] ch = new char[128]; // 缓冲区
            int len;
            do {
                len = reader.read(ch);
                if (len == -1)
                    break;
                buffer.append(new String(ch, 0, len));
            } while (len != -1);
            System.out.println(buffer.toString());
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 3. 释放资源
            if (reader != null) {
                try {
                    reader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

        /* 输出流 */

        Writer writer = null;

        try {
            // 1. 打开流
            writer = new FileWriter("d:\test.txt");
            // 2. 写入
            writer.write(buffer.toString());
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 3. 释放资源
            if (writer != null) {
                try {
                    writer.flush();
                    writer.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

package com.lovo;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

/**
 * 字节输入输出流测试
 * 
 * @author 
 *
 */
public class IOTest {

    public static void main(String[] args) {
        StringBuffer buffer = new StringBuffer(); // 字符串缓冲
        
        /* 输入流 */
        InputStream in = null;

        try {
            // 1. 打开输入流
            in = new FileInputStream("E:\jg\exercise.txt");
            // 2. 读取
//            byte[] b = new byte[128];
            byte[] b = new byte[1024 * 4];
            int len = in.read(b); // 返回读取到的字节数，返回-1表示读取到流结尾
            while(len != -1){
                buffer.append(new String(b, 0, len)); // 将读取到的字节解析为String追加到缓冲
                len = in.read(b);
            }
//            System.out.println("读到" + len + "字节的数据");
            System.out.println(buffer.toString());
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 3. 释放资源，关闭输入流
            if (in != null){
                try {
                    in.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        
        /* 输出流 */
        OutputStream out = null;
        
        try {
            File file = new File("D:\test\demo\test.txt");
            if (!file.getParentFile().exists()){ // 文件路径不存在，则创建路径中所有不存在的目录
                file.getParentFile().mkdirs();
            }
            // 1. 打开输出流
            out = new FileOutputStream(file);
            // 2. 写
            out.write(buffer.toString().getBytes());
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 3. 释放输出流资源
            if (out != null){
                try {
                    out.flush();
                    out.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

(7).对象流：ObjectInputStream(反序列化操作)或ObjectOutputStream(序列化操作)

     补充：

           Serializable"标记接口":实现对象序列化

           transient修饰符：该属性在写入文件时，没有被写入；读取时，也读取不到。

package com.lovo.day2;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.Date;

public class ObjectTest {

    public static void main(String[] args) {
        Student stu = new Student("张飞", 18, true, 10.0, new Date(), new Course(
                1, "语文"));
        Student stu2 = new Student("张飞2", 18, true, 10.0, new Date(), new Course(
                2, "数学"));

        // 序列化
        ObjectOutputStream out = null;

        try {
            out = new ObjectOutputStream(
                    new FileOutputStream("d:\student.bin"));
            out.writeObject(stu);
            out.writeObject(stu2);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (out != null) {
                try {
                    out.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

        // 反序列化
        ObjectInputStream in = null;

        try {
            in = new ObjectInputStream(new FileInputStream("d:\student.bin"));
            Student stu1 = (Student) in.readObject();
            System.out.println(stu1);

            System.out.println("*****************");

            System.out.println(stu1.getCourse());
            
            System.out.println("##########################");
            
            Student stu21 = (Student) in.readObject();
            System.out.println(stu21);
            
            System.out.println("*****************");
            
            System.out.println(stu21.getCourse());
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } finally {
            if (in != null) {
                try {
                    in.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}