java io实例具体解释

import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.io.PipedInputStream;
import java.io.PipedOutputStream;
import java.io.PrintStream;
import java.io.PushbackInputStream;
import java.io.RandomAccessFile;
import java.io.SequenceInputStream;
import java.io.Serializable;
import java.io.Writer;
import java.util.zip.ZipEntry;
import java.util.zip.ZipException;
import java.util.zip.ZipFile;
import java.util.zip.ZipOutputStream;


import org.junit.Before;
import org.junit.Test;


/**
 * 流操作
 * @author Administrator
 *
 */
public class FileOpera {
//String path="";
String str="";
@Before
public void init(){
  //path="d:"+File.separator+"test";
  str="d:"+File.separator+"test"+File.separator+"test.txt";
}
/*使用RandomAccessFile写入文件*/
@Test 
     public void testAccess() throws IOException{
  init();
  File file=new File(str);
  RandomAccessFile f=new RandomAccessFile(file,"rw");
  f.writeBytes("abcdef");
  f.writeInt(21);
  f.writeDouble(32.11);
  f.close();  //会乱码
}
/*字节流输出到文件OutputStream InputputStream*/
@Test
public void testByte1() throws IOException{
 init();
 File file =new File(str);
 //OutputStream out=new FileOutputStream(file);
 OutputStream out=new FileOutputStream(file,true);
 String s="总共多少人";
 out.write(s.getBytes());//按字节
 out.flush();
 out.close();
}
/*字符流输出到文件 Reader(读) Writer(写)*/
@Test
public void testReader() throws IOException{
init();
File file=new File(str);
Writer writer=new FileWriter(file,true);
//Writer writer=new OutputStreamWriter(new FileOutputStream(file));//将字节输出流转换为字符输出流
writer.write("你好世界");
writer.flush();
writer.close();
}
/*内存字节流-------------使用内存操作流（字节方式）ByteArrayInputStream ByteArrayOutputStream*/
@Test
public void testByte() throws IOException{
String str="ROLLENHOLT";
        ByteArrayInputStream input=new ByteArrayInputStream(str.getBytes());//以字节数组方式读入缓存区
        ByteArrayOutputStream output=new ByteArrayOutputStream();
        int temp=0;
        while((temp=input.read())!=-1){
            char ch=(char)temp;
            output.write(Character.toLowerCase(ch));
        }
        String outStr=output.toString();
        input.close();
        output.close();
        System.out.println(outStr);
}
/*字节管道流 主要是进行两个线程之间的通信  PipedOutputStream PipedInputStream */
@Test
public void testPied(){
Send send=new Send();
        Revice recive=new Revice();
        try{
            //管道连接
            send.getOut().connect(recive.getInput());
        }catch (Exception e) {
            e.printStackTrace();
        }
        new Thread(send).start();
        new Thread(recive).start();
}
class Send implements Runnable{
        private PipedOutputStream out=null;
        public Send(){
         out= new PipedOutputStream(); 
        }
        public PipedOutputStream getOut(){
          return this.out;
        }
@Override
public void run() {
String message="hello 中国";
       try{
           out.write(message.getBytes());
       }catch (Exception e) {
           e.printStackTrace();
       }try{
           out.close();
       }catch (Exception e) {
           e.printStackTrace();
       }
}

}
class Revice implements Runnable{
private PipedInputStream input=null;
   public Revice(){
       this.input=new PipedInputStream();
   }
   public PipedInputStream getInput(){
       return this.input;
   }
   public void run(){
       byte[] b=new byte[1000];
       int len=0;
       try{
           len=this.input.read(b);
       }catch (Exception e) {
           e.printStackTrace();
       }try{
           input.close();
       }catch (Exception e) {
           e.printStackTrace();
       }
       System.out.println("接受的内容为 "+(new String(b,0,len)));
   }
}
/*打印流 PrintStream*/
@Test
public void testPrint() throws FileNotFoundException{
   init();
   File file=new File(str);
   PrintStream print=new PrintStream(new FileOutputStream(file,true));
   print.print("爱我中华");
   print.flush();
   print.close();
}
/*输出到屏幕上*/
@Test
public void testSreen(){
OutputStream out=System.out;
        try{
            out.write("hello".getBytes());
        }catch (Exception e) {
            e.printStackTrace();
        }
        try{
            out.close();
        }catch (Exception e) {
            e.printStackTrace();
        }
}
/*输入输出重定向*/
@Test
public void testRedirect(){
// 此刻直接输出到屏幕
        System.out.println("hello");
        init();
        File file = new File(str);
        try{
            System.setOut(new PrintStream(new FileOutputStream(file,true)));
        }catch(FileNotFoundException e){
            e.printStackTrace();
        }
        System.out.println("这些内容在文件里才干看到哦！");
        
        //重定向err输出
        System.err.println("这些在控制台输出");
        try{
            System.setErr(new PrintStream(new FileOutputStream(file,true)));
        }catch(FileNotFoundException e){
            e.printStackTrace();
        }
        System.err.println("这些在文件里才干看到哦！

");
}
/*BufferedReader仅仅能接受字符流的缓冲区。由于每个中文须要占领两个字节，所以须要将System.in这个字节输入流变为字符输入流，採用*/
@Test
public void testBuffer(){
BufferedReader buf = new BufferedReader(new InputStreamReader(System.in));//将字节流转化为字符流
        String str = null;
        System.out.println("请输入内容");
        try{
            str = buf.readLine();
        }catch(IOException e){
            e.printStackTrace();
        }
        System.out.println("你输入的内容是：" + str);
}
/*数据操作流DataOutputStream、DataInputStream类*/
@Test
public void testData() throws IOException{
init();
File file=new File(str);
char[] ch = { ‘A‘, ‘B‘, ‘C‘ };
DataOutputStream out=new DataOutputStream(new FileOutputStream(file,true));
for(char temp : ch){
           out.writeChar(temp);
    }
    out.close();
}
/*合并流 SequenceInputStream*/
@Test
public void testSequence() throws IOException{
File file1 = new File("d:" + File.separator +"test"+File.separator+"test.txt");
        File file2 = new File("d:" + File.separator +"test"+File.separator+"hello2.txt");
        File file3 = new File("d:" + File.separator +"test"+File.separator+"hello.txt");
        if(!file1.exists()){
          file1.createNewFile();
        }
        if(!file2.exists()){
             file2.createNewFile();
    }
   if(!file3.exists()){
      file3.createNewFile();
    }
        InputStream input1 = new FileInputStream(file1);
        InputStream input2 = new FileInputStream(file2);
        OutputStream output = new FileOutputStream(file3);
        // 合并流
        SequenceInputStream sis = new SequenceInputStream(input1, input2);
        int temp = 0;
        while((temp = sis.read()) != -1){
            output.write(temp);
        }
        input1.close();
        input2.close();
        output.close();
        sis.close();
}
/*文件压缩 ZipOutputStream类*/
@Test
public void testZip() throws IOException{
 init();
 File file=new File(str);
 String path="d:"+File.separator+"test"+File.separator+"test.zip";
 File zipFile=new File(path);
 InputStream in=new FileInputStream(file);
 ZipOutputStream zip=new ZipOutputStream(new  FileOutputStream(zipFile));
 zip.putNextEntry(new ZipEntry(file.getName()));
       // 设置凝视
       zip.setComment("hello");
       int temp = 0;
       while((temp = in.read()) != -1){
           zip.write(temp);
       }
       in.close();
       zip.close();
}
/*解压缩ZipFile类*/
@Test
public void testZipFile() throws ZipException, IOException{
init();
String str="d:"+File.separator+"test"+File.separator+"test.zip";
String path="d:"+File.separator+"test"+File.separator+"zip.txt";
File file=new File(str);
File zipf=new File(path);
ZipFile zipFile = new ZipFile(file);
System.out.println("压缩文件的名称为：" + zipFile.getName());
ZipEntry entry = zipFile.getEntry("test.txt");
        InputStream input = zipFile.getInputStream(entry);
        OutputStream output = new FileOutputStream(zipf);
        int temp = 0;
        while((temp = input.read()) != -1){
            output.write(temp);
        }
        input.close();
        output.close();
}
/*PushBackInputStream回退流*/
@Test
public void testPush() 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){
            if(temp == ‘,‘){
                push.unread(temp);
                temp = push.read();
                System.out.print("(回退" + (char) temp + ") ");
            }else{
                System.out.print((char) temp);
            }
        }
}
/*System 类的一些操作*/
@Test
public void testSys(){
System.out.println("系统默认编码为：" + System.getProperty("file.encoding"));
}
/**
* 将一个对象流化即实现Serializable接口（默认将所有属性序列化）还能够实现一组对象的序列化
* 假设不想所有属性被实例化能够在实体中使用如private transient String name;  transient属性
* 能够在对象输入（ObjectInputStream）输出（ObjectOutputStream）流中直接操作对象
* 
* 实现Externalizable接口。能够将部分属性实例化
* 
* 
* @throws IOException 
* @throws ClassNotFoundException 
*/
/*ObjectOutputStream*/
@Test
public void testObject() throws IOException, ClassNotFoundException{
   init();
   File file = new File(str);
       ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(file,true));
       oos.writeObject(new Person("laoma", 20,"男"));
       oos.close();
       
       //查看
       ObjectInputStream input = new ObjectInputStream(new FileInputStream(file));
       Object obj = input.readObject();
       input.close();
       System.out.println(obj);
}

/*PushBackInputStream回退流*/
@Test
public void testRect(){

}

}

參考自：http://www.cnblogs.com/rollenholt/archive/2011/09/11/2173787.html