各种拆分文件的方式

一：按文件行数拆分

Java代码  

1. package com.yesky.apachelog.util.file;  
2.   
3. import java.io.BufferedReader;  
4. import java.io.BufferedWriter;  
5. import java.io.File;  
6. import java.io.FileNotFoundException;  
7. import java.io.FileReader;  
8. import java.io.FileWriter;  
9. import java.io.IOException;  
10. import java.util.ArrayList;  
11. import java.util.Iterator;  
12. import java.util.List;  
13. import java.util.StringTokenizer;  
14.   
15. import com.yesky.apachelog.util.regex.ApacheRegexString;  
16.   
17. /** 
18.  * 按行读取文件，并按行数对文件进行拆分 
19.  */  
20. public class SeparatorByLine {  
21.     List<String> FilePathArr = new ArrayList<String>();  
22.     String FileName = null;// 原文件名  
23.     long FileSize = 0;// 原文件的大小  
24.   
25.     public SeparatorByLine() {  
26.     }  
27.   
28.     /** 
29.      *  
30.      * @param fileAndPath 
31.      *            原文件名及路径 
32.      */  
33.     private void getFileAttribute(String fileAndPath)// 取得原文件的属性  
34.     {  
35.         File file = new File(fileAndPath);  
36.         FileName = file.getName();  
37.         FileSize = file.length();  
38.     }  
39.   
40.     /** 
41.      *  
42.      * @param fileAndPath 
43.      *            原文件及完整路径 
44.      * @param currentBlock 
45.      *            当前块的序号 
46.      * @return 现在拆分后块的文件名 
47.      */  
48.     private String generateSeparatorFileName(String fileAndPath,  
49.             int currentBlock)// 生成折分后的文件名，以便于将来合并  
50.     {  
51.         return fileAndPath + ".part" + currentBlock;  
52.     }  
53.   
54.     /** 
55.      * 按行写文件 
56.      *  
57.      * @param fileSeparateName：拆分的文件名及路径 
58.      * @param tempLine：一行的内容 
59.      * @return 
60.      */  
61.     private boolean writeFileByLine(String fileSeparateName,  
62.             List<String> tempList)// 往硬盘写文件  
63.     {  
64.         BufferedWriter writer = null;  
65.         try {  
66.             writer = new BufferedWriter(new FileWriter(fileSeparateName, true),  
67.                     10 * 1024 * 1024);  
68.             Iterator<String> it = tempList.iterator();  
69.             while (it.hasNext()) {  
70.                 String s = (String) it.next();   
71.                 writer.append(s);  
72.                 writer.newLine();  
73.             }  
74.             writer.flush();  
75.             writer.close();  
76.         } catch (IOException e) {  
77.             e.printStackTrace();  
78.             return false;  
79.   
80.         } finally {  
81.             if (writer != null)  
82.                 try {  
83.                     writer.close();  
84.                 } catch (IOException e) {  
85.                     // TODO Auto-generated catch block  
86.                     e.printStackTrace();  
87.                 }  
88.         }  
89.   
90.         return true;  
91.   
92.     }  
93.   
94.     /** 
95.      * 拆分文件， 
96.      *  
97.      * @param fileAndPath 
98.      * @param currentPath 
99.      * @param linNum：行数 
100.      * @return：路径， 
101.      */  
102.     public List<String> separatorFileByLine(String fileAndPath,  
103.             String currentPath, long linNum)// 折分文件主函数  
104.     {  
105.   
106.         List<String> list = new ArrayList<String>();  
107.         getFileAttribute(fileAndPath);// 将文件的名及大小属性取出来  
108.         if (null != currentPath && !("").equals(currentPath)) {  
109.             this.createFolder(currentPath);  
110.         }  
111.   
112.         BufferedReader reader = null;  
113.         try {  
114.             reader = new BufferedReader(new FileReader(fileAndPath));  
115.         } catch (FileNotFoundException e) {  
116.             // TODO Auto-generated catch block  
117.             e.printStackTrace();  
118.         }  
119.         String temp = "";  
120.         int partName = 1;  
121.         String FileCurrentNameAndPath = null;  
122.         try {  
123.             while ((temp = reader.readLine()) != null) {  
124.                   
125.                 if (currentPath == null || ("").equals(currentPath))  
126.                     FileCurrentNameAndPath = generateSeparatorFileName(  
127.                             fileAndPath, partName);  
128.                 else  
129.                     FileCurrentNameAndPath = generateSeparatorFileName(  
130.                             currentPath + FileName, partName);  
131.                 temp = temp.replaceAll("\"", "'");  
132.                 String regexStr=ApacheRegexString.regexString(temp);   
133.                 if (regexStr != null) {  
134.                     list.add(regexStr);  
135.                 }  
136.   
137.                 if (list.size() > 0) {  
138.                     if (list.size() % linNum == 0) {  
139.                         writeFileByLine(FileCurrentNameAndPath, list);  
140.                         FilePathArr.add(FileCurrentNameAndPath);  
141.                         partName++;  
142.                         list.clear();  
143.                     }  
144.                 }  
145.             }  
146.             if (list != null && list.size() > 0) {  
147.                 writeFileByLine(FileCurrentNameAndPath, list);  
148.                 FilePathArr.add(FileCurrentNameAndPath);  
149.                 list.clear();  
150.             }  
151.             reader.close();  
152.         } catch (IOException e) {  
153.             e.printStackTrace();  
154.         } finally {  
155.             if (reader != null)  
156.                 try {  
157.                     reader.close();  
158.                 } catch (IOException e) {  
159.                     // TODO Auto-generated catch block  
160.                     e.printStackTrace();  
161.                 }  
162.         }  
163.   
164.         return FilePathArr;  
165.     }  
166.   
167.     /** 
168.      * 新建目录 
169.      *  
170.      * @param folderPath 
171.      *            目录 
172.      * @return 返回目录创建后的路径 
173.      */  
174.     public void createFolder(String folderPath) {  
175.         String path = folderPath;  
176.         StringTokenizer st = new StringTokenizer(path, "/");  
177.         String path1 = st.nextToken() + "/";  
178.         String path2 = path1;  
179.         while (st.hasMoreTokens()) {  
180.             path1 = st.nextToken() + "/";  
181.             path2 += path1;  
182.             File inbox = new File(path2);  
183.             if (!inbox.exists())  
184.                 inbox.mkdir();  
185.         }  
186.     }  
187.   
188.     public List<String> getFilePathArr() {  
189.         return FilePathArr;  
190.     }  
191.   
192.     public static void main(String[] args) {  
193.         SeparatorByLine separator = new SeparatorByLine();  
194.         String fileAndPath = "e:\\test\\object_access_20091119.log";// 文件名及路径  
195.         long blockSize = 300000000;// 每一个文件块的大小，大小是按字节计算  
196.         Iterator<String> it = separator.separatorFileByLine(fileAndPath, "",  
197.                 blockSize).iterator();  
198.         while (it.hasNext()) {  
199.             System.out.println("=====" + it.next());  
200.         }  
201.   
202.     }  
203.   
204. }  

 二：按大小

Java代码  

1. package com.yesky.util.file;  
2.   
3. import java.io.File;  
4. import java.io.FileNotFoundException;  
5. import java.io.FileOutputStream;  
6. import java.io.RandomAccessFile;  
7. import java.util.ArrayList;  
8. import java.util.Iterator;  
9. import java.util.List;  
10. import java.util.StringTokenizer;  
11.   
12. /** 
13.  * 文件分隔器:给定文件的路径和每一块要拆分的大小，就可以按要求拆分文件 
14.  * 如果指定的块给原文件都还要大，为了不动原文件，就生成另一个文件，以.bak为后缀，这样可以保证原文件 
15.  * 如果是程序自动拆分为多个文件，那么后缀分别为".part序号"，这样就可以方便文件的合并了 原理：很简单，就是利用是输入输出流，加上随机文件读取。 
16.  */  
17. public class Separator {  
18.     String FileName = null;// 原文件名  
19.     long FileSize = 0;// 原文件的大小  
20.     long BlockNum = 0;// 可分的块数  
21.   
22.     public Separator() {  
23.     }  
24.   
25.     /** 
26.      *  
27.      * @param fileAndPath 
28.      *            原文件名及路径 
29.      */  
30.     private void getFileAttribute(String fileAndPath)// 取得原文件的属性  
31.     {  
32.         File file = new File(fileAndPath);  
33.         FileName = file.getName();  
34.         FileSize = file.length();  
35.     }  
36.   
37.     /** 
38.      *  
39.      * @param blockSize 
40.      *            每一块的大小 
41.      * @return 能够分得的块数 
42.      */  
43.     private long getBlockNum(long blockSize)// 取得分块数  
44.     {  
45.         long fileSize = FileSize;  
46.         if (fileSize <= blockSize)// 如果文件的大小小于分割的大小就只能分割为一个  
47.             return 1;  
48.         else {  
49.             if (fileSize % blockSize > 0) {  
50.                 return fileSize / blockSize + 1;  
51.             } else  
52.                 return fileSize / blockSize;  
53.         }  
54.     }   
55.   
56.     /** 
57.      *  
58.      * @param fileAndPath 
59.      *            原文件及完整路径 
60.      * @param currentBlock 
61.      *            当前块的序号 
62.      * @return 现在拆分后块的文件名 
63.      */  
64.     private String generateSeparatorFileName(String fileAndPath,  
65.             int currentBlock)// 生成折分后的文件名，以便于将来合并  
66.     {  
67.         return fileAndPath + ".part" + currentBlock;  
68.     }  
69.   
70.     /** 
71.      *  
72.      * @param fileAndPath 
73.      *            原文件及完整路径 
74.      * @param fileSeparateName 
75.      *            文件分隔后要生成的文件名，与原文件在同一个目录下 
76.      * @param blockSize 
77.      *            当前块要写的字节数 
78.      * @param beginPos 
79.      *            从原文件的什么地方开始读取 
80.      * @return true为写入成功，false为写入失败 
81.      */  
82.     private boolean writeFile(String fileAndPath, String fileSeparateName,  
83.             long blockSize, long beginPos)// 往硬盘写文件  
84.     {  
85.         RandomAccessFile raf = null;  
86.         FileOutputStream fos = null;  
87.         byte[] bt = new byte[1024 * 1024 * 10];  
88.         long writeByte = 0;  
89.         int len = 0;  
90.         try {  
91.             raf = new RandomAccessFile(fileAndPath, "r");  
92.             raf.seek(beginPos);  
93.             fos = new FileOutputStream(fileSeparateName);  
94.             while ((len = raf.read(bt)) > 0) {  
95.                 if (writeByte < blockSize)// 如果当前块还没有写满  
96.                 {  
97.                     writeByte = writeByte + len;  
98.                     if (writeByte <= blockSize)  
99.                         fos.write(bt, 0, len);  
100.                     else {  
101.                         len = len - (int) (writeByte - blockSize);  
102.                         fos.write(bt, 0, len);  
103.                     }  
104.                 }  
105.             }  
106.             fos.close();  
107.             raf.close();  
108.         } catch (Exception e) {  
109.             e.printStackTrace();  
110.             try {  
111.                 if (fos != null)  
112.                     fos.close();  
113.                 if (raf != null)  
114.                     raf.close();  
115.             } catch (Exception f) {  
116.                 f.printStackTrace();  
117.             }  
118.             return false;  
119.         }  
120.         return true;  
121.     }  
122.   
123.     /** 
124.      *  
125.      * @param fileAndPath 
126.      *            原文路径及文件名 
127.      * @param currentPath:e:/test2/ 
128.      *            拆分后的文件存储路径，可以为null，如果为null或者“”，拆分后的文件和原文件在相同的目录下 
129.      * @param blockSize 
130.      *            要拆分的每一块的大小 
131.      * @return true为拆分成功，false为拆分失败 
132.      */  
133.     public List<String> separatorFile(String fileAndPath, String currentPath,  
134.             long blockSize)// 折分文件主函数  
135.     {  
136.         List<String> list = new ArrayList<String>();  
137.         getFileAttribute(fileAndPath);// 将文件的名及大小属性取出来  
138.         System.out.println("FileSize:" + FileSize);  
139.         System.out.println("blockSize:" + blockSize);  
140.         BlockNum = getBlockNum(blockSize);// 取得分块总数  
141.         System.out.println("BlockNum:" + BlockNum);  
142.         // System.exit(0);  
143.         if (null != currentPath && !("").equals(currentPath)) {  
144.             System.out.println("创建拆分文件目录");  
145.             this.createFolder(currentPath);  
146.         }  
147.   
148.         if (BlockNum == 1)// 如果只能够分一块，就一次性写入  
149.             blockSize = FileSize;  
150.         long writeSize = 0;// 每次写入的字节  
151.         long writeTotal = 0;// 已经写了的字节  
152.         String FileCurrentNameAndPath = null;  
153.         for (int i = 1; i <= BlockNum; i++) {  
154.             if (i < BlockNum)  
155.                 writeSize = blockSize;// 取得每一次要写入的文件大小  
156.             else  
157.                 writeSize = FileSize - writeTotal;  
158.             if (BlockNum == 1) {  
159.                 if (currentPath == null || ("").equals(currentPath))  
160.                     FileCurrentNameAndPath = fileAndPath + ".bak";  
161.                 else  
162.                     FileCurrentNameAndPath = currentPath + FileName + ".bak";  
163.             } else {  
164.                 if (currentPath == null || ("").equals(currentPath))  
165.   
166.                     FileCurrentNameAndPath = generateSeparatorFileName(  
167.                             fileAndPath, i);  
168.   
169.                 else  
170.                     FileCurrentNameAndPath = generateSeparatorFileName(  
171.                             currentPath + FileName, i);  
172.             }  
173.             System.out.print("本次写入:" + writeSize);  
174.             System.out.println("拆分后的文件路径==" + FileCurrentNameAndPath);  
175.   
176.             // System.exit(0);  
177.             writeFile(fileAndPath, FileCurrentNameAndPath, writeSize,  
178.                     writeTotal);// 循环往硬盘写文件  
179.             // 把拆分文件地址存入list  
180.             list.add(FileCurrentNameAndPath);  
181.             writeTotal = writeTotal + writeSize;  
182.             System.out.println(" 总共写入:" + writeTotal);  
183.         }  
184.         return list;  
185.     }  
186.   
187.     /** 
188.      * 新建目录 
189.      *  
190.      * @param folderPath 
191.      *            目录 
192.      * @return 返回目录创建后的路径 
193.      */  
194.     public void createFolder(String folderPath) {  
195.         String path = folderPath;  
196.         StringTokenizer st = new StringTokenizer(path, "/");  
197.         String path1 = st.nextToken() + "/";  
198.         String path2 = path1;  
199.         while (st.hasMoreTokens()) {  
200.             path1 = st.nextToken() + "/";  
201.             path2 += path1;  
202.             File inbox = new File(path2);  
203.             if (!inbox.exists())  
204.                 inbox.mkdir();  
205.         }  
206.     }  
207.   
208.     public static void main(String[] args) {  
209.         Separator separator = new Separator();  
210.         String fileAndPath = "e:\\catalina.out";// 文件名及路径  
211.         long blockSize = 1024 * 1024 * 50;// 每一个文件块的大小，大小是按字节计算  
212.         List l = separator.separatorFile(fileAndPath, "", blockSize);  
213.   
214.         Iterator it = l.iterator();  
215.         while (it.hasNext()) {  
216.             System.out.println("=====" + it.next());  
217.         }  
218.   
219.     }  
220.   
221. }  

 文件合并

Java代码  

1. package com.yesky.util.file;  
2.   
3. /** 
4.  * 合并文件：合并由拆分文件拆分的文件 
5.  * 要求将拆分文件放到一个文件夹中 
6.  * 主要利用随机文件读取和文件输入输出流 
7.  */  
8. import java.io.File;  
9. import java.io.FileInputStream;  
10. import java.io.IOException;  
11. import java.io.RandomAccessFile;  
12.   
13. import java.util.Arrays;  
14. import java.util.StringTokenizer;  
15.   
16. public class Combination {  
17.     String srcDirectory = null;// 拆分文件存放的目录  
18.     String[] separatedFiles;// 存放所有拆分文件名  
19.     String[][] separatedFilesAndSize;// 存放所有拆分文件名及分件大小  
20.     int FileNum = 0;// 确定文件个数  
21.     String fileRealName = "";// 据拆分文件名确定现在原文件名  
22.   
23.     public Combination() {  
24.         srcDirectory = "e:\\test\\";  
25.     }  
26.   
27.     /** 
28.      *  
29.      * @param sFileName 
30.      *            任一一个拆分文件名 
31.      * @return 原文件名 
32.      */  
33.     private String getRealName(String sFileName) {  
34.         StringTokenizer st = new StringTokenizer(sFileName, ".");  
35.         return st.nextToken() + "." + st.nextToken();  
36.     }  
37.   
38.     /** 
39.      * 取得指定拆分文件模块的文件大小 
40.      *  
41.      * @param FileName 
42.      *            拆分的文件名 
43.      * @return 
44.      */  
45.     private long getFileSize(String FileName) {  
46.         FileName = srcDirectory + FileName;  
47.         return (new File(FileName).length());  
48.     }  
49.   
50.     /** 
51.      * 生成一些属性，做初使化 
52.      *  
53.      * @param drictory 
54.      *            拆分文件目录 
55.      */  
56.     private void getFileAttribute(String drictory) {  
57.         File file = new File(drictory);  
58.         separatedFiles = new String[file.list().length];// 依文件数目动态生成一维数组，只有文件名  
59.         separatedFiles = file.list();  
60.         // 依文件数目动态生成二维数组，包括文件名和文件大小  
61.         // 第一维装文件名，第二维为该文件的字节大小  
62.         separatedFilesAndSize = new String[separatedFiles.length][2];  
63.         Arrays.sort(separatedFiles);// 排序  
64.         FileNum = separatedFiles.length;// 当前文件夹下面有多少个文件  
65.         for (int i = 0; i < FileNum; i++) {  
66.             separatedFilesAndSize[i][0] = separatedFiles[i];// 文件名  
67.             separatedFilesAndSize[i][1] = String  
68.                     .valueOf(getFileSize(separatedFiles[i]));// 文件大上  
69.         }  
70.         fileRealName = getRealName(separatedFiles[FileNum - 1]);// 取得文件分隔前的原文件名  
71.     }  
72.   
73.     /** 
74.      * 合并文件：利用随机文件读写 
75.      *  
76.      * @return true为成功合并文件 
77.      */  
78.     private boolean CombFile() {  
79.         RandomAccessFile raf = null;  
80.         long alreadyWrite = 0;  
81.         FileInputStream fis = null;  
82.         int len = 0;  
83.         byte[] bt = new byte[1024];  
84.         try {  
85.             raf = new RandomAccessFile(srcDirectory + fileRealName, "rw");  
86.             for (int i = 0; i < FileNum; i++) {  
87.                 raf.seek(alreadyWrite);  
88.                 fis = new FileInputStream(srcDirectory  
89.                         + separatedFilesAndSize[i][0]);  
90.                 while ((len = fis.read(bt)) > 0) {  
91.                     raf.write(bt, 0, len);  
92.                 }  
93.                 fis.close();  
94.                 alreadyWrite = alreadyWrite  
95.                         + Long.parseLong(separatedFilesAndSize[i][1]);  
96.             }  
97.             raf.close();  
98.         } catch (Exception e) {  
99.             e.printStackTrace();  
100.             try {  
101.                 if (raf != null)  
102.                     raf.close();  
103.                 if (fis != null)  
104.                     fis.close();  
105.             } catch (IOException f) {  
106.                 f.printStackTrace();  
107.             }  
108.             return false;  
109.         }  
110.         return true;  
111.     }  
112.   
113.     public static void main(String[] args) {  
114.         Combination combination = new Combination();  
115.         combination.getFileAttribute(combination.srcDirectory);  
116.         combination.CombFile();  
117.         System.exit(0);  
118.     }  
119. }