字节流

最新推荐文章于 2023-04-10 17:20:17 发布

岿然如故

最新推荐文章于 2023-04-10 17:20:17 发布

阅读量160

点赞数

分类专栏：基础知识文章标签： jvm java

本文链接：https://blog.csdn.net/cl66666666/article/details/109790395

版权

基础知识专栏收录该内容

32 篇文章 1 订阅

订阅专栏

字节流写数据

字节流抽象基类：

InputStream：这个抽象类是表示字节输入流的所有类的超类

OutputStream：这个抽象类是表示字节输出流的所有类的超类

子类名特点：子类名称都是以其父类名作为子类名的后缀

字节输出流：

FileOutputStream(String name)：创建文件输出流以指定的名称写入文件

使用字节输出流写数据的步骤：

创建字节输出流对象(调用系统功能创建了文件，创建字节输出流对象，让字节输出流对象指向文件)

调用字节输出流对象的写数据方法

释放资源(关闭此文件输出流并释放与此流相关联的任何系统资源) —很重要

package com.itxuexi.it17.FileOutput01;

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

public class FileOutputStreamDemo01 {
    public static void main(String[] args) throws IOException {
        //创建字节输出流对象
        FileOutputStream fos = new FileOutputStream("G:\\javaSE_code\\fos.txt");
        /*
        做了三件事情：
            A:调用系统功能创建了文件
            B:创建了字节输出流对象
            C:让字节输出流对象指向创建好的文件
        */

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

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

字节流写数据的3种方式

方法名	说明
void write(int b)	将指定的字节写入此文件输出流一次写一个字节数据
void write(byte[] b)	将 b.length字节从指定的字节数组写入此文件输出流一次写一个字节数组数据
void write(byte[] b, int off, int len)	将 len字节从指定的字节数组开始，从偏移量off开始写入此文件输出流一次写一个字节数组的部分数据

package com.itxuexi.it17.FileOutput01;

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

public class FileOutputStreamDemo02 {
    public static void main(String[] args) throws IOException {
        //构造方法

        //FileOutputStream(String name)：创建文件输出流以指定的名称写入文件
        //new Flie   不为空     new FileOutputStream(new ("G:\\javaSE_code\\fos.txt"));
        FileOutputStream fos = new FileOutputStream("G:\\javaSE_code\\fos.txt");

        //new Flie 等同上面方法
//        File file = new File("G:\\javaSE_code\\fos.txt");
//        FileOutputStream fos2 = new FileOutputStream(file);

        //void write(byte[] b)  一次写一个字节数组数据
        byte [] bys = {97,98,99,100,101};
        fos.write(bys);                  //abcde
//        byte[] bys = "bacde".getBytes(); 等同于上面方法

        // void write(byte[] b, int off, int len) 从偏移量off开始写入此文件输出流 ,一次写一个字节数组的部分数据
        byte [] byss = {97,98,99,100,101};
        fos.write(byss,1,3);     //bcd

        fos.close();

    }
}

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

字节流写数据如何实现换行：注意不同系统 \r\n

字节流写数据如何实现追加写入：

public FileOutputStream(String name,boolean append)

创建文件输出流以指定的名称写入文件。如果第二个参数为true ，则字节将写入文件的末尾而不是开头

package com.itxuexi.it17.FileOutput01;

/*
字节流换行
    windos: \n\r
    linux: \n
    mac:\r
 */

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

public class FileOutputStreamDemo03 {
    public static void main(String[] args) throws IOException {
        //append: true   在文件末尾追加写入 ;不加会重写文件
        FileOutputStream fos = new FileOutputStream("G:\\javaSE_code\\fos.txt",true);

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

        //释放内存
        fos.close();

    }
}

字节流写数据加异常处理

try{
	可能出现异常的代码;
}catch(异常类名 变量名){
	异常的处理代码;
}finally{
	执行所有清除操作;
}

finally：在异常处理时提供finally块来执行所有清除操作。比如说IO流中的释放资源

finally特点：被finally控制的语句一定会执行，除非JVM退出

package com.itxuexi.it17.FileOutput01;

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

public class FileOutputStreamDemo04 {
    public static void main(String[] args) {
//        try {
//            FileOutputStream fos = new FileOutputStream("G:\\javaSE_code\\fos.txt",true);
//            fos.write("hello".getBytes());
//            fos.close();
//        } catch (IOException e) {
//            e.printStackTrace();
//        }

        FileOutputStream fos = null;
        try {
            fos = new FileOutputStream("G:\\javaSE_code\\fos.txt",true);
            fos.write("hello".getBytes());
            fos.close();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //判断文件不为null了时，执行释放资源操作 ；加强系统健壮性
            if (fos != null) {
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        

    }
}

字节流练习题

字节流读数据

一次读一个字节数据

把文件fos.txt中的内容读取出来在控制台输出

package com.itxuexi.it17.FileOutput01;

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

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

        /*
        //调用字节流输入对象的读数据方法
        byte [] bys = new byte[5];

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

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

        //第三次读数据
        len = fis.read(bys);
        System.out.println(len);                            //lo
        System.out.println(new String(bys));
         */

        byte[] bys = new byte[1024];
        int len;
        while ((len = fis.read(bys)) != -1) {
            System.out.print(new String(bys, 0, len));
        }

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

    }
}

字节流复制文本文件

package com.itxuexi.it17.FileOutput01;

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

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

分析：
复制文本文件，其实就把文本文件的内容从一个文件中读取出来(数据源)，然后写入到另一个文件中(目的地)
数据源：
E:\\itcast\\窗里窗外.txt --- 读数据 --- InputStream --- FileInputStream
目的地：
myByteStream\\窗里窗外.txt --- 写数据 --- OutputStream --- FileOutputStream

 */
public class FileOutputStreamEx03 {
    public static void main(String[] args) throws IOException {
        //根据数据源创建字节输入流对象
        FileInputStream fis = new FileInputStream("G:\\javaSE_code\\fos.txt");

        //根据目的地创建字节输出流对象
        FileOutputStream fos = new FileOutputStream("G:\\javaSE_code\\out\\fos.txt");

        int by;
        while ((by = fis.read())!= -1){
            fos.write(by);
        }

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

    }
}

字节流读数据(数组)

package com.itxuexi.it17.FileOutput01;

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

public class FileOutputStreamEx04 {
    public static void main(String[] args) throws IOException {
        //创建字节流对象
        FileInputStream fis = new FileInputStream("G:\\javaSE_code\\fos.txt");

        //
        byte[] bye = new byte[1024];
        int len;
        while ((len = fis.read(bye))!= -1){
            System.out.println(new String(bye,0,len));
        }
        fis.close();
    }
}

字节流复制图片

package com.itxuexi.it17.FileOutput01;

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

public class FileOutputStreamEx05 {
    public static void main(String[] args) throws IOException {
        //根据数据源创建字节输入流对象
        FileInputStream fis = new FileInputStream("G:\\javaSE_code\\IMG_1093.JPG");

        //根据目的地创建字节输出流对象
        FileOutputStream fos = new FileOutputStream("G:\\javaSE_code\\out\\IMG_1093.JPG");

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

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

字节缓冲流

字节缓冲流介绍

lBufferOutputStream：该类实现缓冲输出流。通过设置这样的输出流，应用程序可以向底层输出流写入字节，而不必为写入的每个字节导致底层系统的调用

lBufferedInputStream：创建BufferedInputStream将创建一个内部缓冲区数组。当从流中读取或跳过字节时，内部缓冲区将根据需要从所包含的输入流中重新填充，一次很多字节

构造方法：

BufferedOutputStream(OutputStream out) 创建字节缓冲输出流对象

BufferedInputStream(InputStream in) 创建字节缓冲输入流对象

package com.itxuexi.it18.Buffered01;

import java.io.*;

public class BufferedDemo01 {
    public static void main(String[] args) throws IOException {
        //字节缓冲输出流：BufferedOutputStream(OutputStream out)
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("G:\\javaSE_code\\fos.txt"));

        //写数据
        bos.write("hello\n\r".getBytes());
        bos.write("world\n\r".getBytes());

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

        //字节缓冲输入流：BufferedInputStream(InputStream in)
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("G:\\javaSE_code\\fos.txt"));

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

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

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

    }
}

字节流复制视频(字节流/字节缓冲流读取字节/字节数组耗时)

package com.itxuexi.it18.Buffered01;

import java.io.*;

public class BufferedDemo02 {
    public static void main(String[] args) throws IOException {
        //记录开始时间
        long startTime = System.currentTimeMillis();
//        mothod1();   //共耗时126732毫秒
        mothod2();     //共耗时172毫秒
//        mothod3();     //共耗时687毫秒
//        mothod4();     //共耗时57毫秒
        
        //记录结束时间
        long endTime = System.currentTimeMillis();

        System.out.println("共耗时" + (endTime - startTime) + "毫秒");
    }

    //字节缓冲流一次读写一个字节数组
    public static void mothod4 () throws IOException{
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("G:\\javaSE_code\\10-Java语言(Hello World).avi"));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("G:\\javaSE_code\\out\\10-Java语言(Hello World).avi"));

        byte [] bys = new byte[1024];
        int len;
        while((len = bis.read(bys)) != -1){
            bos.write(bys,0,len);
        }
        bis.close();
        bos.close();
    }

    //字节缓冲流一次读写一个字节
    public static void mothod3() throws IOException{
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("G:\\javaSE_code\\10-Java语言(Hello World).avi"));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("G:\\javaSE_code\\out\\10-Java语言(Hello World).avi"));

        int by;
        while ((by = bis.read()) != -1){
            bos.write(by);
        }

        bis.close();
        bos.close();
    }


    //字节流一次读写一个字节
    public static void mothod2() throws IOException{
        //创建源地址
        FileInputStream fis = new FileInputStream("G:\\javaSE_code\\10-Java语言(Hello World).avi");
        FileOutputStream fos = new FileOutputStream("G:\\javaSE_code\\out\\10-Java语言(Hello World).avi");

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

    }

    //基本字节流一次读写一个字节
    public static void mothod1() throws IOException {
        //创建源地址
        FileInputStream fis = new FileInputStream("G:\\javaSE_code\\10-Java语言(Hello World).avi");
        //创建目标地址
        FileOutputStream fos = new FileOutputStream("G:\\javaSE_code\\out\\10-Java语言(Hello World).avi");

        int by;
        while ((by = fis.read()) != -1) {
            fos.write(by);
        }
        fos.close();
        fis.close();

    }
}