java第一阶段-JavaSE-Day20-IO流

一、File类

        1、概述

        File类是文件和目录（文件夹）路径名的抽象表示。File既可以表示文件，也可以表示文件夹，它是通过文件或者文件夹路径方式来表示的

        路径：文件夹路径：C:\Users\liguoxiang\Desktop\基础班day01\视频

        文件路径：:C:\Users\liguoxiang\Desktop\会议.txt)

        File类是对磁盘文件的描述，类中定义一些常用的属性和操作文件的功能

        创建File对象的时候通过路径来创建

        2、路径

        路径就是描述文件或文件夹在磁盘位置的一个字符串

        路径分为两类：绝对路径和相对路径

        ①绝对路径：

        指的就是从根目录开始到具体的文件名下的路径

        在windows系统上根路径指的是盘符（C:、D:）

        ②相对路径

        指的所说的路径是基于某个参照路径而来的路径

        3、File的构造方法

        使用File一定要导包

        ①File（String path）

        创建一个以path路径为目标文件的文件对象

        ②File（String parent，String child）

        创建一个以parent+child拼接后的路径为目标文件的文件对象

        ③File（File file，String child）

        创建一个以file文件对象的路径+child拼接后的路径为目标文件的文件对象

        代码示例：

        参考下文

        4、File的创建方法

        功能：

        ①boolean createNewFile（）：创建调用对象对应路径的文本文件

        创建成功返回true，失败返回false

        注意事项：

        被调用时确保怎建所在的目录已经存在

        ②boolean mkdir（）：创建单机文件夹（就只是一个文件夹） 如果已经存在就返回false，否        则返回true

        注意事项：

                被调用的时候确保目录所在的目录已经存在

        ③boolean mkdirs（）：创建多级文件夹

package com.offcn.demo01;

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

public class Demo01 {
    public static void main(String[] args) throws IOException {
        //1.File(String path):
        //创建一个以path路径为目标文件的文件对象
        //File对象创建后，并不意味着描述的路径下文件或文件夹一定存在
        File f1 = new File("C:\\Users\\皇陆洋\\Desktop\\a");
        System.out.println(f1);
        //创建文件夹
        boolean b0 = f1.mkdir();
        System.out.println(b0 ? "成功" : "失败");

        File f2 = new File("Day20\\1.txt");
        System.out.println(f2);
        //创建文件
        boolean b1 = f2.createNewFile();//不存在则创建，存在则不创建
        System.out.println(b1 ? "创建成功" : "创建失败");

        //万能文件分隔符：/
        File f3 = new File("Day20/a/2.txt");
        System.out.println(f3);
        //f3.createNewFile();//系统找不到指定的路径异常，因为a文件夹不存在

        //2、File（String parent,String child）
        //创建一个以parent+文件分隔符+child拼接后的路径为目标文件的文件对象
        String parent = "C:\\Users\\皇陆洋\\Desktop";
        String child = "b/c";
        File f4 = new File(parent,child);
        System.out.println(f4);
        //boolean b2 = f4.mkdir();
        //System.out.println(b2 ? "创建成功" : "创建失败");
        boolean b3 = f4.mkdirs();
        System.out.println(b3 ? "创建成功" : "创建失败");

        //3、File(File parent,String child);
        //创建一个以file文件对象的路径+child拼接后的路径为目标文件的文件对象
        File parent2 = new File("C:\\Users\\皇陆洋\\Desktop");
        String child2 = "c";
        File f5 = new File(parent2,child2);
        System.out.println(f5);
    }
}

        创建方法练习：

        在模块的创建的a/b/c/d中创建一个文件名称1.txt

        ①创建文件夹a/b/c/d对象

        ②调用mkdirs方法创建文件夹

        ③得到1.txt对象

        ④调用createNewFile方法

package com.offcn.demo01;

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

public class Demo02 {
    public static void main(String[] args) throws IOException {
        File f1 = new File("Day20/a/b/c/d");
        f1.mkdirs();
        File f2 = new File(f1,"1.txt");
        boolean b = f2.createNewFile();
        System.out.println(b);
    }
}

        5、File的删除功能

        boolean delete():删除磁盘中对应的文本文件

        注意：

        ①删除文件夹时只能删除空文件夹

        ②删除不走回收

        ③也可以删除文件

package com.offcn.demo02;

import java.io.File;

public class Demo01 {
    public static void main(String[] args) {
        File f1 = new File("C:/Users/皇陆洋/Desktop/a");
        f1.delete();
    }
}

        6、File的重命名（剪切）方法

        renameTo（File dest）：改名字的方法：f1 = File("day/19/a/2.txt")

        使用场景：

        同一个文件夹下：重命名的功能 f1.renameTo("day19/a/3.txt")

        不同文件夹下：剪切功能 f1.renameTo("day/b/2.txt");

        代码示例：

package com.offcn.demo02;

import java.io.File;

public class Demo02 {
    public static void main(String[] args) {
        File f1 = new File("Day20/a/1.txt");
        File f2 = new File("Day20/a/3.txt");
        f1.renameTo(f2);
        File f3 = new File("Day20/b/3.txt");
        f2.renameTo(f3);
    }
}

        7、File的判断功能

        ①exists（）：判断调用对象对应的文本文件是否存在

        ②isFile（）：判断调用对象对应的文本文件是不是文件

        ③isDirectory（）：判断调用对象对应的文本文件是不是文件夹

        代码：

        8、File的获取功能

        ①getAbsolutePath()：获取文件对象的绝对路径

        ②getPath()：获取构造方法传入的路径

        ③getName()：获取文件对象的文件名

        文件对象的名：包含包路径的全限定类名, 但是这个方法获取的是不包含包路径的文件名

        ④length()：

        获取文件中内容的长度，单位字节

        使用场景：

        主要是给文件的File对象调用的，文件夹对象调用没有意义。

        文件夹没有大小【大小根据内部文件的大小决定】

        ⑤String[] list()：

        获取文件夹下所有文本文件的文件名，返回值是一个字符串数组

        ⑥File[] listFiles()：

        获取文件夹下所有文本文件的File对象，返回值是一个File数组

        代码示例：

package com.offcn.demo02;

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

public class Demo03 {
    public static void main(String[] args) {
        //1、exists();判断调用对象对应的文本文件是否存在
        //此方法用途就是在创建文件或文件夹之前判断是否存在
        //可以提高程序的执行效率
        File f1 = new File("Day20/1.txt");
        File f2 = new File("Day20/a");
        System.out.println(f1.exists());
        //2、isFile():判断文本文件是不是文件
        System.out.println(f1.isFile());
        System.out.println(f2.isFile());
        //3、isDirectory():判断是不是文件夹
        System.out.println(f1.isDirectory());
        System.out.println(f2.isDirectory());

        //length()获取文件中内容的长度
        System.out.println(f1.length());

        //
        String[] filenames = f2.list();
        System.out.println(Arrays.toString(filenames));
        //
        File[] files = f2.listFiles();
        for (File file : files) {
            System.out.println(files);
        }
    }
}

二、IO流

（一）IO概述

        1、概述

        IO指的就是文件的读写

        图示：

 

        2、IO流分类

        按流向划分：

                输入流：运输数据进内存的流

                输出流：运输数据出内存的流

        按功能划分

                字节流：运输的时候以字节为单位操作的流

                字符流：运输的时候以字符为单位操作的流

        时机开发的时候往往两种结合使用：

                字节输入流 InputStream

                字节输出流 OutputStream

                字符输入流 Reader

                字符输出流 Writer

        四个流也称为基本流，这四个类型类都是抽象类，都不能直接创建对象

        3、IO流类的使用流程：

                ①导包

                ②创建IO流对象，并去处理些带来的异常

                ③使用IO流对象调用相关功能对数据进行操作，读写时也有编译时异常，需要处理

                ④关闭流对象，关闭方法也有异常，也需要处理

（二）字节流

        1、概述：

        在使用IO流对数据进行传输时使用的以字节为单位操作数据的流就叫做字节流，也就是读写的操作时用的都是字节数据，这种刘就叫做字节流

        2、分类：

        功能和流向划分为进行结合分为字节输入流和字节输出流

        3、InoutStream(字节输入流)

        3.1 概述

        它是字节输入流的顶层父类，它是一个抽象类，定义所有字节输入流的共性功能和属性，没有提供功能实现，所以不能创建对象

        3.2 常用功能：

        ①int read(): 一次读取一个字节数据到内存

        ②int read(byte[] bytes):使用字节数组取读取多个字节的内容到内存

        ③int available(): 返回未读取的字节的个数

        ④close（）：关闭流

        3.3 注意：

        InputStream这个类是一个抽象类，他不能创建对象他的功能自己使用不了，只能去找他的子类来调用，根据设备的不同，对应的子类也不同。

        4.FileInputStream

        4.1概述

        纯文本文件：只能放文字符号的文件就是纯文本文件

        流媒体文件：可以放文字，图片，视频，音乐

        字节流什么类型文件都可以操作、纯文本文件和流媒体文件都可以

        FileInputStream是InputStream的子类，他只负责完成磁盘文本文件到内存数据输入互交的操作。输入功能都是InputStream的功能

        4.2 构造方法

        FileInputStream（File file）：创建一个可以读取指定File对象对应的文件的字节输入流对象

        FileInputStream（String path）：创建一个可以读取指定路径对应文件的字节流输入流对象

        注意：绑定文件路径下一定要存在这个文件

        4.3int read（）注意事项

        ①read（）方法，字节输入流对象每次读取一个字节，光标向后移动一位，每次读取以光标所在位置开始读取

        ②read（）返回值表示读取的字符

        ③read（）方法结束的标志，所有的字节数读取完毕继续读取的时候得到的是-1

        示例代码：

public static void demo()throws Exception{
    //创建一个字节输入流
    File f = new File("Day20/c/1.txt");
    FileInputStream fis = new FileInputStream(f);
    int i = fis.read();
    System.out.println(i);
    i = fis.read();
    System.out.println(i);
    i = fis.read();
    System.out.println(i);
    i = fis.read();
    System.out.println(i);
    i = fis.read();
    System.out.println(i);
    fis.close();
}

 

public class Demo01 {
    public static void main(String[] args) throws Exception {
        FileInputStream fis = new FileInputStream("Day20/c/1.txt");
        int i = 0;
        while ((i = fis.read()) != -1){
            System.out.println((char)i);
        }
        fis.close();
    }

        5、Int read(byte[] bs)注意事项

        ①read（byte[] bs）方法，如果文件长度够，每次读取bs.length个字节到数组中，如果文件长度不够，将剩余的内容放到数组中。

        例如:

        byte[] bs = new byte[10]; 文件字节数:20个字节 第一读取时就往bs数组中存储10字节. 第

        二次读取再从文件取出10个字节放到这个bs数组中.

        byte[] bs = new byte[4]; 文件字节数:10个字节 第一次读取前四个字节,剩余6字节, 第二个

        再去读四个字节, 剩余2个, 在读取只能往数组中放2个字节.

        ②read(byte[] bs)返回值表示读取的字节个数，也就是存储到数组中字节个数

        ③read(byte[] bs)方法结束的标志，所有的字节数读取完毕后继续读取得到的是-1

        代码：

public class Demo02 {
    public static void main(String[] args) throws Exception {
        FileInputStream fis = new FileInputStream("Day20/c/2.txt");
        byte[] bs = new byte[4];
        int len = 0;
        while((len =fis.read(bs))!= -1){
            String s = new String(bs,0,len);
            System.out.println(s);
        }

    }
}

        捕获异常的写法

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

public class Demo01 {
    public static void main(String[] args) {
        FileInputStream fis = null;
        try {
            fis = new FileInputStream("Day20/c/2.txt");
            int i = 0;
            while ((i = fis.read()) != -1){
                System.out.println((char)i);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

        6、OutputStream【字节输出流】

        概述：

        OutputStream是字节输出流的顶层父类，是一个抽象类，定义了所有的字节输出流共性功能

        OutputStream自己不能创建对象，不能使用自己的功能，只能找他的子类

        子类根据设备不同有不同的子类，常见的子类：FileOutStream

        常用功能：

        void write（int b）：输出字节内容到指定的目标文件中

        void write（byte[] arr）:输出字节数组中所有的字节内容到目标文件中

        void write(byte[] arr,int offset,int len):输出字节数组中指定范围的字节内容到目标文件中

        offset：输出的字节个数

        void close（）：关闭流

        7、FileOutputStream

        概述：

        文件字节输出流(纯文本文件和流媒体文件都可以使用这种流写出)，是OutputStream的子类，负责内存和磁 盘文件之间的数据的输出交互的流，功能都是OutputStream的功能

        构造方法：

        FileOutputStream(File file)：创建以指定File对象对应的文件为目标文件的字节输出流对象         FileOutputStream(String path)：创建以指定path路径对应的文件为目标文件的字节输出流对象

        注意事项：

        字节输出流对象创建的时候指定的目标文件不存在自动的给创建文件【前提：文件所在的目录在磁盘真实存在 的】

        字节输出流对象创建的时候指定的目标文件存在，会对已经存在的文件进行格式化

package com.offcn.demo06;

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

public class Demo01 {
    public static void main(String[] args) throws IOException {
        FileOutputStream fos = new FileOutputStream("Day20/c/3.txt");
        System.out.println(fos);
        fos.write(97);
        fos.write(98);

        byte[] bs = {48,49,50,51,52,53,54};
        fos.write(bs);

        byte[] bs1 = {67,68,69,70};
        fos.write(bs1,0,3);
        fos.close();
    }
}

 

package com.offcn.demo06;

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

public class Demo02 {
    public static void main(String[] args) {
        FileOutputStream fos = null;
        try {
            fos = new FileOutputStream("Day20/d/my.txt");
            String s = "我爱学习java,java使我快乐!";
            byte[] b = s.getBytes();
            fos.write(b);
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                fos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
}

        8、字节流完成的文件拷贝

        需求

        把一个指定的文件复制到指定的另一个路径文件中

        分析：

 

        就是一个文件中的数据到另一个文件中去 --- 文件和文件之间不能直接交流借助内存 把源文件的数据读到内存中，读过来的同时立马写到目标文件中去---- 完成数据的复制转移

                1、准备读写的流对象 创建字节输入流对象 创建字节输出流对象

                2、边读边写 一次有可能读不完 需要重复的读写 、

                需要循环

                单字节拷贝

 

package com.offcn.demo07;

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

public class Demo01 {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("Day20/c/a.txt");
        FileOutputStream fos = new FileOutputStream("Day20/c/b.txt");
        int i = 0;
        while((i = fis.read()) != -1){
            fos.write(i);
        }
        fos.close();
        fis.close();
    }
}

字节数组拷贝

 

package com.offcn.demo07;

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

public class Demo02 {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("Day20/c/a.txt");
        FileOutputStream fos = new FileOutputStream("Day20/c/c.txt");
        int len = 0;
        byte[] b = new byte[3];
        while ((len = fis.read(b)) != -1){
            fos.write(b,0,len);
        }
        fos.close();
        fis.close();
    }
}