文件处理

 

2. import java.awt.Rectangle;
3. import java.awt.Robot;
4. import java.awt.image.BufferedImage;
5. import java.io.BufferedInputStream;
6. import java.io.BufferedOutputStream;
7. import java.io.File;
8. import java.io.FileInputStream;
9. import java.io.FileNotFoundException;
10. import java.io.FileOutputStream;
11. import java.io.IOException;
12. import java.util.ArrayList;
13. import java.util.Enumeration;
14. import java.util.List;
15. import java.util.zip.ZipEntry;
16. import java.util.zip.ZipFile;
18. import javax.imageio.ImageIO;
20. import org.apache.log4j.Logger;
22. /**
23.  * 处理文件的基本操作。
24.  *
25.  * @author 
26.  * @version 2005.12.16_02.
27.  * @version 2006.2.22 add getAllFiles
28.  * @version 2006.4.3 add FILE_SEPARATOR;
29.  * @version 2006.4.22 add getSize();
30.  */
31. public class FileFiend {
32.     public static final String FILE_SEPARATOR = System
33.             .getProperty("file.separator");
35.     private final static Logger logger = Logger.getLogger(FileFiend.class);
37.     /**
38.      * 删除指定的文件夹。
39.      *
40.      * @param directoryPath
41.      * @return 是否成功 成功=true.
42.      */
43.     public static boolean deleteDirectory(String directoryPath) {
44.         File file;
45.         File[] files;
46.         file = new File(directoryPath);
47.         if (file != null) {
48.             if (file.exists() && file.isDirectory()) {
49.                 files = file.listFiles();
50.                 if (files != null) {
51.                     for (int i = 0; i < files.length; i++) {
52.                         if (files[i].exists()) {
53.                             if (files[i].isDirectory()) {
54.                                 deleteDirectory(files[i].getPath());
55.                             } else if (files[i].isFile()) {
56.                                 boolean isHad = files[i].delete();
57.                                 if (!isHad) {
58.                                     logger
59.                                             .info("delete file <<<<<<<faile>>>>>>>:"
60.                                                     + files[i]);
61.                                     return false;
62.                                 }
63.                             }
64.                         }
65.                     }
66.                     file.delete();
67.                 }
68.             } else if (!file.exists() && file.isDirectory()) {
69.                 logger.debug("directory do not exists!:" + directoryPath
70.                         + " at _File.deleteDirectory()");
71.                 return true;
72.             }
73.         } else {
74.             logger.debug("file Object is null!:path=" + directoryPath);
75.             return false;
76.         }
77.         return true;
78.     }
80.     /**
81.      * 删除指定的文件
82.      *
83.      * @param filePath
84.      * @return int:1=delete sucess;0=delete <<<<<<<faile>>>>>>>;2=no such
85.      *         file;
86.      */
87.     public static int deleteFile(String filePath) {
88.         File file = new File(filePath);
89.         if (file != null) {
90.             if (file.exists()) {
91.                 if (file.delete()) {
92.                     logger.debug("delete the file sucess: " + filePath);
93.                     return 1;
94.                 } else {
95.                     logger.debug("delete the file <<<<<<<faile>>>>>>>: "
96.                             + filePath);
97.                     return 0;
98.                 }
99.             } else {
100.                 logger.debug("this file do not existe :" + filePath);
101.                 return 2;
102.             }
103.         } else {
104.             logger.debug("file Object is null!:path=" + filePath);
105.             return 2;
106.         }
108.     }
110.     /**
111.      * 从String中创建文件，如果此文件存在覆盖掉，如果不存在创建此文件。
112.      *
113.      * @param filePath
114.      * @param fileData
115.      * @return 写文件是否成功.
116.      * @throws IOException
117.      */
118.     public static boolean writeFile(String filePath, String fileData,
119.             String charsetName) {
120.         if (filePath == null || fileData == null) {
121.             logger.debug("the fileName or fileData is null: fileName="
122.                     + filePath + " fileData=" + fileData);
123.             return false;
124.         } else if (filePath.equals("") || filePath.trim().equals("")) {
125.             logger.debug("the fileName or fileData is   : fileName=" + filePath
126.                     + " fileData=" + fileData);
127.             return false;
128.         }
129.         FileOutputStream fileOutputStream = null;
130.         try {
131.             byte[] data = fileData.getBytes(charsetName);
132.             File file = new File(filePath);
133.             if (!file.exists()) {
134.                 logger.debug("this file is not exist!:" + filePath);
135.                 file.createNewFile();
136.                 logger.debug("creat file!:" + filePath);
137.             }
138.             fileOutputStream = new FileOutputStream(filePath);
139.             fileOutputStream.write(data);
140.             fileOutputStream.close();
141.             logger.debug("write file:" + filePath);
142.             return true;
143.         } catch (FileNotFoundException e) {
144.             logger.debug(e.getMessage());
145.         } catch (IOException e) {
146.             logger.debug(e.getMessage());
147.         } finally {
148.             if (fileOutputStream != null) {
149.                 try {
150.                     fileOutputStream.close();
151.                 } catch (IOException e) {
152.                     logger.debug(e.toString());
153.                     e.printStackTrace();
154.                 }
155.             }
156.         }
157.         return false;
158.     }
160.     /**
161.      * 将byte[]的数据写入文件，如果此文件存在覆盖掉，如果不存在创建此文件。
162.      *
163.      * @param filePath
164.      *            文件全路径.
165.      * @param fileData
166.      *            文件数据.
167.      * @return 写文件是否成功.
168.      */
169.     public static boolean writeFile(String filePath, byte[] fileData) {
170.         if (filePath == null || fileData == null) {
171.             logger.debug("filePath or fileData is null");
172.             return false;
173.         } else if (filePath.trim().equals("")) {
174.             logger.debug("filePath is /"/"!");
175.             return false;
176.         }
177.         FileOutputStream write;
178.         try {
179.             write = new FileOutputStream(filePath);
180.             write.write(fileData);
181.             write.close();
182.             logger.debug("write file:" + filePath + " success!");
183.             return true;
184.         } catch (FileNotFoundException e) {
185.             logger.debug(e.getMessage());
186.         } catch (IOException e) {
187.             logger.debug(e.getMessage());
188.         }
189.         return false;
190.     }
192.     /**
193.      * 从String中创建文件，如果此文件存在覆盖掉，如果不存在创建此文件,如果文件路径上的目录没有则创建此目录。
194.      *
195.      * @param filePath
196.      * @param fileData
197.      * @return 写文件是否成功.
198.      * @throws IOException
199.      */
200.     public static boolean directWriteFile(String filePath, String fileData,
201.             String charsetName) {
202.         if (filePath == null || fileData == null) {
203.             logger.debug("the fileName or fileData is null: fileName="
204.                     + filePath + " fileData=" + fileData);
205.             return false;
206.         } else if (filePath.equals("") || filePath.trim().equals("")) {
207.             logger.debug("the fileName or fileData is   : fileName=" + filePath
208.                     + " fileData=" + fileData);
209.             return false;
210.         }
211.         String fileDir = filePath.substring(0, filePath.lastIndexOf(System
212.                 .getProperty("file.separator")));
213.         boolean flag = makeDirectory(fileDir);
214.         if (!flag) {
215.             return false;
216.         }
217.         FileOutputStream fileOutputStream = null;
218.         try {
219.             byte[] data = fileData.getBytes(charsetName);
220.             File file = new File(filePath);
221.             if (!file.exists()) {
222.                 logger.debug("this file is not exist!:" + filePath);
223.                 file.createNewFile();
224.                 logger.debug("creat file!:" + filePath);
225.             }
226.             fileOutputStream = new FileOutputStream(filePath);
227.             fileOutputStream.write(data);
228.             fileOutputStream.close();
229.             logger.debug("write file:" + filePath);
230.             return true;
231.         } catch (FileNotFoundException e) {
232.             logger.debug(e.getMessage());
233.         } catch (IOException e) {
234.             logger.debug(e.getMessage());
235.         } finally {
236.             if (fileOutputStream != null) {
237.                 try {
238.                     fileOutputStream.close();
239.                 } catch (IOException e) {
240.                     logger.debug(e.toString());
241.                     e.printStackTrace();
242.                 }
243.             }
244.         }
245.         return false;
246.     }
248.     /**
249.      * 将byte[]的数据写入文件，如果此文件存在则覆盖掉，如果不存在创建此文件,目录不存在也直接创建其目录。
250.      *
251.      * @param filePath
252.      *            文件全路径.
253.      * @param fileData
254.      *            文件数据.
255.      * @return 写文件是否成功.
256.      */
257.     public static boolean directWriteFile(String filePath, byte[] fileData) {
258.         if (filePath == null || fileData == null) {
259.             logger.debug("filePath or fileData is null");
260.             return false;
261.         } else if (filePath.trim().equals("")) {
262.             logger.debug("filePath is /"/"!");
263.             return false;
264.         }
265.         String fileDir = filePath.substring(0, filePath.lastIndexOf(System
266.                 .getProperty("file.separator")));
267.         boolean flag = makeDirectory(fileDir);
268.         if (!flag) {
269.             return false;
270.         }
271.         FileOutputStream write;
272.         try {
273.             write = new FileOutputStream(filePath);
274.             write.write(fileData);
275.             write.close();
276.             logger.debug("write file:" + filePath + " success!");
277.             return true;
278.         } catch (FileNotFoundException e) {
279.             logger.debug(e.getMessage());
280.         } catch (IOException e) {
281.             logger.debug(e.getMessage());
282.         }
283.         return false;
284.     }
286.     /**
287.      * 将指定的文件解压缩到指定的文件夹，解压后的文件夹目录和给定的压缩文件名相同.
288.      *
289.      * @param zipFilePath
290.      *            全路径
291.      * @param unZipDirectory
292.      *            全路径
293.      * @return 解压缩文件是否成功.
294.      * @throws IOException
295.      */
296.     public static boolean unZipFile(String zipFilePath, String unZipDirectory)
297.             throws IOException {
298.         ZipFile zipFile = new ZipFile(zipFilePath);
299.         Enumeration entries = zipFile.entries();
300.         if (zipFile == null) {
301.             return false;
302.         }
303.         while (entries.hasMoreElements()) {
304.             ZipEntry zipEntry = (ZipEntry) entries.nextElement();
305.             File f = new File(unZipDirectory + FILE_SEPARATOR
306.                     + zipEntry.getName());
307.             if (zipEntry.isDirectory()) {
308.                 if (!f.exists() && !f.mkdirs())
309.                     throw new IOException("Couldn't create directory: " + f);
310.             } else {
311.                 BufferedInputStream is = null;
312.                 BufferedOutputStream os = null;
313.                 try {
314.                     is = new BufferedInputStream(zipFile
315.                             .getInputStream(zipEntry));
316.                     File destDir = f.getParentFile();
317.                     if (!destDir.exists() && !destDir.mkdirs()) {
318.                         throw new IOException("Couldn't create dir " + destDir);
319.                     }
320.                     os = new BufferedOutputStream(new FileOutputStream(f));
321.                     int b = -1;
322.                     while ((b = is.read()) != -1) {
323.                         os.write(b);
324.                     }
325.                 } finally {
326.                     if (is != null)
327.                         is.close();
328.                     if (os != null)
329.                         os.close();
330.                 }
331.             }
332.         }
333.         return true;
334.     }
336.     /**
337.      * 将给定的文件cut到指定的全路径，如果该路径不存在自动创建该路径。
338.      *
339.      * @param filePath
340.      *            全路径。
341.      * @param toDirectory
342.      *            全路径。
343.      * @return 是否成功 成功==true.
344.      */
345.     public static boolean cutFile(String filePath, String toDirectory) {
346.         if (filePath == null || toDirectory == null) {
347.             logger
348.                     .info("the filePath or toDirectory is null ! when cut this file: "
349.                             + filePath + "---- to:" + toDirectory);
350.             return false;
351.         } else if (filePath.trim().equals("") || toDirectory.trim().equals("")) {
352.             logger
353.                     .info("the filePath or toDirectory is /"/"! when cut this file: "
354.                             + filePath + "---- to:" + toDirectory);
355.             return false;
356.         }
357.         if (copyFile(filePath, toDirectory)) {
358.             int delte = deleteFile(filePath);
359.             if (delte == 1) {
360.                 return true;
361.             } else {
362.                 logger
363.                         .info("copy the file sucess form "
364.                                 + filePath
365.                                 + "----to:"
366.                                 + toDirectory
367.                                 + " but delete this file <<<<<<<faile>>>>>>> when cut this file.");
368.                 return false;
369.             }
370.         } else {
371.             logger.debug("copy the file <<<<<<<faile>>>>>>> form " + filePath
372.                     + "----to:" + toDirectory + " when cut this file.");
373.             return false;
374.         }
375.     }
377.     /**
378.      * 将指定的文件夹cut到指定的路径下，如果该路径不存在，将窜关键该路径。
379.      *
380.      * @param directory
381.      *            全路径
382.      * @param toDirectory
383.      *            全路径
384.      * @return 是否成功 成功==true.
385.      */
386.     public static boolean cutDirectory(String directory, String toDirectory) {
387.         if (copyDirectory(directory, toDirectory)) {
388.             boolean isDelete = deleteDirectory(directory);
389.             if (isDelete) {
390.                 logger.debug("cut directory success: form"
391.                         + " directory ---- to " + toDirectory);
392.                 return true;
393.             } else {
394.                 logger
395.                         .info("copy directory sucess but delete <<<<<<<faile>>>>>>> when cut the directory form"
396.                                 + " directory ---- to " + toDirectory);
397.                 return false;
398.             }
399.         } else {
400.             return false;
401.         }
403.     }
405.     /**
406.      * 判断是文件系统中是否存在此文件。
407.      *
408.      * @param filePath
409.      *            全路径
410.      * @return 文件在系统中=true.
411.      */
412.     public static boolean isHave(String filePath) {
413.         if (filePath == null) {
414.             logger
415.                     .info("not know file isHave .filePath is null! at _File.isHave");
416.             return true;
417.         } else if (filePath.trim().equals("")) {
418.             logger
419.                     .info("not know file isHave . filePath is /"/"! at _File.isHave");
420.             return true;
421.         }
422.         File file = new File(filePath);
423.         if (file.exists()) {
424.             return true;
425.         }
426.         return false;
427.     }
429.     /**
430.      * 将指定的文件copy到指定的路径下，如果该路径不存在将创建此路径。
431.      *
432.      * @param filePath
433.      *            全路径
434.      * @param toDirectoryPath
435.      *            全路径
436.      * @return 是否成功 成功==true.
437.      */
438.     public static boolean copyFile(String filePath, String toDirectoryPath) {
439.         if (filePath == null || toDirectoryPath == null) {
440.             logger
441.                     .info("the filePath or toDirectory is null at _File.copyFile()");
442.             return false;
443.         } else if (filePath.trim().equals("")
444.                 || toDirectoryPath.trim().equals("")) {
445.             logger
446.                     .info("the filePath or toDirectory is /"/" at _File.copuFile()");
447.             return false;
448.         }
449.         File directory = new File(toDirectoryPath);
450.         if (!directory.exists()) {
451.             makeDirectory(toDirectoryPath);
452.         }
454.         File file = new File(filePath);
455.         String toFilePath = toDirectoryPath + FILE_SEPARATOR + file.getName();
456.         File toFile = new File(toFilePath);
457.         try {
458.             if (!file.isFile()) {
459.                 logger.debug("can not get FileInputStream from this file:"
460.                         + filePath);
461.                 return false;
462.             }
463.             FileInputStream fis = new FileInputStream(file);
464.             FileOutputStream fos = new FileOutputStream(toFile);
465.             byte[] data = new byte[fis.available()];
466.             int bytesRead;
467.             while ((bytesRead = fis.read(data)) != -1) {
468.                 fos.write(data, 0, bytesRead);
469.             }
470.             fos.flush();
471.             fos.close();
472.             fis.close();
473.             logger
474.                     .info("copy file file:" + file + "-----to:"
475.                             + toDirectoryPath);
476.             return true;
477.         } catch (FileNotFoundException e) {
478.             logger.debug(e.getMessage());
479.         } catch (IOException e) {
480.             logger.debug(e.getMessage());
481.         }
482.         return false;
483.     }
485.     /**
486.      * 将指定的文件copy到指定的路径下，如果该路径不存在将创建此路径。
487.      *
488.      * @param sfilePath
489.      *            全路径
490.      * @param toDirectoryPath
491.      *            全路径
492.      * @return 是否成功 成功==true.
493.      */
494.     public static boolean copyFileByFilePath(String sfilePath, String dfilePath) {
495.         if (sfilePath == null || dfilePath == null) {
496.             logger.info("the filePath is null at _File.copyFile()");
497.             return false;
498.         } else if (sfilePath.trim().equals("") || dfilePath.trim().equals("")) {
499.             logger.info("the filePath is /"/" at _File.copuFile()");
500.             return false;
501.         }
502.         String toFileDir = dfilePath.substring(0, dfilePath.lastIndexOf(System
503.                 .getProperty("file.separator")));
504.         boolean flag = makeDirectory(toFileDir);
505.         if (!flag) {
506.             return false;
507.         }
508.         File file = new File(sfilePath);
509.         File toFile = new File(dfilePath);
510.         try {
511.             if (!file.isFile()) {
512.                 logger.debug("can not get FileInputStream from this file:"
513.                         + sfilePath);
514.                 return false;
515.             }
516.             FileInputStream fis = new FileInputStream(file);
517.             FileOutputStream fos = new FileOutputStream(toFile);
518.             byte[] data = new byte[fis.available()];
519.             int bytesRead;
520.             while ((bytesRead = fis.read(data)) != -1) {
521.                 fos.write(data, 0, bytesRead);
522.             }
523.             fos.flush();
524.             fos.close();
525.             fis.close();
526.             logger.info("copy file file:" + file + "-----to:" + dfilePath);
527.             return true;
528.         } catch (FileNotFoundException e) {
529.             logger.debug(e.getMessage());
530.         } catch (IOException e) {
531.             logger.debug(e.getMessage());
532.         }
533.         return false;
534.     }
536.     /**
537.      * 将指定的文件夹copy到指定的路径下，如果指定的制定的路径不存在，创建此路径;指定的路径存在将覆盖.
538.      *
539.      * @param directoryPath
540.      *            全路径
541.      * @param toDirectoryPath
542.      *            全路径
543.      * @return 是否成功 成功==true.
544.      */
545.     public static boolean copyDirectory(String directoryPath,
546.             String toDirectoryPath) {
547.         File file;
548.         File[] files;
549.         file = new File(directoryPath);
550.         if (file.exists() && file.isDirectory()) {
551.             files = file.listFiles();
552.             if (files != null) {
553.                 for (int i = 0; i < files.length; i++) {
554.                     if (files[i].exists()) {
555.                         if (files[i].isDirectory()) {
556.                             copyDirectory(files[i].getPath(), toDirectoryPath
557.                                     + FILE_SEPARATOR + files[i].getName());
558.                         } else if (files[i].isFile()) {
559.                             copyFile(files[i].getPath(), toDirectoryPath);
560.                         }
561.                     }
562.                 }
563.             }
564.         } else {
565.             logger.debug("file not exists or is not directory!");
566.             return false;
567.         }
568.         logger.debug("copy directory form:" + directoryPath + "to :"
569.                 + toDirectoryPath + ".");
570.         return true;
571.     }
573.     /**
574.      * 从给定的字符串中创建文件系统路径。
575.      *
576.      * @param directory
577.      *            给定的路径表示字符串。
578.      * @return 是否成功 成功==true.
579.      */
580.     public static boolean makeDirectory(String directory) {
581.         File file = new File(directory);
582.         if (!file.exists()) {
583.             if (file.mkdirs()) {
584.                 logger.debug("make dirctory success!:" + directory);
585.                 return true;
586.             } else {
587.                 logger.debug("make dirctory <<<<<<<faile>>>>>>>!:" + directory);
588.                 return false;
589.             }
590.         } else {
591.             logger.debug("this directory is existed!:" + directory);
592.             return true;
593.         }
594.     }
596.     /**
597.      * 从文件中读出数据放到String中.
598.      *
599.      * @param filePath
600.      *            文件路径.
601.      * @param encoding
602.      *            编码格式.
603.      * @return 文件的String.
604.      */
605.     public static String readFile(String filePath, String encoding) {
606.         String contents = null;
607.         FileInputStream fissrc;
608.         try {
609.             fissrc = new FileInputStream(filePath);
610.             int len = fissrc.available();
611.             byte[] data = new byte[len];
612.             int actual = 0;
613.             int bytesread = 0;
614.             while ((bytesread != len) && (actual != -1)) {
615.                 actual = fissrc.read(data, bytesread, len - bytesread);
616.                 bytesread += actual;
617.             }
618.             contents = new String(data, "GBK");
619.         } catch (FileNotFoundException e) {
620.             e.printStackTrace();
621.         } catch (IOException e) {
622.             e.printStackTrace();
623.         }
625.         return contents;
626.     }
628.     /**
629.      * 获得所有的文件名.
630.      *
631.      * @param directoryPath
632.      * @return
633.      */
634.     public static List getAllFiles(String directoryPath) {
635.         List allFiles = new ArrayList();
636.         if (!isHave(directoryPath)) {
637.             return allFiles;
638.         } else {
639.             File file = new File(directoryPath);
640.             if (file.isDirectory()) {
641.                 File[] files = file.listFiles();
642.                 for (int i = 0; i < files.length; i++) {
643.                     allFiles.add(files[i].getName());
644.                 }
645.                 return allFiles;
646.             } else {
647.                 return allFiles;
648.             }
649.         }
650.     }
652.     /**
653.      * 不区别文件和文件夹地获取其大小.
654.      *
655.      * @param path
656.      *            文件或者文件夹的大小.
657.      * @return long 类型的大小 bytes
658.      * @throws FileNotFoundException
659.      * @since 2006.4.22
660.      */
661.     public static long getSize(String path) throws FileNotFoundException {
662.         File file = new File(path);
663.         if (file.isFile()) {
664.             return getFileSize(path);
665.         } else {
666.             return getDirectorySize(path, 0);
667.         }
668.     }
670.     /**
671.      * 返回一个文件的大小.
672.      *
673.      * @param filePath
674.      *            文件的全路径.
675.      * @return long bytes value 文件大小.
676.      * @throws FileNotFoundException
677.      * @since 2006.4.22
678.      */
679.     public static long getFileSize(String filePath)
680.             throws FileNotFoundException {
681.         File file = new File(filePath);
682.         if (!file.exists()) {
683.             throw new FileNotFoundException("this file is not exited: "
684.                     + filePath);
685.         }
686.         return file.length();
687.     }
689.     /**
690.      * 返回一个文件夹的大小.
691.      *
692.      * @param directoryPath
693.      *            文件夹的全路径.
694.      * @return 文件夹大小.
695.      * @throws FileNotFoundException
696.      * @since 2006.4.22
697.      */
698.     public static long getDirectorySize(String directoryPath)
699.             throws FileNotFoundException {
700.         return getDirectorySize(directoryPath, 0);
701.     }
703.     /**
704.      * 递归的获取文件夹的每一个文件的大小,并计算总的大小.
705.      *
706.      * @param directoryPath
707.      *            文件夹大小.
708.      * @param size
709.      *            递归参数
710.      * @return long bytes value;
711.      * @throws FileNotFoundException
712.      * @since 2006.4.22
713.      */
714.     private static long getDirectorySize(String directoryPath, long size)
715.             throws FileNotFoundException {
716.         File file = new File(directoryPath);
717.         File[] files = file.listFiles();
718.         for (int i = 0; i < files.length; i++) {
719.             String filePath = files[i].getAbsolutePath();
720.             if (files[i].isDirectory()) {
721.                 size = getDirectorySize(filePath, size);
722.             } else {
723.                 size += getFileSize(filePath);
724.             }
725.         }
726.         return size;
727.     }
729.     /**
730.      * @author
731.      * @param filePath
732.      * @return long bytes value;
733.      * @since 1.0.0 从文件中读出数据放到byte中.
734.      * @createTime 2006-11-06 13:50:20
735.      */
736.     public static byte[] readFileByByte(String filePath) {
737.         byte[] data = null;
738.         FileInputStream fissrc;
739.         try {
740.             fissrc = new FileInputStream(filePath);
741.             int len = fissrc.available();
742.             data = new byte[len];
743.             int actual = 0;
744.             int bytesread = 0;
745.             while ((bytesread != len) && (actual != -1)) {
746.                 actual = fissrc.read(data, bytesread, len - bytesread);
747.                 bytesread += actual;
748.             }
749.             fissrc.close();
750.         } catch (FileNotFoundException e) {
751.             e.printStackTrace();
752.         } catch (IOException e) {
753.             e.printStackTrace();
754.         }
756.         return data;
757.     }
759.     /**
760.      * 删除非空目录
761.      *
762.      * @param dir
763.      * @throws IOException
764.      * @author
765.      * @create 2008-8-30 下午12:46:18
766.      * @since
767.      */
768.     public static void deleteDirectory(File dir) throws IOException {
769.         if ((dir == null) || !dir.isDirectory()) {
770.             throw new IllegalArgumentException("Argument " + dir
771.                     + " is not a directory. ");
772.         }
774.         File[] entries = dir.listFiles();
775.         int sz = entries.length;
777.         for (int i = 0; i < sz; i++) {
778.             if (entries[i].isDirectory()) {
779.                 deleteDirectory(entries[i]);
780.             } else {
781.                 entries[i].delete();
782.             }
783.         }
785.         dir.delete();
786.     }
788.     /**
789.      * 捕捉屏幕
790.      *
791.      * @param fileName
792.      * @author
793.      * @param top
794.      * @param left
795.      * @create 2008-8-30 下午08:03:10
796.      * @since
797.      */
798.     public static void snapShotsf(String fileName, int left, int top) {
799.         try {
800.             BufferedImage screenshot = (new Robot())
801.                     .createScreenCapture(new Rectangle(left, top, 640, 526));
802.             String name = fileName + ".jpg";
803.             File f = new File(name);
804.             ImageIO.write(screenshot, "jpg", f);
806.         } catch (Exception ex) {
807.             System.out.println(ex);
808.         }
809.     }
811. }