Java中IO操作的小感悟

最新推荐文章于 2024-09-15 19:46:31 发布

king_min007

最新推荐文章于 2024-09-15 19:46:31 发布

阅读量431

点赞数

分类专栏： java se 文章标签： java io path file byte windows

java se 专栏收录该内容

7 篇文章 0 订阅

订阅专栏

Java中IO操作的小感悟（原创）

Java中IO操作的小感悟

（文件复制的几种方法）

在有铁锹、车的情况下把一堆沙子运到目的地有几种方法？

答：有如下几种方法：

1、用铁锹铲上沙子走到目的地，一铁锹一铁锹的运输。（小样累不死你不算完）

2、用铁锹把沙子先铲到车子上，然后车子到底有多大？

①车子如果足够装下这堆沙子那最好，直接装车拉走。

②车子本身不够大不能装下这堆沙子，那就装车到目的地卸车然后回来，如此反复直到车子足够装下剩下的沙子为止。

实际上IO操作无非上面所述三种方法。小铁锹法、大卡车法、小车快跑法。

小铁锹法的具体实现：

File fileTarget = new File(targetPath);// 目标文件实例化

InputStream streamIn = new FileInputStream(fileSource);// 输入流,输入对象源文件（锁定沙堆位置）

OutputStream streamOut = new FileOutputStream(fileTarget);// 输出流,输出对象目标文件（锁定目的地位置）

int tempOneByte = 0;// 声明一个字节的缓存（亮出小铁锹）

// （在没把这堆沙子铲完之前，就循环往复的干吧）

while ((tempOneByte = streamIn.read()) > -1) {// 逐个字节读取，在输入流没有读到文件结尾时（开始干活，铲沙子）

streamOut.write(tempOneByte);// 逐个字节写入（把沙子放到目的地）

}

大卡车法的具体实现：

File fileTarget = new File(targetPath);// 目标文件实例化

byte[] tempContainer = new byte[(int) fileSource.length()];// 新建字节数组缓存源文件内容（找个能一次装下这堆沙子的大卡车来）

InputStream streamIn = new FileInputStream(fileSource);// 输入流,输入对象源文件（锁定沙堆位置）

streamIn.read(tempContainer);// 将源文件以输入流方式读入到字节数组（将沙子直接装车）

OutputStream streamOut = new FileOutputStream(fileTarget);// 输出流,输出对象目标文件（锁定目的地位置）

streamOut.write(tempContainer);// 将字节数组写入到目标文件（到地方了可以卸车了）

小车快跑法的实现：

File fileTarget = new File(targetPath);// 目标文件实例化

InputStream streamIn = new FileInputStream(fileSource);// 输入流,输入对象源文件（锁定沙堆位置）

OutputStream streamOut = new FileOutputStream(fileTarget);// 输出流,输出对象目标文件（锁定目的地位置）

byte[] buff = new byte[1024];// 声明1024字节的缓存（小车，这个车就只能装这么多东西了）

//（在没把这堆沙子铲完之前，就循环往复的干吧）

for (int i = 0; (i = streamIn.read(buff)) > 0;) {// 逐个缓存读取，再输入流到达结尾时i=-1不满足循环条件（开始装车了）

streamOut.write(buff);// 逐个缓存写入（到地方了，卸车）

}

*在大卡车法和小车快跑法中都没有看到小铁锹的身影。估计是语言的智能化简化了小铁锹这个过程吧。

以上是最近向跳河学习java.io时的一点小感悟和跟我一样的菜鸟一同分享。

posted @ 2011-12-16 01:49 最近想跳河阅读(19) 评论(0) 编辑

文件与文件夹的创建、删除、复制

  1 /**
  2  * @author 最近想跳河
  3  * 文件与文件夹的创建、删除、复制
  4  */
  5 public class FileManager {
  6     /**
  7      * 创建文件
  8      * @param path 文件路径
  9      * @return boolean类型
10      */
11     public static boolean crtFile(String path){
12         boolean flag = false;//参数返回值，局部变量
13         File file = new File(path);
14         if (!file.exists()){
15             try {//创建一个文件
16                 flag = file.createNewFile();
17             } catch (IOException e) {
18                 e.printStackTrace();
19             }
20         }
21         return flag;
22     }
23     /**
24      * 创建文件夹
25      * @param path 文件夹路径
26      * @return boolean类型
27      */
28     public static boolean crtFolder(String path){
29         boolean flag = false;//参数返回值，局部变量
30         File file = new File(path);
31         if (!file.exists()){
32             flag = file.mkdir();
33         }
34         return flag;
35     }
36     /**
37      * 删除文件
38      * @param path 文件路径
39      * @return boolean类型
40      */
41     public static boolean delFile(String path){
42         boolean flag = false;//参数返回值，局部变量
43         File file = new File(path);
44         if(file.exists()&& file.isFile()){//文件且存在
45             flag =file.delete();//删除，给局部变量赋值
46         }
47         return flag;
48     }
49     /**
50      * 删除文件夹以及子文件及文件夹先删除“所有子文件夹”下的文件，最后把这个空文件夹删除
51      * @param path 文件夹路径
52      */
53     public static void delFolder(String path) {
54         File folder = new File(path);
55         if (folder.exists() && folder.isDirectory()) {// 文件夹存在且是文件夹
56             File[] lists = folder.listFiles();// 取得文件夹下的所有文件与文件夹
57             for (int i = 0; i < lists.length; i++) {
58                 if (lists[i].isFile()) {// 取得所有文件
59                     lists[i].delete();// 删除文件
60                 }
61                 if (lists[i].isDirectory()) {// 取得所有文件夹
62                     delFolder(lists[i].getPath());// 递归，将所有文件夹下的文件全部删除
63                 }
64             }
65         }//递归循环出来一次，就删除一个文件夹
66         folder.delete();// 文件夹下的文件全部删除，删除空文件夹
67     }
68
69     /**
70      * 复制文件,此为复制文件的正解。逐个缓存读取源文件，逐个缓存写入目标文件文件结尾将会返回-1 这种方法可以读取写入的文件大小不受限制
71      * @param sourcePath 源文件路径
72      * @param targetPath 目标文件路径
73      * @throws IOException 抛错
74      */
75     public static void copyFile(String sourcePath, String targetPath)
76             throws IOException {
77         if (!sourcePath.equals(targetPath)) {// 源文件路径和拷贝的目标路径不一致才可以执行
78             File fileSource = new File(sourcePath);// 源文件实例化
79             if (fileSource.exists()) {// 源文件存在
80                 if (fileSource.isFile()) {// 判断源文件是否为“文件”
81                     File fileTarget = new File(targetPath);// 目标文件实例化
82                     InputStream streamIn = new FileInputStream(fileSource);// 输入流,输入对象源文件
83                     OutputStream streamOut = new FileOutputStream(fileTarget);// 输出流,输出对象目标文件
84                     byte[] buff = new byte[1024];// 声明1024字节的缓存
85                     for (int i = 0; (i = streamIn.read(buff)) > 0;) {// 逐个缓存读取，再输入流到达结尾时i=-1不满足循环条件
86                         streamOut.write(buff);// 逐个缓存写入
87                     }
88                     streamIn.close();// 关闭输入流
89                     streamOut.close();// 关闭输出流
90                 }
91             }
92         }
93     }
94
95     /**
96      * 复制文件夹
97      * @param source 源文件夹
98      * @throws IOException
99      */
100     public static void copyFolder(String source, String target)
101             throws IOException {
102         if (!source.equals(target)) {// 源文件路径和拷贝的目标路径不一致才可以执行
103             File fileSource = new File(source);// 源文件实例化
104             if (fileSource.exists()) {// 源文件存在
105                 if (fileSource.isDirectory()) {// 判断源文件是否为“文件夹”
106                     File fileTarget = new File(target);
107                     fileTarget.mkdir();// 创建目标文件夹
108                     File[] lists = fileSource.listFiles();// 取得此文件夹下的所有文件及文件夹
109                     for (int i = 0; i < lists.length; i++) {
110                         if (lists[i].isFile()) {
111                             // 路径寻找较为周折，源路径不会变化。目标路径=拷贝文件路径+分隔符+源文件名称
112                             FileManager.copyFile(lists[i].getPath(),
113                                     fileTarget.getPath() + File.separatorChar
114                                             + lists[i].getName());
115                         }
116                         if (lists[i].isDirectory()) {// 有子文件夹则递归，递归只需要考虑下一个就可以了
117                             copyFolder(lists[i].getPath(), target
118                                     + File.separatorChar + lists[i].getName());// 递归
119                         }
120                     }
121                 }
122             }
123         }
124     }
125 }

posted @ 2011-12-16 01:03 最近想跳河阅读(23) 评论(0) 编辑

2011年12月15日

指定目录下的文件模糊搜索

//递归方法的外部变量，文件列表
private List<File> files = new ArrayList<File>(

    /** 在指定目录下文件的模糊搜索
     * @param fileName 文件名称
     * @param path 给定的搜索目录
     * @return 返回List<File>类型
     */
    public List<File> getFiles(String keyWord,String path){
        File folder = new File(path);//指定搜索文件夹
        if (folder.exists() && folder.isDirectory()) {//存在，必须是文件夹
            File[] lists = folder.listFiles();//取得给定文件夹下的文件数组
            if (lists != null) {
                for (File f : lists) {//遍历
                    if (f.isFile()) {//如果是文件，开始比对文件名
                        if (f.getName().contains(keyWord)) {//字符串是否包含某些字符？
                             this.files.add(f);
                        }
                    }
                    if (f.isDirectory()){//如果是文件夹，递归开始
                        this.getFiles(keyWord, f.getPath());
                    }
                }
            }
        }//这个变量在这个递归方法的外部
        return this.files;
    }

);

posted @ 2011-12-15 01:14 最近想跳河阅读(20) 评论(0) 编辑

在指定文件夹下搜索文件

1 //递归方法的外部变量
2 private File fil

//根据给定的文件名在指定的文件路径中进行搜索
    /** 在指定目录下搜索文件
     * @param fileName 文件名称
     * @param path 给定的搜索目录
     * @return 返回File类型
     */
    public File getFiles(String fileName, String path) {
        File folder = new File(path);//指定搜索文件夹
        if (folder.exists() && folder.isDirectory()) {//存在，必须是文件夹
            File[] lists = folder.listFiles();//取得给定文件夹下的文件数组
            if (lists != null) {
                for (File f : lists) {//遍历
                    if (f.isFile()) {//如果是文件，开始比对文件名
                        if (fileName.equals(f.getName())) {//？这里用“==”
                             this.file = f;
                        }
                    }
                    if (f.isDirectory()){//如果是文件夹，递归开始
                        this.getFiles(fileName, f.getPath());
                    }
                }
            }
        }//这个变量在这个方法的外部
        return this.file; //返回File类型
    }

posted @ 2011-12-15 00:29 最近想跳河阅读(16) 评论(0) 编辑

2011年12月14日

取得给定目录下的所有文件夹和文件，并象Windows资源管理器一样排列

1 /**
2  * @author 最近想跳河
3  *
4  */
5 public class FileList {
6
7     // 文件夹或文件的深度
8     private int levels;
9
10     // 取得文件夹或文件的图标
11     private String getCoin() {
12         String coin = "";// "" or null ?
13         for (int i = 0; i < levels; i++)
14             coin += " ";
15         return coin;
16     }
17
18     // 取得给定目录下的所有文件夹和文件，并象Windows资源管理器一样排列
19     public void getAll(String path) {
20         File folder = new File(path);// 取得文File类型的“目录”
21         if (folder.exists() && folder.isDirectory()) {// “目录”必须存在，并且是文件夹
22             System.out.print(this.getCoin() + "+" + folder.getName() + "\n");// 输出“目录”名称
23             this.levels++;// 在这之下的是下一级的文件夹或文件
24             File[] lists = folder.listFiles();// 取得此文件夹下的所有文件及文件夹
25             if (lists != null) {
26                 for (File f : lists) {// 遍历文件夹
27                     if (f.isFile())// 判断是否为“文件”
28                         System.out.print(this.getCoin() + "-" + f.getName() + "\n");
29                 }
30                 for (int i = 0; i < lists.length; i++) {// 遍历文件夹
31                     if (lists[i].isDirectory())// 判断是否为“目录”
32                         this.getAll(lists[i].getPath());
33                 }
34             }
35             this.levels--;// 退回到上一级目录
36         }
37     }
38 }