Java---IO流（之）字符流_字符缓冲流_字节流__字节缓冲流-------对文件进行操作（特别的基础，了解即可）

Java字符流对与文本的操作

---

操作一：输出文本的内容
输出一：进行字符输出

1：创建字符流对象

Reader readfile = new FileReader("test/1.txt");

2：读取数据

方案one：int test1 = readfile.read(); System.out.println(test1);弊端每次只能输出一个文本中的数据
方案two；int a=0;while(( a=readfile.read())!=-1) {System.out.println(a);} 通过循环数据来输出文本中的数据
注意要点：
例如文本的内容是m y c,拥有三个字符，
第一注意点：文件输出是有指针问题的，指针随着输出的情况来进行改变，也就是说当我第一输出的是m的话，当我再次执行输出语句的话输出的就是y，然后就是 c。
第二注意点是最后输出内容，当我进行的输出语句的内容已经完全将文本中的内容进行输出的时候，当再次执行输出语句是，输出的内容是**-1**.
第三点注意点：输出文本内容，输出的是字符串的代表的整数）
第四点注意点：运行文件可能出现错误，要先在执行前抛出错误，然后再执行代码即可

3：释放资源：在执行完后进行IO流关闭：

readfile.close();

问题：

那么请问一下为什么在文件操作完后要关闭流呢？
愿因1：每一个对文件的操作都是由缓存的，关闭流可以释放缓存
原因二：当你对硬盘中的文件进行操作时，不进行流关闭的情况下，操作文件内容是没有将操作写入硬盘文件中的
（例如：当你打开一个文件没有对它进行关闭，然后再对这个文件进行操作是会出现被占用的情况，这与流的概念差不多）

完整代码演示：

public class reader {
	public  static void main(String args[]) throws Exception {
		//字符流读取数据
Reader readfile = new FileReader("test/1.txt"); //文件内容为aaa
		
		//读取数据
		
//		int test1 = readfile.read();
//		System.out.println(test1);
		
		//由于在文件中含有许多的数据，通过循环来输出文件的内容
		int a=0;
		while(( a=readfile.read())!=-1) {
			System.out.println(a);
		}
		
		
		//释放资源
				readfile.close();
				}
-------------------------------------------
输出结果：
方法一：
97
方法二：
97
97
97
这是两种方法的输出结果：方法一：每次只能输出一个数据
方法二：可以全部的输出文件中数据

输出方式二：
字符流读取数据——按照字符数组读取
步骤与上面差不多的步骤，
区别就在于：创建一个数组来进行数据的输出
方法读取：
char [] chs = new char[字符数] int len = r.read(chs) 将数据通过数组的方式进行输出
其他的都与方式一相同，只需注意在最后的输出问题
代码：

public class reader {
	public  static void main(String args[]) throws Exception {
		//按照数组的方式去读取文件中的数据
		//a,b,c,d,e,f,g
		Reader test1 = new FileReader("test/a/b/1.txt");
		char [] chs = new char[3];
		int len = test1.read(chs);
		System.out.println(chs);
		System.out.println(len);
				
		while((len=test1.read(chs))!=-1) {
			System.out.println(chs);
			System.out.println(len);
			
		}
		//释放资源
		test1.close();}
		}
----------------------------------------------------------------------------------
输出结果：
abc
3
def
3
gef
1

结果解释：
len 为进行输出更替输出返回的字符数，刚开始数组是空的然后第一次，满足的情况为a，b，c
。之后根据循环进行第二次输出满足的情况为d,e,f。第三次输出因为指针后只有一个g，所以把g替换第二次输出的d，其他的则不变，所以最后输出的则是g，e,f len值为1.这就是数组的输出原则。

操作二：写入文件
通过字符流去更换文件的原本内容，或则将内容写入文件
前提：抛出异常错误，当自己不知道出现什么异常是可以抛出一个总的异常包 throws Exception

一：创建字符输出的对象
二：写入数据
三：释放资源

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

		Writer wri = new FileWriter("test/1.txt");  //创建对象


		//一次写入一个数字                           //写入方法一
		wri.write("睡");
	
		//一次写进一个字符数组                       //写入方法二
		char[] a= {'我','是','中','国','人'};
		wri.write(a,2,3);


		//一次写入一个字符串                        //写入方法三
		wri.write("知识改变命运");


		wri.close();                              //释放资源
	}

字符流拷贝文件

功能通过代码是去实现文件拷贝功能，对一个文件的读取内容，然后将读取的内容复制到目的路径中，如果含有这个文件，直接复制到此文件中，如果没有文件，系统会自动创建文件，然后将文件的内容输入到目的路径中。

方法一：

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


public class copyDemo {
	public static void main(String args[])throws Exception {
		//代码实现拷贝功能,将从一个文本读取的内容,复制到另外的文件中
		
		//创建读取文件对象
		FileReader  fr = new FileReader("test/copy/1.txt");
		
		//创建写入的文件对象
		FileWriter  fw = new FileWriter("test/copy/2.txt");
		//通过循环,内容进行写入
		int len;
		while ((len=fr.read())!=-1) {
			fw.write(len);
		}
		//释放资源
		fr.close();
		fw.close();
	}
}

方法二：

通过数组的方式来对文件进行拷贝方法很简单。

public class copyDemo {
	public static void main(String args[])throws Exception {
		FileReader  fr1 = new  FileReader("test/copy/1.txt");
				
		FileWriter  fw = new FileWriter("test/copy/2.txt");
		
		char [] chs = new char [2048]; //输入的最好是1024的倍数，因为计算机底层的换算计算单位是1024
		int len;
		while ((len = fr1.read(chs))!=-1) {
			fw.write(chs,0,len);
		}
		fr1.close();
		fw.close();
	}
}

字符缓冲流拷贝文件的标准代码

BufferredReader ：字符缓冲输入流（高效输入流）
BufferedWriter ：字符缓冲输出流（高效输出流）

区别： 因为在底层它们都有自己的默认缓冲区，好处就在于即使没有手动定义字符数组，在底层他们也是以字符数组的方式进行读写。
代码区别： 此方法代码只在创建对象时，不同剩下的代码格式都与上文相同，无需创建数组只需输出写入即可。
代码演示：

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

public class bufferDemo {

	public static void main(String[] args) throws Exception {
		// TODO Auto-generated method stub
		BufferedReader br = new BufferedReader(new FileReader("test/copy/1.txt"));
		BufferedWriter bw = new BufferedWriter(new FileWriter("test/copy/2.txt"));
		
		int len;
		while ((len = br.read() )!=-1) {
			bw.write(len);
		}
		br.close();
		bw.close();
	
	
	}

}

通过字符缓冲流”一次读写一行“的方式

BufferredReader ：
成员方法：
public void readLine（）： //一次读取一行数据并返回读取数据的内容，读不到返回null
BufferedWriter ：
public void newLine（）： //每次读取到的数据从新的一行开始输出

代码演示：将1.txt中的数据复制到2.txt中

import java.io.FileReader;
import java.io.FileWriter;
import java.io.*;

public class file_readline {

	public static void main(String[] args)throws Exception {
		// TODO Auto-generated method stub
		//创建字符缓冲流输入对象，关联源数据
		BufferedReader br = new BufferedReader(new FileReader("test/copy/1.txt"));
		//创建字符缓冲流输入对象，关联目的路径
		BufferedWriter bw = new BufferedWriter(new FileWriter("test/copy/2.txt"));
		//创建变量存放读取的数据
		String str;
		//通过循环将满足条件的数据赋值给变量
		while ((str = br.readLine()) != null) {
			//将变量中的数据写到文件中
			bw.write(str);
			bw.newLine();
		}
		//释放资源
		br.close();
		bw.close();
		
	}

}

普通字节流读写

方法一：一次读写一个字节

字节流的用法
FileInputStream：普通的字节输入流，用来读取数据 构造方法：
public FileInputStream(string pathname); 成员方法：public int read():
读取数据一次一个字节，并返回读取的数据，读不到就返回 -1

---

FileOutputStream:普通的字节输出流，用来写数据
构造方法：public FileOutputStream(string
pathname); 成员方法：public void write（int 变量名）；一次写一个字节

import java.io.*;


public class bytefile {

	public static void main(String[] args) throws Exception {
		// TODO Auto-generated method stub
		//创建字节输入流对象
		FileInputStream bis = new FileInputStream("test/a/a.jpg");
		//创建字节输出流对象
		FileOutputStream bos = new FileOutputStream("test/a/b.jpg");
		//定义变量
		int by ;
		//通过循环进行写入
		while((by = bis.read()) !=-1 ) {
			bos.write(by);
		}
		//释放资源
		bis.close();
		bos.close();
		
		
	}

}

方法二：通过字节数组进行读写

		FileInputStream bis = new FileInputStream("test/a/a.jpg");
		
		FileOutputStream bos = new FileOutputStream("test/a/c.jpg");
		
		byte [] by = new byte[1024];
		
		int len ;
	
		while((len = bis.read(by)) !=-1 ) {
			bos.write(by,0,len);  //从0开始到有效字节结束
		}
		
		bis.close();
		bos.close();

方法三：通过字节缓冲流

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

public class bytes_huanchong {

	public static void main(String[] args) throws Exception {
		// TODO Auto-generated method stub
		BufferedInputStream bis = new BufferedInputStream(new FileInputStream("test/a/a.jpg"));
		
		BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("test/a/d.jpg"));
		
		int len;
		while((len = bis.read())!=-1) {
			bos.write(len);
		}
		
		bis.close();
		bos.close();
	}

}

注意：
1：代码基本上都是大同小异，代码总共就是那几步，着重介绍的是怎么去使用这些方法。
2：方法的使用都也差不多，区别主要是如何创建一个新对象。
3：缓冲流都有自己的缓冲区，速度特别的快。

本次博客非常的简单，只需要知道方法的使用即可。