JavaIO流（十一）

I in O out 流 人群流

文件上传，文件下载，导入导出，数据缓存

一、FIle文件、文件操作

1.1、文件操作

找到文件，获取文件相关信息属性（不是文件内容），是文件名 文件大小
使用代码 对 电脑上面的文件/文件夹进行增删改查。
获取不了具体得内容——不能读文件

1.2、File(类)对象的创建使用

file.exists()： 判断目录（文件）是否存在；

file.makir() : 创建一级目录；

file.makirs() : 创建多级目录；

file.delete() : 删除一个目录（文件)；

file.isDirectory():判断是否是一个目录；

file.isFile(): 判断是否是一个文件；

file.getAbsolutePath():打印路径；

file.getParent()： 打印父目录；

file.list(): 遍历目录下所有文件名和文件夹名(子代)；

file.listFiles(): 遍历目录下所有文件（目录）名，带路径；

File file =new File("D:\\java");//创建File对象
boolean state=file.exists();//判断是否存在
 
 File file1=new File("D:\\java\\test01\\a.txt\\b.txt");
        boolean state1=file1.exists();
        if(!state1){//判断如果没有目录就直接执行
            file1.mkdirs();//创建多个文件夹//mkdir是创建一个目录
        }
   File filed=new File("D:\\java\\test01\\a.txt\\b.txt");
        if(file1.exists()){
            System.out.println(file1.delete());
        }// 删除一个目录（文件)；
 
  //判断是否是一个目录；
        File file3=new File("D:\\java");
       System.out.println(file3.isDirectory()+","+file3.isFile());//true,false
       //file.isDirectory():判断是否是一个目录；file.isFile():     判断是否是一个文件；
        File[] lis=file3.listFiles();//把file3里面的所有目录给一个数组
        for(File f1:lis){//遍历数组输出路劲
            System.out.println(f1.getAbsolutePath());//获取绝对路径
        }
        System.out.println(file3.list());//  遍历目录下所有文件名和文件夹名(子代)；
        System.out.println(file3.getParent());//打印父目录；
        System.out.println(file3.listFiles());// 遍历目录下所有文件（目录）名，带路径；
 

查找文件

public class FileTools {
 
    public static void main(String[] args) {
 
        File fileread = new File("D:\\java");
        bianli(fileread);
    }//递归所有文件目录
    public static void bianli(File file){
        File[] file1=file.listFiles();
        for (File file2:file1){
            System.out.println(file2.getAbsolutePath());
            if (file2.isDirectory()){//判断如果还有目录了就继续调 递归执行
                bianli(file2);
            }
        }
    }
 
}

案例：

作业1:控制台输入一个字符串，以这个字符串为基准创建目录。

//:控制台输入一个字符串，以这个字符串为基准创建目录。
public class Sr {
    public static void cj(String s){
        File file=new File(s);
        if (!file.exists()){
            file.mkdirs();
        }
    }
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        cj(sc.next());
 
    }
}

作业2:自己封装一个方法。然后删除指定目录。

public class SC {
    public void sc(String st){
        File file=new File(st);
        file.delete();
    }
    //输入绝对路劲文件夹删除次文件夹
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        SC sc1=new SC();
        sc1.sc(sc.next());
    }
}

二、IO流操作

I是input输入流 O是out输出流

2.1、什么是流

程序中的流是指数据从一处移动到另一处，是一连串不间断的数据集合，即是一连串流动的字节。（文件 将内容写到电脑文件中 、控制台 我们的sout控制台输出 其实就是io操作、网络 浏览网页就是 服务器 用io的形式将网页发送给浏览器），

Java类库的设计者通过设计大量的类来攻克这些难题，这些类就位于****java.io****包中。（封装思想 IO操作很复杂 但是java设计者将这些复杂的操作封装成一个一个的类 我们不需要知道到底是怎么实现的 只需要知道 进行io操作 该用哪个类 调用哪个函数/方法即可）。

IO流指的就是数据流。

2.2、分类：

方向有： 输入流，输出流

种类：字符流，字节流：

字符输入流，字符输出流，
字节输入流，字节输出流。
都有基本流，包装流
**四大基流 ：**字符流：FileReader FileWriter 字节流 FileInputStream FileOutputStream

2.3、流的使用过程

首先Flie拿到文件，
将文件转成流，（需要输出转输出，输入转输入）
然后开始进行读操作，写操作
然后刷新内存—为了写
然后关闭流 （一定记得关闭）

2.4、字节输入流和字节输出流以及字节包装流

流的关闭：先打开的后关闭，后打开的先关闭。

2.4.2、FIleinputStream 字节输入流

InputStream是一个抽象类
InputStream----FileInputStream字节流的基础流

方法描述
public void close()关闭输入流
public abstract int read()以数字的方式读取内容
public int read(byte[] b)将内容读到byte数组中，同时返回读入的个数

 
      File file=new File("D:\\java\\课堂笔记\\day01.txt");
       // read2(file);
        try {
            InputStream is=new FileInputStream(file);
            System.out.println(is.read());//一个字节是八位01二进制
            //read会读出来一个字节然后会吧字节转换成十进制的整数类型转成
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }

读取

    public static void read(File file) {
        try {
            InputStream is = new FileInputStream(file);//创建输入流对象
            int a;
            int[] ints = new int[1024];//次时数组只能存储50个 会发生错误 如何解决
            int i = 0;
            for (; (a = is.read()) != -1; i++) {
                ints[i] = a;
            }
            System.out.println(new String(ints, 0, i));//0,i 只将读取的转换。空的不转换
            is.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
 
    }

循环读取

  public static void read2(File file){
        try {
            InputStream is=new FileInputStream(file);
            byte[] bytes=new byte[100];
            int a;//.read会吧is读成一个字节 转换成int十进制类一个
            while ((a=is.read(bytes))!=-1){//我每次读了a的长度然后循环读这个长度的内容一直到没有内容了停止
                System.out.println(new String(bytes,0, a));
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
 
    }

2.4.2、FileOutputStream 字节输出流

OutputStream----FileOutputStream字节输出基础流
方法描述
public void close()关闭输出流

public abstract void write(int b)在数据流中写入一个字节

public void write(byte[] b,int off,int len)在数据流中写入一个指定范围的byte数组

public void write(byte[] b)在数据流中写入一个byte数组

public void flush()刷新缓冲区

写入字符串

static void write1(){
        File file=new File("D:\\java\\test01\\a.doc");//选择文件 
        //如果没有创建文件
        if (!file.exists()){
            try {
                file.createNewFile();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        try {
            //字节流    输出流   基础流
            OutputStream os=new FileOutputStream(file,true);//默认是覆盖
           // os.write();
            String str="Hello World!";//创建字符串
            byte[] bytes=str.getBytes();//吧字符串放_(:з」∠)_数组里面
            os.write(bytes);//写出数组
            os.flush();//强制吧缓存的东西推到流里面   刷新对象
            os.close();//关闭流
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

复制文件

static void copy2(){
 
        try {
            long l1=System.currentTimeMillis();
            InputStream in=new FileInputStream("D:\\java\\test01\\a.doc");
			//输入流
            OutputStream os=new FileOutputStream("D:\\java\\test01\\b.doc");
			//输出流
            byte[] bytes=new byte[1];
            int a=0;
            while ((a=in.read(bytes))!=-1){
                os.write( bytes,0,a);
            }
            in.close();//关闭
            os.close();
            long l2=System.currentTimeMillis();
            System.out.println(l2-l1);//做了毫米计算  判断了运行时间的
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

包装类and 缓冲流
字节输入流，字节输出流
缓冲流：​
1.不带缓冲的流读取到一个字节或字符就直接输出
​ 2.带有缓冲的流读取到一个字节或字符先不输出，等达到缓冲区容量再一次性写出
BufferedInputStream 字节输入缓冲流
BufferedOutputStream 字节输出缓冲流

  static void read3(){//读取文件包装
        File f1=new File("D:\\java\\test01\\a.doc");
        try {
            InputStream is=new FileInputStream(f1);
            BufferedInputStream bis =new BufferedInputStream(is);
            //创建一个字节输入流的包装流
            byte[] bytes=new byte[100];
            int a;
            while ((a=bis.read(bytes))!=-1){
                System.out.println(new String(bytes,0,a));
            }
            bis.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    public static void write2(){//写入文件包装
        try {
            OutputStream os=new FileOutputStream("D:\\java\\test01\\a.doc",true);
            BufferedOutputStream bos=new BufferedOutputStream(os);
            //创建字节输出包装流
            String str="Hello World!";
            byte[] bytes=str.getBytes(StandardCharsets.UTF_8);
            bos.write(bytes);
            bos.flush();
            bos.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
 
    }

2.5、对象流（序列化）重要

ObjectInputStream 将文件中的对象读取到程序中。
ObjectOutputStream将程序中的对象写入到文件中。
序列化 (Serialization)是将对象的状态信息转换为可以存储或传输的形式的过程。在序列化期间，对象将其当前状态写入到临时或持久性存储区。以后，可以通过从存储区中读取或反序列化对象的状态，重新创建该对象。《序列化的工具有很多》
对象以特殊的形式进行转换，获取一个字符串的 序列化
**反序列化：**转换回来。

 public static void duixiang(){
       try {
           //将对象序列化
           OutputStream os=new FileOutputStream("D:\\java\\test01\\c.txt");//输出流
           ObjectOutputStream oss=new ObjectOutputStream(os);//对象输出流
            Student stu=new Student(34,"zhangyifan");//对象
            oss.writeObject(stu);//写出对象
            oss.flush();
            oss.close();
            //将对象的反序列化
            InputStream is=new FileInputStream("D:\\java\\test01\\c.txt");//基本输入流
            ObjectInputStream ois=new ObjectInputStream(is);//包装对象输入流
            Student iss=(Student) ois.readObject();//流转换 对象类型
           System.out.println(ois);
           System.out.println(iss);
 
       } catch (FileNotFoundException e) {
           e.printStackTrace();
       } catch (IOException e) {
           e.printStackTrace();
       } catch (ClassNotFoundException e) {
           e.printStackTrace();
       }
   }

public class Student implements Serializable {//序列化必须实现Serializable 接口
    int age;
    String name;
 
    public Student(int age, String name) {
        this.age = age;
        this.name = name;
    }
 
    @Override
    public String toString() {
        return "Student{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}
 

数据模型类：私有属性，get/set方法，无参构造有参构造，toString(),实现Serializable序列化接口，并且添加序列化的versionUId

字符流

字符流里面没有对象流的序列化

字符基础流
FileReader 字符输入流

FileWriter 字符输出流

字符包装流
BufferReader 包装缓冲输入流
方法
ublic abstract void close()关闭输入流
public int read()读取单个字符
public int read(char[] c)将内容读取到字符数组中，并返回读取的长度
BufferWriter 包装缓冲输出流
方法
public abstract void close()关闭输出流public void write(String str)输出字符串
public void write(char[] c)输出字符数组
public abstract void flush()强制清空缓存

   static  void fz1(File file){
        Long l1=System.currentTimeMillis();
        File file1=new File("D:\\java\\test01\\a.txt");
        try {
            Reader fileReader=new FileReader(file1);//字符输入流
            Writer fileWriter=new FileWriter(file); //字符输出流
            char[] bytes=new char[100];
            int length;
            while (-1 != (length = fileReader.read(bytes))){
                fileWriter.write(bytes,0,length);
            }
            fileWriter.write("成功率");
            fileWriter.flush();
            fileWriter.close();
            fileReader.close();
            Long l2=System.currentTimeMillis();
            System.out.println(l2-l1);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

 static  void fz(File file){
        Long l1=System.currentTimeMillis();
        File file1=new File("D:\\java\\test01\\a.txt");
        try {
            //创建字符输入流
            FileReader fileReade=new FileReader(file1);
            //创建缓冲输入流
            BufferedReader fileReader=new BufferedReader(fileReade);
            //创建字符输出流
            FileWriter fileWrite=new FileWriter(file);
            //创建缓冲输出流
            BufferedWriter fileWriter=new BufferedWriter(fileWrite);
            //数据操作
            char[] bytes=new char[100];
            int length;
            while (-1 != (length = fileReader.read(bytes))){
                fileWriter.write(bytes,0,length);
            }
            fileWriter.newLine();//换行
            fileWriter.write("成功率");
            //关闭
            fileWriter.flush();
            fileWriter.close();
            fileReader.close();
 
            Long l2=System.currentTimeMillis();
            System.out.println(l2-l1);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

.转换流

字节流和字符流之间的转换类：
InputStreamReader 将字节流转换成字符流
OutputStreamWriter 将书写的字符流转换成字节流写到文件里。

创建字节输入流
FileInputStream 字节输入流名=new FileInputStream（输入流文件地址）;
创建转换流
InputStreamReader 字符输入流名=new InputStreamReader（字节输入流名,输入格式）;//将读取的字节流抓换成字符流	_可以指明编码格式	
 将读取的字节流抓换成字符流
 
创建字节输出流
FileOutputStream 字节输出名=new FileOutputStream（字节输出流地址,false/true）;默认是false就是覆盖的意思 如果为true就是追加的意思
创建字节输出流的转换
OutputStreamWriter 字符输出名=new OutputStreamWriter（ 字节输出名,输出格式）;
将书写的字节流转换成字符流写到文件里。
 //将书写的字符转换成字节流——可以指明编码格式 转换流就是对字节流的封装，将字节流封装成一个字符流，可以指明编码格式。字符流要关闭。

public class FIlefz {
    public static void main(String[] args) {
        File file1=new File("D:\\java\\test01\\aNew.java");
        fz1(file1);
    }
    static  void fz1(File file){
        Long l1=System.currentTimeMillis();
        try {
            InputStream is=new FileInputStream("D:\\java\\test01\\a.java");//gbk编码的a.java
            InputStreamReader isr=new InputStreamReader(is,"gbk");
            OutputStream os=new FileOutputStream(file);
            OutputStreamWriter osw=new OutputStreamWriter(os, StandardCharsets.UTF_8);
            char[] bytes=new char[100];
            int length;
            while (-1 != (length = isr.read(bytes))){
                osw.write(bytes,0,length);
            }
            osw.write("成功率");
            osw.flush();
            osw.close();
            isr.close();
            Long l2=System.currentTimeMillis();
            System.out.println(osw);
            System.out.println(l2-l1);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

异常

public void test() throws Exception{
 
    InputStream is = null;
    //try {
        is = new FileInputStream("D:\\java\\test01\\c.txt");
        OutputStream os = new FileOutputStream("D:\\java\\test01\\C.txt");
        byte[] bytes = new byte[100];
        int a;
        while ((a = is.read(bytes)) != -1) {
            os.write(bytes, 0, a);
        }
        is.close();
        os.close();
  /*  } catch (FileNotFoundException e){
            e.printStackTrace();
        } catch (IOException e) {
        e.printStackTrace();
    }*/
}