java复习6--IO

IO流
IO流用来处理设备间的数据传输
java对数据的操作是通过流的方式进行操作
java用于操作流的对象都在IO包中
流按操作数据分为两种：字节流和字符流
按流分为：输入流和输出流
从硬盘已有的数据读取出来放到内存中的这个过程是输入流
将内存中的数据存储到硬盘中的这个过程是输出流
字符流
字符流的抽象基类
Reader Writer
只是处理纯文本数据，优先考虑字符流，否则字节流
IO分类
字节流
读 InputStream
写 OutputStream
字符流
读 Reader
InputStreamReader
FileReader
BufferdReader
写 Writer
OutputStreamWriter
FileWriter
BufferedWriter
IO体系中，子类后缀是父类名称，前缀是体现自己功能的名字
Reader常见方法
int read(); 读取一个字符，返回读到了字符（0-65535），如果读到末尾。返回-1
int read(char[]); 将读到的字符存入指定的数组中，返回读到的字符个数，末尾，-1
close();释放资源
Writer常见方法
void write(char ch ); 将一个字符写入到流中
void write(char[] ); 将一个字符数组写入到流中
void write(String); 将一个字符串写入到流中
void flush(); 刷新流，将流中的数据刷新到目的地，流还存在
void close();关闭资源 ，关闭前先调用flush()，刷新流中的数据到目的地，然后关闭
FielWriter
没有特有方法，只有自己的构造方法
用于处理文件 有默认编码表 有临时缓冲
FileWriter(String filename);
调用系统资源
在指定位置创建一个文件，如果文件存在，覆盖
FileWriter(String filename,boolean true);
. . . . . .
FileReader
用于读取文本文件的流对象，用于关联文本文件
FileWriter fileWriter = new FileWriter(String filename);
异常处理
public class FileHandler{
public static void main(String[] args){
FileWtriter fileWriter = null;//定义为全局，关闭的时候也要使用
try{
fileWriter = new FileWriter(“E:\1.txt”);
fileWriter.write(“abcd”);
fileWriter.flush();
fileWriter.write(“ef”);
}catch(IOException e){
e.printStackTrace();
}finally{
if(! fileWriter = null){ //防止空指针异常，运行时异常要作健壮性判断
try{
fiileWriter.close();
}catch(IOException e){
throw new RuntimeException(“关闭异常”);
}
}
}
}
}
Tips
当指定绝对路径时，定义目录分隔符的两种方式
反斜线 (“C:\1.txt”);
斜线 (“C:/1.txt”);
读取字符流两种方式
一次读取一个字符
FileReader fileReader = null;
try{
fileReader = new FileReader(“E:\1.txt”);
int lens = 0;
while((len = fileReader.read()) != -1){
syso(len);
}catch(IOException e){e.printStackeTrace();}
finally{
if(fileReader != null){
try{ fileReader.close(); }catch(IOException e){e.printStackTrace();}
}
}
}
将读取的字符放入一个字符数组
FileReader fileReader = null;
try{
fileReader = new FileReader(“E:\1.txt”);
char[] ch = new char[1024];
int lens = 0;
while((len = fileReader.read( ch)) != -1){
syso(new String(ch , 0 , len));
}catch(IOException e){e.printStackeTrace();}
finally{
if(fileReader != null){
try{ fileReader.close(); }catch(IOException e){e.printStackTrace();}
}
}
}
复制文本文件的原理
FileReader fileReader = null;
FileWriter fileWriter null;
try{
filereader = new FileReader(“from.txt”);
fileWriter = new FileWriter(“to.txt”);
char[] ch = new char[1024];
int lens = 0;
while((lens = fileReader.read(ch)) != -1){
fileWriter.write(ch , 0 , lens );
}
}catch(IOException e){e.printStackTrace();}
finally{
if(filleReader != null){ fileReader.close(); }
if(fileWriter != null ) { fileWriter.close(); }
}
字符流缓冲区
原理
将数组进行封装，变成对象，方便对缓冲区的操作，并提供了方便操作的方法
readLine() newLine()
BufferedWriter.newLine();跨平台的换行符
BufferedReader.readLine();一次读取一行，到行标记时，将行标记之前的字符数据作为
字符串返回，读到末尾，返回null
缓冲的存在是为了增强流的功能，需要建立再有流存在的基础上
BufferedWriter bfWriter = new BufferedWriter(new FileWriter(“a.txt”));
bfWriter.write(“asdfg”);
bfWriter.flush();------一定要刷新
bfWriter,close();
BufferedReader bfReader = new BufferedReader(new FileReader(“a.txt”));
String line = null;
while( (line = bfReader.readLine()) != null){
syso(line);
}
bfReader.close();
自定义缓冲区
public class MyBuffedReader extends Reader{
private Reader r;
public MyBufferedReader(Reader r){
this.r = r;
}
private char[] buf = new char[1024];
//记录缓冲区数据的个数
private int count = 0, pos = 0;
//一次从缓冲区读取一个
public int myRead() throws IOException {
//判断缓冲区是否有数据，如果没有就从源获取
if(count == 0){
count = r.read(buf);
pos = 0;
}
if(count < 0) return -1;
char ch = buf[pos];
pos++;
count–;
return ch;
}
//一次读取一行
public String myReadLine() throws IOException {
//定义一个临时容器
StringBuilder sb = new StringBuilder();
//定义一个变量。接收读取的字符对应的二进制数
int ch = 0;

						while((ch = myRead()) != -1){
							//当读取到\r时，跳出本次循环，进行下次循环
							if( ch == '\r'){ continue; }
							//当读取到\n时，直接跳出循环
							if( ch == '\n'){ return sb.toString(); }
							//当都没有读取到时，就将这些数据存储到临时容器中
							sb.append((char) ch );
						}
						
						//当临时容器的长度不等于0时，就输出字符
						if(sb.length() != 0){	return sb.toString(); }
						return null;
			}
		}
	通过缓冲区的形式，对文本文件进行拷贝
		public class BufferedCopyTest{
			public static void main (String[] args){
				BufferedReader br = new BufferedReader(new FileReader("e:\\a.txt"));
				BufferedWriter bw = new BufferedWriter(new FileWriter("i:\\copy.txt"));
				String lens = null;
				whiile((lens = br.readLine()) != null){
					bw.write(lens);
					bw.newLine();
					bw.flush();
				}
				bw.close)(;
				br.close();
			}
		}