Java-IO

public class Member {
    private String name;  
    private int age;  
    public Member() {  
    }  
   public Member(String name, int age) {  
        this.name = name;  
        this.age = age;  
    }  
    public void setName(String name){  
        this.name = name;  
    }  
    public void setAge(int age) {  
        this.age = age;  
    }  
    public String getName() {  
        return name;  
    }  
    public int getAge() {  
        return age;  
    }  
}

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

/**
 * DataOutputStream
 */
public class DataStreamTest {
    public static void main(String[] args) {
        Member[] members = { new Member("Justin", 90), 
                             new Member("momor", 95), 
                             new Member("Bush", 88) };
        try {
            DataOutputStream dos = new DataOutputStream(new FileOutputStream("E:/member.txt"));
            for (Member member : members) {
                // 写入UTF字符串
                dos.writeUTF(member.getName());
                // 写入int数据
                dos.writeInt(member.getAge());
            }
            dos.flush();// 将流中的数据刷新到目的地
            dos.close();// 关闭流

            DataInputStream dis = new DataInputStream(new FileInputStream("E:/member.txt"));
            // 读出数据并还原为对象
            for (int i = 0; i < members.length; i++) {
                String name = dis.readUTF();// 读出UTF字符串
                int score = dis.readInt();// 读出int数据
                members[i] = new Member(name, score);
            }
            dis.close();// 关闭流

            // 显示还原后的数据
            for (Member member : members) {
                System.out.printf("%s	%d%n", member.getName(), member.getAge());
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;

/**
 * FileInputStream  字节输入流
 */
public class FileInputStreamTest {
    public static void main(String[] args) {
        InputStream in = null;//文件输入流  
         try{  
             in = new FileInputStream(new File("E:/fileInputStreamTest.txt"));  
             /*
              * FileInputStream是有缓冲区的，所以用完之后必须关闭，否则可能导致内存占满，数据丢失。 
              */  
             int i = 0;//接收读取的内容
             //streamReader.read()从文件读取一个字节，并当做int类型返回，如果遇到文件末尾，则返回-1
             while((i = in.read())!=-1) {
                 System.out.print((char)i);//打印读取的内容
             }  
         }catch (final IOException e) {  
             e.printStackTrace();  
         }finally{  
             try{  
                 in.close();  //关闭流
             }catch (IOException e) {  
                e.printStackTrace();  
             }  
         }  
    }
}

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

/**
 * 文件拷贝
 */
public class FileCopy {
    public static void main(String[] args) {
         byte[] b=new byte[512];   //一次取出的字节数大小,缓冲区大小  
         int i=0;  
         FileInputStream input=null;  
         FileOutputStream out =null;  
         try {  
            input=new FileInputStream("E:/fileInputStreamTest.txt");  
            out=new FileOutputStream("E:/copy.txt",true); //如果文件不存在会自动创建,true表示写在文件末尾  
             
            while ((i=input.read(b))!=-1) { //i的目的在于防止最后一次读取的字节小于b长度,否则会自动被填充0
                //使用输出流写入读取的内容到指定文件
               out.write(b, 0, i);
            }  
         } catch (final IOException e) {  
            e.printStackTrace();  
         }finally{  
            try {  
               input.close();  
               out.close();  
            } catch (IOException e) {  
               e.printStackTrace();  
            }  
         }  
    }
}

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

/**
 * BufferedReader、BufferedWriter
 */
public class FileWriterTest {
    public static void main(String[] args) throws IOException{
        BufferedReader br = new BufferedReader(new FileReader(new File("E:/printTest.txt")));
        BufferedWriter bw = new BufferedWriter(new FileWriter(new File("E:/writeCopy.txt")));
        
        String str = null;
        try {
            while((str = br.readLine())!=null) { //一次读一行
                bw.write(str);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            br.close();
            bw.close();
        }
    }
}

import java.io.Serializable;

public class Student implements Serializable{
    
    private static final long serialVersionUID = 1L;
    private String name;  
    private int age;  
    public Student() {}
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public Student(String name, int age) {  
         this.name = name;  
         this.age = age;  
    }  
    @Override  
    public String toString() {  
        return "Student [name=" + name + ", age=" + age + "]";  
    }  
}

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.ArrayList;
import java.util.List;

/**
 *    ObjectOutputStream
 */
public class ObjectStream {
    public static void main(String[] args) {
        // 对象输入输出流
        ObjectOutputStream ow = null;
        ObjectInputStream or = null;
        List<Student> stuList = new ArrayList<Student>();
        Object obj = null;
        try {
            // 先将对象输出到文件中
            ow = new ObjectOutputStream(new FileOutputStream("E:/student.txt"));
            ow.writeObject(new Student("gg", 22));
            ow.writeObject(new Student("tt", 18));
            ow.writeObject(new Student("rr", 17));
            ow.writeObject(null);//添加一个null  是为了后续判断是否读取到末尾
            // 然后从该文件读取对象
            or = new ObjectInputStream(new FileInputStream("E:/student.txt"));
            
            while((obj = or.readObject())!=null) {
                stuList.add((Student) obj);// 将读取的对象强转成Student对象
            }
            for (Student student : stuList) {
                System.out.println(student.getName() + "-" + student.getAge());
            }
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } finally {
            try {
                ow.close();
                or.close();//关闭流
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

import java.io.FileReader;
import java.io.IOException;
import java.io.PrintWriter;

/**
 * PrintWriter
 */
public class PrintTest {
    public static void main(String[] args) {
        FileReader reader=null;        //读取字符文件的流  
        PrintWriter writer=null;    //写字符到控制台的流  
        char[] b=new char[512];   //一次取出的字节数大小,缓冲区大小  
        int i=0;  
        try {  
           reader=new FileReader("E:/fileInputStreamTest.txt");  
           //writer=new PrintWriter(System.out);  //输出到控制台
           writer=new PrintWriter("E:/printTest.txt");  //输出指定文件，没有自动创建
           
           while ((i = reader.read(b))!=-1) {  
              writer.write(b, 0, i);  
           }  
        } catch (IOException e) {  
           e.printStackTrace();  
        }finally{  
           try {  
              reader.close();  
           } catch (IOException e) {  
              e.printStackTrace();  
           }  
           writer.close();
        }  
    }
}

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.PushbackInputStream;
/**
 * 回退流：PushbackInputStream类继承了FilterInputStream类是iputStream类的修饰者。
 * 提供可以将数据插入到输入流前端的能力(当然也可以做其他操作)。
 * 简而言之PushbackInputStream类的作用就是能够在读取缓冲区的时候提前知道下一个字节是什么，
 * 其实质是读取到下一个字符后回退的做法，这之间可以进行很多操作，这有点向你把读取缓冲区的过程当成一个数组的遍历，
 * 遍历到某个字符的时候可以进行的操作，
 * 当然，如果要插入，能够插入的最大字节数是与推回缓冲区的大小相关的，插入字符肯定不能大于缓冲区吧！
 */
public class PushBackInputStreamTest {
    public static void main(String[] args) throws IOException {
        String str = "hello,rollenholt";  
        PushbackInputStream push = null; // 声明回退流对象  
        ByteArrayInputStream bat = null; // 声明字节数组流对象  
        bat = new ByteArrayInputStream(str.getBytes());  
        push = new PushbackInputStream(bat); // 创建回退流对象，将拆解的字节数组流传入  
        int temp = 0;  
        while ((temp = push.read()) != -1) { // push.read()逐字节读取存放在temp中，如果读取完成返回-1  
           if (temp == ',') { // 判断读取的是否是逗号
              push.unread(temp); //回到temp的位置  
              temp = push.read(); //接着读取字节  
              System.out.print("(回退" + (char) temp + ") "); // 输出回退的字符  
           } else {  
              System.out.print((char) temp); // 否则输出字符  
           }  
        }  
    }
}

import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.SequenceInputStream;
import java.util.Enumeration;
import java.util.Vector;

/**
 * SequenceInputStream
 */
public class SequenceInputStreamTest {
     /** 
       *  SequenceInputStream合并流，
       *   将与之相连接的流集组合成一个输入流并从第一个输入流开始读取， 
       *   直到到达文件末尾，接着从第二个输入流读取，依次类推，直到到达包含的最后一个输入流的文件末尾为止。 
       *   合并流的作用是将多个源合并合一个源。可接收枚举类所封闭的多个字节流对象。 
       */  
      public static void main(String[] args) {  
         doSequence();  
      }  
      private static void doSequence() {  
         // 创建一个合并流的对象  
         SequenceInputStream sis = null;  
         // 创建输出流。  
         BufferedOutputStream bos = null;  
         try {  
            // 构建流集合。  
            Vector<InputStream> vector = new Vector<InputStream>();  
            vector.addElement(new FileInputStream("E:/text1.txt"));  
            vector.addElement(new FileInputStream("E:/text2.txt"));  
            vector.addElement(new FileInputStream("E:/text3.txt"));  
            Enumeration<InputStream> e = vector.elements();  
       
            sis = new SequenceInputStream(e);  //将多个输入流合并到合并流
            bos = new BufferedOutputStream(new FileOutputStream("E:/text4.txt",true));//true追加末尾
            // 读写数据  
            byte[] buf = new byte[1024];  
            int len = 0;  
            while ((len = sis.read(buf)) != -1) {  
               bos.write(buf, 0, len);  
               bos.flush();
            }  
         } catch (FileNotFoundException e1) {  
            e1.printStackTrace();  
         } catch (IOException e1) {  
            e1.printStackTrace();  
         } finally {  
            try {  
               if (sis != null)  
                  sis.close();  
            } catch (IOException e) {  
               e.printStackTrace();  
            }  
            try {  
               if (bos != null)  
                  bos.close();  
            } catch (IOException e) {  
               e.printStackTrace();  
            }  
         }  
      }  
}