求多线程读取一个文件，然后写到另外一个文件中的Java实现。

这个是我写的三个类，用于多线程操作读取文件内容和写入文件内容，不知道是不是你合你味口。
________________第一个类______读取内容__写入内容____________________
package pro;

import java.io.*;
public class ReadFileToWriteOtherFile {

private File oldFile;
private File newFile;
private BufferedReader br;
private BufferedWriter bw;
private String totalString="";
private Boolean flag=true; //用于标记文件名是否存在 true表示存在

public ReadFileToWriteOtherFile()
{
oldFile=null;
newFile=null;
br=null;
bw=null;
System.out.println("初始化成功");
}
public void readInfoFromFile(String fileName)
{

System.out.println("开始读取");
try
{

oldFile=new File(fileName);
if(oldFile.exists()) //如果文件存在
{
System.out.println("存在");
br=new BufferedReader(new FileReader(oldFile));
String info=br.readLine(); //读取一行
while(info!=null)
{
totalString+=info; //将读取到的一行添加到totalString中
info=br.readLine(); //再读取下一行
//System.out.println(totalString);
}
System.out.println("读取完成，准备写入…………");
}
else //如果文件不存在
{
System.out.println("文件不存在");
flag=false; //标记该文件不存在
}
// System.out.println("totalString="+totalString);
}
catch(FileNotFoundException e)
{
System.out.println(e);System.out.println("开始读取中1");
}
catch(IOException e)
{System.out.println(e);System.out.println("开始读取中2");}

}
public void writeInfoToFile(String fileName)
{
if(!flag) //如果标记前面的文件不存在，则return
{
flag=true; //改回原来的文件标记符
return;
}
try
{
newFile=new File(fileName);
if(newFile.exists()) //如果存在，不用创建新文件
{
System.out.println("文件存在，可以写入!");
}
else //如果不存在，则创建一个新文件
{
System.out.println("文件不存在，准备创建新文件");
newFile.createNewFile();
System.out.println("文件创建成功，可以写入");
}
bw=new BufferedWriter(new FileWriter(newFile,true));
// System.out.println("totalString="+totalString);
bw.write(totalString,0,totalString.length());
bw.flush(); //刷新缓冲区
System.out.println("写入完成");
totalString="\r\t"; //清空原来的字符串
}
catch(FileNotFoundException e)
{System.out.println(e);}
catch(IOException e)
{System.out.println(e);}

}
}
________________第二个类______一个自定义的线程类____________________
package pro;

import java.lang.Thread;
public class MyThread extends Thread
{
private int index; //用于数组的位置
private String[] fileNames; //定义一个字符串数组
ReadFileToWriteOtherFile bftwo=new ReadFileToWriteOtherFile(); //定义前面的自定义类
public MyThread(String[] fileNames,int index) //index表示数组位置标号
{
this.index=index;
this.fileNames=fileNames;
}
public void run()
{

bftwo.readInfoFromFile(fileNames[index]);//传入数组中的字符串参数
bftwo.writeInfoToFile("b.txt"); //传入写入的目的地文件
//index++; //数组位置加1
System.out.println("==============");//分隔线

}
}
________________第三个类______主程序____________________
package pro;
//import org.springframework.context.ApplicationContext;
//import org.springframework.context.support.ClassPathXmlApplicationContext;
import java.io.*;
public class BeanRunApp {

/**
* Method main
*
*
* @param args
*
*/
public static void main(String[] args)
{
/* ApplicationContext apc=new ClassPathXmlApplicationContext("beans.xml");
ClassRoom croom=(ClassRoom)apc.getBean("classRoom");
croom.out();
System.out.println("over");
*/
long startTime=System.currentTimeMillis();
String[] a={"a.txt","c.txt","d.txt","e.txt"}; //用一个符品数组保存文件名

for(int i=0;i { //把这个数组和i的值作为构造函数传入线程类
MyThread myth=new MyThread(a,i);
System.out.println("--------------------------------");
myth.start(); //执行
System.out.println("当前的线程是:"+myth.getName());
}
long endTime=System.currentTimeMillis();
System.out.println("耗时:"+(endTime-startTime)+"毫秒");
}
}

我这有个单线程的，你看看吧！ 读写的也挺快！

我这个是读java和cs文件的！ 你再改改吧！ 仅供参考！！！
package FileReader;

import java.io.BufferedInputStream;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileFilter;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;

/**
*
* @author Dongzai1005 2010-10-16
* @version 1.0
*
*/
public class FileReader {
// 读取符合要求的文件,忽略其他文件
static boolean copy(String[] str){
// 目标文件夹，没有自动创建
File targetDir = new File("D:");
// 参数str,传入源文件夹目录以及选择的文件
File srcDir = new File(str[0]);
final String str_java = str[1];
final String str_cs = str[2];
// 源文件夹不存在，则返回
if (!srcDir.exists()) {
return false;
} else {
// 查找所有的java文件
File[] arr = srcDir.listFiles(new FileFilter() {
public boolean accept(File f) {
// 当选择时，将标识置为1
int[] arr1 = new int[3];
// 没有选择java文件
if (null == str_java || "".equals(str_java)) {
arr1[1] = 1;
}
// 没有选择cs文件
if (null == str_cs || "".equals(str_cs)) {
arr1[2] = 1;
}
// 全选
if (arr1[1] == 0 && arr1[2] == 0) {
arr1[0] = 1;
}
// 当前文件为文件夹时，返回false
if (f.isDirectory()) {
return false;
} else if (arr1[0] == 1) {
// java和cs文件
if (f.getName().endsWith(".java")) {
return f.getName().endsWith(".java");
} else if (f.getName().endsWith(".cs")) {
return f.getName().endsWith(".cs");
}
} else if (arr1[1] == 1) {
// cs文件
if (f.getName().endsWith(".cs")) {
return f.getName().endsWith(".cs");
} else {
return false;
}
} else if (arr1[2] == 1) {
// java文件
if (f.getName().endsWith(".java")) {
return f.getName().endsWith(".java");
} else
return false;
}
return false;
}
});
String targetPath = targetDir.getPath();
// 文件路径
File f = new File(targetPath);
// 如果文件夹不存在，则创建新文件夹
if (!f.exists()) {
f.mkdirs();
}
StringBuilder sb = new StringBuilder();
// 目标文件的绝对路径
String targetFile = targetPath + File.separatorChar + "Code.txt";
PrintWriter out = null;
try {
out = new PrintWriter(new BufferedWriter(
new FileWriter(targetFile)));
} catch (IOException e) {
return false;
}
int i = 0;
// 遍历符合条件的文件
for (File file : arr) {
i++;
// 截取当前文件名称
String name = file.getName();
int index = name.indexOf('.');
name = name.substring(0, index);
BufferedInputStream in = null;
try {
in = new BufferedInputStream(
new FileInputStream(file.getPath()), 8192);
} catch (FileNotFoundException e) {
return false;
}
// 缓存
byte[] buffer = new byte[4096];
int length = -1;
sb.append("对象名：" + name);
sb.append("\r\n");
// 读取数据
try {
while ((length = in.read(buffer)) != -1) {
// 读取文件
String s = new String(buffer, 0, length);
sb.append(s);
}
} catch (IOException e) {
e.printStackTrace();
}
sb.append("\r\n");
try {
in.close();
} catch (IOException e) {
return false;
}
}
out.println(sb.toString());
out.flush();
out.close();
if (i > 0) {
return true;
} else {
return false;
}
}
}
}