JDK6.0学习笔记（二十）文件切割

 

1. /**
2.  * 文件切割
3.  * 允许用户指定切割的尺度
4.  * 允许用户指定切割后小文件存放的路径，同时生成起“索引”作用的 文件，以便以后合并小文件
5.  * 切割机合并小文件
6.  * 输入参数  切割还是合并（切割  0，合并  1）、
7.  * 文件名（切割的文件的路径，合并，索引文件的位置） 
8.  * 切割尺度，以字节为单位，合并时输入0
9.  * 目标目录（切割，小文件和索引文件存放的位置，合并，大文件存放的路径）
10.  * 如：0 GoogleEarth.exe 102400 temp\ 
11.  *     1 temp\GoogleEarth.exe_count 0 temp\ 
12.  *     GoogleEarth.exe_count   索引文件
13.  * */
15. public class FileSplit {
16.     public static void main(String[] args) {
17.         if (args.length != 4) {
18.             System.out
19.                     .println("Usage: java FileSplit CutOrLink(0/1) FileName(if link then input CountFile) UnitSize(if link then input 0) TargetDirectory");
20.             return;
21.         }
23.         if (args[0].equals("0")) {
24.             CutFile cutFile = new CutFile();
25.             cutFile.fileName = args[1];
26.             cutFile.unitSize = Long.parseLong(args[2]);
27.             cutFile.targetDir = args[3];
28.             int count = 0;
29.             try {
30.                 count = cutFile.cutFile();
31.                 System.out.println("分解成" + count + "个小文件...");
32.             } catch (Exception e) {
33.                 e.printStackTrace();
34.             }
35.         }
37.         if (args[0].equals("1")) {
38.             LinkFile linkFile = new LinkFile();
39.             linkFile.fileName = args[1];
40.             linkFile.targetDir = args[3];
41.             int count = 0;
42.             try {
43.                 count = linkFile.linkFile();
44.                 System.out.println("将" + count + "个小文件合并...");
45.             } catch (Exception e) {
46.                 e.printStackTrace();
47.             }
48.         }
49.     }
50. }

1. /**
2.  * 文件切割功能类 
3.  * */
5. import java.io.*;
7. public class CutFile {  //文件切割功能类
8.     public String fileName = null;
10.     public long unitSize = 0;
12.     public String targetDir = null;
14.     public int cutFile() throws Exception {
15.         File file = new File(fileName);
16.         long size = file.length();// 总字节数
17.         int count = 0;// 小文件数
18.         long pos = 0;// 当前位置
19.         long last = 0;// 剩余字节数
20.         DataInputStream dis = new DataInputStream(new BufferedInputStream(
21.                 new FileInputStream(file), (int) unitSize));// 生成文件流
22.         byte[] databuf = new byte[(int) unitSize];
23.         while (pos < size) {
24.             count++;
25.             last = size - pos;
26.             if (last < unitSize)
27.                 databuf = new byte[(int) last];
28.             dis.read(databuf);
29.             System.out.println("count=" + count + ";pos=" + pos
30.                     + ";databuf.length=" + databuf.length);
31.             pos = pos + databuf.length;
32.             // 写小文件
33.             try {
34.                 RandomAccessFile raf = new RandomAccessFile(targetDir
35.                         + file.getName() + "_" + count, "rw");
36.                 raf.write(databuf);
37.                 raf.close();
38.             } catch (Exception e) {
39.                 throw e;
40.             }
41.         }
42.         // 记载小文件数
43.         File file1 = new File(targetDir + file.getName() + "_count");
44.         FileWriter fw = new FileWriter(file1);
45.         BufferedWriter bw = new BufferedWriter(fw);
46.         String str = (new Integer(count)).toString();
47.         bw.write(str, 0, str.length());
48.         bw.flush();
49.         bw.close();
50.         // 返回
51.         return count;
52.     }
53. }

1. /**
2.  * 文件合并功能类 
3.  * */
5. import java.io.*;
7. public class LinkFile {
8.     public String fileName = null;
10.     public String targetDir = null;
12.     public int linkFile() throws Exception {
13.         // 得到小文件数
14.         int count = 0;
15.         try {
16.             File countFile = new File(this.fileName);
17.             FileReader fr = new FileReader(countFile);
18.             BufferedReader br = new BufferedReader(fr);
19.             br.mark(1);
20.             count = Integer.parseInt(br.readLine());
21.             br.close();
22.         } catch (Exception e) {
23.             throw e;
24.         }
25.         // 还原文件名和目录名
26.         String oldFileName = null;
27.         String countFileDir = null;
28.         try {
29.             String countFileName = new File(this.fileName).getName();
30.             countFileDir = fileName.substring(0,
31.                     this.fileName.lastIndexOf(countFileName))
32.                     .replace('\\', '/');
33.             oldFileName = countFileName
34.                     .substring(0, countFileName.length() - 6);
35.         } catch (Exception e) {
36.             throw e;
37.         }
38.         // 合并小文件
39.         FileInputStream fis = null;
40.         byte[] data = null;
41.         try {
42.             FileOutputStream fos = new FileOutputStream(this.targetDir
43.                     + oldFileName);
44.             for (int i = 1; i <= count; i++) {
45.                 fis = new FileInputStream(countFileDir + oldFileName + "_" + i);
46.                 data = new byte[fis.available()];
47.                 fis.read(data);
48.                 fis.close();
49.                 fos.write(data);
50.             }
51.             fos.close();
52.         } catch (Exception e) {
53.             throw e;
54.         }
55.         // 返回
56.         return count;
57.     }
58. }