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();
    }
}