文件-File

jiezi

5 年前

package com.ljw.study;

import java.io.File;
import java.util.Arrays;
import java.util.Date;

public class FileDemo {public static void main(String[] args) {
        // 构造文件对象
        // 绝对路径，构造文件夹对象
        File f1 = new File("d:/work/code/ljw/Test");
        System.out.println(f1.exists()); // 文件是否存在
        
        // 相对路径, 如果是 eclipse 的话，就是相对于项目目录
        File f2 = new File("employee.ser");
        System.out.println("f2 的绝对路径：" + f2.getAbsolutePath());
        System.out.println(f2.exists());
        
        // 以 f1 为父目录创建文件对象
        File f3 = new File(f1,"LOL.exe");
        System.out.println("f3 的绝对路径：" + f3.getAbsolutePath());
        
        System.out.println(f2.isDirectory()); // 是否是文件夹
        
        System.out.println(f2.isFile()); // 是否为文件(非文件夹)
        
        System.out.println(f2.length()); // 文件长度
        
        System.out.println(new Date(f2.lastModified())); // 最后的修改时间
        
//        System.out.println(f2.renameTo(new File("employee.ser")));// 文件重命名
        
        System.out.println(Arrays.toString(f1.list())); // 以字符串数组的形式，返回当前文件夹下的所有文件（不包含子文件及子文件夹）System.out.println(Arrays.toString(f1.listFiles())); // 以文件数组的形式，返回当前文件夹下的所有文件（不包含子文件及子文件夹）// 以字符串形式返回获取所在文件夹
        System.out.println(f1.getParent());
  
        // 以文件形式返回获取所在文件夹
        f2.getParentFile();
        // 创建文件夹，如果父文件夹 skin 不存在，创建就无效
        f1.mkdir();
  
        // 创建文件夹，如果父文件夹 skin 不存在，就会创建父文件夹
        f1.mkdirs();
  
        // 创建一个空文件, 如果父文件夹 skin 不存在，就会抛出异常
        f1.createNewFile();
        // 所以创建一个空文件之前，通常都会创建父目录
        f1.getParentFile().mkdirs();
  
        // 列出所有的盘符 c: d: e: 等等
        f1.listRoots();

        // 刪除文件
        f.delete();
  
        // JVM 结束的时候，刪除文件，常用于临时文件的删除
        f.deleteOnExit()}
}

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
  
public class TestStream {public static void main(String[] args) {
        try {
            // 准备文件 lol.txt 其中的内容是 AB，对应的 ASCII 分别是 65 66
            File f =new File("d:/lol.txt");
            // 创建基于文件的输入流
            FileInputStream fis =new FileInputStream(f);
            // 创建字节数组，其长度就是文件的长度
            byte[] all =new byte[(int) f.length()];
            // 以字节流的形式读取文件所有内容
            fis.read(all);
            for (byte b : all) {
                // 打印出来是 65 66
                System.out.println(b);
            }
             
            // 每次使用完流，都应该进行关闭
            fis.close();} catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();}
    }
}

package com.ljw.practice;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class FileDemo {public static void main(String[] args) {
        // TODO Auto-generated method stub
        File f = new File("d:/xyz/abc/def/lol2.txt");
        f.getParentFile().mkdirs();
        
        try {FileOutputStream outputFile = new FileOutputStream(f);
            String s = "秋天，多了一些思念";
            byte[] b = s.getBytes(); // 将字符串转换为字节数组 byte[]
            outputFile.write(b);
            outputFile.close();} catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();} catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();}
        
    }
}


package com.ljw.practice;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class FileDemo {public static void main(String[] args) {File f = new File("d:/lol.txt");
        
        try(FileReader fr = new FileReader(f)){// 数据流写在 try()里面，系统会帮我们自动关闭数据流
            char[] c = new char[(int) f.length()];
            fr.read(c);
            for(char i:c) {System.out.print(i);
            }
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();} catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();}
    }
}


package com.ljw.practice;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class FileDemo {public static void main(String[] args) {File f = new File("d:/lol.txt");
        File f2 = new File("d:/lol2.txt");
        
        try(FileReader fr = new FileReader(f);FileWriter fw = new FileWriter(f2)){char[] c = new char[(int) f.length()];
            fr.read(c); // 读出数据到字符数组
            fw.write(c); // 写入数据从数组到文件
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();} catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();}
    }
}

缓存流必须建立在一个存在的流的基础上
以介质是硬盘为例，字节流和字符流的弊端：在每一次读写的时候，都会访问硬盘。如果读写的频率比较高的时候，其性能表现不佳。
为了解决以上弊端，采用缓存流。缓存流在读取的时候，会一次性读较多的数据到缓存中，以后每一次的读取，都是在缓存中访问，直到缓存中的数据读取完毕，再到硬盘中读取。
如果需要立即将缓存中的数据写入硬盘，可以使用 flush() 方法


package stream;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;

public class TestStream {public static void main(String[] args) {File f = new File("d:/lol.txt");
        // 创建文件字符流
        // 缓存流必须建立在一个存在的流的基础上
        try (FileReader fr = new FileReader(f);
                BufferedReader br = new BufferedReader(fr);
            )
        {while (true) {
                // 一次读一行
                String line = br.readLine();
                if (null == line)
                    break;
                System.out.println(line);
            }
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();}
    
    }
}

package com.ljw.practice;

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;

public class FileDemo {public static void main(String[] args) {File f = new File("d:/lol2.txt");
        
        try (
                // 创建文件字符流
                FileWriter fw = new FileWriter(f);
                // 缓存流必须建立在一个存在的流的基础上              
                PrintWriter pw = new PrintWriter(fw);              
        ) {pw.println("garen kill teemo");
            pw.println("teemo revive after 1 minutes");
            pw.println("teemo try to garen, but killed again");
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();}
    }
}

使用数据流的 writeUTF()和 readUTF() 可以进行数据的格式化顺序读写
要用 DataInputStream 读取一个文件，这个文件必须是由 DataOutputStream 写出的，否则会出现 EOFException，因为 DataOutputStream 在写出的时候会做一些特殊标记，只有 DataInputStream 才能成功的读取。

以数据流的方式读写数据

package com.ljw.practice;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class FileDemo {public static void main(String[] args) {write();
        read();}
    
    private static void read() {File f = new File("d:/lol2.txt");
        try(FileInputStream fi = new FileInputStream(f); 
                DataInputStream di = new DataInputStream(fi); // 创建一个数据流对象
            ) 
        {boolean b = di.readBoolean();
            int i = di.readInt();
            String s = di.readUTF();
            System.out.println(b);
            System.out.println(i);
            System.out.println(s);
            
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();} catch (IOException e1) {
            // TODO Auto-generated catch block
            e1.printStackTrace();}
        
    }
    
    private static void write() {File f = new File("d:/lol2.txt");
        
        try(FileOutputStream fo = new FileOutputStream(f);
                DataOutputStream dos = new DataOutputStream(fo);
            )
        {dos.writeBoolean(false);
            dos.writeInt(200);
            dos.writeUTF("中国");
            
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();} catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();}
    }
}

把一个对象序列化有一个前提是：这个对象的类，必须实现了 Serializable 接口

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
  
import charactor.Hero;
    
public class TestStream {public static void main(String[] args) {
        // 创建一个 Hero garen
        // 要把 Hero 对象直接保存在文件上，务必让 Hero 类实现 Serializable 接口
        Hero h = new Hero();
        h.name = "garen";
        h.hp = 616;
          
        // 准备一个文件用于保存该对象
        File f =new File("d:/garen.lol");
 
        try(
            // 创建对象输出流
            FileOutputStream fos = new FileOutputStream(f);
            ObjectOutputStream oos =new ObjectOutputStream(fos);
            // 创建对象输入流              
            FileInputStream fis = new FileInputStream(f);
            ObjectInputStream ois =new ObjectInputStream(fis);
        ) {oos.writeObject(h);
            Hero h2 = (Hero) ois.readObject();
            System.out.println(h2.name);
            System.out.println(h2.hp);
               
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();} catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();}
    }
}

package com.ljw.practice;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class FileDemo {public static void main(String[] args) {
        // TODO Auto-generated method stub
        File file = new File("d:/F.docx");
        
        try {FileInputStream inFile = new FileInputStream(file);
            int i = 1;
            while(true) {byte[] b = new byte[1024*100];
                int n = inFile.read(b);
                if(n==-1) {  // 没有读到数据返回 -1
                    break;
                }
                File f1 = new File(String.format("d:/F-%d.docx",i)); // 占位符
                FileOutputStream outFile = new FileOutputStream(f1);
                outFile.write(b);
                i++;
            }    
            
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();} catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();}
    }
}

package com.ljw.practice;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class FileDemo {public static void main(String[] args) {
        // TODO Auto-generated method stub
        File newF = new File("d:/newF.docx");
        try {FileOutputStream outNewF = new FileOutputStream(newF);
            for(int i=1;i<5;i++) {File f = new File(String.format("d:/F-%d.docx", i));
                byte[] b = new byte[(int) f.length()];
                FileInputStream inf = new FileInputStream(f);
                inf.read(b);
                outNewF.write(b);
                inf.close();}
            outNewF.close();} catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();} catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();}
    }
}

package com.ljw.practice;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

public class FileDemo {public static void main(String[] args) {File f = new File("d:/lol.txt");
        try (FileInputStream fis = new FileInputStream(f);) {byte[] all = new byte[(int) f.length()];
            fis.read(all);
        
            // 文件中读出来的数据是
            System.out.println("文件中读出来的数据是：");
            for (byte b : all)
            {
                int i = b&0xff;  // 只取 16 进制的后两位
                System.out.println(Integer.toHexString(i));
            }
            System.out.println("把这个数字，放在 GBK 的棋盘上去：");
            String str = new String(all,"GBK");
            System.out.println(str);
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();}
    }
}

复制文件或文件夹
查找指定的内容

package com.ljw.practice;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;

public class FilePractice {public static void main(String[] args) {
        //---------- 复制文件 --------------
        File srcFile = new File("d:/lol.txt");
        File destFile = new File("d:/lol3.txt");
        copyFile(srcFile,destFile);
        
        //---------- 复制文件夹 ------------
        File srcFolder = new File("d:/xyz");
        File destFolder = new File("d:/xyz- 副本");
        copyFolder(srcFolder,destFolder);
        
        //---------- 查找 ---------------
        String s = "hello";
        findFileContent(s, srcFolder);
        
    }
    
    /**
     * 复制文件
     * @param srcFile：源文件
     * @param destFile：目标文件
     * @return void
     */
    public static void copyFile(File srcFile, File destFile) {if(srcFile.exists()) {
            try(    
                    // 创建读取文件流对象
                    FileInputStream fi = new FileInputStream(srcFile);            
                    // 创建写入文件流对象
                    FileOutputStream fo = new FileOutputStream(destFile);
                    
                )
            {byte[] b = new byte[10];
                int i;
                while(true) {i = fi.read(b);
                    if(-1==i) {break;}
                    fo.write(b,0,i);
                }
            } catch (FileNotFoundException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();} catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();}
        }else {System.out.println("文件不存在");
        }
    }
        
        
    /**
     * 复制文件夹
     * @param srcFile
     * @param destFile
     */
    public static void copyFolder(File srcFile, File destFile) {if(srcFile.isDirectory()) {File[] files = srcFile.listFiles();
            destFile.mkdir();
            for(File f:files) {if(f.isDirectory()) {String newFolderPath = destFile.getAbsolutePath()+"\\"+f.getName();
                    File newFolder = new File(newFolderPath);
                    newFolder.mkdir();
                    System.out.println("新文件夹的位置是："+newFolderPath);
                    copyFolder(f,newFolder);
                }else {String newFilePath = destFile.getAbsolutePath()+"\\"+f.getName();
                    System.out.println("新文件的位置是："+newFilePath);
                    File newF = new File(newFilePath);
                    copyFile(f,newF);
                }
            }
        }else {copyFile(srcFile, destFile);
        }
    }
    
    /**
     * 查找指定的文件内容
     * @param s：要查找的字符串
     * @param file：要查找的文件对象
     */
    public static void findFileContent(String s,File file) {if(file.isDirectory()) {File[] files = file.listFiles();
            for(File f:files) {findFileContent(s,f);
            }
        }else {
            try(FileReader fr = new FileReader(file);
                    BufferedReader br = new BufferedReader(fr);
                ) {while(true) {String str = br.readLine();
                    if(null == str) {break;}
                    if(str.contains(s)) {System.out.println("找到目标字符串"+s+", 在文件："+file.getAbsolutePath());
                        break;
                    }
                }
                
            } catch (FileNotFoundException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();} catch (IOException e1) {
                // TODO Auto-generated catch block
                e1.printStackTrace();}
        }
    }
}

文件-File

文件

1. 文件的一些常用方法

2. 读取和写入文件数据

2.1 以字节流方式

2.1.1 读取数据

2.1.2 写入数据

2.2 以字符流方式

2.2.1 读取数据

2.2.2 写入数据

2.3 以缓存流方式

2.3.1 读取数据

2.3.2 写入数据

2.4 以数据流方式

2.4.1 实例

2.5 以对象流(序列化对象)

3. 拆分文件和合并文件

3.1 拆分文件

3.2 合并文件

4. 中文问题

综合练习

文件

1. 文件的一些常用方法

2. 读取和写入文件数据

2.1 以字节流方式

2.1.1 读取数据

2.1.2 写入数据

2.2 以字符流方式

2.2.1 读取数据

2.2.2 写入数据

2.3 以缓存流方式

2.3.1 读取数据

2.3.2 写入数据

2.4 以数据流方式

2.4.1 实例

2.5 以对象流(序列化对象)

3. 拆分文件 和 合并文件

3.1 拆分文件

3.2 合并文件

4. 中文问题

综合练习

3. 拆分文件和合并文件