字节流和字符流
Java流
字符流操作
使用字符流读取文件
使用字符流写文本文件
字节流操作
使用字节流读取文本文件
使用字节流写文本文件

Java流
我们知道了如何利用file类对文件或者目录属性进行操作，但File类不能访问文件的内容，即不能从文件中读取数据或向文件里写数据。

读文件，是指把文件的数据读取到内存中，反之写文件就是把内存中的数据写到文件中。

流呢，是指一连串流动的字符，是以先进先出的方式发送和接收数据的通道。

在java.io包中，封装了许多输入\输出流API。在程序中，这些输入输出流的类的对象成为流对象。可以通过这些流对象将内存中的数以流的方式写入文件，也可以通过流对象将文件中的数据以流的方式读取到内存。

流对象构造的时候往往会和数据源联系起来。数据源分为源数据流和目标数据流源。

1.输入流联系的是源流数据源

2.输出流联系的则是目标数据源。

按照不同的分类方式，可以将流分成不同的类型。

1.按照流的流向进行划分可以分成输入流和输出流。

输出流：OUTPutStream和Writter作为基类。只能向其中写入数据，不能读。

输入流：InputStream和Reader作为基类。只能读取数据，不能写。

2.按照所操作的数据单元的不同，流又可以分成字节流和字符流。

字节流操作的最小的数据单位为8位字节，而字符流操作的最下数据单元是16位字符。

字节流和字符流的区分也很简单，字节流建议使用于二进制数据操作，而字符流用于文本。他们的用法几乎一样。
字符流操作
使用字符流读取文件
1.字符流输入流Reader类

Reader类是读取字符流的抽象类，他提供了常用的方法。

int read（） 输入流中读取单个字符

int read（byte[] c）从输入流中读取c.length长度的字符，保存到字符数组C中，返回实际读取的字符数。

read（char[] c,int off,int len）从输入流中读取最多len的长度字符，保存到字符数组c中，保存的位置从off位置开始，返回实际读取的字符长度。

close（） 关闭流

2.字符输入流FileReader类

FileReader类是Reader的子类，常用的构造方法格式如下。

FileReader（String fileName）其中，fileName是指要从中读取数据文件的名称。使用的方法如下：
Reader fr=new FileReader（“C:\\myTest.txt”）；

3.使用FileReader读取文件

使用字符流类FileReader读取文本文件的操作如下。

1.引入类
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;

2.创建FileReader对象
Reader re = new FileReader("C:\\mytest.txt");

3.利用FileReader类方法读取文本文件

int read（）；//读取单个字符

4.关闭相关的流对象

fr.close();
l练习：
Reader fe=null;
		StringBuffer sbf=null;
		try {
			fe=new FileReader("hello.txt");
			char ch[]=new char[1024];//创建字符数组作为中转站
			sbf=new StringBuffer();
					int lenth=fe.read(ch);//将字符读入数组
					while((lenth!=-1)){
						sbf.append(ch);//追加字符
						lenth=fe.read();
					}		
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally{
			if(fe!=null){
				try {
					fe.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}

创建字符的中转站，存入每次读取的数据内容，然后调用FileReader对象的Read（）方法将字符读入数组ch，并追加到字符串sbf中。
或者我们可以这样写：
char[] cbuf = new char[5];
		int len = 0;
		try {
			fileReader = new FileReader(file);
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		}
		try {
			while ((len = (fileReader.read(cbuf))) != -1) {
				String str = new String(cbuf, 0, len);
				System.out.println(str);
			}

上面我们演示了FileReader类读取文件。而开发中，我们会将FileReader类和BufferReader类结合使用。提高文件的效率。
4.字符输入流BufferedReader类

BufferedReader类是Reader的子类，它与FileReader类的区别在于BufferReader类带有缓冲区，它可以先把一批数据读到缓冲区，接下来的读操作都是从缓冲区内获取数据，避免每次都从数据源读取数据进行字符编码转换，从而提高读取操作的效率。BufferedReader类常用的构造方法如下。

BufferedReader（Reader in）;

使用此方法创建字符输入对象如下。
Reader fr=new FileReader（“C:\\mytest.txt”）;
BufferedReader br=new BufferedReader(fr);

其中br就是创建的一个使用默认大小输入缓冲区的缓冲字符输入流。

5.使用FileReader和BufferedReader读取文本文件。

具体操作如下；

1.引入相关类

2.创建一个BufferedReader对象

3.利用BufferedReader类的方法读取文本文件的数据。

4.关闭相关的流对象。

测试代码：
public static void main(String[] args) {
		// TODO Auto-generated method stub
		Reader fe=null;
		BufferedReader br=null;
		try {
			fe=new FileReader("hello.txt");
			br=new BufferedReader(fe);
					String lenth=br.readLine();//读取行内容
					while(lenth!=null){
						System.out.println(lenth);
						lenth=br.readLine();
					}
		} catch (Exception e) {
			System.out.println("文件不存在");
		}finally{
				try {
					if(br!=null){
						br.close();
					}
					if(fe!=null){
					fe.close();
					}
				} catch (IOException e) {
					e.printStackTrace();
				}	
		}
	}


使用字符流写文本文件
1.字符流输出Writer

writer类是向文件写入数据流的字符流，它提供了常用的方法。

writer（string str）将str字符串里包含的字符输出到指定的输出流中

writer（String str，int off，int len）将str字符串里从off位置开始长度为len的字符输出到输出流中。

close（）关闭输出流

flush（）刷新输出流

2.字符输出流FileWriter类

FileWriter类是Reader的子类，常用的构造方法如下：

FileWriter（String fileName）

其中，filename表示与系统有关的文件名，使用此构造方法创建字符流输出流对象如下。

Writer fr=new FileWriter（“C:\myTest.txt”）；

3.使用FileWriter写文本文件

使用FileWriter将数据写入文本文件的步骤如下。

1.引入相关类

2.创建一个FileWriter对象

3.利用FileWriter类的方法写文本文件。

4.相关流对象的清空和关闭。

4.字符输出流BufferedWriter类

同理BufferedWriter也是Writer的子类。其他的情况和上面的BufferedReader类相同。

5.BufferedWriter和FileWriter写文本文件

步骤其实是和上面相同。直接练习显示
try{fw=new FileWriter("hello.txt");
			bw=new BufferedWriter(fw);
					bw.write("大家好");
					bw.write("dsafdfa");
					bw.newLine();//插入换行
					bw.write("dthadsn");
					bw.write(123);
					bw.flush();//刷新流
					bw.close();//关闭流
	}				

字节流操作
使用字节流读取文本文件
1.字节输入流InputStream类

字节输入流InputStream的作用就是将文件中的数据输入到内部存储器（内存）中，它提供了一系列和读取数据有关的方法，常用的方法如下。

int read（） 读取一个字符

int read（byte[] b）将数据读到字节中

int read（byte[] b,int off,int len）从输入流中读取最多len长度的字节，保存到字节数组b中，保存的位置从off开始。

void close（） 关闭输入流

int availabe() 返回输入流读取的估计字节数

无参的read()方法从输入流读取一个八位的字节，把它转换为0~255的整数返回。

有参的两个read（）方法从输入流批量读取若干字节。从文件或键盘读数据时，采用read（byte[] b）或者int read（byte[] b,int off,int len）方法可以减少进行物理读文件或键盘的次数，提高输入输出操作效率。

2.字节输入流FileInputStream类

在实际应用中，我们通常使用InputStream的子类FileStream类来实现本文文件内容的读取，常用的构造方法如下。

1）FileinputStream（File file）。其中，file指定文件数据源。使用此构造方法创建文件输入流对象如下。
File file=new File（“C:\\myTest.txt”）;
InputStream fileObject=new FileInputStream(file);

此时的文件输入流对象fileObject就和数据源（“C:\myTest.txt”）;联系起来了。

2)FileInputStream（String name）。其中，name指定文件数据源包含路径信息。使用此构造方法创建文件输入流对象如下。
InputStream in =new FileInputStream(“C:\\myTest.txt”);

3.使用FileInputStream读取文件

使用FileInputStream读取文件具体操作如下。

1）引入相关类
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;

2）创建一个文件输入流对象
InputStream fileObject=new FileInputStream(“C:\\myTest.txt”);

3）利用文件输入的方法读取文本文件的数据。
fileObject.avaliable()//可读取的字节数
fileObject.read()//读取文件的数据

4）关闭文件输入流对象。
fileObject.close();

下面我们示例学习一下。首先，我们创建一个文件，hello.txt，然后文件保存的内容为abc，然后输出到控制台上。

示例：
FileInputStream fis=null;
		try{
			fis=new FileInputStream("hello.txt");
			int data;
			System.out.println("可读取的字节数"+fis.available());
			System.out.println("文件内容为：");
			while((data=fis.read())!=-1){
				System.out.println(data+" ");
			}
		}catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		}finally{
			if(fis!=null){
				try {
					fis.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}

发现输出的东西和文件中的东西不一致，那是因为InputStream和read方法是从输入流读取一个八位字节，把它转换为0~255的整数返回。abc各占一个字节所以输出的整数就是97 98 99.
注意：使用FileInputStream类读文件数据的时候还要注意下面方面。

1）read（）方法返回整数，若读取的是字符串，则需要强制类型转换。例如如果想正常输出abc则要修改语句System.out.print((char)data+" ");

2）流对象使用完毕之后要关闭。
使用字节流写文本文件
1.字节输出流OutputStream类

字节输出流OutputStream类的作用是把内存中的数据输出到文件中，它提供了一系列文件中写数据的有关方法。常见的方法如下。

void write（int c）写入一个字节数据

void write（byte[] buf）写入数组buf的所有字节

void write（byte[] b,int off,int len）将字节数组从off位置开始，长度为len的字节数据输出到输出流中。

void close（） 关闭输出流

2.字节输出流FileOutputStream类

我们通常使用OutputStream的子类FileOutputStream类来实现向文本文件写入数据，常用的构造方法有以下三个。

1）FileOutputStream（File file）。其中，file指定文件目标数据源。使用此构造方法创建文件输出流对象如下。
File file=new File（“C:\\myTest.txt”）;
FileOutputStream fos=new FileOutputStream（file）；

此时的文件输出流fos就和目标数据源（“C:\myTest.txt”）联系起来。

2）FileOutputStream（String name）。其中，name指定目标文件数据源，包含路径信息。
FileOutputStream fos=new FileOutputStream（“C:\\myTest.txt”）;

3）FileOutputStream（String name，boolean append）。其中，name指定目标文件数据源，包含路径信息。append表示是否在文件末尾添加数据，若设置为true，则在文件末尾添加数据。使用此构造方法创建文件输出流对象如下。
FileOutputStream fos=new FileOutputStream（“C:\\myTest.txt”，true）;

要注意的是第一种方法和第二种构造方法在向文件写数据时将覆盖文件中原有内容。另外，在使用FileOutputStream的构造方法创建FileOutputStream实例时，如果相应的文件并不存在，就会自动创建一个空的文件。若参数file或name表示的文件路劲尽管存在，但是代表一个文件目录，则此时会抛出FileNotFoundException异常。
3.使用FileOutputStream写文本文件

使用FileOutputStream向文本文件中写入数据的具体使用步骤。

1）引入相关的类。
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;

2)构造一个文件输出流对象
OutputStream fos=new FileOutputStream（“C:\\myTest.txt”）;

3）利用文件输出流的方法把数据写入文本文件中
String str=“好好学习”;
byte[] words =str.getBytes[];
fos.write(words,0,words.length);

4)关闭文件输出流
fos.close();

下面示例是具体的应用。
	FileOutputStream fos=null;
		try {
			String str="学习xuexi";
			byte[] words=str.getBytes();//字节数组
			fos=new FileOutputStream("hello.txt");//写文件
			fos.write(words,0,words.length);
			System.out.println("hello 文件已经更新了");
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			if(fos!=null){
				try {
					fos.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}

首先将要写入文件的字符串通过getBytes（）方法转换成字节数组words，然后调用输出流对象的write（）方法，将字节数组words中的内容添加到文件(“hello.txt”)的末尾。
注意：

// 字节流处理 （  .jpg  .mp3 .mp4 .avi .doc  .ppt）

// 字符流 处理  （.txt .java）字符流

同理，字符流中也有缓冲输入输出    BufferedInputStream 和	BufferedOutputStream

使用方式和字节流也一样。

示例复制音乐：
public  void  BufferedTest() {
		File file1 = new File("admin.mp3");
		File file2=new File("tom.mp3");
		FileInputStream fileInputStream=null;
		FileOutputStream fileOutputStream=null;
		try {
			fileInputStream = new FileInputStream(file1);
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		}
		try {
			fileOutputStream = new  FileOutputStream(file2);
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		}
		BufferedInputStream bufferedInputStream = new BufferedInputStream(fileInputStream);
		BufferedOutputStream bufferedOutputStream = new  BufferedOutputStream(fileOutputStream);
		byte  [] buffer=new byte[1024];
		int len=0;
		try {
			while((len=bufferedInputStream.read(buffer))!=-1) {	
				bufferedOutputStream.write(buffer, 0, len);
				
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
		if(fileInputStream!=null) {
			try {
				fileInputStream.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		if(fileOutputStream!=null) {
			try {
				fileOutputStream.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}

概述
IO流分类：
流向
  输入流	读取数据	FileReader	Reader
   输出流	写出数据	FileWriter	    Writer
 数据类型
     字节流	
     	字节输入流   读取数据	InputStream
	    字节输出流   写出数据	OutputStream
	字符流
	     字符输入流  读取数据	    Reader
          字符输出流  写出数据	Writer

利用字符流复制文本文件
利用字符流将当前工程下的IODemo.java拷贝到d盘的a文件夹下
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

/*
 * 使用字符流复制文本文件
 * 
 * 数据源		IODemo.java
 * 目的地		d:\\IODemo.java

 * 	
 */
public class FileCopyDemo {
	public static void main(String[] args) throws IOException  {
		//创建字符输入流对象
		FileReader fr = new FileReader("IODemo.java");
		//创建字符输出流对象
		FileWriter fw = new FileWriter("d:\\IODemo.java");
		
		//一次读写一个字符
		
		/*int ch;
		while((ch = fr.read()) != -1) {
			fw.write(ch);
			fw.flush();
		}*/
		
		//一次读写一个字符数组
		int len;//用于存储读到的字符个数
		char[] chs = new char[1024];
		while((len = fr.read(chs)) != -1) {
			fw.write(chs,0,len);
			fw.flush();
		}
		
		//释放资源
		fw.close();
		fr.close();
	}
}

利用字节流复制文本文件
利用字节流将当前工程下的IODemo.java拷贝到d盘下
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

/*
 * 使用字节流复制文本文件
 * 
 * 数据源		IODemo.java
 * 目的地		d:\\a\\IODemo.java
 * 

 */
public class FileCopyDemo {
	public static void main(String[] args) throws IOException  {
		//创建字节输入流对象
		FileInputStream fis = new FileInputStream("IODemo.java");
		//创建字节输出流对象
		FileOutputStream fos = new FileOutputStream("d:\\a\\IODemo.java");
		
		//一次读写一个字节
		/*int by;
		while((by = fis.read()) != -1) {
			fos.write(by);
		}*/
		//一次读写一个字节数组
		int len;//存储读到的字节个数
		byte[] bys = new byte[1024];
		while((len = fis.read(bys)) != -1) {
			fos.write(bys,0,len);
		}
		
		
		//释放资源
		fos.close();
		fis.close();
	}
}

复制图片
字节流可以操作所有类型的文件,因为所有的文件在计算机中都是以字节形式存储

而字符流只能用来操作纯文本类型的文件,不能操作字节类型的文件

能使用字符流一定可以使用字节流，但是使用字节流不一定能使用字符流

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

/*
 * 分别使用字符流和字节流复制图片
 * 
 * 二进制文件只能使用字节流进行复制（使用windows自带记事本打开读不懂的）
 * 文本文件的复制即可使用字符流，也可以使用字节流
 * 
 * 先随便复制一张图片至项目下
 */
public class CopyImage {
	public static void main(String[] args) throws IOException  {
		//method();
		
		//创建字节输入流对象
		FileInputStream fis = new FileInputStream("a.jpg");
		//创建字节输出流对象
		FileOutputStream fos = new FileOutputStream("d:\\a.jpg");
		
		//一次读写一个字节数组
		int len;//用于存储读到的字节个数
		byte[] bys = new byte[1024];
		while((len = fis.read(bys)) != -1) {
			fos.write(bys,0,len);
		}
		
		//释放资源
		fos.close();
		fis.close();
	}

	private static void method() throws FileNotFoundException, IOException {
		//创建字符输入流对象
		FileReader fr = new FileReader("a.jpg");
		//创建字符输出流对象
		FileWriter fw = new FileWriter("d:\\a.jpg");
		
		//一次读写一个字符数组
		int len;//用于存储读到的字符个数
		char[] chs = new char[1024];
		while((len = fr.read(chs)) != -1) {
			fw.write(chs,0,len);
			fw.flush();
		}
		
		//释放资源
		fw.close();
		fr.close();
	}
}

在计算机中保存的数据都只是二进制符号并按字节为单位来保存，对计算机看来字符A并不是字符A，而只是一个没有意义的二进制数字是一个字节。我们利用JAVA的IO类进行读写数据的时候所提供的大部份的方法都是采用读写字节的方式，而且通过这种读写字节的方法是可以保存任可类型的数据的，因为任数据类型在计算机中都是字节码，前提是你要先将你写入的数据先转换成字节类型再通过输出流类输出，而要使得读取出来的数据对我们的程序有意义，我们必须将读取出来的字节按它保存时所表达的意义转换回来，如：保存的时候是char型的，那么我们就要把读取出来的字节数据类型转换成char类型还原它来所表达的意义，要不如果直接输出这个字节数据所得的仅仅是一个16进制的符号，对我们来说是没有意义的。所以，在JAVA里字节类型是一种万能的数据类型，也是数据在计算机里的真正面目。
 
JAVA的IO类为了方便我们输入输出那些基本的数据类型，基本上在各种的IO类里都提供了针对专门各种的基本数据类型的读写方法，这些方法其实是已经封装了那些转换代码了，如：readInt writeInt 等，但似乎就是没有提供读写STRING类型的方法，原因是JAVA提供了专门读写文本字符的IO类，如：reader writer这两个抽像基类，以及由其派生出来的子类都是专门用来读写文本字符的。因此，如果你要读取文本文件的都话就不要去用inputstrem outStrem这一系列的IO类了，而要使用reader writer 这系列的类了，因为它们不是针对文本的，如果非要用不可的话，你就要在程序中设定专门的程序代码来做这些字符的转换了。如下代码所示：
 
RandomAccessFile ra=new RandomAccessFile("c://1.txt","rw");  //RandomAccessFile类不支持字符的直接读写的
 
String s=new String("hello world");  
 
ra.write(s.getBytes()); //将String转换成字节类型
 
byte buf[]=new byte[1024];   //定义一个字节数组用以接收读取到的字节数据
 
raf.read(buf,0,512);  //RandomAccessFile类不支持字符的直接读取
  
System.out.println("name:"+new String(buf));  //将读取出来的字节数据转换成String并输出。
 
这里还有一个问题，那就是字符编码的问题，在JAVA虚拟机上字符是以UNICODE的格式来表示的，而我们的机器则是以本地机字符集对字符编码的，所以存在同一个字符有两种不同的表示，因此，当我们想以GB2312也就是简体中文的格式来把这些字符保存在文件上，并以简体中文的格式在显示器（输出流）上显示这些字符，那么我们只得先将UNICODE格式的String转换成GB2312格式的字符编码即s.getBytes()，其实这个方法的作用是用本地的字符编码将UNICODE格式的字符编码转换成GB2312的编码，除非你的机器本地编码是采用UNICODE格式，否则这样的转换是免不了的，即使采用包装类也只是用方法来把这个转换过程隐藏了。JAVA采用UNICODE来做为JVM的字符编码，是因为UNICODE是全球的统一标准，有助于JAVA 的跨平台实现，但无奈现实中还是有很多系统仍然采用各自国家的字符编码，因此JAVA不得不提供一种方法来进行UNICODE与当地字符编码的转换。

目标：理解掌握IO流

重点：

1.IO的英文全称为input（输入）、output（输出）

2.输入是指从磁盘输入到内存（读文件），输出是指从内存输出到磁盘（写文件）

3.IO流下面的结构图



4.字节流每次读取或者写入一个字节，而字符流每次读取或者写入一个字符（两个字节），通常字节流用来对图片、音频、视频等文件进行操作，而字符流用来对文本文件进行操作

5.节点流是处理流的基础，因为处理流的构造方法中需要一个其他流作为参数传递，例如

new BufferedReader(new FileReader(filePath));

6.处理流比节点流的效率更高

代码：

1.利用节点字节流对图片文件进行复制粘贴
package May.Ninth.IO;
/**
 * 复制粘贴一个图片、音频、视频
 */
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class OthersFileCopy {

	public static void main(String[] args) {

		new OthersFileCopy().read("E:Javatest/1.jpg", "E:Javatest/1/2.jpg");
	}

	public void read(String path1, String path2) {
		// 创建一个字节缓冲区域
		byte[] bs = new byte[1024];
		// 创建源文件对象
		File file1 = new File(path1);
		// 判断源文件是否存在
		if (file1.exists()) {
			// 创建一个目标文件对象
			File file2 = new File(path2);
			// 判断目标文件是否存在，不存在，则创建目标文件
			if (!file2.exists()) {
				try {
					file2.createNewFile();
					System.out.println("目标文件创建成功");
				} catch (IOException e) {
					e.printStackTrace();
				}
			} else {
				System.out.println("目标文件已存在");
			}
			// 初始化字节输入流
			FileInputStream fis = null;
			// 初始化字节输出流
			FileOutputStream fos = null;
			try {
				// 创建字节输入流
				fis = new FileInputStream(file1);
				// 创建字节输出流
				fos = new FileOutputStream(file2);
				// 循环读取数据,read()方法返回本次所读取的数据长度，当文件已经被读取到了末尾时，read()方法会返回一个-1
				int lengh = 0;
				while ((lengh = fis.read(bs)) != -1) {
					// 将bs数据写入目标文件中
					fos.write(bs, 0, lengh);
					// 强制刷新fos流
					fos.flush();
				}
			} catch (IOException e) {
				e.printStackTrace();
			} finally {
				try {
					// 关闭字节输出流
					fos.close();
					// 关闭字节输入流
					fis.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		} else {
			System.out.println("源文件不存在，请重试");
		}
	}
}


2.利用缓冲流对文本文件进行复制粘贴
package May.Tenth.IO_Buffered;

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

/**
 * 复制一个文本文件
 * @author Jia
 *
 */
public class CopyJpgFile {

	public static void main(String[] args) {
		new CopyJpgFile().copyJPGFile("E:/Javatest/1.txt","E:/Javatest/1" );
		
	}

	public void copyJPGFile(String path1, String path2) {
		// 创建源文件的对象
		File file = new File(path1);
		// 创建目标文件的路径
		path2 = path2 + "/" + file.getName();
		// 判断源文件是否存在
		if (file.exists()) {
			// 声明BufferedReader、BufferedWriter对象
			BufferedReader br = null;
			BufferedWriter bw = null;
			try {
				// 创建BufferedReader、BufferedWriter对象，参数为对应的节点流对象
				br = new BufferedReader(new FileReader(file));
				bw = new BufferedWriter(new FileWriter(path2));
				// 循环读取源文件，readline()方法每次返回一行源文件内容，读到源文件末尾时，返还一个null对象
				String str = null;
				while ((str = br.readLine()) != null) {
					// 将读取到的数据写到目标文件
					bw.write(str);
					// 强制刷新
					bw.flush();
				}
				System.out.println("文件复制成功");
			} catch (IOException e) {
				e.printStackTrace();
			} finally {
				try {
					// 关闭对象
					bw.close();
					br.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}else{
			System.out.println("文件未找到");
		}
	}
}




备注：文件加密下次再说