IO流

创建源 -> 选择流 -> 操作 -> 释放

节点流 1.2.3.4.

1.访问文件

• FileInputStream
• FileOutputStream

  //创建源
    File fileIn=new File("D:\note.txt");
    File fileOut=new File("D:\out.txt");
    //选择流
    FileInputStream fis=new FileInputStream(fileIn);
    FileOutputStream fos=new FileOutputStream(fileOut);
    //操作
     //中间容器
    byte[] flush=new byte[1024];
     //接受长度
    int len=0;
     //循环读取
    while((len=fis.read(flush))!=-1) {
     //写出
     fos.write(flush,0,len);
    }
    //释放
    fos.close();
    fis.close();

• FileReader
• FileWriter

//创建源
File fileIn=new File("D:\note.txt");
File fileOut=new File("D:\out.txt");
//选择流
FileReader fr=new FileReader(fileIn);
FileWriter fw=new FileWriter(fileOut);
//操作
 //中间容器
char[] flush=new char[1024];
 //接受长度
int len=0;
 //循环读取
while((len=fr.read(flush))!=-1) {
 //写出
 fw.write(flush,0,len);
}
//释放
fw.close();
fr.close(); 

2.访问(字节/字符)数组

• ByteArrayInputStream

• ByteArrayOutputStream

• CharArrrayReader

• CharArrayWriter

3.访问管道//?

• PipedInputStream

• PipedOutputStream

  （1）是线程间传输数据的一种方式 （2）PipedOutStream作为源点往管子写数据，PipedInputStream作为终点去读数据。这个Pipe是一块缓冲区。 （3）缓冲区类似于环形的缓冲区，但遇满就会阻塞停止写入。

• PipedReader

• PipedWriter

4.访问字符串

• StringReader
• StringWriter

//StringReader
     String s="当月色染云鬓成霜";
     StringReader sr=new StringReader(s);
     char[] flush=new char[1024];
     int len=0;
     while((len=sr.read(flush))!=-1) {
     System.out.println(new String(flush,0,len));
     }
     //StringWriter
     StringWriter sw=new StringWriter(); 
     sw.write("haha");
     sw.append(" lowlow ");
     sw.write("haha");
     System.out.println(sw.toString());//打印出haha lowlow haha
     //释放
     sr.close();
     sw.close();

5.对象流

• ObjectInputStream
• ObjectOutputStream

//ObjectOutputStream
     //创建流
     ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream(new               File("D:\out.txt")));
     //写入
     oos.writeDouble(123.456);
     oos.writeInt(369);
     oos.writeBoolean(true);
     oos.writeUTF("不约儿童");
     //释放
     oos.close();

    //ObjectInputStream
     //创建流
     ObjectInputStream ois=new ObjectInputStream(new FileInputStream(new                  File("D:\out.txt")));
     //读取(读与写的顺序一致)
     double d=ois.readDouble();
     int i=ois.readInt();
     boolean b=ois.readBoolean();
     String s=ois.readUTF();
     //释放
     ois.close();

6.转换流

• InputStreamReader

• OutputStreamWriter

  字节流转字符流，可以编码解码

    //InputStreamReader
     File f=new File("D:\note.txt");
     InputStreamReader isr=new InputStreamReader(new FileInputStream(f),"gbk");
     char[] flush=new char[1024];
     while(isr.read(flush)!=-1) {
     System.out.println(new String(flush));
     }
     isr.close();
     //OutputStreamWrter
     File file=new File("D:\out.txt");
     OutputStreamWriter osw=
     new OutputStreamWriter(new FileOutputStream(file),"gbk");
     osw.append("什么妖魔鬼怪");
     osw.close();

过滤器流

7.缓冲流

• 不带缓冲的操作，每读一个字节就要写入一个字节，由于涉及磁盘的IO操作相比内存的操作要慢很多，所以不带缓冲的流效率很低。

• 带缓冲的流，可以一次读很多字节，但不向磁盘中写入，只是先放到内存里。等凑够了缓冲区大小的时候一次性写入磁盘，这种方式可以减少磁盘操作次数，速度就会提高很多！

• 所谓的buffer其实就是一个byte[]。 BufferedOutputStream的每一次write其实是将内容写入byte[]，当buffer容量到达上限时，会触发真正的磁盘写入。 而另一种触发磁盘写入的办法就是调用flush()，BufferedOutputStream在close()时会自动flush 。

• 关闭流时只关闭外层的处理流

• BufferedInputStream
• BufferedOutputStream

   //选择流
    BufferedInputStream bis=new BufferedInputstream(fis);
    BufferedOutputstream bos=new BufferedOutputStream(fos);
    //释放
    bos.close();
    bis.close();

• BufferedReader
  • read(char[])
  • readLine()
• BufferedWriter

//选择流
    BufferedReader br=new BufferedReader(fr);
    BufferedWriter bw=new BufferedWriter(fw);
    String line;
     //循环读取:使用readLine()方法
    while((line=br.readLine())!=null) {
     //操作
     bw.write(line+"
");
    }
    //释放
     bw.close();
     br.close();

8.数据流

• DataInputStream

• DataOutputStream

只能处理基本类型和字符串，无法处理Object

9.打印流

• PrintStream

写数据入文件方便，print()传入什么类型的数据，就会写入什么类型的数据

PrintStream ps=new PrintStream(new  File("D:\out.txt"));
 ps.append("asd");
 ps.println(234);
 ps.append("nn");
 ps.close();

10.推回输入流

• PushbackInputStream

• PushbackReader

Pushback用于输入流允许字节被读取,然后返回（即“推回”）到流。

//选择流
    	ByteArrayInputStream bais=new ByteArrayInputStream("abcdefg".getBytes());
    	PushbackInputStream pis=new PushbackInputStream(bais);
    	//操作
    	int len=0;
    	while((len=pis.read())!=-1) {
    		if((char)len=='d') {
    			pis.unread('s');
    		}
    		System.out.print((char)len);
    	}
    	//释放
    	pis.close();

其他

System.in/.out/.err/setIn()/setOut()