JavaIO流

 一.File类

1.概述

File即就是文件和目录路径的抽象表示,一个File对象即表示一个计算机文件或目录

2.构造方法

2.1通过参数为指定的文件路径字符串形式创建File对象

File file=new File("E:/dome.txt");

2.2通过参数为指定文件路径的父类File型对象和指定的文件路径字符串形式为参数创建File对象 

 File file1=new File(file,"E:dome.txt");

2.3通过参数为指定文件路径的父类字符串形式和指定的文件路径字符串形式为参数创建File对象

File file2=new File("E:","E:/dome.tex");

3.常用的方法

3.1较为简单的方法

 canRead()  判断文件是否可读
 canWrite()  判断文件是否可写，即是否可以更改
 exists()       判断文件是否存在
 getName()   获取文件的名字
 getPath()     获取文件的路径
getParent()  获得父盘的路径
isFile()          判断file对象是否是个文件，除过是文件之外，还有可能是目录
isAbsolute()  判断文件路径是否是绝对路径类似于（E:/dome.txt）
lastModified()获取此文件最后一次修改的时间

import java.io.File;
import java.io.IOException;
import java.util.Arrays;
import java.util.Date;
public class FileDome1 {
    public static void main(String[] args) throws IOException {
        File file=new File("E:/dome.txt");
        //通过参数为指定的文件路径字符串形式创建File对象
        File file1=new File(file,"E:dome.txt");
        //通过参数为指定文件路径的父类File型对象和指定的文件路径字符串形式为参数创建File对象
        File file2=new File("E:","E:/dome.tex");
        //通过参数为指定文件路径的父类字符串形式和指定的文件路径字符串形式为参数创建File对象
        System.out.println(file.canRead());
        //判断文件是否可读
        System.out.println(file.canWrite());
        //判断文件是否可写，即是否可以更改
        System.out.println(file.exists());
        //判断文件是否存在
        System.out.println(file.getName());
        //获取文件的名字
        System.out.println(file.getPath());
        //获取文件的路径
        System.out.println(file.getParent());
        //获得父盘的路径
        System.out.println(file.isFile());
        //判断file对象是否是个文件，除过是文件之外，还有可能是目录
        System.out.println(file.isAbsolute());
        //判断文件路径是否是绝对路径类似于（E:/dome.txt）
        System.out.println(file.lastModified());
        //对此文件最后一次的修改时间
        System.out.println(new Date(1639646490793L));
        //对此文件最后一次的修改时间转换为可读的
        }
    }
}
//输出结果：
true
true
true
dome.txt
E:\dome.txt
E:\
true
true
1639648136772
Thu Dec 16 17:21:30 CST 2021

3.2较为重要的方法

        delete();
        //删除此对象代表的文件,删除时一次只能删一级，且文件夹必须为空；
        createNewFile();
        //会向上抛出一个IOException，因为可能需要创建的文件并不可能存在,例如“X:dome”
        file7.mkdir();
        //创建一个此路径的文件夹
        //file7.mkdirs();
        //创建一个此路径的多级文件夹
        File file4=new File("E:/dome");
        String[] g=file4.list();
        //list（）获取对象中所有文件的名字
        for (String l:g){
            System.out.println(l);
        }
        File[] f=file4.listFiles();
        //获取对象中所有文件的路径

package FIle类;
import java.io.File;
import java.io.IOException;
import java.util.Arrays;
import java.util.Date;

public class FileDome1 {
    public static void main(String[] args) throws IOException {
        File file=new File("E:/dome.txt");
        //通过参数为指定的文件路径字符串形式创建File对象
        file.delete();
        //删除此对象代表的文件,删除时一次只能删一级，且文件夹必须为空；
        file.createNewFile();
        //会向上抛出一个IOException，因为可能需要创建的文件并不可能存在,例如“X:dome"
        File file6=new File("E:/dome.java");
        file6.createNewFile();
        File file7=new File("E:/dome");
        file7.mkdir();
        //创建一个此路径的文件夹
        //file7.mkdirs();
        //创建一个此路径的多级文件夹
        File file4=new File("E:/dome");
        String[] g=file4.list();
        //list（）获取对象中所有文件的名字
        for (String l:g){
            System.out.println(l);
        }
        File[] f=file4.listFiles();
        //获取对象中所有文件的路径
        for(File k:f){
            System.out.println(k);
        }
    }
}
//输出结果：
54.txt
556.txt
吃的马上.txt
死哦.txt
E:\dome\54.txt
E:\dome\556.txt
E:\dome\吃的马上.txt
E:\dome\死哦.txt

 二.IO流的概述

1.IO即就是input（读）和output（写）操作，从数据的传输方向上分为输入流，输出流。

输入流：将电脑硬盘上的数据读入到指定的程序中

输出流：将程序中的数据读入目标设备中

例如QQ换头像操作

就是将硬盘中的数据读入到QQ程序中，因为在电脑上删除之后或者换台电脑依旧可以看到头像，；所以QQ程序中的数据写入了QQ服务区中。

2.IO流数据编码格式分为字节流和字符流

字节流：即每次读入的数据以字节为单位

字符流：即每次读入的数据已字符为单位

3.IO流根据封装类型的不同分为节点流和处理流

节点流:封装的内容为特定的数据源，字符串，字符串数组等

处理流：封装的对象为流对象，其中提供了缓冲功能，提高了读写效率

三.字节流

1.概述：InputStream和OutStream的子类都是字节流，可以读写二进制，主要处理音频，文件，歌曲等文件，处理单元为1个字节，字节流的常用类为FileInputStream和FileOutputStream

2.常用方法

InputStream类：
2.1read()方法  以一个字节为单位读取，以整数的的形式返回读取的字节大小，当返回-1时，证明已读取到输入流的末尾，但需要抛出IOException异常，或者使用try{}catch{}语句

OutputStream类：

2.2write()方法  将read（）方法返回的整数传入write（）方法中，然后读入目标设备中

public class Dome1 {
    public static void main(String[] args) throws IOException {
        FileInputStream in = null;
        FileOutputStream out = null;
        {
            try {
                in = new FileInputStream("E:/dome.txt");
                out = new FileOutputStream("F:dome1.txt");
                int b = 0;//将读取的值赋给b,再将b写入out对象中
                while ((b = in.read()) != -1) {
                    System.out.println(b);
                    out.write(b);
                }
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if(in!=null){
                    in.close();
                }
                if(out!=null){
                    out.close();
                }
            }
        }
    }
}

InputStream类：

2.3read(byte[] byte)  读入一系列字节，存储到byte数组中，以整数形式返回字节大小，当返回-1

时，证明已读取到输入流的末尾，但需要抛出IOException异常，或者使用try{}catch{}语句。

OutputStream类：

2.4write（byte[] byte ,int off,int length）将存储读入数据的byte[]数组，传入write（）方法中，且需要定义开始写出的位置，以及文件大小

public class Dome2 {
    public static void main(String[] args) throws IOException {
        FileInputStream in =new FileInputStream("E:/dome.txt");
        FileOutputStream out=new FileOutputStream("F:/dome2.txt");
        byte[]bytes=new byte[8];
        int size=0;
        //read(byte [] bytes) 此时read返回值依旧是int型，但返回的是实际向数组中装入字节的个数；
        // 例如文件中共22个字节，一次只能装8个，则最后一次装入的时6个字节
        while((size=in.read(bytes))!=-1){
            out.write(bytes,0,size);
        }
        if(in!=null){
            in.close();
        }
        if(out!=null){
            out.close();
        }
    }
}

四.处理流

BufferInputStream类：

2.3read(File file)   BufferedInputStream类中read（）方法会有一个缓冲区,起到一个缓冲作用，只有读入的内容足够缓冲数组的容量时，默认容量为8024kb,才会读入byte数组中中，然后再写出

BufferOutputStream类：

2.2write()方法  

public class Dome3 {
    public static void main(String[] args) throws IOException {
        InputStream in=new FileInputStream("E:/dome.txt");
        OutputStream out=new FileOutputStream("F:/dome4.txt");
        BufferedInputStream bin=new BufferedInputStream(in);
        BufferedOutputStream bout=new BufferedOutputStream(out,1024);
        int k=0;
        byte[]bytes=new byte[1024];
        //BufferedInputStream类中read（）方法会有一个缓冲区的作用，只有读入的内容足够byte数组 
        // 的容量时，才会读入k中，然后再写出
        //如果一次读入的数据大于缓冲数组的容量，则直接读入
        while ((k= bin.read(bytes))!=-1){
            bout.flush();
            bout.write(bytes,0,1024);
        }
    }
}