IO流基礎使用

IO流基礎使用，留着複習

8位1字節，2個字節1個字符
字節流：主要有InputStream、OutputStream作爲基類
字符流：主要有Reader、Writer作爲基類

輸入流
InputStream：
    int read();
    int read(byte[] b);
    int read(byte[] b,int off,int len);
Reader：
    int read();
    int read(char[] cbuf);
    int read(char[] cbuf,int off,int len);
輸出流
OutputStream：
    void write(int c);
    void write(byte[]/char[] buf);
    void write(byte[]/char[] buf,int off,int len);
Write：
    void write(String str);
    void write(String str,int off,int len);
    
轉換流
    InputStreamReader：將字節輸入流轉換成字符輸入流
    OutputStreamReader：將字節輸出流轉換成字符輸出流
    
緩衝流
    字節緩衝流
        BufferedInputStream
        BufferedOutputStream
    字符緩衝流
        BufferedReader
        BufferedWriter

 

基本使用：

public class FileDemo {

	public static void main(String[] args) throws IOException {
		byteStream();
		charStream();
		streamReader();
		inputBuffer();
		streamReaderBuffer();
	}
	
	/**
	 * 	字節流
	 * @throws IOException
	 */
	public static void byteStream() throws IOException {
		//字節流複製文件
		/*InputStream fis = new FileInputStream("F:/xuehao.jpg");
		OutputStream fos = new FileOutputStream("F:/shawanyi.jpg");;
		int read = 0;
		while(read != -1) {
			read = fis.read();
			fos.write(read);
		}
		fis.close();
		fos.close();*/
		
		InputStream fis = new FileInputStream("F:/xuehao.jpg");
		OutputStream fos = new FileOutputStream("F:/byteStream.jpg");;
		byte[] bytes = new byte[1024 * 4];
		int read;
		while((read = fis.read(bytes)) != -1) {
			fos.write(bytes,0,read);
		}
		fis.close();
		fos.close();
	}
	
	/**
	 * 	字符流    字符流不要複製圖片，會出現圖片寫入錯誤
	 * @throws IOException
	 */
	public static void charStream() throws IOException {
//		File f = new File("F:/demo.txt");
//		Writer out=new FileWriter(f);
//		out.write("demo text~~~~~");
//		out.close();
		
		//字符流複製文本文件，不要複製圖片
		File f = new File("F:/demo.txt");
		File outFile = new File("F:/charStream.txt");
		Writer out = new FileWriter(outFile);
		Reader reader=new FileReader(f);
		char[] c = new char[1024*4];
		int len;
		while((len = reader.read(c)) != -1) {
			out.write(c,0,len);
		}
		reader.close();
		out.close();
	}
	
	/**
	 *	字節流字符流之間轉換	
	 * @throws IOException
	 */
	public static void streamReader() throws IOException {
		File file = new File("F:/demo.txt");
		FileInputStream fis = new FileInputStream(file);//字節流
		InputStreamReader isr = new InputStreamReader(fis);//轉換流
		Writer writer = new FileWriter("F:/streamReader.txt");
		char[] c = new char[1024 * 4];
		int len;
		while((len = isr.read(c)) != -1) {
			writer.write(c,0,len);
		}
		writer.close();
		isr.close();
		fis.close();
	}
	
	/**
	 * 	字節流用緩衝流形式輸出
	 * @throws IOException
	 */
	public static void inputBuffer() throws IOException {
		File file = new File("F:/xuehao.jpg");
		FileInputStream fis = new FileInputStream(file);
		BufferedInputStream bis = new BufferedInputStream(fis);
		File fileout = new File("F:/inputBuffer.jpg");
		FileOutputStream fos = new FileOutputStream(fileout);
		BufferedOutputStream bos = new BufferedOutputStream(fos);
		int len;
		byte[] b = new byte[1024 * 2];
		while((len = bis.read(b)) != -1) {
			bos.write(b,0,len);
		}
		bos.flush();
		bos.close();
		fos.close();
		bis.close();
		fis.close();
	}
	
	/**
	 * 	字節流轉換字符流，用緩衝流形式輸出
	 * @throws IOException
	 */
	public static void streamReaderBuffer() throws IOException {
		File file = new File("F:/demo.txt");
		FileInputStream fis = new FileInputStream(file);//字節流
		InputStreamReader isr = new InputStreamReader(fis);//轉換流
		BufferedReader bufferedReader = new BufferedReader(isr);
		
		Writer writer = new FileWriter("F://streamReaderBuffer.txt");
		BufferedWriter bufferedWriter = new BufferedWriter(writer);
		char[] c = new char[1024 * 4];
		int len ;
		while((len = bufferedReader.read(c)) != -1) {
			bufferedWriter.write(c,0,len);
		}	
		//關流的時候    先開後關
		bufferedWriter.flush();
		bufferedWriter.close();
		writer.close();
		bufferedReader.close();
		isr.close();
		fis.close();
	}
}