java IO流

package com.sun.io;

import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.SequenceInputStream;
import java.io.Serializable;
import java.util.Enumeration;
import java.util.Vector;

import org.junit.Test;

public class IODemo {
    @Test
    public void createFile() throws IOException {
        // File f = new File("D:/eadp1.txt"); 和下面的效果相同
        File f = new File("D:\eadp1.txt");
        // 当且仅当不存在具有此抽象路径名指定名称的文件时，不可分地创建一个新的空文件。API
        // 该目录下没有此文件则创建，创建成功返回true，如果存在返回false；如果目录是不存在的话那会抛出IO异常
        System.out.println(f.createNewFile());
        System.out.println("该分区大小" + f.getTotalSpace() / (1024 * 1024 * 1024) + "G"); // 返回由此抽象路径名表示的文件或目录的名称。
        f.mkdirs(); // 创建此抽象路径名指定的目录，包括所有必需但不存在的父目录。
        // f.delete(); // 删除此抽象路径名表示的文件或目录
        System.out.println("文件名  " + f.getName()); // 返回由此抽象路径名表示的文件或目录的名称。
        System.out.println("文件父目录字符串 " + f.getParent());// 返回此抽象路径名父目录的路径名字符串；如果此路径名没有指定父目录，则返回
    }

    @Test
    public void fileInputStream() throws IOException {
        int count = 0;
        InputStream streamReader = new FileInputStream(new File("D:\eadp1.txt"));
        byte[] b = new byte[(int) new File("D:\eadp1.txt").length()];
        System.out.println("---长度是： " + b.length + " 字节");
        while (streamReader.read() != -1) { // 读取文件字节，并递增指针到下一个字节
            count++;
        }
        System.out.println("---长度是： " + count + " 字节");
        streamReader.close();
    }

    @Test
    public void copyFile() throws IOException {
        // TODO自动生成的方法存根
        byte[] buffer = new byte[512]; // 一次取出的字节数大小,缓冲区大小
        int numberRead = 0;
        FileInputStream input = null;
        FileOutputStream out = null;
        input = new FileInputStream("D:\eadp1.txt");
        out = new FileOutputStream("D:\eadp.txt"); // 如果文件不存在会自动创建

        while ((numberRead = input.read(buffer)) != -1) { // numberRead的目的在于防止最后一次读取的字节小于buffer长度，
            out.write(buffer, 0, numberRead); // 否则会自动被填充0
        }
        System.out.println("成功");
        input.close();
        out.close();
    }

    /**
     * 可以看我另一篇博客java序列化 把数据存到数据库中
     * 
     * @throws IOException
     * @throws ClassNotFoundException
     */
    @Test
    public void copyObject() throws IOException, ClassNotFoundException {

        ObjectOutputStream objectwriter = new ObjectOutputStream(new FileOutputStream("D:\student.txt"));
        objectwriter.writeObject(new Student("gg", 22));
        objectwriter.writeObject(new Student("tt", 18));
        objectwriter.writeObject(new Student("rr", 17));
        ObjectInputStream objectreader = new ObjectInputStream(new FileInputStream("D:\student.txt"));
        for (int i = 0; i < 3; i++) {
            System.out.println(objectreader.readObject());
        }
        objectreader.close();
        objectwriter.close();
    }

    /**
     * 合并流
     * 
     * @throws IOException
     */
    @Test
    private void doSequence() throws IOException {
        // 创建一个合并流的对象
        SequenceInputStream sis = null;
        // 创建输出流。
        BufferedOutputStream bos = null;
        // 构建流集合。
        Vector<InputStream> vector = new Vector<InputStream>();
        vector.addElement(new FileInputStream("D:	ext1.txt"));
        vector.addElement(new FileInputStream("D:	ext2.txt"));
        vector.addElement(new FileInputStream("D:	ext3.txt"));
        Enumeration<InputStream> e = vector.elements();
        sis = new SequenceInputStream(e);
        bos = new BufferedOutputStream(new FileOutputStream("D:	ext4.txt"));
        // 读写数据
        byte[] buf = new byte[1024];
        int len = 0;
        while ((len = sis.read(buf)) != -1) {
            bos.write(buf, 0, len);
            bos.flush();
        }
    }
}

class Student implements Serializable {
    private static final long serialVersionUID = 1L;
    private String name;
    private int age;

    public Student(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student [name=" + name + ", age=" + age + "]";
    }
}

这里有个问题，对象的序列化是方便了我们去操作多个类（对象存在字段中），但是如果是数据迁移的话这些二进制数据就完全失去了作用，那是否考虑存为json

呢，其实这种方法也不好，解析json也是个复杂的过程，最好的方式还是对象！当然这也因需求而异