day19： IO、OutputStream、FileOutputStream、高效流（缓冲区，一个一个存取）、字符流

最新推荐文章于 2024-04-24 22:52:03 发布

LI JS@你猜啊

最新推荐文章于 2024-04-24 22:52:03 发布

阅读量1.3k

点赞数 1

分类专栏： JAVASE 文章标签： java 后端开发语言

本文链接：https://blog.csdn.net/m0_45209551/article/details/123493849

版权

JAVASE 专栏收录该内容

11 篇文章 0 订阅

订阅专栏

一回顾

1.File 文件对象
2.构造方法:
     A.public File(File parent,String child)
     B.public File(String pathname)
     C.public File(String parent,String child)
3.常规的方法
    创建:
      public boolean createNewFile() 创建空的文件
      public boolean mkdir() 创建一级目录
      public boolean mkdirs() 创建多级目录
    删除
      public boolean delete() 删除文件和空文件夹(一级目录)
    剪切与重命名
       public boolean renameTo(File dest) 同目录重命名  不同目录剪切
    判断性
      public boolean exists() 判断文件是否存在
      public boolean isDirectory() 判断是否是文件夹
      public boolean isFile() 判断是否是文件
    得到性
      public String getAbsolutePath() 获取绝对路劲的字符串
      public String getParent() 获取父路径
      public String getName() 获取文件名称
      public long length() 获取文件内容的长度
      public String getPath() 获取文件对象构造方法的路劲File
  3.递归:
      A.方法反复自己调用自己
      B.注意点:
         a.递归中方法的参数逐渐变小  朝着不递归的方向发展
         b.递归避免栈内存溢出
      C.递归的内存图

二 IO

2.1 简介

1.I==>Input  输入   Output 输出   用于不通过设备进行信息的交互
2.使用的场景:
    A.文件的复制
    B.文件上传的下载
    C.(即时通信)微信中信息的传递
3.IO 分类
   流向划分:输入流与输出流
   类型划分:字节流与字符流
4.输入流与输出流的解释
5.字节流与字符流的解释
  字节流:
     A.万物皆字节  系统上任何的资源都可以使用字节来进行表示  
     B.一般读写文件 音视频 图片
     C.分类:字节输入流(读)   字节输出流(写)
  字符流:  
      A.字符流=字节流+编码表 字符流的底层也是使用字节流来进行操作的  只能底层通过编码表将字节转换为字符
      B.读取纯字符的文件 
      C.分类：字符输入流(读) 与字符输出流(写)
6.IO操作的注意点:
   A.所有的流的资源都是java.io包下
   B.使用流资源的时候 可能会产生异常 需要对异常处理(捕获 抛出)
   C.所有的流资源使用之后 必须进行关闭 因为流资源比较消耗内存

step01-输入流与输出流的解释

2.2 OutputStream

2.2.1简介

1.此抽象类是表示输出字节流的所有类的超类
  A.OUtputStream 是一个抽象类
  B.OutputStream输出字节流的所有类的超类

2.2.2 常用的方法

方法的名称	方法的描述
public void close()	关闭流资源
public void flush()	将缓冲区的数据刷新到硬盘中
public abstract void write(int b)	一个一个字节写入
public void write(byte[] b)	将字节数组的内容写入
public void write(byte[] b, int off, int len)	将字节数组的指定的长度的内容写入

2.2.3 子类

2.3 FileOutputStream

2.3.1简介

A.文件输出流是用于将数据写入 File  将数据写入到文件中
B.FileOutputStream 用于写入诸如图像数据之类的原始字节的流
C.要写入字符流，请考虑使用 FileWriter

2.3.2 构造方法

构造方法的名称	构造方法的描述
public FileOutputStream(File file)	创建一个向指定 File 对象表示的文件中写入数据的文件输出流
public FileOutputStream(String name)	创建一个向具有指定名称的文件中写入数据的输出文件流
public FileOutputStream(String name, boolean append)	创建一个向具有指定 name 的文件中写入数据的输出文件流(为false则文件头开始写入,为true 在文件内容末尾出开始写入)

2.3.3 构造方法的三件事

A.实例化FileOutputStream
B.创建一个空的文件
C.将FileOutputStream 对象指向这个空的文件

2.3.4 使用的步骤

A.实例化FileOutputStream
B.调用写的方法
C.关闭资源

2.3.5 一个一个字节写入

package com.qf.demo01;

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

public class Test01 {
    public static void main(String[] args) throws IOException {
        //实例化FileOutputStream
        FileOutputStream  fos  = new FileOutputStream("d:\\a\\1.txt");
        //一个一个字节写入
        fos.write(97);
        fos.write(98);
        fos.write(99);
        fos.close();
    }
}

2.3.6 一次写入多个字节

package com.qf.demo01;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;

public class Test02 {
    public static void main(String[] args) throws IOException {
        //实例化FileOutputStream
        OutputStream os  = new FileOutputStream("d:\\a\\2.txt");
        //调用写的方法
        byte [] b ={97,98,99};
        os.write(b);
        //关闭资源
        os.close();

    }
}

2.3.7 使用字节流写字符串到文件中

package com.qf.demo01;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;

public class Test04 {
    public static void main(String[] args) throws IOException {
        //实例化FileOutputStream
        OutputStream os  =new FileOutputStream("d:\\a\\4.txt",true);
        String s="陈亮宇东鹏哥";
        //将字符串转换为字节数组
        byte[] b = s.getBytes();
        os.write(b);
        os.close();


    }
}

2.3.8 写入的原理

2.3.9 写入的内容说明

问题:写入的字节是 97  98  99  使用记事本打开就是  a  b  c 
原因:记事本打开的文件的时候 如果字节的范围是 0-127  使用ASCII表来识别  
    超出范围 使用的记事本默认的码表来识别  默认的码表就是GBK

2.4 InputStream

2.2.1简介

1.此抽象类是表示字节输入流的所有类的超类
  A.InputStream 是一个抽象类
  B.InputStream是输入流的所有类的超类

2.2.2 常用方法

方法的名称	方法的描述
public void close()	关闭资源
public abstract int read()	一个一个字节读取
public int read(byte[] b)	将读取的内容存入到缓冲数组中
public int read(byte[] b, int off, int len)	读取指定长度的内容存入缓冲数组中

2.2.3 子类

2.5 FileInputStream

2.5.1简介

A.FileInputStream  用于来读取文件中的内容
B.FileInputStream 用于读取诸如图像数据之类的原始字节流  用于操作字节
C.要读取字符流，请考虑使用 FileReader

2.5.2 构造方法

构造方法的名称	构造方法的描述
public FileInputStream(File file)	通过打开一个到实际文件的连接来创建一个 FileInputStream
public FileInputStream(String name)	通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的路径名 name

2.5.3 构造方法的两件事

A.实例化FileInputStream
B.将FileInputStream 指向文件

2.5.4 使用的步骤

A.实例化FileInputStream
B.调用读取的方法
C.关闭流资源

2.5.5 一个字节一个字节读

package com.qf.demo02;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;

public class Test01 {
    public static void main(String[] args) throws IOException {
        //实例化 FileInputStream
        InputStream is  = new FileInputStream("d:\\a\\1.txt");
        //调用读的方法
        int r1 = is.read();
        System.out.println((char) r1);
        int r2 =is.read();
        System.out.println((char) r2);
        int r3 = is.read();
        System.out.println((char) r3);
        //关闭资源
        is.close();
    }
}

2.5.6 读取的原理

2.5.7改造之后的代码

package com.qf.demo02;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;

public class Test02 {
    public static void main(String[] args) throws IOException {
        //实例化 FileInputStream
        InputStream is  = new FileInputStream("d:\\a\\1.txt");
         int length=-1;
        //使用while循环读取
        while ((length =is.read())!=-1) {
            System.out.println((char) length);
        }
        //关闭资源
        is.close();

    }
}

2.5.8 一次读取多个字节

public class Test03 {
    public static void main(String[] args) throws IOException {
        //实例化FileInputStream
        InputStream  is   = new FileInputStream("d:\\a\\1.txt");
        //定义一个缓冲区的数组
        byte[] b = new byte[2];
        int  leng1 =is.read(b);
        System.out.println(leng1);
        System.out.println(Arrays.toString(b));
        int  leng2 = is.read(b);
        System.out.println(leng2);
        System.out.println(Arrays.toString(b));
        int leng3 = is.read(b);
        System.out.println(leng3);
        System.out.println(Arrays.toString(b));

        int leng4 = is.read(b);
        System.out.println(leng4);
        System.out.println(Arrays.toString(b));
        //关闭资源
        is.close();


    }
}

2.5.9 分析一次读取多个字节

2.5.9.1 改造之后的代码

package com.qf.demo02;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;

public class Test04 {
    public static void main(String[] args) throws IOException {
        InputStream is  = new FileInputStream("d:\\a\\1.txt");
        //定义缓存区的数组
        byte [] b  = new byte[1024];
        int length=-1;
        while ((length=is.read(b)) !=-1){
            System.out.println(new String(b,0,length));
        }
        //关闭资源
        is.close();


    }
}

2.5.9.2 read() 与 read(b)比较

A.read() 一个一个字节读  效率低   read(b) 一次读取多个字节放入到数组  效率高
B.read() 返回值是读取的字节       read(b) 返回值是读取的有效的字节的个数

2.6 案例

step01 需求 d盘中的图片复制到c盘

step02 分析

A.将d盘中图片读取出来   字节输入流
B.读取的内容写入到c盘   字节输出流

step03 代码

package com.qf.demo02;

import java.io.*;

public class Test05 {
    public static void main(String[] args) throws IOException {
        //实例化输入流
        InputStream is  = new FileInputStream("d:\\a\\1.jpg");
        //实例化输出流
        OutputStream  os  = new FileOutputStream("c:\\admin\\1.jpg");
        byte [] b  = new byte[1024];
        int length =-1;
        while ((length =is.read(b)) !=-1) {
            os.write(b,0,length);
        }
        //关闭资源
         os.close();
         is.close();
    }
}

2.7 高效流

2.7.1简介

1.高效输入流
     A.BufferedInputStream
     B.内部创建一个缓冲的数组  缓冲区的数组的长度是8192 效率高
2.高效输出流
     A.BufferedOutputStream
     B.内部创建一个缓冲的数组  缓冲区的数组的长度是8192 效率高
3.高效输入流与输出流  
   本身没有读取文件的内容的功能  只能对InputStream与OutputStream的封装 提供一个缓冲区数组 
4. 高效流原因:
     高效读:底层会封装一个缓冲的数组   高效流一次会读取8192个字节的数据 存入缓冲区数组中
           每一次获取数据的时候就可以从缓冲数组(内部)中获取  避免与磁盘进行多次交互 所有高效

2.7.2 常用的构造方法

方法的名称	方法的描述
public BufferedInputStream(InputStream in)	创建一个 BufferedInputStream 并保存其参数，即输入流 in
public BufferedOutputStream(OutputStream out)	创建一个新的缓冲输出流，以将数据写入指定的底层输出流

2.7.3 高效流-写

package com.qf.demo03;

import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;

public class Test01 {
    public static void main(String[] args) throws IOException {
        //实例化BufferedOutputStream
        OutputStream os  = new FileOutputStream("d:\\a\\5.txt");
        BufferedOutputStream   bos  = new BufferedOutputStream(os);
        bos.write(97);
        bos.write(98);
        bos.write(99);
        bos.close();
        os.close();

    }
}

2.7.4 高效流-读

package com.qf.demo03;

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;

public class Test02 {
    public static void main(String[] args) throws IOException {
        InputStream is = new FileInputStream("d:\\a\\5.txt");
        BufferedInputStream  bis  = new BufferedInputStream(is);
        int leng=-1;
        while ((leng=bis.read()) !=-1) {
            System.out.println(leng);
        }
        //关闭资源
        bis.close();
        is.close();
    }
}

2.7.5 案例-使用高效流读写视频

package com.qf.demo03;

import java.io.*;

public class Test03 {
    public static void main(String[] args) throws IOException {
        //实例化高效流
        OutputStream os = new FileOutputStream("d:\\a\\1.mp4");
        BufferedOutputStream  bos  = new BufferedOutputStream(os);
        InputStream is  = new FileInputStream("C:\\Users\\Administrator\\Desktop\\第一阶段\\day19\\视频\\01-回顾.mp4");
        BufferedInputStream   bis   = new BufferedInputStream(is);
        int length =-1;
        while ((length=bis.read()) !=-1){
            bos.write(length);
        }
        //关闭资源 从下往上关闭资源
        bos.close();
        bis.close();
        is.close();
        os.close();

    }
}

2.8 关闭资源

1.从下往上进行关闭(最后的使用先关闭)
2.不管是否发生异常 都会要关闭io流资源 在finally中关闭流资源
3.关闭流资源 需要进行非空验证

代码

package com.qf.demo04;

import java.io.*;

public class Test01 {
    public static void main(String[] args) {
        OutputStream os = null;
        BufferedOutputStream bos = null;
        InputStream is = null;
        BufferedInputStream bis = null;
        try {
            os = new FileOutputStream("d:\\a\\1.mp4");
            bos =new BufferedOutputStream(os);
            is =new FileInputStream("C:\\Users\\Administrator\\Desktop\\第一阶段\\day19\\视频\\01-回顾.mp4");
            bis =new BufferedInputStream(is);
            int length = -1;
            while ((length = bis.read()) != -1) {
                bos.write(length);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                if (bos !=null){
                    bos.close();
                }

                if (bis !=null){
                    bis.close();
                }
                if (is !=null ){
                    is.close();
                }
                if (os !=null){
                    os.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

三字符流

3.1 字符流的简介

1.字符流:用于读写字符
2.分类:字符输入流(读)  字符输出流(写)
3.使用字符流原因:
    使用字节流读取字符 需要将读取的内容来进行转换,转换错误可能会出现乱码  使用字节操作字符比较麻烦
    字符流=字节流+编码表
4.任何的编码表下 中文的第一个字节都是负数  根据这个规律来进行转换

3.2 编码表

1.编码表:编码表就是提供字节转换为字符的规则
2.常见的编码表
  A.ASCII码表 西方国家通用的编码表 都是西方常用的一些字符的符号 范围是0-127 
             所有编码表的0-127 都是遵循ASCII码表规则  48 ==> '0'  97==> 'a'  65==> 'A'
  B.GBK
      G2312延伸的一种编码表  这个编码表示可以提供转换为中文的规则  一个中文在GBK编码表下占两个字节
      软件:记事本 eclipse....
  c.unicode
       万国码表 这个码表中包含全世界国家所有语言通用的字符  万国码表的范围 0-65535
       这个一般用于国际交流的使用使用
  D.UTF-8(重点)
       在开发界通用的编码格式  大部分公司使用的编码都是UTF-8
       一个中文占三个字节

3.3 字符串的编解码

方法的名称	方法的描述
public byte[] getBytes(Charset charset)	将字符串转换为字节数组,按照指定的编码表
public String(byte[] bytes, Charset charset)	将字节数组转换为字符串,按照指定的编码表

代码

package com.qf.demo05;

import java.io.UnsupportedEncodingException;
import java.util.Arrays;

public class Test01 {
    public static void main(String[] args) throws UnsupportedEncodingException {
        //定义一个字符串
        String s ="中国";
        byte[] bytes = s.getBytes();
        System.out.println(Arrays.toString(bytes));
        //定义字符串
        String s1 =new String(bytes,"UTF-8");
        System.out.println(s1);
        byte[] b=s.getBytes("GBK");
        System.out.println(Arrays.toString(b));
        String s2 = new String(b,"GBK");
        System.out.println(s2);
    }
}

3.4 字符流-写Witer

3.4.1 简介

A.Writer 写入字符流的抽象类
B.子类必须实现的方法仅有 write(char[], int, int)、flush() 和 close()。
C.多数子类将重写此处定义的一些方法，以提供更高的效率和/或其他功能

3.4.2 常规的一些方法

3.4.3 子类

A.FileWriter

3.5 FileWriter

3.5.1 简介

A.用来写入字符文件的便捷类
B.可以先在 FileOutputStream 上构造一个 OutputStreamWriter 设置编码表格式
C.FileWriter 用于写入字符流。要写入原始字节流，请考虑使用 FileOutputStream。

3.5.2 构造方法

方法的名称	方法的描述
public FileWriter(File file)	根据给定的 File 对象构造一个 FileWriter 对象
public FileWriter(File file, boolean append)	根据给定的 File 对象构造一个 FileWriter 对象。如果第二个参数为 true，则将字节写入文件末尾处，而不是写入文件开始处
public FileWriter(String fileName)	根据给定的文件名构造一个 FileWriter 对象
public FileWriter(String fileName, boolean append)	根据给定的文件名以及指示是否附加写入数据的 boolean 值来构造 FileWriter 对象

3.5.3 字符流-写

package com.qf.demo06;

import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;

public class Test01 {
    public static void main(String[] args) throws IOException {
        Writer w  = new FileWriter("1.txt");
        w.write(97);
        w.write(new char[]{'b','c'});
        w.write("今天天气真好！适合学习java");
        w.close();
    }
}

3.6 字符流-读 Reader

3.6.1简介

A.用于读取字符流的抽象类
B.子类必须实现的方法只有 read(char[], int, int)
C.多数子类将重写此处定义的一些方法，以提供更高的效率和/或其他功能

3.6.2 常用的方法

3.6.3 字符流-读

package com.qf.demo06;

import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;

public class Test02 {
    public static void main(String[] args) throws IOException {
        Reader  r  = new FileReader("1.txt");
        char [] ch = new char[1024];
        int length=-1;
        while ((length =r.read(ch)) !=-1) {
            System.out.println(new String(ch,0,length));
        }
        //关闭资源
        r.close();
    }
}

3.7总结

####

LI JS@你猜啊

关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
打赏
0
评论
day19： IO、OutputStream、FileOutputStream、高效流（缓冲区，一个一个存取）、字符流

一回顾1.File 文件对象2.构造方法: A.public File(File parent,String child) B.public File(String pathname) C.public File(String parent,String child)3.常规的方法创建: public boolean createNewFile() 创建空的文件 public boolean mkdir() 创建一级目录 ...
复制链接

扫一扫