java---IO流：字节流_字节流追加字节-优快云博客

本文链接：https://blog.youkuaiyun.com/z2021_000000/article/details/125525145

字节流写数据

package IO流.字节流.字节流写数据;

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

/*
        字节流抽象基类
            inputStream: 这个抽象类是表示字节输入流的所有类的超类
            outputStream: 这个抽象类表示字节输出流的所有类的超类
            子类名特点: 子类名称都是以其父类名作为子类名的后缀

        FileOutputStream:文件输出流  用于将数据写入File
            FileOutputStream(String name): 创建文件输出流以指定的名写入文件

        使用字节输出流写数据的步骤：
            创建字节输出流对象
            调用字节输出流对象的写数据方法
            释放资源

 */
public class 字节流写数据 {
    public static void main(String[] args) throws IOException {
        //创建字节输出流对象
        FileOutputStream fos=new FileOutputStream("idea_text\\fos.txt");
        /*
            做了三件事情：
                1，调用系统功能创建了文件
                2，创建了字节输出流对象
                3，让字节输出流对象指向创建好的文件
         */

        //void write(int b) 将指定的字节写入此文件输出流。
        fos.write(97);
//        fos.write(57);
//        fos.write(55);

        //最后都要释放资源
        //void close() 关闭此文件输出流并释放与此流相关联的任何系统资源
        fos.close();


    }
}

字节流写数据的3种方式

package IO流.字节流.字节流写数据;
/*
        void write(int b)
            将指定的字节写入此文件输出流。
            一次写一个字节数据
        void write(byte[] b)
            将 b.length字节从指定的字节数组写入此文件输出流。
            一次写一个字节数组数据
        void write(byte[] b, int off, int len)
            将 len字节从指定的字节数组开始，从偏移量 off开始写入此文件输出流。
            一次写一个字节数组的部分数据
 */

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class 字节流写数据的3种方式 {
    public static void main(String[] args) throws IOException {
        //创建文件输出流以指定的名称写入文件
        FileOutputStream fos = new FileOutputStream("idea_text\\fos.txt");
        //new File(name)
//        FileOutputStream fos = new FileOutputStream(new File("idea_text\\fos.txt"));

        //创建文件输出流以写入由指定的File对象表示的文件
//        FileOutputStream(File file)
//        File file=new File("idea_text\\fos.txt");
//        FileOutputStream fos2 = new FileOutputStream(file);
//        FileOutputStream fos2 = new FileOutputStream(new File("idea_text\\fos.txt"));

/*        //void write(int b)
        fos.write(97);
        fos.write(98);
        fos.write(99);
        fos.write(100);
        fos.write(101);*/

        //void write(byte[] b)
//        byte[] bys={97,98,99,100,101};
        //byte[] getBytes() :返回字符串对应的字节数组
        byte[] bys ="abcde".getBytes();
//        fos.write(bys);

        //void write(byte[] b, int off, int len)
        fos.write(bys,1,3);

        //释放资源
        fos.close();






    }
}

字节流写数据的两个小问题

package IO流.字节流.字节流写数据;
/*
        1，字节流写数据如何实现换行呢？
            window：\r\n
            linux:  \n
            mac:   \r

        2,字节流如何实现追加写入呢？
            public FileOutputStream (String name,boolean append)
                创建文件输出流以指定的名称写入文件
                如果第二个参数为ture，则字节将写入文件的末尾而不是开头

 */

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

public class 字节流写数据的两个小问题 {
    public static void main(String[] args) throws IOException {
        //创建字节输出流对象
        //追加写入
        FileOutputStream fos=new FileOutputStream("idea_text\\fos.txt",true);

        //写数据
        for (int i=0;i<10;i++){
            fos.write("hello".getBytes());
            fos.write("\r\n".getBytes());//换行
        }

        //释放资源
        fos.close();
    }
}

字节流写数据加异常处理

package IO流.字节流.字节流写数据;
/*
        finally：
            在异常处理时提供finally块来执行所有的清除操作。
          特点：
                被finally控制的语句一定会执行，除非JVM退出

 */

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

public class 字节流写数据加异常处理 {
    public static void main(String[] args){

        //加finally来释放资源
        FileOutputStream fos = null;
        try{
            fos=new FileOutputStream("idea_text\\fos.txt");
            fos.write("hello".getBytes());
        }catch(IOException e){
            e.printStackTrace();
        }
        finally{
            if (fos!=null){
                try{
                    fos.close();
                }catch(IOException e){
                    e.printStackTrace();
                }
            }

        }
    }
}

字节流读数据：

一次读一个字节数据

package IO流.字节流.字节流读数据.一次读一个字节数据;
/*
    字节流读数据：
        需求：
            把文件fos.txt中的内容读取出来在控制台输出

            FileInputStream从文件系统中的文件获取输入字节。
                FileInputStream(String name)
                    通过打开与实际文件的连接来创建一个 FileInputStream ，
                    该文件由文件系统中的路径名 name命名。

            使用字节输入流读数据的步骤：
                1，创建字节输入流对象
                2，调用字节输入流对象的读取数据方法
                3，释放资源

 */

import java.io.FileInputStream;

import java.io.IOException;

public class 一次读一个字节数据 {
    public static void main(String[] args) throws IOException {
        //创建字节输入流对象
        //FileInputStream(String name)
        FileInputStream fis=new FileInputStream("idea_text\\fos.txt");

        //调用字节输入流对象的读取数据
        int by;
        /*
            fis.read():读数据
            by=fis.read():把读取的数据赋值给by
            by ！=-1 ：判断读取的数据是否为-1
         */
        while ((by = fis.read()) != -1){
            System.out.println((char)by);
        }

        //释放资源
        fis.close();
    }

}

复制文本文件

package IO流.字节流.字节流读数据.一次读一个字节数据;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

/*
        需求：
            把“D:\\1\\java\\窗里窗外.txt”复制到模块目录下的“窗里窗外.txt”

        分析：
            1，复制文本文件，其实就把文本文件的内容从一个文件中读取出来（数据源）
                然后写入另一个文件中（目的地）
            2，数据源：
                D:\\1\\java\\窗里窗外.txt---读数据---InputSteam---FileInputStream
            3，目的地
                idea_text\\窗里窗外.txt---写数据---OutputStream---FileOutputStream

 */
public class 复制文本文件 {
    public static void main(String[] args) throws IOException {
        //根据数据源创建字节输入流对象
        FileInputStream fis=new FileInputStream("D:\\1\\java\\窗里窗外.txt");

        //根据目的地创建字节输出流对象
        FileOutputStream fos=new FileOutputStream("idea_text\\窗里窗外.txt");

        //读取数据（一次读取一个字节）
        int by;
        while ((by=fis.read())!=-1){
            fos.write(by);
        }


        //释放资源
        fis.close();
        fos.close();

    }
}

一次读一个字节数组数据

package IO流.字节流.字节流读数据.一次读一个字节数组数据;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

/*
    字节流读数据：
        需求：
            把文件fos.txt中的内容读取出来在控制台输出

            使用字节输入流读数据的步骤：
                1，创建字节输入流对象
                2，调用字节输入流对象的读取数据方法
                3，释放资源

 */
public class Demo {
    public static void main(String[] args) throws IOException {
        //创建字节输入流对象
        FileInputStream fis=new FileInputStream("idea_text\\fos.txt");

        //调用字节输入流对象的读取数据方法
        //int read(byte[] b) 从该输入流读取最多 b.length个字节的数据到一个字节数组。
/*
        byte[] bys=new byte[5];

        //第一次读数据
        int len = fis.read(bys);
        System.out.println(len);
        //String (byte[] bytes)
        System.out.println(new String(bys));

        //第二次读数据
        len = fis.read(bys);
        System.out.println(len);
        //String (byte[] bytes)
        System.out.println(new String(bys));

        //第三次读数据
        len = fis.read(bys);
        System.out.println(len);
        //String (byte[] bytes)
        System.out.println(new String(bys));
        */
/*
        hello\r\n
        world\r\n
         *//*


        */
/*
        第一次：hello
        第二次：\r\nwor
        第三次：ld\r\nr
         *//*


*/

        //代码优化：
        byte[] bys =new byte[1024];
        int len;
        while ((len = fis.read(bys)) != -1){
            System.out.println(new String(bys,0,len));
        }

        //释放资源
        fis.close();


    }
}

复制图片

package IO流.字节流.字节流读数据.一次读一个字节数组数据;


import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;


/*
        需求：
            把“D:\\1\\1.jpg”复制到模块目录下的“1.jpg”

        思路：
            1，根据数据源创建字节输入流对象
            2，根据目的地创建字节输出流对象
            3，读写数据，复制图片（一次读取一个字节数组，一次写入一个字节数组）
            4，释放资源

 */
public class 复制图片 {
    public static void main(String[] args) throws IOException {
        //根据数据源创建字节输入流对象
        FileInputStream fis = new FileInputStream("D:\\1\\1.jpg");
        //根据目的地创建字节输出流对象
        FileOutputStream fos=new FileOutputStream("idea_text\\1.jpg");

        //读写数据
        byte[] bys=new byte[1024];
        int len;
        while((len=fis.read(bys))!=-1){
            fos.write(bys,0,len);
        }

        //释放资源
        fis.close();
        fos.close();

    }
}

字节缓冲流

package IO流.字节流.字节缓冲流;
/*

1,  BufferOutputStream:该类实现缓冲输出流。
    通过设置这样的输出流，应用程序可以向底层输出流写入字节，而不必为写入的每个字节导致底层系统的调用
2,  BufferedInputStream:创建BufferedInputStream将创建一个内部缓冲区数组。
    当从流中读取或跳过字节时，内部缓冲区将根据需要从所包含的输入流中重新填充，一次很多字节

    构造方法:
    字节缓冲输出流:BufferedOutputStream(OutputStreamout)
    字节缓冲输入流:BufferedInputStream(InputStreamin)

    为什么构造方法需要的是字节流，而不是具体的文件或者路径呢?
    ●字节缓冲流仅仅提供缓冲区，而真正的读写数据还得依靠基本的字节流对象进行操作

 */

import java.io.*;

public class Demo {
    public static void main(String[] args) throws IOException {
/*
        //字节缓冲输出流:BufferedOutputStream(OutputStreamout)
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("idea_text\\bos.txt"));
        //写数据
        bos.write("hello\r\n".getBytes());
        bos.write("world\r\n".getBytes());
        //释放资源
        bos.close();

        */

        //字节缓冲输入流:BufferedInputStream(InputStreamin)
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("idea_text\\bos.txt"));

        //一次读取一个字节数据
//        int by;
//        while((by=bos.read())!=-1){
//            System.out.println((char)by);
//        }

        //一次读取一个字节数组数据
        byte[] bys=new byte[1024];
        int len;
        while((len=bis.read())!=-1){
            System.out.println(new String(bys,0,len));
        }

        //释放资源
        bis.close();
    }
}

复制视频

package IO流.字节流.字节缓冲流;
/*
        需求：
            把“D:\\1\\字节流复制视频.avi”复制到模块目录下的“idea_text\\字节流复制视频.avi”

        思路：
            1，根据数据源创建字节输入流对象
            2，根据目的地创建字节输出流对象
            3，读写数据，复制视频
            4，释放资源
 */

import java.io.*;

public class 复制视频 {
    public static void main(String[] args) throws IOException{
        //记录开始时间
        long startTime = System.currentTimeMillis();

        //复制视频
        method1();

        //记录结束时间
        long endTime = System.currentTimeMillis();
        System.out.println("共耗时："+(endTime-startTime)+"毫秒");

    }
    public static void method1() throws IOException {
        //根据数据源创建字节输入流对象
        BufferedInputStream bis=new BufferedInputStream(new FileInputStream("D:\\1\\字节流复制视频.avi"));
        //根据目的地创建字节输出流对象
        BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream("idea_text\\字节流复制视频.avi"));

        //读写数据，复制视频

        //一次读写一个字节
        int by;
        while ((by = bis.read()) != -1){
            bos.write(by);
        }

        //一次读写以个字节数组数据
        //耗时更少，推荐使用
        byte[] bys=new byte[1024];
        int len;
        while ((len = bis.read())!=-1){
            bos.write(bys,0,len);
        }

        //释放资源
        bis.close();
        bos.close();
    }
}