[Java]IO操作/输入流输出流/文件流/包装流

》》分类（各种都有输入输出）

》四大基流

字节流（多用于二进制文件）InputSream和OutStream

字符流（多用于文章以及有特殊字符的包括中文的文件）Reader和Writer

》文件流(纯文本txt）

FileReader文件的字符输入流

FileWriter文件的字符输出流

FileOutputStream文件的字节输出流

FileInputStream文件的自己输入流

字节流代码

package 文件流;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Arrays;

public class FileStream {

	public static void inputStream() throws Exception {
		String dir = "src/file/stream.txt";
		File file = new File(dir);
		InputStream input = new FileInputStream(file);
		
		// 具体的读取操作
		int data = input.read();//指针，读取一个字节，运行一次读一个
		System.out.println(data);
		
		 byte[] buffer = new byte[5];
         input.read(buffer);
         System.out.println(Arrays.toString(buffer));
         System.out.println(input.read(buffer));// 5 读取了5个字节

		
		//最常用的操作，建立一个缓冲区，一次读读取n个,n=byte数
		byte[] buffer2 = new byte[1024];
		int len = -1;// 表示当前读取的字节总数，为-1时已经读完了
		while ((len = input.read(buffer2)) != -1) {
			//将读出来的数据放进一个数组里
			String str = new String(buffer2, 0, len);
			System.out.println(str);
		}
		input.close();
	}

	public static void outStream() throws Exception {
		/*
		 * 1.创建目标对象，表示把数据保存到哪一个文件 
		 * 2.创建文件字节输出流对象，看它的构造器
		 * 3.具体的输出操作，往外写操作。
		 * 4.关闭资源对象
		 */
		// 注意默认是当前文件夹路径
		String dir = "src/file/stream.txt";// 文件可以创建， 目录创建不了
		File file = new File(dir);
		
		OutputStream output = new FileOutputStream(file, true);
		// 默认FileOutputStream(file,false)，表示覆盖且不追加字符

		output.write(65);
		output.write("tiffany".getBytes());
		output.write("tiffany".getBytes(), 0, "lsaj".length());
		output.close();
	}

	public static void main(String[] args) throws Exception {
		outStream();//把东西写进文件里
		inputStream();//把文件的东西读出来

	}

}

字节流代码

package 文件流;

import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;

public class FileCharacter {

	public static void output() throws Exception {
		String scr = "src/file/Character.txt";
		File dicfile = new File(scr);
		FileWriter out = new FileWriter(dicfile,true);//不加true不追加
		out.write("哈哈哈");
		out.write("ABCDE", 3, 2);// DE
		out.write("\n");
		out.write("HIJKL");

		out.flush();// 在close之前会自动调用
		out.close();

	}

	public static void input() throws Exception {
		/*
		 * 1.创建源 
		 * 2.创建流对象 
		 * 3.读取
		 * 4.关闭流
		 */

		String scr = "src/file/Character.txt";
		File scrFile = new File(scr);
		FileReader in = new FileReader(scrFile);

		char[] buffer = new char[5];//一次读[]个
		int len = -1;
		len = in.read(buffer);
		while (len != -1) {
			System.out.println(buffer);
			len = in.read(buffer);
		}

//		int ch = in.read();// 一次读取一个字符
//		System.out.print((char) in.read());
//		System.out.print((char) in.read());
//		System.out.print((char) in.read());
//		System.out.print((char) in.read());
//		System.out.print((char) in.read());

		in.close();

	}

	public static void main(String[] args) throws Exception {
		output();
		input();
	}

}

》包装流（对节点流有增强功能，因为节点流太慢了……，节点包括字符和字节）

包装流隐藏了底层节点流的差异，并对外提供了更方便的输入\输出功能，让我们只关心这个高级流的操作

使用包装流包装了节点流，程序直接操作包装流，而底层还是节点流和IO设备操作

关闭包装流的时候，只需要关闭包装流即可

》分类

缓冲流

BufferedOutputStream字节缓冲输出流

BufferedInputStream字节缓冲输出流

BufferedWriter字节缓冲字符输出流

BufferedRead字节缓冲字符出入流

字节缓冲流代码

package 缓冲流;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.OutputStream;

public class BufferedStream {

	public static void main(String[] args) throws Exception {

		// 写操作
		OutputStream out = new FileOutputStream("src/file/stream.txt");
		BufferedOutputStream buf = new BufferedOutputStream(out);
		// 简写 ，true允许追加,运行一次追加一次
		// BufferedOutputStream buf2 = new BufferedOutputStream(new
		// FileOutputStream("stream2.txt",true));

		buf.write("hello,tiffany".getBytes());
		buf.write("hhhh".getBytes());
		buf.close();

		// 读操作
		BufferedInputStream bin = new BufferedInputStream(new FileInputStream(
				"src/file/stream.txt"));
		byte[] buffer = new byte[1024];
		int len = -1;
		while ((len = bin.read(buffer)) != -1) {
			System.out.println(new String(buffer, 0, len));
		}
		bin.close();

	}

}

字符缓冲流代码

package 缓冲流;

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

public class BufferedCharacter {

	public static void main(String[] args) throws Exception {
		
		
		//写操作
		  BufferedWriter bufout = new BufferedWriter(new FileWriter("src/file/rw.txt"));
          bufout.write("Tiffany");
          bufout.newLine();
          bufout.write("缓冲流读写操作");
          bufout.close();
          
          
          //读操作
          BufferedReader bufin =  new BufferedReader(new FileReader("src/file/rw.txt"));
//        char[] buffer = new char[1024];
//        int len = -1;
//        while((len= in.read(buffer))!=-1){
//              System.out.println(new String(buffer,0,len));//直接写会有白板，所有New 一个String 包装一下
//              len = in.read(buffer);
//        }
          
          
          //一行行读，增强功能
          String line = null;
          while((line = bufin.readLine())!=null){
                System.out.println(line);
          }
          
          bufin.close();
    }


	}

数组流（内存流）：把流放进内存或取出内存

ByteArrayInputStream字节数组输入流

ByteArrayOutStream字节数组输出流

CharArrayReader字符数组输入流

CharArrayWriter字符数组输出流

StringWriter字符串输出流

StringReader字符串输入流

字节数组流

package 内存流;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;

public class ByteArrayStream {

	public static void main(String[] args) throws Exception {

		 //字节输出流 程序--->内存
	      ByteArrayOutputStream   bos = new ByteArrayOutputStream();
	      bos.write("ABCDEFG".getBytes());
	      //要使用存储的临时数据
	      byte[] buffer = bos.toByteArray();
	      
	      //自己输入流：内存--->程序
	      ByteArrayInputStream    bis = new ByteArrayInputStream(buffer);
	      byte[] bys = new byte[5];
	      int len = -1;
	      while((len = bis.read(bys))!=-1){
	            System.out.println(new String(bys,0,len) );
	      }
	      

		
	}

}

字节数组流

package 内存流;

import java.io.CharArrayReader;
import java.io.CharArrayWriter;

public class CharArray {

	public static void main(String[] args) throws Exception {
		
		 // 字符输出流 程序--->内存
        CharArrayWriter bos = new CharArrayWriter();
        bos.write("ABCDEFG");
        // 要使用存储的临时数据
        char[] buffer = bos.toCharArray();
        // 自己输入流：内存--->程序
        CharArrayReader bis = new CharArrayReader(buffer);
        char[] bys = new char[5];
        int len = -1;
        while ((len = bis.read(bys)) != -1)
        {
              System.out.println(new String(bys, 0, len));
        }


	}

}

字符串流

package 内存流;

import java.io.StringReader;
import java.io.StringWriter;

public class Strings {

	public static void main(String[] args) throws Exception {
		 //字符串的输入流
        StringWriter sw = new StringWriter();
        sw.write("现在是少女时代，以后是少女时代，永远是少女时代");
        System.out.println(sw.toString());
        
        //字符的输出流
        StringReader sr = new StringReader(sw.toString());
        char[] buffer = new char[1024];
        int len = -1;
        while((len = sr.read(buffer))!=-1){
              System.out.println(new String(buffer,0,len));
        }
        sr.close();
        sw.close();

	}

}

转换流：把字节流转换成字符流

要操作中文，但如果接收的是二进制文件，只能用转换流转换

InputStreamReader

OutStreamWriter

package 转换流;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.Reader;
import java.io.Writer;

public class StreamTransform {

	public static void main(String[] args) throws Exception {

		File copyFile = new File("src/file/stream.txt");
		File pasteFile = new File("src/file/Character.txt");

		Reader in = new InputStreamReader(new FileInputStream(copyFile), "gbk");
		Writer out = new OutputStreamWriter(new FileOutputStream(pasteFile),
				"gbk");

		char[] buffer = new char[1024];
		int len = -1;
		len = in.read(buffer);
		while (len != -1) {
			out.write(buffer, 0, len);
			len = in.read(buffer);
		}

		in.close();
		out.close();

	}

}