Java之文件操作及IO流

File类的文件操作

File类中的对文件的相关操作：

        //File对象表示一个文件或文件夹
        File file = new File("E:\\log4j.log");
        //判断是不是文件
        System.out.println(file.isFile());
        file = new File("E:\\Program_Files");
        //判断是不是文件夹
        System.out.println(file.isDirectory());

        //删除文件
        file = new File("E:\\log4j.log");
        System.out.println(file.delete());
        //删除目录时目录必须为空，否则删除失败
        file = new File("E:\\a");
        System.out.println(file.delete());

        file = new File("E:\\a\\b");
        System.out.println(file.getParent());//返回上级目录
        System.out.println(file.getParentFile());//返回上级目录对应的File对象
        System.out.println(file.getPath());//返回file对象所对应的路径

        System.out.println(file.getName());//返回File对象所表示的最后一级路径的名字
        file = new File("E:\\a\\b\\c.txt");
        System.out.println(file.getName());

        //创建文件夹
        file = new File("E:\\aa");
        System.out.println(file.mkdir());//仅能创建一级目录
        file = new File("E:\\aa\\bb\\cc");
        System.out.println(file.mkdirs());//可以创建多级目录

        //创建文件
        file = new File("E:\\aaa");
        try {
            System.out.println(file.createNewFile());
        } catch (IOException e) {
            e.printStackTrace();
        }

        //判断路径或文件夹是否存在
        System.out.println(file.exists());
        file = new File("E:\\aa\\bb\\cc");
        System.out.println(file.exists());

        //重命名
        file.renameTo(new File("E:\\aa\\bb\\ab"));


        //返回该路径下所有子目录或子文件的名字
        file = new File("E:\\Program_Files");
        for (String name:file.list()) {
            System.out.println(name);
        }

        //返回该路径下所有子目录或子文件的File对象
        for (File subFile:file.listFiles()) {
            System.out.println(subFile);
        }

可以使用File中的separator静态常量来表示文件路径间的分隔符：

//Windows和Linux系统中文件的分隔符不同，Windows中为“\”，Linux中为“/”，可以用File.separator分隔
        file = new File("E://aa"+File.separator+"bb");
        System.out.println(file.exists());

编写一个算法，可以输出某一目录下所有的子文件的数量，同时输出所有的文件路径以及最后一级空目录：

public static void iterator(File file){
        if(file.isDirectory()){//判断是否是文件夹
            File[] files = file.listFiles();
            if(files!=null){//文件夹下所有问价或子文件夹
                for (File subFile : files) {
                    iterator(subFile);
                }
            }
            System.out.println(file.getPath());//输出文件夹路径
        }else{
            count++;//为类内部定义的全局变量
            System.out.println(file.getPath());//输出文件路径
        }
    }

IO流

实现对某一文件的输入和输出

1. 字节流：FileInputStream和FileOutputStream

		//以一个一个字节为单位对文件进行输入和输出（速度非常慢）
        File a = new File("G:\\video.mp4");
        File b = new File("G:\\test\\video.mp4");
        FileInputStream inputStream = new FileInputStream(a);
        FileOutputStream outputStream = new FileOutputStream(b);
        int data;
        while((data=inputStream.read())!=-1){
            outputStream.write(data);
        }
        
		//以许多字节为单位对文件进行输入和输出（速度很快）
		File a = new File("G:\\video.mp4");
        File b = new File("G:\\test\\video.mp4");
        FileInputStream inputStream = new FileInputStream(a);
        FileOutputStream outputStream = new FileOutputStream(b);
        byte[] car = new byte[1024];//每次输入输出1024字节的内容
        int length=0;
        while((length=inputStream.read(car))!=-1){
            outputStream.write(car,0,length);
        }

2. 字符流：FileReader和FileWriter

		//以一个一个字符为单位对文件进行输入和输出（速度非常慢）
        FileReader reader = new FileReader("E:\\a.txt");
        FileWriter writer = new FileWriter("G:\\a.txt");
        int data;
        while((data= reader.read())!=-1){
            writer.write(data);
        }
        writer.flush();
        writer.close();
        reader.close();
        
		//以许多字符为单位对文件进行输入和输出（速度很快）
        FileReader reader = new FileReader("E:\\a.txt");
        FileWriter writer = new FileWriter("G:\\a.txt");
        char[] car = new char[1024];//每次输入输出1024个字符的内容
        int length=0;
        while((length= reader.read(car))!=-1){
            writer.write(car,0,length);
        }
        writer.flush();
        writer.close();
        reader.close();

3. 字节缓冲流：BufferedInputStream和BufferedOutputStream

缓冲流可以更快速的对文件进行读写操作，因为它事先已经将文件加载到内存的缓冲区中，在读写文件时不再需要对硬盘进行操作，所以有更高的读写速度。
但要注意写文件结束后一定要调用flush方法将缓冲区的内容写出来，否则最终文件会丢失数据。

        FileInputStream inputStream = new FileInputStream("E:\\a.txt");
        BufferedInputStream bufferedInputStream = new BufferedInputStream(inputStream);
        FileOutputStream outputStream = new FileOutputStream("G:\\a.txt");
        BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(outputStream);
        byte[] car = new byte[1024];
        int length;
        while((length=bufferedInputStream.read(car))!=-1){
            bufferedOutputStream.write(car,0,length);
        }
        bufferedOutputStream.flush();//将缓冲区的内容刷出来
        bufferedInputStream.close();
        bufferedOutputStream.close();

4. 字符缓冲流：

        FileReader reader = new FileReader("E:\\a.txt");
        BufferedReader bufferedReader = new BufferedReader(reader);
        FileWriter writer = new FileWriter("G:\\a.txt");
        BufferedWriter bufferedWriter = new BufferedWriter(writer);
        char[] car = new char[1024];
        int length=0;
        while((length= bufferedReader.read(car))!=-1){
            bufferedWriter.write(car,0,length);
        }
        bufferedWriter.flush();//将缓冲区的内容刷出来
        bufferedWriter.close();
        bufferedWriter.close();

5. 转换流：InputStreamReader和OutputStreamWriter

        //转换流：将字节流转换为字符流，可以解决字符流乱码问题
        FileInputStream inputStream = new FileInputStream("E:\\a.txt");
        InputStreamReader reader = new InputStreamReader(inputStream,"GBK");//以GBK的编码对文件读取
        FileOutputStream outputStream = new FileOutputStream("G:\\a.txt");
        OutputStreamWriter writer = new OutputStreamWriter(outputStream,"UTF-8");//以UTF-8的编码写出文件
        char[] car = new char[1024];
        int length=0;
        while((length= reader.read(car))!=-1){
            writer.write(car,0,length);
        }
        writer.flush();
        writer.close();
        reader.close();

6. 带缓冲区的转换流：InputStreamReader和OutputStreamWriter

//缓冲的转换流
        FileInputStream inputStream = new FileInputStream("E:\\a.txt");
        BufferedInputStream bufferedInputStream = new BufferedInputStream(inputStream);
        InputStreamReader reader = new InputStreamReader(bufferedInputStream,"GBK");

        FileOutputStream outputStream = new FileOutputStream("G:\\a.txt");
        BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(outputStream);
        OutputStreamWriter writer = new OutputStreamWriter(bufferedOutputStream,"UTF-8");
        char[] car = new char[1024];
        int length=0;
        while((length= reader.read(car))!=-1){
            writer.write(car,0,length);
        }
        writer.flush();
        writer.close();
        reader.close();