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

JavaIO流（十一）