各种拆分文件的方式

一：按文件行数拆分

 package com.yesky.apachelog.util.file;

 import java.io.BufferedReader;
 import java.io.BufferedWriter;
 import java.io.File;
 import java.io.FileNotFoundException;
 import java.io.FileReader;
 import java.io.FileWriter;
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.Iterator;
 import java.util.List;
 import java.util.StringTokenizer;

 import com.yesky.apachelog.util.regex.ApacheRegexString;

 /**
  * 按行读取文件，并按行数对文件进行拆分
  */
 public class SeparatorByLine {
     List<String> FilePathArr = new ArrayList<String>();
     String FileName = null;// 原文件名
     long FileSize = 0;// 原文件的大小

     public SeparatorByLine() {
     }

     /**
      *
      * @param fileAndPath
      *            原文件名及路径
      */
     private void getFileAttribute(String fileAndPath)// 取得原文件的属性
     {
         File file = new File(fileAndPath);
         FileName = file.getName();
         FileSize = file.length();
     }

     /**
      *
      * @param fileAndPath
      *            原文件及完整路径
      * @param currentBlock
      *            当前块的序号
      * @return 现在拆分后块的文件名
      */
     private String generateSeparatorFileName(String fileAndPath,
             int currentBlock)// 生成折分后的文件名，以便于将来合并
     {
         return fileAndPath + ".part" + currentBlock;
     }

     /**
      * 按行写文件
      *
      * @param fileSeparateName：拆分的文件名及路径
      * @param tempLine：一行的内容
      * @return
      */
     private boolean writeFileByLine(String fileSeparateName,
             List<String> tempList)// 往硬盘写文件
     {
         BufferedWriter writer = null;
         try {
             writer = new BufferedWriter(new FileWriter(fileSeparateName, true),
                     10 * 1024 * 1024);
             Iterator<String> it = tempList.iterator();
             while (it.hasNext()) {
                 String s = (String) it.next();
                 writer.append(s);
                 writer.newLine();
             }
             writer.flush();
             writer.close();
         } catch (IOException e) {
             e.printStackTrace();
             return false;

         } finally {
             if (writer != null)
                 try {
                     writer.close();
                 } catch (IOException e) {
                     // TODO Auto-generated catch block
                     e.printStackTrace();
                 }
         }

         return true;

     }

     /**
      * 拆分文件，
      *
      * @param fileAndPath
      * @param currentPath
      * @param linNum：行数
      * @return：路径，
      */
     public List<String> separatorFileByLine(String fileAndPath,
             String currentPath, long linNum)// 折分文件主函数
     {

         List<String> list = new ArrayList<String>();
         getFileAttribute(fileAndPath);// 将文件的名及大小属性取出来
         if (null != currentPath && !("").equals(currentPath)) {
             this.createFolder(currentPath);
         }

         BufferedReader reader = null;
         try {
             reader = new BufferedReader(new FileReader(fileAndPath));
         } catch (FileNotFoundException e) {
             // TODO Auto-generated catch block
             e.printStackTrace();
         }
         String temp = "";
         int partName = 1;
         String FileCurrentNameAndPath = null;
         try {
             while ((temp = reader.readLine()) != null) {

                 if (currentPath == null || ("").equals(currentPath))
                     FileCurrentNameAndPath = generateSeparatorFileName(
                             fileAndPath, partName);
                 else
                     FileCurrentNameAndPath = generateSeparatorFileName(
                             currentPath + FileName, partName);
                 temp = temp.replaceAll("\"", "'");
                 String regexStr=ApacheRegexString.regexString(temp);
                 if (regexStr != null) {
                     list.add(regexStr);
                 }

                 if (list.size() > 0) {
                     if (list.size() % linNum == 0) {
                         writeFileByLine(FileCurrentNameAndPath, list);
                         FilePathArr.add(FileCurrentNameAndPath);
                         partName++;
                         list.clear();
                     }
                 }
             }
             if (list != null && list.size() > 0) {
                 writeFileByLine(FileCurrentNameAndPath, list);
                 FilePathArr.add(FileCurrentNameAndPath);
                 list.clear();
             }
             reader.close();
         } catch (IOException e) {
             e.printStackTrace();
         } finally {
             if (reader != null)
                 try {
                     reader.close();
                 } catch (IOException e) {
                     // TODO Auto-generated catch block
                     e.printStackTrace();
                 }
         }

         return FilePathArr;
     }

     /**
      * 新建目录
      *
      * @param folderPath
      *            目录
      * @return 返回目录创建后的路径
      */
     public void createFolder(String folderPath) {
         String path = folderPath;
         StringTokenizer st = new StringTokenizer(path, "/");
         String path1 = st.nextToken() + "/";
         String path2 = path1;
         while (st.hasMoreTokens()) {
             path1 = st.nextToken() + "/";
             path2 += path1;
             File inbox = new File(path2);
             if (!inbox.exists())
                 inbox.mkdir();
         }
     }

     public List<String> getFilePathArr() {
         return FilePathArr;
     }

     public static void main(String[] args) {
         SeparatorByLine separator = new SeparatorByLine();
         String fileAndPath = "e:\\test\\object_access_20091119.log";// 文件名及路径
         long blockSize = 300000000;// 每一个文件块的大小，大小是按字节计算
         Iterator<String> it = separator.separatorFileByLine(fileAndPath, "",
                 blockSize).iterator();
         while (it.hasNext()) {
             System.out.println("=====" + it.next());
         }

     }

 }

 二：按大小

 package com.yesky.util.file;

 import java.io.File;
 import java.io.FileNotFoundException;
 import java.io.FileOutputStream;
 import java.io.RandomAccessFile;
 import java.util.ArrayList;
 import java.util.Iterator;
 import java.util.List;
 import java.util.StringTokenizer;

 /**
  * 文件分隔器:给定文件的路径和每一块要拆分的大小，就可以按要求拆分文件
  * 如果指定的块给原文件都还要大，为了不动原文件，就生成另一个文件，以.bak为后缀，这样可以保证原文件
  * 如果是程序自动拆分为多个文件，那么后缀分别为".part序号"，这样就可以方便文件的合并了 原理：很简单，就是利用是输入输出流，加上随机文件读取。
  */
 public class Separator {
     String FileName = null;// 原文件名
     long FileSize = 0;// 原文件的大小
     long BlockNum = 0;// 可分的块数

     public Separator() {
     }

     /**
      *
      * @param fileAndPath
      *            原文件名及路径
      */
     private void getFileAttribute(String fileAndPath)// 取得原文件的属性
     {
         File file = new File(fileAndPath);
         FileName = file.getName();
         FileSize = file.length();
     }

     /**
      *
      * @param blockSize
      *            每一块的大小
      * @return 能够分得的块数
      */
     private long getBlockNum(long blockSize)// 取得分块数
     {
         long fileSize = FileSize;
         if (fileSize <= blockSize)// 如果文件的大小小于分割的大小就只能分割为一个
             return 1;
         else {
             if (fileSize % blockSize > 0) {
                 return fileSize / blockSize + 1;
             } else
                 return fileSize / blockSize;
         }
     }

     /**
      *
      * @param fileAndPath
      *            原文件及完整路径
      * @param currentBlock
      *            当前块的序号
      * @return 现在拆分后块的文件名
      */
     private String generateSeparatorFileName(String fileAndPath,
             int currentBlock)// 生成折分后的文件名，以便于将来合并
     {
         return fileAndPath + ".part" + currentBlock;
     }

     /**
      *
      * @param fileAndPath
      *            原文件及完整路径
      * @param fileSeparateName
      *            文件分隔后要生成的文件名，与原文件在同一个目录下
      * @param blockSize
      *            当前块要写的字节数
      * @param beginPos
      *            从原文件的什么地方开始读取
      * @return true为写入成功，false为写入失败
      */
     private boolean writeFile(String fileAndPath, String fileSeparateName,
             long blockSize, long beginPos)// 往硬盘写文件
     {
         RandomAccessFile raf = null;
         FileOutputStream fos = null;
         byte[] bt = new byte[1024 * 1024 * 10];
         long writeByte = 0;
         int len = 0;
         try {
             raf = new RandomAccessFile(fileAndPath, "r");
             raf.seek(beginPos);
             fos = new FileOutputStream(fileSeparateName);
             while ((len = raf.read(bt)) > 0) {
                 if (writeByte < blockSize)// 如果当前块还没有写满
                 {
                     writeByte = writeByte + len;
                     if (writeByte <= blockSize)
                         fos.write(bt, 0, len);
                     else {
                         len = len - (int) (writeByte - blockSize);
                         fos.write(bt, 0, len);
                     }
                 }
             }
             fos.close();
             raf.close();
         } catch (Exception e) {
             e.printStackTrace();
             try {
                 if (fos != null)
                     fos.close();
                 if (raf != null)
                     raf.close();
             } catch (Exception f) {
                 f.printStackTrace();
             }
             return false;
         }
         return true;
     }

     /**
      *
      * @param fileAndPath
      *            原文路径及文件名
      * @param currentPath:e:/test2/
      *            拆分后的文件存储路径，可以为null，如果为null或者“”，拆分后的文件和原文件在相同的目录下
      * @param blockSize
      *            要拆分的每一块的大小
      * @return true为拆分成功，false为拆分失败
      */
     public List<String> separatorFile(String fileAndPath, String currentPath,
             long blockSize)// 折分文件主函数
     {
         List<String> list = new ArrayList<String>();
         getFileAttribute(fileAndPath);// 将文件的名及大小属性取出来
         System.out.println("FileSize:" + FileSize);
         System.out.println("blockSize:" + blockSize);
         BlockNum = getBlockNum(blockSize);// 取得分块总数
         System.out.println("BlockNum:" + BlockNum);
         // System.exit(0);
         if (null != currentPath && !("").equals(currentPath)) {
             System.out.println("创建拆分文件目录");
             this.createFolder(currentPath);
         }

         if (BlockNum == 1)// 如果只能够分一块，就一次性写入
             blockSize = FileSize;
         long writeSize = 0;// 每次写入的字节
         long writeTotal = 0;// 已经写了的字节
         String FileCurrentNameAndPath = null;
         for (int i = 1; i <= BlockNum; i++) {
             if (i < BlockNum)
                 writeSize = blockSize;// 取得每一次要写入的文件大小
             else
                 writeSize = FileSize - writeTotal;
             if (BlockNum == 1) {
                 if (currentPath == null || ("").equals(currentPath))
                     FileCurrentNameAndPath = fileAndPath + ".bak";
                 else
                     FileCurrentNameAndPath = currentPath + FileName + ".bak";
             } else {
                 if (currentPath == null || ("").equals(currentPath))

                     FileCurrentNameAndPath = generateSeparatorFileName(
                             fileAndPath, i);

                 else
                     FileCurrentNameAndPath = generateSeparatorFileName(
                             currentPath + FileName, i);
             }
             System.out.print("本次写入:" + writeSize);
             System.out.println("拆分后的文件路径==" + FileCurrentNameAndPath);

             // System.exit(0);
             writeFile(fileAndPath, FileCurrentNameAndPath, writeSize,
                     writeTotal);// 循环往硬盘写文件
             // 把拆分文件地址存入list
             list.add(FileCurrentNameAndPath);
             writeTotal = writeTotal + writeSize;
             System.out.println(" 总共写入:" + writeTotal);
         }
         return list;
     }

     /**
      * 新建目录
      *
      * @param folderPath
      *            目录
      * @return 返回目录创建后的路径
      */
     public void createFolder(String folderPath) {
         String path = folderPath;
         StringTokenizer st = new StringTokenizer(path, "/");
         String path1 = st.nextToken() + "/";
         String path2 = path1;
         while (st.hasMoreTokens()) {
             path1 = st.nextToken() + "/";
             path2 += path1;
             File inbox = new File(path2);
             if (!inbox.exists())
                 inbox.mkdir();
         }
     }

     public static void main(String[] args) {
         Separator separator = new Separator();
         String fileAndPath = "e:\\catalina.out";// 文件名及路径
         long blockSize = 1024 * 1024 * 50;// 每一个文件块的大小，大小是按字节计算
         List l = separator.separatorFile(fileAndPath, "", blockSize);

         Iterator it = l.iterator();
         while (it.hasNext()) {
             System.out.println("=====" + it.next());
         }

     }

 }

 文件合并

 package com.yesky.util.file;

 /**
  * 合并文件：合并由拆分文件拆分的文件
  * 要求将拆分文件放到一个文件夹中
  * 主要利用随机文件读取和文件输入输出流
  */
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.IOException;
 import java.io.RandomAccessFile;

 import java.util.Arrays;
 import java.util.StringTokenizer;

 public class Combination {
     String srcDirectory = null;// 拆分文件存放的目录
     String[] separatedFiles;// 存放所有拆分文件名
     String[][] separatedFilesAndSize;// 存放所有拆分文件名及分件大小
     int FileNum = 0;// 确定文件个数
     String fileRealName = "";// 据拆分文件名确定现在原文件名

     public Combination() {
         srcDirectory = "e:\\test\\";
     }

     /**
      *
      * @param sFileName
      *            任一一个拆分文件名
      * @return 原文件名
      */
     private String getRealName(String sFileName) {
         StringTokenizer st = new StringTokenizer(sFileName, ".");
         return st.nextToken() + "." + st.nextToken();
     }

     /**
      * 取得指定拆分文件模块的文件大小
      *
      * @param FileName
      *            拆分的文件名
      * @return
      */
     private long getFileSize(String FileName) {
         FileName = srcDirectory + FileName;
         return (new File(FileName).length());
     }

     /**
      * 生成一些属性，做初使化
      *
      * @param drictory
      *            拆分文件目录
      */
     private void getFileAttribute(String drictory) {
         File file = new File(drictory);
         separatedFiles = new String[file.list().length];// 依文件数目动态生成一维数组，只有文件名
         separatedFiles = file.list();
         // 依文件数目动态生成二维数组，包括文件名和文件大小
         // 第一维装文件名，第二维为该文件的字节大小
         separatedFilesAndSize = new String[separatedFiles.length][2];
         Arrays.sort(separatedFiles);// 排序
         FileNum = separatedFiles.length;// 当前文件夹下面有多少个文件
         for (int i = 0; i < FileNum; i++) {
             separatedFilesAndSize[i][0] = separatedFiles[i];// 文件名
             separatedFilesAndSize[i][1] = String
                     .valueOf(getFileSize(separatedFiles[i]));// 文件大上
         }
         fileRealName = getRealName(separatedFiles[FileNum - 1]);// 取得文件分隔前的原文件名
     }

     /**
      * 合并文件：利用随机文件读写
      *
      * @return true为成功合并文件
      */
     private boolean CombFile() {
         RandomAccessFile raf = null;
         long alreadyWrite = 0;
         FileInputStream fis = null;
         int len = 0;
         byte[] bt = new byte[1024];
         try {
             raf = new RandomAccessFile(srcDirectory + fileRealName, "rw");
             for (int i = 0; i < FileNum; i++) {
                 raf.seek(alreadyWrite);
                 fis = new FileInputStream(srcDirectory
                         + separatedFilesAndSize[i][0]);
                 while ((len = fis.read(bt)) > 0) {
                     raf.write(bt, 0, len);
                 }
                 fis.close();
                 alreadyWrite = alreadyWrite
                         + Long.parseLong(separatedFilesAndSize[i][1]);
             }
             raf.close();
         } catch (Exception e) {
             e.printStackTrace();
             try {
                 if (raf != null)
                     raf.close();
                 if (fis != null)
                     fis.close();
             } catch (IOException f) {
                 f.printStackTrace();
             }
             return false;
         }
         return true;
     }

     public static void main(String[] args) {
         Combination combination = new Combination();
         combination.getFileAttribute(combination.srcDirectory);
         combination.CombFile();
         System.exit(0);
     }
 }