Java IO流（二）

• File类
• 字符流与字节流

File 类

1.1 File 概述

　　打开API，搜索File类。阅读其描述：File文件和目录路径名的抽象表示形式。即，Java中把文件或者目录（文件夹）都封装成File对象。也就是说如果我们要去操作硬盘上的文件，或者文件夹只要找到File这个类即可,那么我们就要研究研究File这个类中都有那些功能可以操作文件或者文件夹呢

1.2 File类的构造函数

File(String pathname) :将一个字符串路径封装成File对象

 File(String parent,String child):传入一个父级路径和子级路径

 File(File parent,String child):传入一个File类型的父级路径和子级路径

1.2.1 案例代码一：

package com.gao_01;
import java.io.File;
/*
 * File:文件和目录路径名的抽象表示形式，File 类的实例是不可变的
 * 
 * 构造方法：
 *         File(File parent, String child) 
 *         File(String pathname) 
 *         File(String parent, String child)      
 * 
 * 
 */
public class FileDemo {
    public static void main(String[] args) {
        //File(String pathname) ：将指定的路径名转换成一个File对象
        //File f = new File("D:\\a\\b.txt");
        
        //File(String parent, String child) : 根据指定的父路径和文件路径创建File对象
        //File f2 = new File("D:\\a","b.txt");
        
        //File(File parent, String child) :根据指定的父路径对象和文件路径创建File对象
        //File parent = new File("D:\\a");
        //File f3 = new File(parent,"b.txt");
        
        File f4 = new File(new File("D:\\a"),"b.txt");
        
    }
}

1.3 类创建和删除功能

boolean createNewFile():指定路径不存在该文件时时创建文件,返回true,否则返回false

boolean mkdir():当指定的单级文件夹不存在时创建文件夹并返回true，否则返回false

boolean mkdirs():当指定的多级文件夹某一级文件夹不存在时,创建多级文件夹并返回true,否则返回false

boolean delete():删除文件或者删除单级文件夹

1.3.1 案例代码二：

package com.gao_01;

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

/*
 *     创建功能
 *         boolean createNewFile()  
 *         boolean mkdir()  
 *         boolean mkdirs()  
 *     删除功能
 *         boolean delete() 
 * 
 *  绝对路径：固定不可改变的路径，以盘符开头
 *  相对路径：相对某个参照物，不能以盘符开头
 *          在eclipse中相对路径相对应当前项目的根目录
 *  
 *  
 *  注意：删除一个文件夹，这个文件夹下面不能有其他的文件和文件夹

 */
public class FileDemo2 {
    public static void main(String[] args) throws IOException {
          File f = new File("d:\\a\\b.txt");//绝对路径
          File f2 = new File("a.txt");//相对路径
        
         //boolean createNewFile() : 当指定文件不存在时创建文件并返回true，否则返回false
         System.out.println(f2.createNewFile());
        
         
        //boolean mkdir()   : 当指定文件夹不存在时创建文件夹并返回true，否则返回false
        File f3 = new File("b");
        System.out.println(f3.mkdir());
        
        //boolean mkdirs() : 创建指定文件夹，当文件夹所在的目录不存在，则顺道一块创建了
        File f4 = new File("c\\d\\e");
        System.out.println(f4.mkdir());
        System.out.println(f4.mkdirs());
        
        File f5 = new File("c.txt");
        System.out.println(f5.mkdir());
        
        //boolean delete() :当指定的文件或文件夹存在时删除文件或者文件夹 并返回true，否则返回false
        System.out.println(f2.delete());
        System.out.println(f3.delete());

        File f6 = new File("c");
        System.out.println(f6.delete());
        
    }
}

1.4 File 类的判断功能

boolean exists():判断指定路径的文件或文件夹是否存在

boolean isAbsolute():判断当前路路径是否是绝对路径

boolean isDirectory():判断当前的目录是否存在

boolean isFile():判断当前路径是否是一个文件

boolean isHidden():判断当前路径是否是隐藏文件

1.4.1 案例代码三：

package com.gao_01;
import java.io.File;
import java.io.IOException;

/*
 *    判断功能
 *         boolean exists()  
 *         boolean isAbsolute()  
 *         boolean isDirectory() 
         boolean isFile()  
         boolean isHidden() 
 */
public class FileDemo3 {
    public static void main(String[] args) throws IOException {
        //method();
        //method2();
        //method3();
        
        method4();
    }

    private static void method4() {
        File f = new File("d:\\a\\b.txt");
        //boolean isHidden() :判断File对象指向的路径是否有隐藏属性，如果隐藏了则返回true，否则返回false
        
        System.out.println(f.isHidden());
    }

    private static void method3() {
        File f = new File("a.txt");
        File f2 = new File("b");
        //boolean isDirectory() ：判断File对象指向的路径是否是文件夹，如果是则返回true，否则返回false
        //boolean isFile()  : 判断File对象指向的路径是否是文件，如果是则返回true，否则返回false
        
        //System.out.println(f.isDirectory());
        //System.out.println(f2.isDirectory());
        
        System.out.println(f.isFile());
        System.out.println(f2.isFile());
    }

    private static void method2() {
        //File f = new File("a.txt");
        File f2 = new File("d:\\a\b.txt");
        
        //boolean isAbsolute() :判断File对象指向的路径是否是绝对路径，如果是绝对路径则返回true，否则返回false
        System.out.println(f2.isAbsolute());
    }

    private static void method() {
        File f = new File("a.txt");
        //f.createNewFile();
        
        //boolean exists() : 判断文件或者文件夹是否存在，如果存在则返回true，否则返回false
        System.out.println(f.exists());
    }
}

1.5 File 类的获取功能和修改名字功能

  File getAbsoluteFile():获取文件的绝对路径,返回File对象

  String getAbsolutePath():获取文件的绝对路径,返回路径的字符串

  String getParent():获取当前路径的父级路径,以字符串形式返回该父级路径

  File getParentFile():获取当前路径的父级路径,以字File对象形式返回该父级路径

  String getName():获取文件或文件夹的名称

  String getPath():获取File对象中封装的路径

  long lastModified():以毫秒值返回最后修改时间

  long length():返回文件的字节数

  boolean renameTo(File dest): 将当前File对象所指向的路径 修改为 指定File所指向的路径

1.5.1 案例代码四：

 package com.gao_01;

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

/*
 *    获取功能
         File getAbsoluteFile()  
 *         String getAbsolutePath() 
 *         String getParent()  
 *         File getParentFile() 
 *         String getName() 
 *         String getPath()  
          long lastModified() 
          long length() 
      修改功能：
         boolean renameTo(File dest)
 */
public class FileDemo4 {
    public static void main(String[] args) throws IOException  {
        //method();
        //method2();
        //method3();
        
        File f = new File("d.txt");
        File f2 = new File("e.txt");
        
        //boolean renameTo(File dest) : 将当前File对象所指向的路径 修改为 指定File所指向的路径
        //注意：修改的文件路径不能存在，如果存在则修改失败
        System.out.println(f.renameTo(f2));
    }

    private static void method3() {
        File f = new File("a.txt");
        File f2 = new File("d:\\a\\b.txt");
        File f3 = new File("b");
        
        //String getName() : 获取文件和文件夹的名称
        //System.out.println(f.getName());
        //System.out.println(f2.getName());
        //System.out.println(f3.getName());
        
        //String getPath() : 返回创建File对象时给的路径
        //System.out.println(f.getPath());
        //System.out.println(f2.getPath());
        //System.out.println(f3.getPath());
        
        //long lastModified() : 以毫秒值的形式返回最后修改时间
        //System.out.println(f.lastModified());
        //2514023311294
        //Date d = new Date(2514023311294L);
        //System.out.println(d.toLocaleString());
        
        //long length() : 返回文件的字节数
        System.out.println(f.length());
        System.out.println(f3.length());
    }

    private static void method2() throws IOException {
        //File f = new File("a.txt");
        
        //File f2 = new File("b","c.txt");
        //System.out.println(f2.createNewFile());
        
        File parent = new File("b");
        File f3 = new File(parent,"c.txt");
        if(!parent.exists()) {
            parent.mkdirs();
        }
        System.out.println(f3.createNewFile());
        
        //String getParent() 
        System.out.println(f3.getParent());
        //File getParentFile() 
        System.out.println(f3.getParentFile());
    }

    private static void method() {
        File f = new File("d:\\a\\b.txt");
        File f2 = new File("a.txt");
        
        //File getAbsoluteFile()  ：以File对象的形式返回当前File对象所有指向的绝对路径
        System.out.println(f2.getAbsoluteFile());
        //String getAbsolutePath() : 返回File对象所指向的绝对路径
        System.out.println(f2.getAbsolutePath());
    }
}

1.6 File 类的其他获取功能

String[] list():以字符串数组的形式返回当前路径下所有的文件和文件夹的名称

File[] listFiles():以File对象的形式返回当前路径下所有的文件和文件夹的名称

static File[] listRoots():获取计算机中所有的盘符

1.6.1 案例代码五：

package com.gao_01;
import java.io.File;

/*
 *     String[] list() 
     File[] listFiles() 
     static File[] listRoots() 
 */
public class FileDemo5 {
    public static void main(String[] args)  {
        //method();
        //method2();
        
        //static File[] listRoots() :  返回的是所有盘符
        File[] files = File.listRoots();
        for (File file : files) {
            System.out.println(file);
        }
    }

    private static void method2() {
        File f = new File("b");
        File f2 = new File("D:\\workspace\\myFile");
        File f3 = new File("c.txt");
        
        //File[] listFiles()
        File[] files = f3.listFiles();
        for (File file : files) {
            System.out.println(file.getName());
        }
    }

    private static void method() {
        File f = new File("b");
        File f2 = new File("D:\\workspace\\myFile");
        File f3 = new File("c.txt");
        
        //String[] list() : 返回当前路径下所有的文件和文件夹名称
        //注意：只有指向文件夹的File对象才可以调用该方法
        String[] files = f3.list();
        for (int i = 0; i < files.length; i++) {
            System.out.println(files[i]);
        }
    }
}

1.7 File 类的两个案例

1.7.1 案例代码六：

输出指定目录下所有的java文件名（包含子目录）

package com.gao_02;

import java.io.File;

/*
 * 需求：输出指定目录下所有的java文件名（包含子目录）
 */
public class RecurrenceTest {
    public static void main(String[] args) {
        File f = new File("src");
        //File f = new File("src\\com\\itheima_01\\RecurrenceDemo.java");
        method(f);
    }
    
    public static void method(File file) {
        if(file.isDirectory()) {
            File[] files = file.listFiles();
            for (File f : files) {
                //判断是否是文件对象
                if(f.isFile()) {
                    if(f.getName().endsWith(".java")) {
                        System.out.println(f.getName());
                    }
                }
                else if(f.isDirectory()){
                    //是一个目录对象
                    method(f);
                }
            }
        }
    }
    
    
    //输出指定目录下的所有java文件名（不包含子目录）
    public static void method2(File file) {
        if(file.isDirectory()) {
            File[] files = file.listFiles();
            for (File f : files) {
                //判断是否是文件对象
                if(f.isFile()) {
                    if(f.getName().endsWith(".java")) {
                        System.out.println(f.getName());
                    }
                }
            }
        }
    }
    
}

1.7.2 案例代码七

删除指定的目录（包含子目录）

package com.gao_02;

import java.io.File;

/*
 * 需求：删除指定的目录（包含子目录）
 * 
 * 注意：如果要删除一个目录，则需要先删除这个目录下的所有子文件和子目录
 * 
 */
public class RecurrenceTest2 {
    public static void main(String[] args) {
        File f = new File("d:\\a");
        method(f);
    }
    
    //删除指定目录下所有文件和目录
    public static void method(File file) {
        if(file.isDirectory()) {
            //干掉自己所有的子文件和子目录
            //获取所有的子文件和子目录
            File[] files = file.listFiles();
            for (File f : files) {
                if(f.isFile()) {
                    //直接干掉他
                    System.out.println(f.getName());
                    f.delete();
                }
                else if(f.isDirectory()) {
                    //继续查看是否还有文件和子目录
                    method(f);
                }
            }
            
            //干掉自己
            System.out.println(file.getName());
            file.delete();
        }
    }
}

1.7.3 案例代码八：

将指定目录(包含内容)复制到另一个目录中

package com.itheima_02;

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

/*
 * 需求：将指定目录(包含内容)复制到另一个目录中
 * 
 * 源目录        目标目录
 * 
 * 
 * 分析：
 *         首先我们要获取源目录下所有的文件和子目录，
 *                 我们可以把源目录封装成一个File对象，
 *                 我们可以调用File类listFiles()方法，
 *                 我们可以获取源目录下所有的文件和子目录所对应的File对象。
 *         如果我们获取到的是文件
 *                 先在目标目录中创建该文件所对应的目录，
 *                 进行文件的复制。
 *         如果我们获取到的是子目录
 *                 看看子目录下面是否还有其他的文件和更深层次的子目录
 * 
 * 
 * 

 */
public class RecurrenceTest3 {
    public static void main(String[] args) throws IOException  {
        //源目录
        File src = new File("d:\\myAPI");
        //目标目录
        File dest = new File("d:\\a");
        
        copyDir(src,dest);
    }
    
    public static void copyDir(File src,File dest) throws IOException {
        //为了严谨起见，我们首先对源目录和目标目录进行判断，看他们到底是不是目录
        if(src.isDirectory() && dest.isDirectory()) {
            
            File newDir = new File(dest , src.getName());
            if(!newDir.exists()) {
                newDir.mkdir();
            }
                
            //获取源目录下所有的文件和子目录
            File[] files = src.listFiles();
            
            for (File file : files) {
                if(file.isFile()) {
                    //如果File对象是文件，我们就进行文件的复制
                    /*
                     * 
                     * 假设file对象指向的文件是d:\\myAPI\\classpath,
                     * 我们要把这个文件复制到d:\\a\\myAPI
                     * 
                     * src:        d:\\myAPI
                     * dest:    d:\\a
                     * file:    d:\\myAPI\\classpath
                     * 
                     * "d:\\a" + "myAPI" =  d:\\a\\myAPI
                     * 
                     */
                    
                    //d:\\a\\myAPI
                    /*File newDir = new File(dest , src.getName());
                    if(!newDir.exists()) {
                        newDir.mkdir();
                    }*/
                    
                    //创建输入流对象
                    FileInputStream fis = new FileInputStream(file);
                    //创建输出流对象
                    // "d:\\a\\myAPI" + "classpath" = d:\\a\\myAPI\\classpath
                    FileOutputStream fos = new FileOutputStream(new File(newDir,file.getName()));
                    
                    byte[] bys = new byte[1024];
                    int len;
                    
                    while((len = fis.read(bys)) != -1) {
                        fos.write(bys, 0, len);
                    }
                    
                    fis.close();
                    fos.close();
                }
                else if(file.isDirectory()) {
                    //如果File对象是子目录，递归，看看子目录下面到底有什么
                    /*
                     * src: d:\\myAPI
                     * dest: d:\\a
                     * 
                     * 新的源目录：d:\\myAPI\\bin
                     * 新目标目录：d:\\a\\myAPI
                     * 
                     * 
                     */
                    
                    //File newDir = new File(dest,src.getName());
                            
                    copyDir(file,newDir);
                }
            }
        }
    }
}

字符流与字节流

2.1 概述

 IO流分类：

    流向

        输入流       读取数据       FileReader    Reader

         输出流     写出数据       FileWriter     Writer

     数据类型

           字节流 

                字节输入流   读取数据     InputStream

                 字节输出流   写出数据     OutputStream

            字符流

                  字符输入流  读取数据     Reader

                  字符输出流  写出数据    Writer

2.2 利用字符流复制文本文件

利用字符流将当前工程下的IODemo.java拷贝到d盘的a文件夹下

2.2.1 案例代码九：

package com.gao_02;

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

/*
 * 使用字符流复制文本文件
 * 
 * 数据源        IODemo.java
 * 目的地        d:\\IODemo.java

 *     
 */
public class FileCopyDemo {
    public static void main(String[] args) throws IOException  {
        //创建字符输入流对象
        FileReader fr = new FileReader("IODemo.java");
        //创建字符输出流对象
        FileWriter fw = new FileWriter("d:\\IODemo.java");
        
        //一次读写一个字符
        
        /*int ch;
        while((ch = fr.read()) != -1) {
            fw.write(ch);
            fw.flush();
        }*/
        
        //一次读写一个字符数组
        int len;//用于存储读到的字符个数
        char[] chs = new char[1024];
        while((len = fr.read(chs)) != -1) {
            fw.write(chs,0,len);
            fw.flush();
        }
        
        //释放资源
        fw.close();
        fr.close();
    }
}

2.2.2 字符流复制图片的问题解析

2.3 利用字节流复制文本文件

利用字节流将当前工程下的IODemo.java拷贝到d盘下

2.3.1 案例代码十

package com.gao_03;

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

/*
 * 使用字节流复制文本文件
 * 
 * 数据源        IODemo.java
 * 目的地        d:\\a\\IODemo.java
 * 
 */
public class FileCopyDemo {
    public static void main(String[] args) throws IOException  {
        //创建字节输入流对象
        FileInputStream fis = new FileInputStream("IODemo.java");
        //创建字节输出流对象
        FileOutputStream fos = new FileOutputStream("d:\\a\\IODemo.java");
        
        //一次读写一个字节
        /*int by;
        while((by = fis.read()) != -1) {
            fos.write(by);
        }*/
        //一次读写一个字节数组
        int len;//存储读到的字节个数
        byte[] bys = new byte[1024];
        while((len = fis.read(bys)) != -1) {
            fos.write(bys,0,len);
        }
        
        
        //释放资源
        fos.close();
        fis.close();
    }
}

2.4 复制图片

字节流可以操作所有类型的文件,因为所有的文件在计算机中都是以字节形式存储

而字符流只能用来操作纯文本类型的文件,不能操作字节类型的文件

2.4.1 案例代码十一：

package com.gao_04;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

/*
 * 分别使用字符流和字节流复制图片
 * 
 * 二进制文件只能使用字节流进行复制（使用windows自带记事本打开读不懂的）
 * 文本文件的复制即可使用字符流，也可以使用字节流
 * 
 */
public class CopyImage {
    public static void main(String[] args) throws IOException  {
        //method();
        
        //创建字节输入流对象
        FileInputStream fis = new FileInputStream("传智学院.jpg");
        //创建字节输出流对象
        FileOutputStream fos = new FileOutputStream("d:\\传智学院.jpg");
        
        //一次读写一个字节数组
        int len;//用于存储读到的字节个数
        byte[] bys = new byte[1024];
        while((len = fis.read(bys)) != -1) {
            fos.write(bys,0,len);
        }
        
        //释放资源
        fos.close();
        fis.close();
    }

    private static void method() throws FileNotFoundException, IOException {
        //创建字符输入流对象
        FileReader fr = new FileReader("传智学院.jpg");
        //创建字符输出流对象
        FileWriter fw = new FileWriter("d:\\传智学院.jpg");
        
        //一次读写一个字符数组
        int len;//用于存储读到的字符个数
        char[] chs = new char[1024];
        while((len = fr.read(chs)) != -1) {
            fw.write(chs,0,len);
            fw.flush();
        }
        
        //释放资源
        fw.close();
        fr.close();
    }
}

2.5 复制指定目录的所有文件到努力文件

package com.gao;

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

public class CopyDirTest {
    public static void main(String[] args) throws IOException {
        File src = new File("D:\\Java重点笔记及作业");
        File dest = new File("D:\\杂七杂八");
        copyDir(src, dest);
    }

    public static void copyDir(File src, File dest) throws IOException {
        if (src.isDirectory() && dest.isDirectory()) {
            File dir = new File(dest, src.getName());
            if (!dir.exists()) {
                dir.mkdir();
            }
            File[] files = src.listFiles();
            for (File file : files) {
                if (file.isFile()) {
                    copyFile(file, new File(dir, file.getName()));
                } else {
                    copyDir(file, dir);
                }
            }
        }
    }

    public static void copyFile(File file, File dir) throws IOException {
        FileInputStream fis = new FileInputStream(file);
        FileOutputStream fos = new FileOutputStream(dir);

        int len;
        byte[] by = new byte[1024];
        while ((len = fis.read(by)) != -1) {
            fos.write(by, 0, len);
        }
        fis.close();
        fos.close();
    }
}