2020-11-08

最新推荐文章于 2023-03-04 11:37:12 发布

Jacksonjiang111

最新推荐文章于 2023-03-04 11:37:12 发布

阅读量165

点赞数

本文链接：https://blog.csdn.net/Jacksonjiang111/article/details/109562146

版权

字节流

  定义： 文件的输入输出以一个“字节”为单位，进行流处理

FileInputStream 和 FileOutputStream

读入：将文件中的数据读到内存中

常用方法：

	int read() : 一个字节的读取 ，返回字节 的asci码 ，对于汉字会分3次读取 

            int read(byte) ： 按一个数组长度读取， 返回实际读取的字节长度， 数据存放在数组中 

           int read(byte , offset , len) : 读取流中指定长度的数据，并存放在指定位置，

            available() :返回流中剩余的字节长度，如果已读完，则返回0 

           skip(long n ): 丢弃指定的字节长度，从下一个开始读取



`**available**()`  

      File file = new File("d:/aaa.txt");
        FileInputStream fis = new FileInputStream(file);
       //
		byte [] b= new byte[10];
        StringBuffer sb = new StringBuffer();
            //每次读取的长度，  b： 存放数据的数组
          int len = 0;
          while((len = fis.read(b)) !=-1){
              sb.append( new String(b,0,len));
          }

        System.out.println(sb);
        fis.close();

 public static void read2() throws IOException {
        // InputStream是抽象类
        InputStream is = new FileInputStream("d:/aaa.txt");
        //丢弃前两个字节
        is.skip(2);
        System.out.println((char)is.read());
        System.out.println("还剩下多少个字节："+ is.available());
        // 将后面的字节继续使用字节数组读
        byte [] b = new byte[10];
        int len = is.read(b,1,4);
        // 显示数组中读取的所有数据
        System.out.println(Arrays.toString(b));
        //将数组的内容转成字符串  对于空内容不会转换
        System.out.println(new String(b));

        is.close();


    }

文件写出：将内存的数据写出到磁盘中

构造方法：

new FileOutputStream（File/String ）：构造文件对象的写出流，默认覆盖写出

new FileOutputStream(File/String , append): 构造文件对象的写出流，

append：表示在原有文件上追加数据， false ：覆盖

常用方法：

 void write(int) : 写出一个字节 

    void writer(byte []) ：写出一个字节数组，这里需要指定数组的编码格式 “UTF-8”

   void writer(byte[]  , offerset,len) : 写出一个字节数组，指定数组的长度和下标。 从数组的下标开始写出，len表示写出长度

  flush（） ：清空缓存，对于使用缓冲流时，将缓冲强制清空。



   //将内存的数据写出到文件   如果文件不存在，会自动创建， 默认覆盖写入  true:追加
        FileOutputStream fos = new FileOutputStream("d://aaa.txt" ,true);
        String str="今天天气还不错";
        fos.write(99);
        //写出一个字符串    字符串可以转成字节数组 或字符数组
        fos.write(str.getBytes("UTF-8"));
        // 写出指定长度
        fos.write(str.getBytes("UTF-8"),0,3); // 写出这个数组的前2个字节
        // 清空缓存
        fos.flush();
        // 关闭流
        fos.close();
        System.out.println("写出成功");

文件复制：

将文件（图片，文本，视频）从一个目录复制到另一个目录，其中数据长度不变，通过文件读写的方式完成复制

复制过程：从源文件读取数据，然后将数据再出到目标文件中。

/**
     * 单个字节复制
     * @param srcFile 源文件
     * @param disFile 目标文件
     */
    public static void copyFile(File srcFile, File disFile){
        FileInputStream fis=null;
        FileOutputStream fos =null;
        try {
            // 源文件输入流
             fis = new FileInputStream(srcFile);
            // 目标文件输出流
             fos = new FileOutputStream(disFile);
            int n=0;
            while( (n =fis.read()) !=-1){
                 //将读到的n写出到 目标文件中
                 fos.write(n);
             }
            System.out.println("复制成功。。");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally{
            //无论是否发生异常 都会关闭流
            try {
                fos.close();
                fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }

        }

    }

    /**
     * 一个字节数组的赋值
     * @param src  源地址
     * @param disc 目标地址
     */
    public static void copyFile(String src,String disc){
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            //创建 字节输入流
            fis=new FileInputStream(src);
            fos = new FileOutputStream(disc);
            int len=0;
            byte [] b = new byte[1024];
            while( (len= fis.read(b)) !=-1){
                // 写出 实际读取的长度 ，为了避免在最后一次写出时出现多余字节
                fos.write(b,0,len);
            }

            System.out.println("复制成功");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally{
            try {
                fos.close();
                fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }

        }
    }

字符流

字符流用于读写存储字符的文件， 以一个字符为单位，一依次读取字符 文件， 常用类以 Reader或Writer为父类， 对文件的操作使用 java.io.FileReader 和java.io.FileWriter       

读文件  ：FileReader

常用方法：

new FileReader(path): 通过文件路径构建字符输入流

new FileReader(File)：通过文件对象构建字符输入流

int read() ：读取一个字符，返回字符的int类型
int read(char ):读取字符数组长度的数据，返回实际读取字符长度，数据存放在字符数组中
int read(char offerset len):读取指定字符长度的数组，返回实际读取字符的长度，数据存放在字符数组中
mark(int) :标记流中当前位置（读取到哪里了）
markSupported（）：判断此流是否支持mark操作

    reset(): 重置流数据，（又可从头开始读取）

skip(long) :丢弃指定长度字符

读字符文件

    // 1、创建字符输入流
        try {
            FileReader reader = new FileReader("d:/myfile.txt");
            // 丢弃字符
            reader.skip(1);
            //读一个字符
            System.out.println((char)reader.read());
            System.out.println((char)reader.read());
            //读一个字符数组长度
            char [] c = new char[10];
            System.out.println("实际长度："+reader.read(c));
            System.out.println(new String(c));

            //继续读
            int len =  reader.read(c,0,5);
            System.out.println("字符数组："+ Arrays.toString(c));
            System.out.println("读指定长度字符个数："+new String(c,0,len));

            // 将字符流重置
            // reader.reset();
            // System.out.println("重置后继续读："+ reader.read());

            //System.out.println("是否支持标记字符："+reader.markSupported());
            //关闭流,后面就不能使用该对象
            reader.close();

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }

写文件：将内存数据写出到文件中，在写出过程中可以覆盖写出也可以追加写出，FileWriter类创建对象过程

   new FileWriter(String )：指定写出文件地址

new FileWriter(String ,append) : 指定写出文件地址，设置是否追加写出，true表示追加，false表示覆盖

new FileWriter(File)指定写出文件对象

new FileWriter(File ,append);指向写出文件对象，设置是否可追加

常用方法：

    writer(int) :写出一个字符

writer(String)：写出一个字符串

writer(char [] )：写出一个字符数组

writer(char [] , offerset , len)：写出一个指定长度的字符数组

flush() :刷新缓冲， 

close():关闭缓冲 

append(c) :将指定字符添加到此流中

   // 1、创建文件写出流 FileWriter
        try {
            // 文件不存在，可自动创建，但是不会创建目录
            File file = new File("d://myabc/aaa.txt");
            //判断文件目录不存在， 先创建目录
            if(!file.getParentFile().exists()){
                //创建该目录
                file.getParentFile().mkdirs();
            }

            FileWriter writer = new FileWriter("d://myabc/aaa.txt");
            // 写一个字符的asci
            writer.write(98);
            //写字符串
            writer.write("hello");
            //写指定长度的字符串
            writer.write("abcdef",0,3); //写abc
            char [] c = {'L','O','L'};
            //写字符数组
            writer.write(c);
            System.out.println("写出成功");
            writer.flush();
            writer.close();

        } catch (IOException e) {
            e.printStackTrace();
        }

关闭和刷新：

对于带有缓冲功能的写出流，需要先刷新缓冲区，才能将数据写出，如果不刷新则最后不能正常写出。写出流如果刷新后还可以继续写，而关闭了则不能继续写。

面试题 flush 和close的区别？

flush：刷新缓冲，流可以继续使用

close: 先刷新缓冲器，然后再释放系统资源，关闭后不能继续使用

   try {
            FileWriter writer = new FileWriter("1.txt");
            writer.write("刷");
            writer.flush();
            writer.write("新");
            writer.flush();

            writer.write("关");
            writer.close();
            writer.write("闭"); // 这里抛出异常 ， Stream closed
            writer.close();


        } catch (IOException e) {
             e.printStackTrace();
        }

关于换行符

回车符 \r 和换行符 \n ：

回车符：回到一行的开头（return）。

换行符：下一行（newline）。

系统中的换行：

Windows系统里，每行结尾是回车+换行，即 \r\n ；

Unix系统里，每行结尾只有换行，即 \n ；

Mac系统里，每行结尾是回车，即 \r 。从 Mac OS X开始与Linux统一。

缓冲流

一. 缓冲流

缓冲流是处理流的一种，也叫高效流，是对4个基本输入输出流的增强，它让输入输出流具有1个缓冲区，能显著减小与外部的IO次数，从而提高读写的效率，并且提供了一些额外的读写方法。

因为是对4个基本输入输出流的增强，因此缓冲流也有4个，分为字节缓冲流和字符缓冲流。

字节缓冲流：BufferedInputStream 和 BufferedOutputStream
字符缓冲流：BufferedReader 和 BufferedWriter

对象流

  ObjectInputStream
       Object readObject():该方法抛出异常：ClassNotFountException。
  ObjectOutputStream
       voidwriteObject(Object)：被写入的对象必须实现一个接口:Serializable    否则会抛出：NotSerializableException

    java允许类的对象通过串形化进行传输，实现Serializable 接口，虽然这个接口什么都没有，但一个类声明实现这个接口是，只是表明该类加入对象串行化协议。

序列化

1.加入串行化协议，实现接口

2.创建对象，给对象的的属性进行赋值

3.创建对象输出流对象，先创建文件输出字节流，并将其套接到对象流中

4.写对象到文件中，即实现了文件的序列化和串行化，也把对象的状态保存到文件中

反序列化

从文件中读取对象的状态和属性值，从而再生成对象

1.首先要创建文件输入流对象，在把其套接到对象流中

2.从对象输入流的文件中读取文件的状态

Jacksonjiang111

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
2020-11-08

字节流定义：文件的输入输出以一个“字节”为单位，进行流处理 FileInputStream 和 FileOutputStream读入：将文件中的数据读到内存中常用方法： int read() : 一个字节的读取，返回字节的asci码，对于汉字会分3次读取 int read(byte) ：按一个数组长度读取，返回实际读取的字节长度，数据存放在数组中 int read(byte , offset , len) : 读取流中指定
复制链接

扫一扫