Java编程基础21——IO(字节流)

yanbingyun1990 发布于2019-08-19 11:16 / 951人阅读

摘要：流按操作类型分为两种字节流字节流可以操作任何数据因为在计算机中任何数据都是以字节的形式存储的字符流字符流只能操作纯字符数据，比较方便。

1_IO流概述及其分类

1.概念

IO流用来处理设备之间的数据传输

Java对数据的操作是通过流的方式

Java用于操作流的类都在IO包中

流按流向分为两种：输入流，输出流。

流按操作类型分为两种：

字节流 : 字节流可以操作任何数据,因为在计算机中任何数据都是以字节的形式存储的

字符流 : 字符流只能操作纯字符数据，比较方便。

2.IO流常用父类

字节流的抽象父类：

InputStream

OutputStream

字符流的抽象父类：

Reader

Writer

3.IO程序书写

使用前，导入IO包中的类

使用时，进行IO异常处理

使用后，释放资源

2_FileInputStream

read()一次读取一个字节

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

public class Demo1_FileInputStream {
    public static void main(String[] args) throws IOException {
//        demo1();
        FileInputStream fis = new FileInputStream("xxx.txt");    //创建一个文件输入流对象,并关联xxx.txt
        int b;                                                    //定义变量,记录每次读到的字节
        while((b = fis.read()) != -1) {                            //将每次读到的字节赋值给b并判断是否是-1
            System.out.println(b);                                //打印每一个字节
        }
        
        fis.close();                                            //关闭流释放资源
    }

    private static void demo1() throws FileNotFoundException, IOException {
        FileInputStream fis = new FileInputStream("xxx.txt");//创建流对象
        int x = fis.read();                                    //从硬盘上读取一个字节
        System.out.println(x);
        int y = fis.read();
        System.out.println(y);
        int z = fis.read();
        System.out.println(z);
        int a = fis.read();
        System.out.println(a);
        int b = fis.read();
        System.out.println(b);    
        
        fis.close();                                //关流释放资源
    }
}

3_read()方法返回值为什么是int

read()方法读取的是一个字节,为什么返回是int,而不是byte

字节输入流可以操作任意类型的文件，比如图片音频等，这些文件底层都是以二进制形式的存储的，如果每次读取都返回byte，会有可能在读到111111111，而11111111是byte类型的-1，程序在遇到-1就会停止读取，用int类型接收遇到11111111会在其前面补上24个0凑足4个字节，那么byte类型的-1就变成int类型的255了，这样可以保证整个数据读完，而结束标记的-1是int类型的。

4_FileOutputStream

write()一次写出一个字节

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class Demo2_FileOutputStream {

    public static void main(String[] args) throws IOException {
        FileOutputStream fos = new FileOutputStream("yyy.txt");    //自动创建没有的对象
        fos.write(97);                    //虽然写出的是一个int数，但是到文件上的是一个字节，会自动去除前三个八位
        fos.write(98);
        fos.write(99);
        
        fos.close();
    }
}

5_FileOutputStream追加

A:案例演示

public static void main(String[] args) throws IOException {
//        demo1();
        FileOutputStream fos = new FileOutputStream("yyy.txt",true);//追加在第二个参数传true
        fos.write(97);
        fos.write(98);
        
        fos.close();
}

6_拷贝图片

FileInputStream读取

FileOutputStream写出

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

public class Demo3_Copy {
    public static void main(String[] args) throws IOException {
//        demo1();
        FileInputStream fis = new FileInputStream("视频.avi");        //创建输入流对象，关联视频
        FileOutputStream fos = new FileOutputStream("copy.avi");    //创建输出流对象，关联copy.avi
        
        int b;
        while((b = fis.read()) != -1) {                    //在不断读取每个字节
            fos.write(b);                                //将每一个字节写出
            
        }
        fis.close();                                    //关流释放资源
        fos.close();
    }

    private static void demo1() throws FileNotFoundException, IOException {
        FileInputStream fis = new FileInputStream("图片1.png");        //创建输入流对象，关联图片
        FileOutputStream fos = new FileOutputStream("copy.jpg");    //创建输出流对象，关联cop.jpg
        
        int b;
        while((b = fis.read()) != -1) {                    //在不断读取每个字节
            fos.write(b);                                //将每一个字节写出
            
        }
        fis.close();                                    //关流释放资源
        fos.close();
    }
}

7_拷贝音频文件画原理图

A:案例演示

字节流一次读写一个字节复制音频

弊端:效率太低

8_字节数组拷贝之available()方法

A:案例演示

int read(byte[] b):一次读取一个字节数组

write(byte[] b):一次写出一个字节数组

available()获取读的文件所有的字节个数

弊端:有可能会内存溢出

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class Demo3_Copy {
    public static void main(String[] args) throws IOException {    
        //第二种拷贝，不推荐，有可能导致内存溢出
        FileInputStream fis = new FileInputStream("视频.avi");        //创建输入流对象，关联视频
        FileOutputStream fos = new FileOutputStream("copy.avi");    //创建输出流对象，关联copy.avi
//        int len = fis.available();
//        System.out.println(len);
        
        byte[] arr = new byte[fis.available()];                    //创建与文件一样大小的字节数组
        fis.read(arr);                                            //将文件上的字节读取到内存中
        fos.write(arr);                                            //将字节数组中的字节数据写到文件上
        
        fis.close();
        fos.close();
    }
}

9_定义小数组

write(byte[] b)

write(byte[] b, int off, int len)写出有效的字节个数

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class Demo4_ArrayCopy {
    public static void main(String[] args) throws IOException {
//        demo1();
        FileInputStream fis = new FileInputStream("xxx.txt");
        FileOutputStream fos = new FileOutputStream("yyy.txt");
        
        byte[] arr = new byte[2];
        int len;
        while((len = fis.read(arr)) != -1) {
            fos.write(arr,0,len);
        }
        
        fis.close();
        fos.close();
    }

    private static void demo1() throws FileNotFoundException, IOException {
        FileInputStream fis = new FileInputStream("xxx.txt");
        byte[] arr = new byte[2];
        int a = fis.read(arr);                        //将文件上的字节读取到字节数组中
        
        System.out.println(a);                        //读到的有效字节个数
        for (byte b : arr) {                        //第一次获取到文件上的a和b
            System.out.println(b);
        }
        System.out.println("----");
        int c = fis.read(arr);
        System.out.println(c);
        for (byte b : arr) {
            System.out.println(b);
        }
        
        fis.close();
    }
}

10_定义小数组的标准格式

A:案例演示

字节流一次读写一个字节数组复制图片和视频

public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("视频.avi");
        FileOutputStream fos = new FileOutputStream("copy.avi");
        
        byte[] arr = new byte[1024 * 8];
        int len;
        while((len = fis.read(arr)) != -1) {        //忘记写arr，返回的是码表值
            fos.write(arr,0,len);
        }
        
        fis.close();
        fos.close();
    }

11_BufferedInputStream和BufferOutputStream拷贝

A:缓冲思想

字节流一次读写一个数组的速度明显比一次读写一个字节的速度快很多，

这是加入了数组这样的缓冲区效果，java本身在设计的时候，

也考虑到了这样的设计思想(装饰设计模式后面讲解)，所以提供了字节缓冲区流

B.BufferedInputStream

BufferedInputStream内置了一个缓冲区(数组)

从BufferedInputStream中读取一个字节时

BufferedInputStream会一次性从文件中读取8192个, 存在缓冲区中, 返回给程序一个

程序再次读取时, 就不用找文件了, 直接从缓冲区中获取

直到缓冲区中所有的都被使用过, 才重新从文件中读取8192个

C.BufferedOutputStream

BufferedOutputStream也内置了一个缓冲区(数组)

程序向流中写出字节时, 不会直接写到文件, 先写到缓冲区中

直到缓冲区写满, BufferedOutputStream才会把缓冲区中的数据一次性写到文件里

D.小数组的读写和带Buffered的读取哪个更快?

定义小数组如果是8192个字节大小和Buffered比较的话

定义小数组会略胜一筹,因为读和写操作的是同一个数组

而Buffered操作的是两个数组

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

public class Demo5_BufferCopy {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("视频.avi");    //创建输入流对象
        FileOutputStream fos = new FileOutputStream("copy.avi");//创建输出流对象
        
        //byte[] arr = new byte[8192]; 
        BufferedInputStream bis = new BufferedInputStream(fis);//创建缓冲区对象，对输入流进行包装，让其变得更强
        BufferedOutputStream bos = new BufferedOutputStream(fos);    
        
        int b;
        while((b = bis.read()) != -1) {
            bos.write(b);
        }
        
        bis.close();
        bos.close();
    }
}

12_flush和close方法的区别

flush()方法

用来刷新缓冲区的,刷新后可以再次写出

close()方法

用来关闭流释放资源的的,如果是带缓冲区的流对象的close()方法,不但会关闭流,还会再关闭流之前刷新缓冲区,关闭后不能再写出

public static void main(String[] args) throws IOException {
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("视频.avi"));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("copy.mp3"));    
        
        int b;
        while((b = bis.read()) != -1) {
            bos.write(b);
            bos.flush();
        }
//        bos.close();
//        bis.close();
    }

13_字节流读写中文)

字节流读取中文的问题

字节流在读中文的时候有可能会读到半个中文,造成乱码

字节流写出中文的问题

字节流直接操作的字节,所以写出中文必须将字符串转换成字节数组

写出回车换行 write("rn".getBytes());

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

public class Demo6_Chinese {
    public static void main(String[] args) throws IOException {
//        demo1();
        FileOutputStream fos = new FileOutputStream("zzz.txt");
        fos.write("同九年，汝独秀".getBytes());
        fos.write("
".getBytes());
        
        fos.close();
    }
    
    private static void demo1() throws FileNotFoundException, IOException {
        FileInputStream fis = new FileInputStream("yyy.txt");
        byte[] arr = new byte[4];
        int len;
        while((len = fis.read(arr)) != -1) {
            System.out.println(new String(arr,0,len));
        }
        fis.close();
    }
}

14_流的标准处理异常代码1.6版本及其以前

try finally嵌套

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

public class Demo7_TryFinally {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            fis = new FileInputStream("xxx.txt");
            fos = new FileOutputStream("yyy.txt");
            int b;
            while((b = fis.read()) != -1) {
                fos.write(b);
            }
        }finally {
            try {
                if(fis != null)
                    fis.close();
            }finally {                //try fianlly的目的是尽量关闭
                if(fos != null)
                    fos.close();
            }
        }
    }
}

15_流的标准处理异常代码1.7版本

try close

原理

在try()中创建的流对象必须实现了AutoCloseable这个接口,如果实现了,在try后面的{}(读写代码)执行后就会自动调用,流对象的close方法将流关掉

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

public class Demo7_TryFinally {
    public static void main(String[] args) throws IOException {
        try(
            FileInputStream fis = new FileInputStream("xxx.txt");
            FileOutputStream fos = new FileOutputStream("yyy.txt");
            MyClose mc = new MyClose();
        ){
            int b;
            while((b = fis.read()) != -1) {
                fos.write(b);
            }
        }
    }
}

class MyClose implements AutoCloseable{    //实现AutoCloseable，自动调用close();
    public void close() {
        System.out.println("我关了");
    }
}

16_图片加密

给图片加密

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class Demo8_test {
    public static void main(String[] args) throws IOException {
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("图片1.jpg"));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("copy.jpg"));
        
        int b;
        while((b = bis.read()) != -1) {
            bos.write(b ^ 123);//将写出的字节异或上一个数，这个数就是秘钥，解密再异或就行
        }
        
        bis.close();
        bos.close();
    }
}

17_拷贝文件

在控制台录入文件的路径,将文件拷贝到当前项目下

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Scanner;

public class Demo9_test {
    public static void main(String[] args) throws IOException {
        File file = getFile();                //获取文件
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(file));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(file.getName()));
        
        int b;
        while((b = bis.read()) != -1) {
            bos.write(b);
        }
        bis.close();
        bos.close();
    }
    
    //定义一个方法获取键盘录入的文件路径，并封装成file对象返回
    //返回值类型:File    参数列表:无    
    public static File getFile() {
        Scanner sc = new Scanner(System.in);//创建键盘录入对象
        System.out.println("请输入一个文件的路径：");
        while(true) {
            String line = sc.nextLine();        //接收键盘录入的路径
            File file = new File(line);            //封装成File对象，并对其判断
            if(!file.exists()) {
                System.out.println("您录入的文件路劲不存在，请重新录入：");
            }else if(file.isDirectory()) {
                System.out.println("您录入的是文件夹路径，请重新录入：");
            }else {
                return file;                    //弹栈返回路径
            }
        }
    }
}

18_录入数据拷贝到文件

将键盘录入的数据拷贝到当前项目下的text.txt文件中,键盘录入数据当遇到quit时就退出

import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Scanner;

public class Demo10_test {
    public static void main(String[] args) throws IOException {
        Scanner sc = new Scanner(System.in);        //创建键盘录入对象
        FileOutputStream fos = new FileOutputStream("text.txt");//创建输出流对象，关联text.txt文件
        System.out.println("请输入数据：");
        
        while(true) {
            String line = sc.nextLine();            //将键盘录入的数据存储在line中
            if("quit".equals(line)) {
                break;                                //遇到quit退出循环
            }
            fos.write(line.getBytes());                //字符串写出必须转换成字节数组
            fos.write("
".getBytes());
        }
        fos.close();
    }
}

超融合服务器云服务器 java发送字节流 java字节流长度字节流字符流java效率保存字节流

文章版权归作者所有，未经允许请勿转载,若此文章存在违规行为，您可以联系管理员删除。

转载请注明本文地址：https://www.ucloud.cn/yun/77311.html

第十五章输入输出系统

摘要：在包下主要包括输入输出两种流，每种输入输出流又可分为字节流和字符流两大类。输入输出是从程序运行所在的内存的角度而言的。的输入流主要由和作为基类，而输出流主要由和作为基类。本章主要参考和摘自疯狂java讲义上面的(java编程思想的后面看过后有新的内容再补充进去吧)。　　输入输出是所有程序都必需的部分————使用输入机制允许程序读取外部数据(包括磁盘、光盘等存储设备上的数据和用户输入的...

hankkin 2019-08-16 13:48 评论0 收藏0
java 基础 - 收藏集 - 掘金

摘要：基础知识复习后端掘金的作用表示静态修饰符，使用修饰的变量，在中分配内存后一直存在，直到程序退出才释放空间。将对象编码为字节流称之为序列化，反之将字节流重建成对象称之为反序列化。 Java 学习过程｜完整思维导图 - 后端 - 掘金JVM 1. 内存模型( 内存分为几部分？堆溢出、栈溢出原因及实例？线上如何排查？) 2. 类加载机制 3. 垃圾回收 Java基础什么是接口？什么是抽象...

makeFoxPlay 2019-08-15 10:35 评论0 收藏0
高薪程序员&面试题精讲系列22之说说Java的IO流，常用哪些IO流？

摘要：一面试题及剖析今日面试题今天壹哥带各位复习一块可能会令初学者比较头疼的内容，起码当时让我很有些头疼的内容，那就是流。在这里壹哥会从两部分展开介绍流，即与流。除此之外尽量使用字节流。关闭此输入流并释放与流相关联的任何系统资源。一. 面试题及剖析 1. 今日面试题今天壹哥带各位复习一块可...

fnngj 2021-11-23 09:51 评论0 收藏0
快速Get-JAVA-IO流

摘要：除非文件用自带的记事本打开我们能够读懂，才采用字符流，否则建议使用字节流。第四阶段 IO IO流前言：前面的学习我们只能够在已有的一定封闭范围内进行一些操作，但是这显然是无趣的，也是不支持我们实现一些复杂的需求，所以Java提供IO流这样一种概念，方便我们对数据进行操作而使用IO流我们可以实现一些强大的功能，例如针对文件的移动复制等操作，又或者程序与外部文件之间的数据存储或者读...

wangzy2019 2019-08-16 18:33 评论0 收藏0