Java順序設計學習筆記（三）—— IO。本站提示廣大學習愛好者：（Java順序設計學習筆記（三）—— IO）文章只能為提供參考，不一定能成為您想要的結果。以下是Java順序設計學習筆記（三）—— IO正文
時間：2016-3-24 11:02
——IO流（Input/Output）
IO流用來處置設備之間的數據傳輸。
Java對數據的操作是經過流的方式。
Java關於操作流的對象都在IO包中。
流按操作數據分為兩種：字節流與字符流。
字符流為了處置文本數據，可以在外部交融編碼表，編碼表可以自己指定，處置文字時不會呈現亂碼。
圖片等文件運用字節流。
首個中國編碼表——GB2312
後來停止了一次擴容——GBK
再後來為了方便運用，將世界上各個國度的編碼表交融——Unicode，在Unicode編碼表中無論什麼字符，都用兩個字節來表示。
前期Unicode停止了優化，發生了UTF-8，在UTF-8中，能用一個字符就用一個字符，增加空間糜費。
字符流的由來：
不同編碼表之間的字符會發生亂碼，為了防止此景象的發作，Java在流技術上，就基於字節流發生了字符流，字符流可以在字
符流外部指定編碼表，從而處理不同編碼表之間的亂碼問題。
通用字節流，字符流是基於字節流的。
流按流向分為：輸出流和輸入流。
——字符流
FileReader、FIleWriter、BufferedReader、BufferedWriter
1、IO流常用基類（這四個類都是籠統類）
字節流的籠統基類：
InputStream，OutputStream
字符流的籠統基類：
Reader，Writer
注：由這四各類派生出來的子類稱號都是以其父類名作為自類名的後綴。
如：InputStream的子類FileInputStream
如：Reader的子類FileReader
後綴名是父類名，前綴名是該流對象的功用。
2、Writer類
是籠統類，結構辦法是protected，也就是只能在子類中運用。
Writer類的個性辦法：
Writer append(char c)
abstract void close()
封閉流，並刷新流。
當流封閉後，不能再運用write辦法。
abstract void flush()
刷新流
void write(int c)
寫入單個字符。
write()辦法僅僅是將數據寫入到內存當中，也就是寫入到流中，想要將數據寫入文件，需求刷新流。flush()辦法刷新流。
void write(char[] cbuf)
寫入字符數組。
void write(String str)
寫入字符串。
void write(String str,int off,int len)
寫入字符串的某一局部。
str--字符串 off--絕對初始寫入字符的偏移量（從哪開端） len--要寫入的字符數。
既然IO流是用於操作數據的，數據的最罕見表現方式是：文件，那麼就以操作文件為主來演示。
需求：
在硬盤上，創立一個文件並寫入一些文字數據。
找到一個專門用於操作文件的Writer子類對象：FileWriter，前綴名是功用，後綴名是父類名。
（可以發現，Writer完成的子類特點：前綴名是功用，後綴名是父類名）
public static void main(String[] args) throws IOException
{
//創立一個FileWriter對象，該對象一被創立就必需明白被操作的文件
//因而該類沒有無參結構辦法。
FileWriter fw = new FileWriter("aaaass.txt");
fw.write("akkkk");
fw.flush();
fw.close();
}
3、FileWriter
結構辦法：
FileWriter(String fileName)
依據給定的文件名結構一個FileWriter流對象。
FileWriter(String fileName, boolean append)
依據給定的文件名以及指示能否附加寫入數據的boolean值來結構一個FileWriter流對象。
append：一個boolean值，假如為true，則將數據寫入文件末尾處，而不是寫入文件開端處。
也就是完成了文件的續寫，不再從文件掃尾寫數據了。
假如文件不存在，先創立文件再續寫，假如文件存在，直接續寫。
在Windows操作零碎中，換行符是：\r\n
在Linux操作零碎中，換行符是：\n
承繼自Writer的辦法：
abstract void close()
封閉流，並且刷新流。
abstract void flush()
刷新該流的緩沖。
void write(int c)
寫入單個字符。
void write(String str)
寫入字符串。
void write(String str,int off,int len)
寫入字符串的某一局部。
void wrie(cha[] cbuf)
寫入字符數組。
abstract void write(char[ ] cbuf,int off,int len)
寫入字符數組的某一局部。
4、IO異常處置
但凡能和設備發生關系的操作都會發作異常。
FileWriter fw = null; //需求將fw定義在try內部，否則finally無法訪問。
try
{
fw = new FileWriter("A:\\demo3.txt");
fw.write("123123");
}
catch(IOException e)
{
System.out.println("hello"+e.toString());
}
finally
{
try
{
if(fw != null) //封閉流之前需求判別一下fw能否為null，由於假如fw對象創立失敗，調用close時會拋出空指針異常。
fw.close(); //關活動作一定要執行，所以放在finally中，封閉前先判別有沒有流。
}
catch(IOException e2)
{
System.out.println(e2.toString());
}
}
5、FileReader
用來讀取字符文件的便捷類，此類的結構辦法有默許的字符編碼和默許字節緩沖區。
默許編碼可以經過getProperties()辦法獲取以後零碎的編碼。，該編碼表是可變化的。
將文本讀入流中。
結構辦法：
該類的對象一被創立就必需明白要操作的文件，所以該類沒有無參結構辦法。
FileReader(String fileName)
在給定從中讀取數據的文件名的狀況下創立一個新的FileReader流對象。
並且該文件會被創立到指定目錄下，假如該目錄下已有同名文件，將掩蓋原文件。
FileWriter(File file)
指定文件。
承繼自Reader的辦法：
abstract void close()
封閉流並釋放與之關聯的一切資源。
並不刷新流。
int read()
讀取單個字符，前往的是int型的ASCII碼值。
read辦法一次讀取一個字符，而且會自動往下讀。
假如讀到文件的末尾，會前往-1。
代碼示例：
//一次讀取一個字符
public static void main(String[] args)throws IOException
{
//創立一個文件讀取流對象，和指定稱號的文件相關聯
//要保證該文件是存在的
//假如不存在，會發作異常：FileNotFoundException，這個異常是IOException的子類。
FileReader fr = new FileReader("Demo.txt");
int ch = 0;
//調用讀取流對象的read辦法
while((ch = fr.read()) != -1)
{
System.out.print((char)ch);
}
fr.close();
}
int read(char [ ] buff)
將字符讀入數組，前往的是int型的字符個數。
沒有直接讀字符串的辦法。
通常字符數組的長度定義為1024或許是1024的整數倍。
代碼示例：
//運用字符數組讀取字符
public static void main(String[] args)throws IOException
{
FileReader fr = new FileReader("Demo.txt");
//定義一個字符數組，用於存儲讀到的字符。
//該read(char[])辦法前往的是讀到的字符個數。
char[] buf = new char[3];
int num = fr.read(buf);
System.out.println("num=" + num + ".." + new String(buf));
num = fr.read(buf);
System.out.println("num=" + num + ".." + new String(buf));
num = fr.read(buf);
System.out.println("num=" + num + ".." + new String(buf)); //假如讀取到文本末尾，則沒必要全部輸入，所以可以經過
//另一個String辦法來輸入字符數組：String(char[].offset,len)
//功用是將指定長度的字符數組轉換為字符串。
}
//運用循環讀取字符
publicstatic void main(String[] args) throws IOException
{
FileReaderfr = new FileReader("Demo.txt");
char[]ch = new char[3];
int num;
while((num= fr.read(ch)) != -1)
{
System.out.println("num= " + num + ".." + new String(ch,0,num));
}
fr.close();
}
abstract int read(char[ ],int off,int len)
從數組指定地位開端讀入字符，從off處開端讀取字符，要讀取的最多字符數為len。
6、運用FileReader和FileWriter復制文件
public static void main(String[] args) throws IOException
{
//定義讀取流
FileReader fr = new FileReader("D:\\Java3.txt");
//定義一個字符數組來存儲讀取的字符
char[] buf = new char[1024];
//定義輸入流
FileWriter fw = new FileWriter("D:\\copy.txt");
//定義一個num來存儲讀取到的字符個數
int num = 0;
//開端讀取並寫入
while((num = fr.read(buf)) != -1)
{
fw.write(buf);
}
fr.close();
fw.close();
}
7、字符流的緩沖區
緩沖區的呈現進步了對數據的讀寫效率。
對應類
BufferedWriter
BufferedReader
緩沖區要結合流才可以運用，由於緩沖區的為了進步流的操作效率。
在流的根底上對流的功用停止了加強。
8、BufferedReader
從字符輸出流中讀取文本，緩沖各個字符，從而完成字符、數組和行的高效讀取。
讀取流緩沖區在對象樹立時需求有被緩沖的對象，也就是在緩沖區結構辦法中傳入FIleReader的對象。
結構辦法：
BufferedReader(Read in)
創立一個默許大小輸出緩沖區的緩沖字符輸出流。
in是一個流對象。
承繼自Reader的辦法：
void close()
封閉該流並釋放與之關聯的一切資源。
int read()
讀取單個字符。
int read(char[ ],int off,int len)
從指定地位開端讀入，並且指定長度。
特無方法：
String readLine()
讀取一個文本行。遇到'\n'或許'\r'就以為某行終止。
讀完一行會自動跳到下一行。
包括該行內容的字符串，不包括任何行終止符，假如到達流的末尾，則前往null。
由於不會讀取到換行符，所以在讀取進程中普通配合newLine運用。
readLine底層其實就是read辦法。
代碼示例：
import java.io.*;
public class BufferedReaderDemo01 {
public static void main(String[] args) throws IOException
{
//創立一個讀取流對象和文件相關聯
FileReader fr = new FileReader("D:\\Demo.txt");
//為了進步效率，參加了緩沖技術
//將字符讀取流對象作為參數傳遞給緩沖區對象的結構辦法
BufferedReader bufr = new BufferedReader(fr);
// String s1 = bufr.readLine();
// String s2 = bufr.readLine();
// System.out.println("s1 : " + s1);
// System.out.println("s2 : " + s2);
String s = null;
while((s = bufr.readLine()) != null)
{
System.out.println(s);
}
bufr.close();
}
}
9、BufferedWriter
將文本寫入字符輸入流，緩沖各個字符，從而提供單個字符、數組和字符串的高效寫入。（意思就是全部存完一次寫入）
該類的結構辦法必需有參數，由於有流才有緩沖區。
所以在創立緩沖區之前，必需有流對象。普通開發都會參加緩沖區技術，對功能和效率停止加強。
結構辦法：
BufferedWriter(Writer out)
創立一個運用默許大小輸入緩沖區的緩沖字符輸入流。
out是一個Writer流對象。
承繼自Writer的辦法：
void close()
封閉此流並刷新。
void flush()
刷新該流的緩沖。
void write(char [ ],int off,int len)
寫入字符數組的某一局部。
void write(int c)
寫入單個字符。
void write(String s,int off,int len)
寫入字符串的某一局部。
特無方法：
void newLine()
寫入一個行分隔符，換行。
由於在Windows中換行符是“\r\n”，而Linux中換行符為“\n”，會呈現兼容性問題，所以newLine的呈現進步了Java的跨平台性。
代碼示例：
/**
* 2016年3月23日23:45:29
* 運用緩沖區對文件停止寫入
*
* 緩沖區的呈現是為了進步流的操作效率而呈現的
* 所以在創立緩沖區之前，必需要先有對象。
* 該緩沖區中提供了一個跨平台的換行符。
* @author WYC
*
*/
import java.io.*;
public class BufferedWriterDemo01 {
public static void main(String[] args) throws IOException
{
//創立一個字符寫入流對象
FileWriter fw = new FileWriter("D:\\Demo.txt");
//為了進步字符寫入流效率，參加了緩沖技術。
//只需將需求被進步效率的流對象作為參數傳遞給緩沖區的結構函數即可。
BufferedWriter bufw = new BufferedWriter(fw);
for(int i = 1; i <= 100; i++)
{
bufw.write("aaaaaaaaa + " + i);
bufw.newLine();
if(i % 10 == 0)
{
bufw.flush();
}
}
bufw.close();
}
}
10、運用緩沖區復制文本文件
/**
* 經過緩沖區復制文本文件
* 2016年3月24日00:10:28
*
* 該緩沖區提供了一個一次讀一行的辦法readLine()，方便與對文本數據的獲取
* 當readLine前往null時，表示讀到文件末尾
*
* 留意：readLine辦法前往的字符串只前往回車符之前的數據內容，並不前往回車符，所以需求手動newLine
* @author WYC
*
*/
import java.io.*;
public class BufferedTest {
public static void main(String[] args) throws IOException
{
FileReader fr = new FileReader("D:\\Demo.txt");
BufferedReader bufr = new BufferedReader(fr);
FileWriter fw = new FileWriter("D:\\copy.txt");
BufferedWriter bufw = new BufferedWriter(fw);
String s = null;
while((s = bufr.readLine()) != null)
{
bufw.write(s);
bufw.newLine();
bufw.flush();
}
bufr.close();
bufw.close();
}
}
11、LineNumberReader
跟蹤行號的緩沖字符輸出流。
該類承繼自BufferedReader，所以可以直接調用BufferedReader的辦法。
此類定義了辦法setLineNumber(int)和getLineNumber()，用於設置行號和獲取行號，默許狀況下，行號從0開端。
setLineNumber(int)：設置起始行號。
getLineNumber() ：獲取以後行號。
12、輸出輸入舉例
包括了FileReader,FileWriter,BufferedReader,BufferedWriter的用法。
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class FileReaderDemo {
public static void main(String[] args) throws IOException
{
//fr_1();
//fr_2();
//fw_1();
copy();
bufr();
bufw();
}
//運用循環輸入單個字符
public static void fr_1()
{
FileReader fr = null;
int num = 0;
try
{
fr = new FileReader("dd.txt");
while((num = fr.read()) != -1)
{
System.out.print((char)num);
}
}
catch(IOException e)
{
System.out.println("讀入錯誤！順序終止！");
System.exit(0);
}
finally
{
try
{
if(fr != null)
fr.close();
}
catch(IOException e)
{
System.out.println("資源未封閉！");
}
}
System.out.println();
}
//運用循環輸入字節數組，每次循環讀入300個字節。
public static void fr_2()
{
FileReader fr = null;
try
{
int num = 0;
char[]buf = new char[300];
fr = new FileReader("G:\\Java\\eclipse workspace\\IO\\src\\test\\FileReaderDemo.java");
while((num = fr.read(buf)) != -1)
{
System.out.print(new String(buf,0,num));
}
}
catch(IOException e)
{
System.out.println("讀入錯誤！順序終止！");
System.exit(0);
}
finally
{
try
{
if(fr != null)
fr.close();
}
catch(IOException e)
{
System.out.println("資源未封閉！");
}
}
}
//運用循環寫入單個字符
public static void fw_1()
{
FileWriter fw = null;
try
{
fw = new FileWriter("dd.txt",true);
char[] buf = {'1','2','3','4','5'};
for(int i = 0; i < 5;i++)
{
fw.write(buf[i]);
}
}
catch(IOException e)
{
System.out.println("寫入錯誤！順序終止！");
System.exit(0);
}
finally
{
try
{
if(fw != null)
fw.close();
}
catch(IOException e)
{
System.out.println("資源未封閉！");
}
}
}
//拷貝文本文件
public static void copy()
{
FileReader fr = null;
FileWriter fw = null;
try
{
fr = new FileReader("G:\\Java\\eclipse workspace\\IO\\src\\test\\FileReaderDemo.java");
fw = new FileWriter("G:\\Java\\eclipse workspace\\IO\\123.txt");
char [] buf = new char[5];
int num = 0;
while((num = fr.read(buf)) != -1)
{
fw.write(buf);
}
}
catch(IOException e)
{
System.out.println("讀寫失敗！順序終止！");
System.exit(0);
}
finally
{
try
{
if(null != fr)
fr.close();
if(null != fw)
fw.close();
}
catch(IOException e)
{
System.out.println("資源未封閉！");
}
}
}
//創立一個字符讀取流緩沖區
//該緩沖區提供了一個一次讀取一行的辦法：readLine，當讀取到文件末尾的時分前往null
public static void bufr() throws IOException
{
FileReader fr = new FileReader("dd.txt");
BufferedReader bufr = new BufferedReader(fr);
String str = null;
while((str = bufr.readLine()) != null)
{
System.out.println(str);
}
bufr.close();
}
//字符流寫入緩沖區
//緩沖區的呈現是為了進步流的操作效率而呈現的，所以創立緩沖區之前必需要有流對象
//該緩沖區提供了一個跨平台的換行操作：newLine()
public static void bufw() throws IOException
{
//創立一個字符寫入流對象。
FileWriter fw = new FileWriter("dd.txt",true);
//為了進步字符寫入效率，參加了緩沖技術。
//只需將需求被進步效率的流對象作為參數傳遞給緩沖區的結構函數即可。
BufferedWriter bufw = new BufferedWriter(fw);
int i = 0;
while(i < 5)
{
bufw.write("abc"+i);
bufw.newLine();
//只需用到緩沖區就要刷新。flush
bufw.flush();
i++;
}
bufw.close();//封閉緩沖區，相當於封閉流對象。
}
}
13、裝飾設計形式
當想要對已有的對象停止功用加強時，可以定義類，將已有對象傳入，基於已有的功用，並提供增強功用，那麼自定義的該類可以
成為裝飾類。
例如
BufferedReader中的讀取一行：readLine();
裝飾類通常會經過結構辦法承受被裝飾的對象，並基於被裝飾的對象的功用，提供更強的功用。
裝飾形式比承繼要靈敏，防止了集成體系的臃腫，而且降低了類與類之間關系。
裝飾類由於加強已有對象，具有的功用和已有的功用是相反的，只不過提供了更強的功用，所以裝飾類和被裝飾類通常都屬於同一
集體系中。
/**
* 裝飾設計形式
* @author Administrator
*
*/
public class BufferedReaderDemo02 {
public static void main(String[] arsg)
{
SuperCar sc = new SuperCar(new Car());
sc.superRun();
}
}
class Car
{
public void run()
{
System.out.println("啟動");
}
}
class SuperCar
{
private Car c;
public SuperCar(Car c)
{
this.c = c;
}
public void superRun()
{
System.out.println("無鑰匙進入");
c.run();
}
}
——字節流
1、FileOutputStream
假如想要操作圖片數據，就需求用到字節流。
字符串轉成字節數組的辦法：
byte[] String.getBytes()
字符串轉成字符數組的辦法：
String[] toCharArrays()
int available()
前往剩余字符數。
可以經過available()的前往值來確定數組大小，但是虛擬機啟動時默許是64MB，所以需求留意數組大小。
2、字節流緩沖區
BufferedInputStream 和 BufferedOutputStream
10、IOStream
字符流需求刷新數據，而字節流不需求刷新，由於字符流中有一個字符數組，暫時存儲字符數據，刷新後才將數組內容寫入。
字節流假如不運用緩沖區，就不需求刷新操作。
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class FileStream {
public static void main(String[] args) throws IOException
{
//Output();
//Input_1();h
//Input_2();
Input_3();
}
//FileOutputStream復雜用法
public static void Output() throws IOException
{
FileOutputStream fos = new FileOutputStream("fos.txt");
fos.write("abcdefg".getBytes());
fos.close();
}
//FileInputStream復雜用法，讀取單個字節。
public static void Input_1() throws IOException
{
FileInputStream fis = new FileInputStream("fos.txt");
int ch = 0;
while((ch = fis.read()) != -1)
{
System.out.println((char)ch);
}
fis.close();
}
//FileInputStream復雜用法，讀取字節數組。
public static void Input_2() throws IOException
{
FileInputStream fis = new FileInputStream("fos.txt");
byte[] buf = new byte[1024];
int len = 0;
while((len = fis.read(buf)) != -1)
{
System.out.println(new String(buf,0,len));
}
fis.close();
}
//運用FileInputStream中的available()辦法前往文件總的字節數。
//運用available可以定義足夠長的數組一次性全部讀入文件，但是會招致內存溢出，不建議運用
public static void Input_3() throws IOException
{
FileInputStream fis = new FileInputStream("fos.txt");
int num = fis.available();
byte[] buf = new byte[num];
fis.read(buf);
System.out.println(new String(buf));
}
}
11、用FileInputStream和FileOutputStream復制一個圖片
public class CopyPic {
public static void main(String[] args) throws IOException
{
FileInputStream fis = new FileInputStream("C:\\Users\\WYC\\Desktop\\1.jpg");
FileOutputStream fos = new FileOutputStream("C:\\Users\\WYC\\Desktop\\2.jpg");
byte [] buf = new byte[1024];
int len = 0;
while((len = fis.read(buf)) != -1)
{
fos.write(buf);
}
fos.close();
fis.close();
}
}
12、用BufferedI/OStream復制一個圖片
public class BufferedStream {
public static void main(String[] args) throws IOException
{
//copy_pic();
copy_pic2();
}
//運用單個字節復制
public static void copy_pic() throws IOException
{
BufferedInputStream bfis = new BufferedInputStream(new FileInputStream("C:\\Users\\WYC\\Desktop\\1.jpg"));
BufferedOutputStream bfos = new BufferedOutputStream(new FileOutputStream("C:\\Users\\WYC\\Desktop\\3.jpg"));
int num = 0;
while((num = bfis.read()) != -1)
{
bfos.write(num);
}
bfis.close();
bfos.close();
}
//運用字節數組復制
public static void copy_pic2() throws IOException
{
BufferedInputStream bfis = new BufferedInputStream(new FileInputStream("C:\\Users\\WYC\\Desktop\\1.jpg"));
BufferedOutputStream bfos = new BufferedOutputStream(new FileOutputStream("C:\\Users\\WYC\\Desktop\\4.jpg"));
byte[]buf = new byte[1024];
int len = 0;
while((len = bfis.read(buf)) != -1)
{
bfos.write(buf, 0, len);
}
bfis.close();
bfos.close();
}
}
13、讀取鍵盤錄入
import java.io.IOException;
import java.io.InputStream;
/*
* 2015年12月18日22:20:38
* 經過鍵盤錄入數據
* 當錄入一行數據之後，就將該行數據停止打印
* 假如錄入的數據是over
* 就中止錄入
*/
public class KeyboardDemo {
public static void main(String[] args) throws IOException
{
InputStream in = System.in;
int ch = 0;
StringBuilder sb = new StringBuilder();
while((ch = in.read()) != -1)
{
if(ch == '\r')
continue;
if(ch == '\n')
{
String st = sb.toString();
if("over".equals(st))
break;
System.out.println(sb.toString().toUpperCase());
sb.delete(0, sb.length());
}
else
sb.append((char)ch);
}
}
}
14、讀取轉換流
InputStreamReader，專門用於操作字節流的字符流對象。
可以將字節流轉換成字符流。
在結構時需求接納一個字節流對象。
InputStreamReader(InputStream in)
辦法承繼自Reader。
/*
經過方才的鍵盤錄入一行數據並打印其大寫，發現其實就是讀一行數據的原理。
也就是readLine()辦法。
那麼能不能直接運用readLine辦法來完成鍵盤錄入的一行數據的讀取呢？
readLine辦法是字符流緩沖區Buff而狠毒Reader類中的辦法。
那麼能不能將字節流轉成字符流再運用字符流緩沖區的readLine辦法呢？
*/
public class TransStreamDemo {
public static void main(String[] args) throws IOException
{
//字節轉字符
InputStream in = System.in;
InputStreamReader isr = new InputStreamReader(in);
BufferedReader bufr = new BufferedReader(isr);
String line = null;
while((line = bufr.readLine()) != null)
{
if("over".equals(line))
break;
System.out.println(line.toString().toUpperCase());
}
//字符轉字節
OutputStream out = System.out;
OutputStreamWriter osw = new OutputStreamWriter(out);
BufferedWriter bufw = new BufferedWriter(osw);
while((line = bufr.readLine()) != null)
{
if("over".equals(line))
break;
bufw.write(line.toUpperCase());
bufw.newLine();
bufw.flush();
}
bufw.close();
bufr.close();
}
}
15、流操作規律
/*
* 2015年12月19日09:18:54
* 需求：從鍵盤輸出數據，存儲到文件
* 把文件輸入到控制台只需求把傳入的對象互換一下即可
*
*/
public class StreamDemo {
public static void main(String[] args) throws IOException
{
BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("out.txt")));
BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
String line = null;
while((line = bufr.readLine()) != null)
{
if("over".equals(line))
break;
bufw.write(line.toUpperCase());
bufw.newLine();
}
bufw.close();
bufr.close();
}
}
16、總結規律
流操作的根本規律：
最苦楚的就是對象有很多，不知道該用哪一個。
選擇對象可以經過三個步驟來完成：
1、明白源和目的
源：輸出流
InputStream
Reader
目的：輸入流
OutputStream
Writer
2、操作的數據能否是純文本
假如是，就選擇字符流。
假如不是，就選擇字節流。
3、當體系明白後，再明白要運用哪個詳細的對象。
經過設備來停止區分：
源設備：內存，硬盤，鍵盤。
目的設備：內存，硬盤，控制台。
復制文件：將一個文本文件中的數據存儲到另一個文件中。
源：由於是源，所以運用讀取流：InputStream和Reader
是不是操作文本文件？
是！就可以選擇字符流Reader。
明白設備：硬盤中的文件。
Reader體系中可以操作文件的對象是FileReader。
能否需求進步效率？
是！運用BufferedReader緩沖區。
FileReader fr = new FileReader("a.txt");
BufferedReader bufr = new BufferedReader(fr);
目的：由於是目的，所以運用輸入流：OutputStream和Writer
能否純文本？
是！運用字符流Writer
設備：硬盤中的一個文件。
Writer體系中可以操作文件的對象是FIleWriter。
能否需求進步效率？
是！運用BufferedWriter緩沖區。
FileWriter fw = new FileWriter("b.txt");
BufferedWriter bufw = new BufferedWriter(fw);
17、指定編碼表
想要把錄入的數據依照指定的編碼表（utf-8），將數據存儲到文件中。
目的：OutputStream和Writer
能否存儲為文本文件？
是！運用Writer
設備：硬盤中的一個文件
運用Writer體系中可以操作文件的FIleWriter
但是FIleWriter是運用默許的編碼表GBK，存儲時需求參加指定的編碼表utf-8，而指定的編碼表只要轉換流可以指定。
所以要運用的對象是OutputStreamWriter，並且該轉換流對象要接納一個字節輸入流對象（FileOutputStream），還可以接納指定
的編碼表。
OutputStreamWriter osw = new OutputStreamWritrr(new FileOutputStream("a.txt"),"utf-8");
能否需求進步效率？需求。
BufferedWriter bufw = new BufferedWriter(osw);
所以，轉換流什麼時分運用？
通常觸及到字符編碼轉換時，需求用到轉換流。
/*
* 2015年12月19日14:33:15
* 運用轉換流指定utf-8編碼表
*/
public class TransStreamDemo {
public static void main(String[] args) throws IOException
{
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("test1.txt"),"GBK");
BufferedWriter bufw = new BufferedWriter(osw);
BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
String line = null;
while((line = bufr.readLine()) != null)
{
if("over".equals(line))
break;
bufw.write(line);
bufw.newLine();
bufw.flush();
}
bufw.close();
bufr.close();
}
}
18、改動規范輸出輸入設備
System中的setIn和setOut辦法，可以改動輸出輸入設備。
假如setIn辦法參數是一個文本文件，setOut辦法參數也是一個文本文件，就會復制文件。
