解决1TB，1GB大文本文件内容的反转

最近遇到一个笔试题，如何实现一个1TB大小的文本文档的反转，就像字符串的反转一样（“abc...”，“...cba”）；

在网上找了好久，偶尔有找到实现思路的，但是一致没有找到一个完整的代码。所以小弟自己写了，如有不适之处，请大神指教！

package com.arithmatic;


import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Reader;
import java.io.Writer;
import java.util.ArrayList;
import java.util.List;


/**
 * 
 * @Description 写一个方法实现1Tb大小文件的反转
 * @Author 东方·少使
 * @Date 2018年4月19日
 * @Version 1.0
 */
public class ReverseFileContext {


public static void main(String[] args) throws IOException {
List<String> files = new ArrayList<String>() ;

File oldFile = new File("d:\\oldFile.txt") ;
reverserAndSperationFile(oldFile,files);

File newFile = new File("d:\\newFile.txt") ;
writerToFile(files, newFile);
}
/**
* 从文件中拿出来每个子文件合并
* createBy 东方·少使
* @param files
* @param newFile
* @throws IOException
* @throws FileNotFoundException
*/
private static void writerToFile(List<String> files, File newFile) throws IOException, FileNotFoundException {
Writer writer = new FileWriter(newFile) ;
/**
* 1. 遍历集合，拿到每一个子文件名
* 2. 创建子文件夹，读取内容到数组中
* 3. 把数组写到指定的文件中
* 4. 刷新，关闭流，删除子文件夹
*/
for (int i = files.size() - 1; i >= 0  ; i -- ) {
File file = new File(files.get(i)) ;
Reader reader = new FileReader(file) ;
char[] arr = new char[8] ;
int len = -1 ;
while ((len = reader.read(arr, 0, arr.length)) != -1) {
writer.write(arr, 0, len);
}
writer.flush();
reader.close();
file.delete() ;
}
writer.close();
}
/**
* 对一个文件分批进行反转，并保存在文件中，优化：可以再定义一个数组作为缓冲，数组满了以后再写入子文件，这样可以少创建很多子文件夹
* createBy 东方·少使
* @param oldFile
* @throws FileNotFoundException
* @throws IOException
*/
private static void reverserAndSperationFile(File oldFile, List<String> files) throws FileNotFoundException, IOException {

/**
* 定义char数组用来接受输入流读取到的内容
*/
char[] arr = new char[8] ;
int len = -1 ;
FileReader reader = new FileReader(oldFile) ;
/**
* 定义子文件名用增长变量i
*/
int i= -1   ;
char[][] arrs = new char[100][8] ;

while (true) {
int index = -1 ;//arrs数组索引index
while ((len = reader.read(arr, 0, arr.length)) != -1) {

char[] newArr = reverseArr(arr,len);
/**
* 如果arrs长度为100了,那么就可以写入子文件了
*/
arrs[ ++index ] = newArr ;
if (index >= 99 || len < 8) {
break ;
}
}
/**
* 1. 构建子文件名，并保存到一个集合中
*/
StringBuilder builder = new StringBuilder("d:\\newFile") ;
String filename = builder.append( ++ i +".txt").toString() ;
files.add(filename) ;
/**
* 2. 把每一部分的内容反转并写入到子文件中
*/
FileWriter writer = new FileWriter(filename) ;
WriteToSperationFile(writer, arrs, index, len) ;
/**
* 3.如果index小于99说明已经读完了，可以结束了，否则再次进入循环即可
*/
if (index < 99) {
break ;
}

}

reader.close();
}
/**
* 把数组写入到子文件中
* createBy 东方·少使
* @param writer
* @param arrs
* @param index
* @throws IOException 
*/
private static void WriteToSperationFile(FileWriter writer, char[][] arrs, int index, int len) throws IOException {

for (int i = index ; i >= 0; i --) {
if (i == index && len < 8) {
writer.write(arrs[i], 0, len);
}else{
writer.write(arrs[i] );
}

writer.flush();
}

writer.close();
}
/**
* 打印数组
* createBy 东方·少使
* @param arr
* @param length
*/
@SuppressWarnings("unused")
private static void printArr(char[] arr, int length) {
for (int i = 0; i < length ; i ++) {
if (i % 100 == 0) {
System.out.println();
}
System.out.print(arr[i]+" ");
}
System.out.println(new String(arr));
}
/**
* 反转数组
*/
private static char[] reverseArr(char[] arr, int len) {
char[] newArr = new char[len] ;
int length = len ;
for (int i = 0; i < len; i ++) {
newArr[--length] = arr[i] ;
}
return newArr ;
}
}