精华内容
下载资源
问答
  • 字节流 Java中的字节流 千次阅读 多人点赞
    2022-01-08 22:31:46

    2.1 IO流概述和分类

    ##IO流概述:
    IO:输入/输出(input/ouput)
    流:是一种抽象概念,是对数据传输的总称。也就是说数据在设备间的传输称为流,流的本质是数据传输

    IO流就是用来处理设备间数据传输问题的
    常见的应用:文件复制,文件上传,文件下载

    按数据流向:输入流,输出流

    输入流为读数据,输出流为写数据

    按数据类型:字节输入流/输出流,字符输入流/输出流

    一般来说是按数据类型来分的。

    2.2 字节流写数据

    输入流读数据:

    public abstract class InputStream
    extends Object
    implements Closeable
    

    Direct Known Subclasses:
    AudioInputStream, ByteArrayInputStream, FileInputStream, FilterInputStream, InputStream, ObjectInputStream, PipedInputStream, SequenceInputStream, StringBufferInputStream

    输出流写数据:

    public abstract class OutputStream
    extends Object
    implements Closeable, Flushable
    

    Direct Known Subclasses:
    ByteArrayOutputStream, FileOutputStream, FilterOutputStream, ObjectOutputStream, OutputStream, PipedOutputStream

    这里的抽象类InputStream、OutputStream表示 输入字节流、输出字节流的所有类的超类

    字节流抽象类基类:
    1、InputStream:这个抽象类是表示字节输入流的所有类的超类
    2、OutputStream:这个抽象类是表示字节输出流的所有类的超类
    3、子类名特点:子类名称都是以其父类名作为子类名的后缀

    FileOutputStream:文件输出流用于将数据写入文件File

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

    1.创建字节输出流对象(调用系统功能创建了文件,创建字节输出流对象,让字节输出流对象指向文件)
    2.调用字节输出流对象的写数据方法
    3.释放资源(关闭此输出流并释放与此流相关联的任何系统资源)

    FileOutputStream(String name)

    Creates a file output stream to write to the file with the specified name.

    write(int b)

    Writes the specified byte to this file output stream.

    close()

    Closes this file output stream and releases any system resources associated with this stream.

    package dailyioStream;
    
    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("src\\dailyioStream\\fos.txt");
            /*
            这里创建了字节输出流对象 fos
            创建字节输出流对象这里一共有三步操作:
            1.调用了系统功能创建了文件
            2.创建了字节流输出对象
            3.让字节输出流对象指向创建好的文件
             */
            fos.write(97);//写到低层是97(ASCII码),但是我们打开文件内容是a
            fos.write(57);
            fos.write(55);
            
            fos.close();//释放资源,关闭此文件输出流释放并与此流相关联的任何系统资源
    
    
        }
    }
    
    

    2.3 字节流写数据的3种方式

    void write(int b)

    将指定的字节写入到此文件输出流,一次写一个字节数据
    Writes the specified byte to this file output stream.

    package dailyioStream;
    
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.nio.charset.StandardCharsets;
    
    public class FileOutputStreamDemo02 {
        public static void main(String[] args) throws IOException {
            FileOutputStream fos = new FileOutputStream("src\\dailyioStream\\fos.txt");
            fos.write(97);
            fos.close();
        }
    }
    

    void write(byte[] b)

    将b.length字节从指定的字节数组写入此文件输出流,一次写一个字节数组数据
    Writes b.length bytes from the specified byte array to this file output stream.

    package dailyioStream;
    
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.nio.charset.StandardCharsets;
    
    public class FileOutputStreamDemo02 {
        public static void main(String[] args) throws IOException {
            FileOutputStream fos = new FileOutputStream("src\\dailyioStream\\fos.txt");
            byte[] bys = {97,98,99,100,101};
            fos.write(bys);
            fos.close();
        }
    }
    

    void write(byte[] b, int off, int len)

    将len字节从指定的字节数组开始,从偏移量off开始写入此文件输出流,一次写一个字节数组的部分数据

    Writes len bytes from the specified byte array starting at offset off to this file output stream.

    package dailyioStream;
    
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.nio.charset.StandardCharsets;
    
    public class FileOutputStreamDemo02 {
        public static void main(String[] args) throws IOException {
            FileOutputStream fos = new FileOutputStream("src\\dailyioStream\\fos.txt");
            byte[] bs1 = "abcdefghijk".getBytes(StandardCharsets.UTF_8);
            fos.write(bs1,0,1);//从索引off开始,写length个字节
            fos.close();
        }
    }
    
    

    note:String类中有getBytes()可以获取字符串的字节,返回字符串对应的字节数组

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

    1.字节流写数据如何实现换行?(\n换行,\r\n,\r)

    package dailyioStream;
    
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.nio.charset.StandardCharsets;
    
    public class FileOutputStreamDemo03 {
        public static void main(String[] args) throws IOException {
            FileOutputStream fos = new FileOutputStream("src\\dailyioStream\\fos.txt");
            for(int i=0;i<10;i++){
                fos.write("hello".getBytes(StandardCharsets.UTF_8));
                fos.write("\n".getBytes(StandardCharsets.UTF_8));//  \n换行
            }
            fos.close();
        }
    }
    
    

    2.字节流写输出如果实现追加写入?(构造方法中的参数boolean append)

    FileOutputStream的构造方法:

    public FileOutputStream(String name,
                            boolean append)
                     throws FileNotFoundException
    

    这里有带boolean append,如果为true,会从文件的末尾写入数据。
    默认是false,从文件的开头写入数据。

    package dailyioStream;
    
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.nio.charset.StandardCharsets;
    
    public class FileOutputStreamDemo03 {
        public static void main(String[] args) throws IOException {
            FileOutputStream fos = new FileOutputStream("src\\dailyioStream\\fos.txt",true);
            for(int i=0;i<10;i++){
                fos.write("hello".getBytes(StandardCharsets.UTF_8));
                fos.write("\n".getBytes(StandardCharsets.UTF_8));//  \n换行
            }
            for (int i=0;i<10;i++){
                fos.write("world".getBytes());
                fos.write("\n".getBytes(StandardCharsets.UTF_8));
            }
            fos.close();
    
        }
    }
    
    

    2.5 字节流写数据加异常处理

    一般直接在外面包try{}catch{},但是会有一个问题,如果写入数据失败会运行catch的内容,但是close方法没有运行到也就是资源没有被释放。所以在io操作一定要保存内存被释放。

    package dailyioStream;
    
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.nio.charset.StandardCharsets;
    
    public class FileOutputStreamDemo04 {
    
            public static void main(String[] args) throws IOException {
                try {
                    FileOutputStream fos = new FileOutputStream("src\\dailyioStream\\fos.txt",true);
                    for(int i=0;i<10;i++){
                        fos.write("hello".getBytes(StandardCharsets.UTF_8));
                        fos.write("\n".getBytes(StandardCharsets.UTF_8));//  \n换行
                    }
                for (int i=0;i<10;i++){
                    fos.write("world".getBytes());
                    fos.write("\n".getBytes(StandardCharsets.UTF_8));
                }
                fos.close();} catch (IOException e){
                    e.printStackTrace();
                }
    
            }
        }
    

    提供了finally块来执行所有清除操作

    finally:在异常处理时提供finally块来执行所有清除的操作。比如io流中的资源释放。
    特点:被finally块控制的语句一定会执行,除非JVM退出

    try{
    可能出现异常的代码;
    }catch(IOException e){
    异常处理代码;
    }
    finally{
    执行所有清除操作;
    }
    
    package dailyioStream;
    
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.nio.charset.StandardCharsets;
    
    public class FileOutputStreamDemo05 {
        public static void main(String[] args) throws IOException {
            FileOutputStream fos = null;
            try {
                fos = new FileOutputStream("src\\dailyioStream\\fos.txt");
                fos.write("hello".getBytes(StandardCharsets.UTF_8));
            }catch (IOException e){
                e.printStackTrace();
            }finally {
                if (fos!=null){
                    try {
                        fos.close();
                    }catch (IOException e){
                        e.printStackTrace();  
                    }
                }
            }
        }
    }
    
    

    2.6 字节流读数据(一次读一个字节数据)

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

    FileInputStream:从文件系统中的文件获取输入字节

    使用字节输入流读数据的步骤:

    1.创建字节输入流对象
    2.调用字节输入流对象的读数据方法
    3.释放资源

    FileInputStream(String name):通过打开一个文件的连接来创建一个FileInputStream

    Creates a FileInputStream by opening a connection to an actual file, the file named by the path name name in the file system.

    读取一个字节

    public class FileInputStreamDemo01 {
        public static void main(String[] args) throws IOException {
            FileInputStream fis = new FileInputStream("src\\dailyioStream\\fos.txt");
            int read = fis.read();
            System.out.println(read);
            fis.close();
        }
    }
    

    循环读取该文件全部内容

    package dailyioStream;
    
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.IOException;
    
    public class FileInputStreamDemo01 {
        public static void main(String[] args) throws IOException {
            FileInputStream fis = new FileInputStream("src\\dailyioStream\\fos.txt");
            int read = fis.read();
            while(read !=-1){
                System.out.print((char) read);
                read = fis.read();
            }
            fis.close();
        }
    }
    
    

    优化:
    while((read=fis.read()) !=-1)
    1.fis.read()
    2.read=fis.read()
    3.read != -1

    public class FileInputStreamDemo01 {
        public static void main(String[] args) throws IOException {
            FileInputStream fis = new FileInputStream("src\\dailyioStream\\fos.txt");
            int read;
            while((read=fis.read()) !=-1){
                System.out.print((char) read);
            }
            fis.close();
        }
    }
    
    

    案例:复制文本文件

    需求:把”E:\it\java.txt“复制到模块目录下的”java.txt“

    分析:
    1、复制文本文件,其实就是把文本文件的内容从一个文件中读取出来(数据源),然后写入到另外一个文件中(目的地)
    2、数据源:
    ”E:\it\java.txt“—读数据—InputStream—FileInputStream
    3、目的地:
    “src\dailyioStream\java.txt”—写数据—OutputStream—FileOutputStream

    思路:
    1、根本数据源创建字节输入流对象
    2、根据目的地创建字节输出流对象
    3、读写数据,复制文本文件(一次读取一个字节,一次写入一个字节)

    package dailyioStream;
    
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.IOException;
    
    public class CopyTxtDemo {
        public static void main(String[] args) throws IOException {
            FileInputStream fis = new FileInputStream("C:\\Users\\n\\Desktop\\personal\\javaDemo\\java\\案例.txt");
            FileOutputStream fos = new FileOutputStream("src\\dailyioStream\\fos.txt");
    
            int bys;
            bys = fis.read();
            while ((bys=fis.read()) != -1){
                fos.write(bys);
            }
            fis.close();
            fos.close();
        }
    }
    
    

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

    //待续

    更多相关内容
  • 1. 什么是流 ...Java中基本的两个字节流类是InputStream和OutputStream,它们分别代表了组基本的输入字节流和输出字节流。InputStream类与OutputStream类均为抽象类,我们在实际使用中通常使用Java类库中提
  • 主要为大家详细介绍了Java中字符流与字节流的区别,这两个的概念易混淆,今天就为大家进行详细区分,感兴趣的小伙伴们可以参考一下
  • 图片转换成字节流先要转换的IMage对象,转换之后返回字节流。字节流转换成图片,要转换的字节流,转换得到的Image对象,根据图片路径返回图片的字节流,感兴趣的朋友看下下面的代码。 C#将图片和字节流相互转换代码...
  • 本篇文章主要介绍了Java的IO流分为字符流(Reader,Writer)和字节流(InputStream,OutputStream),字节流顾名思义字节流就是将文件的内容读取到字节数组,对初学者很有用,有需要的朋友可以了解一下。
  • 主要为大家详细介绍了Java socket字节流传输示例,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 字节流工具

    2019-02-19 15:14:58
    字节流工具,将流另存为文件、InputStream 转为 byte、byte 转为 InputStream
  • Java 流在处理上分为字符流和字节流。字符流处理的单元为 2 个字节的 Unicode 字符,分别操作字符、字符数组或字符串,而字节流处理单元为 1 个字节,操作字节和字节数组。 Java 内用 Unicode 编码存储字符,字符流...
  • 【Java基础-3】吃透Java IO:字节流、字符流、缓冲流

    万次阅读 多人点赞 2020-09-23 20:12:33
    什么是Java-IO?字符流和字节流的区别与适用场景是什么?缓冲流到底实现了什么?如何高效地读写文件? 本文用大量的示例图和实例,带你吃透Java IO。

    前言

    有人曾问fastjson的作者(阿里技术专家高铁):“你开发fastjson,没得到什么好处,反而挨了骂背了锅,这种事情你为什么要做呢?”

    高铁答道:“因为热爱本身,就是奖励啊!”

    这个回答顿时触动了我。想想自己,又何尝不是如此。写作是个痛苦的过程,用心写作就更加煎熬,需字字斟酌,反复删改才有所成。然而,当一篇篇精良文章出自己手而呈现眼前时,那些痛苦煎熬就都那么值得。如果这些博文能有幸得大家阅读和认可,就更加是莫大的鼓舞了。技术人的快乐就是可以这么纯粹和简单。

    点波关注不迷路,一键三连好运连连!

    IO流是Java中的一个重要构成部分,也是我们经常打交道的。这篇关于Java IO的博文干货满满,堪称全网前三(请轻喷!)

    下面几个问题(问题还会继续补充),如果你能对答如流,那么恭喜你,IO知识掌握得很好,可以立即关闭文章。反之,你可以在后面得文章中寻找答案。

    1. Java IO流有什么特点?
    2. Java IO流分为几种类型?
    3. 字节流和字符流的关系与区别?
    4. 字符流是否使用了缓冲?
    5. 缓冲流的效率一定高吗?为什么?
    6. 缓冲流体现了Java中的哪种设计模式思想?
    7. 为什么要实现序列化?如何实现序列化?
    8. 序列化数据后,再次修改类文件,读取数据会出问题,如何解决呢?

    1 初识Java IO

    IO,即inout,也就是输入和输出,指应用程序和外部设备之间的数据传递,常见的外部设备包括文件、管道、网络连接。

    Java 中是通过流处理IO 的,那么什么是流

    流(Stream),是一个抽象的概念,是指一连串的数据(字符或字节),是以先进先出的方式发送信息的通道。

    当程序需要读取数据的时候,就会开启一个通向数据源的流,这个数据源可以是文件,内存,或是网络连接。类似的,当程序需要写入数据的时候,就会开启一个通向目的地的流。这时候你就可以想象数据好像在这其中“流”动一样。

    一般来说关于流的特性有下面几点:

    1. 先进先出:最先写入输出流的数据最先被输入流读取到。
    2. 顺序存取:可以一个接一个地往流中写入一串字节,读出时也将按写入顺序读取一串字节,不能随机访问中间的数据。(RandomAccessFile除外)
    3. 只读或只写:每个流只能是输入流或输出流的一种,不能同时具备两个功能,输入流只能进行读操作,对输出流只能进行写操作。在一个数据传输通道中,如果既要写入数据,又要读取数据,则要分别提供两个流。

    1.1 IO流分类

    IO流主要的分类方式有以下3种:

    1. 按数据流的方向:输入流、输出流
    2. 按处理数据单位:字节流、字符流
    3. 按功能:节点流、处理流

    在这里插入图片描述

    1、输入流与输出流

    输入与输出是相对于应用程序而言的,比如文件读写,读取文件是输入流,写文件是输出流,这点很容易搞反。

    在这里插入图片描述
    2、字节流与字符流

    字节流和字符流的用法几乎完成全一样,区别在于字节流和字符流所操作的数据单元不同,字节流操作的单元是数据单元是8位的字节,字符流操作的是数据单元为16位的字符。

    为什么要有字符流?

    Java中字符是采用Unicode标准,Unicode 编码中,一个英文字母或一个中文汉字为两个字节。
    在这里插入图片描述
    而在UTF-8编码中,一个中文字符是3个字节。例如下面图中,“云深不知处”5个中文对应的是15个字节:-28-70-111-26-73-79-28-72-115-25-97-91-27-92-124
    在这里插入图片描述

    那么问题来了,如果使用字节流处理中文,如果一次读写一个字符对应的字节数就不会有问题,一旦将一个字符对应的字节分裂开来,就会出现乱码了。为了更方便地处理中文这些字符,Java就推出了字符流。

    字节流和字符流的其他区别:

    1. 字节流一般用来处理图像、视频、音频、PPT、Word等类型的文件。字符流一般用于处理纯文本类型的文件,如TXT文件等,但不能处理图像视频等非文本文件。用一句话说就是:字节流可以处理一切文件,而字符流只能处理纯文本文件。
    2. 字节流本身没有缓冲区,缓冲字节流相对于字节流,效率提升非常高。而字符流本身就带有缓冲区,缓冲字符流相对于字符流效率提升就不是那么大了。详见文末效率对比。

    以写文件为例,我们查看字符流的源码,发现确实有利用到缓冲区:
    在这里插入图片描述
    在这里插入图片描述

    3、节点流和处理流

    节点流:直接操作数据读写的流类,比如FileInputStream

    处理流:对一个已存在的流的链接和封装,通过对数据进行处理为程序提供功能强大、灵活的读写功能,例如BufferedInputStream(缓冲字节流)

    处理流和节点流应用了Java的装饰者设计模式。

    下图就很形象地描绘了节点流和处理流,处理流是对节点流的封装,最终的数据处理还是由节点流完成的。
    在这里插入图片描述
    在诸多处理流中,有一个非常重要,那就是缓冲流

    我们知道,程序与磁盘的交互相对于内存运算是很慢的,容易成为程序的性能瓶颈。减少程序与磁盘的交互,是提升程序效率一种有效手段。缓冲流,就应用这种思路:普通流每次读写一个字节,而缓冲流在内存中设置一个缓存区,缓冲区先存储足够的待操作数据后,再与内存或磁盘进行交互。这样,在总数据量不变的情况下,通过提高每次交互的数据量,减少了交互次数。
    在这里插入图片描述

    联想一下生活中的例子,我们搬砖的时候,一块一块地往车上装肯定是很低效的。我们可以使用一个小推车,先把砖装到小推车上,再把这小推车推到车前,把砖装到车上。这个例子中,小推车可以视为缓冲区,小推车的存在,减少了我们装车次数,从而提高了效率。
    在这里插入图片描述
    需要注意的是,缓冲流效率一定高吗?不一定,某些情形下,缓冲流效率反而更低,具体请见IO流效率对比。

    完整的IO分类图如下:
    在这里插入图片描述

    1.2 案例实操

    接下来,我们看看如何使用Java IO。

    文本读写的例子,也就是文章开头所说的,将“松下问童子,言师采药去。只在此山中,云深不知处。”写入本地文本,然后再从文件读取内容并输出到控制台。

    1、FileInputStream、FileOutputStream(字节流)

    字节流的方式效率较低,不建议使用

    public class IOTest {
    	public static void main(String[] args) throws IOException {
    		File file = new File("D:/test.txt");
    
    		write(file);
    		System.out.println(read(file));
    	}
    
    	public static void write(File file) throws IOException {
    		OutputStream os = new FileOutputStream(file, true);
    
    		// 要写入的字符串
    		String string = "松下问童子,言师采药去。只在此山中,云深不知处。";
    		// 写入文件
    		os.write(string.getBytes());
    		// 关闭流
    		os.close();
    	}
    
    	public static String read(File file) throws IOException {
    		InputStream in = new FileInputStream(file);
    
    		// 一次性取多少个字节
    		byte[] bytes = new byte[1024];
    		// 用来接收读取的字节数组
    		StringBuilder sb = new StringBuilder();
    		// 读取到的字节数组长度,为-1时表示没有数据
    		int length = 0;
    		// 循环取数据
    		while ((length = in.read(bytes)) != -1) {
    			// 将读取的内容转换成字符串
    			sb.append(new String(bytes, 0, length));
    		}
    		// 关闭流
    		in.close();
    
    		return sb.toString();
    	}
    }
    

    2、BufferedInputStream、BufferedOutputStream(缓冲字节流)

    缓冲字节流是为高效率而设计的,真正的读写操作还是靠FileOutputStreamFileInputStream,所以其构造方法入参是这两个类的对象也就不奇怪了。

    public class IOTest {
    
    	public static void write(File file) throws IOException {
    		// 缓冲字节流,提高了效率
    		BufferedOutputStream bis = new BufferedOutputStream(new FileOutputStream(file, true));
    
    		// 要写入的字符串
    		String string = "松下问童子,言师采药去。只在此山中,云深不知处。";
    		// 写入文件
    		bis.write(string.getBytes());
    		// 关闭流
    		bis.close();
    	}
    
    	public static String read(File file) throws IOException {
    		BufferedInputStream fis = new BufferedInputStream(new FileInputStream(file));
    
    		// 一次性取多少个字节
    		byte[] bytes = new byte[1024];
    		// 用来接收读取的字节数组
    		StringBuilder sb = new StringBuilder();
    		// 读取到的字节数组长度,为-1时表示没有数据
    		int length = 0;
    		// 循环取数据
    		while ((length = fis.read(bytes)) != -1) {
    			// 将读取的内容转换成字符串
    			sb.append(new String(bytes, 0, length));
    		}
    		// 关闭流
    		fis.close();
    
    		return sb.toString();
    	}
    }
    

    3、InputStreamReader、OutputStreamWriter(字符流)

    字符流适用于文本文件的读写OutputStreamWriter类其实也是借助FileOutputStream类实现的,故其构造方法是FileOutputStream的对象

    public class IOTest {
    	
    	public static void write(File file) throws IOException {
    		// OutputStreamWriter可以显示指定字符集,否则使用默认字符集
    		OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(file, true), "UTF-8");
    
    		// 要写入的字符串
    		String string = "松下问童子,言师采药去。只在此山中,云深不知处。";
    		osw.write(string);
    		osw.close();
    	}
    
    	public static String read(File file) throws IOException {
    		InputStreamReader isr = new InputStreamReader(new FileInputStream(file), "UTF-8");
    		// 字符数组:一次读取多少个字符
    		char[] chars = new char[1024];
    		// 每次读取的字符数组先append到StringBuilder中
    		StringBuilder sb = new StringBuilder();
    		// 读取到的字符数组长度,为-1时表示没有数据
    		int length;
    		// 循环取数据
    		while ((length = isr.read(chars)) != -1) {
    			// 将读取的内容转换成字符串
    			sb.append(chars, 0, length);
    		}
    		// 关闭流
    		isr.close();
    
    		return sb.toString()
    	}
    }
    

    4、字符流便捷类

    Java提供了FileWriterFileReader简化字符流的读写,new FileWriter等同于new OutputStreamWriter(new FileOutputStream(file, true))

    public class IOTest {
    	
    	public static void write(File file) throws IOException {
    		FileWriter fw = new FileWriter(file, true);
    
    		// 要写入的字符串
    		String string = "松下问童子,言师采药去。只在此山中,云深不知处。";
    		fw.write(string);
    		fw.close();
    	}
    
    	public static String read(File file) throws IOException {
    		FileReader fr = new FileReader(file);
    		// 一次性取多少个字节
    		char[] chars = new char[1024];
    		// 用来接收读取的字节数组
    		StringBuilder sb = new StringBuilder();
    		// 读取到的字节数组长度,为-1时表示没有数据
    		int length;
    		// 循环取数据
    		while ((length = fr.read(chars)) != -1) {
    			// 将读取的内容转换成字符串
    			sb.append(chars, 0, length);
    		}
    		// 关闭流
    		fr.close();
    
    		return sb.toString();
    	}
    }
    

    5、BufferedReader、BufferedWriter(字符缓冲流)

    public class IOTest {
    	
    	public static void write(File file) throws IOException {
    		// BufferedWriter fw = new BufferedWriter(new OutputStreamWriter(new
    		// FileOutputStream(file, true), "UTF-8"));
    		// FileWriter可以大幅度简化代码
    		BufferedWriter bw = new BufferedWriter(new FileWriter(file, true));
    
    		// 要写入的字符串
    		String string = "松下问童子,言师采药去。只在此山中,云深不知处。";
    		bw.write(string);
    		bw.close();
    	}
    
    	public static String read(File file) throws IOException {
    		BufferedReader br = new BufferedReader(new FileReader(file));
    		// 用来接收读取的字节数组
    		StringBuilder sb = new StringBuilder();
    
    		// 按行读数据
    		String line;
    		// 循环取数据
    		while ((line = br.readLine()) != null) {
    			// 将读取的内容转换成字符串
    			sb.append(line);
    		}
    		// 关闭流
    		br.close();
    
    		return sb.toString();
    	}
    }
    

    2 IO流对象

    第一节中,我们大致了解了IO,并完成了几个案例,但对IO还缺乏更详细的认知,那么接下来我们就对Java IO细细分解,梳理出完整的知识体系来。

    Java种提供了40多个类,我们只需要详细了解一下其中比较重要的就可以满足日常应用了。

    2.1 File类

    File类是用来操作文件的类,但它不能操作文件中的数据。

    public class File extends Object implements Serializable, Comparable<File>
    

    File类实现了SerializableComparable<File>,说明它是支持序列化和排序的。

    File类的构造方法

    方法名说明
    File(File parent, String child)根据 parent 抽象路径名和 child 路径名字符串创建一个新 File 实例。
    File(String pathname)通过将给定路径名字符串转换为抽象路径名来创建一个新 File 实例。
    File(String parent, String child)根据 parent 路径名字符串和 child 路径名字符串创建一个新 File 实例。
    File(URI uri)通过将给定的 file: URI 转换为一个抽象路径名来创建一个新的 File 实例。

    File类的常用方法

    方法说明
    createNewFile()当且仅当不存在具有此抽象路径名指定名称的文件时,不可分地创建一个新的空文件。
    delete()删除此抽象路径名表示的文件或目录。
    exists()测试此抽象路径名表示的文件或目录是否存在。
    getAbsoluteFile()返回此抽象路径名的绝对路径名形式。
    getAbsolutePath()返回此抽象路径名的绝对路径名字符串。
    length()返回由此抽象路径名表示的文件的长度。
    mkdir()创建此抽象路径名指定的目录。

    File类使用实例

    public class FileTest {
    	public static void main(String[] args) throws IOException {
    		File file = new File("C:/Mu/fileTest.txt");
    
    		// 判断文件是否存在
    		if (!file.exists()) {
    			// 不存在则创建
    			file.createNewFile();
    		}
    		System.out.println("文件的绝对路径:" + file.getAbsolutePath());
    		System.out.println("文件的大小:" + file.length());
    
    		// 刪除文件
    		file.delete();
    	}
    }
    

    2.2 字节流

    InputStreamOutputStream是两个抽象类,是字节流的基类,所有具体的字节流实现类都是分别继承了这两个类。

    InputStream为例,它继承了Object,实现了Closeable

    public abstract class InputStream
    extends Object
    implements Closeable
    

    InputStream类有很多的实现子类,下面列举了一些比较常用的:
    在这里插入图片描述
    详细说明一下上图中的类:

    1. InputStreamInputStream是所有字节输入流的抽象基类,前面说过抽象类不能被实例化,实际上是作为模板而存在的,为所有实现类定义了处理输入流的方法。
    2. FileInputSream:文件输入流,一个非常重要的字节输入流,用于对文件进行读取操作。
    3. PipedInputStream:管道字节输入流,能实现多线程间的管道通信。
    4. ByteArrayInputStream:字节数组输入流,从字节数组(byte[])中进行以字节为单位的读取,也就是将资源文件都以字节的形式存入到该类中的字节数组中去。
    5. FilterInputStream:装饰者类,具体的装饰者继承该类,这些类都是处理类,作用是对节点类进行封装,实现一些特殊功能。
    6. DataInputStream:数据输入流,它是用来装饰其它输入流,作用是“允许应用程序以与机器无关方式从底层输入流中读取基本 Java 数据类型”。
    7. BufferedInputStream:缓冲流,对节点流进行装饰,内部会有一个缓存区,用来存放字节,每次都是将缓存区存满然后发送,而不是一个字节或两个字节这样发送,效率更高。
    8. ObjectInputStream:对象输入流,用来提供对基本数据或对象的持久存储。通俗点说,也就是能直接传输对象,通常应用在反序列化中。它也是一种处理流,构造器的入参是一个InputStream的实例对象。

    OutputStream类继承关系图:
    在这里插入图片描述

    OutputStream类继承关系与InputStream类似,需要注意的是PrintStream.

    2.3 字符流

    与字节流类似,字符流也有两个抽象基类,分别是ReaderWriter。其他的字符流实现类都是继承了这两个类。

    Reader为例,它的主要实现子类如下图:
    在这里插入图片描述
    各个类的详细说明:

    1. InputStreamReader:从字节流到字符流的桥梁(InputStreamReader构造器入参是FileInputStream的实例对象),它读取字节并使用指定的字符集将其解码为字符。它使用的字符集可以通过名称指定,也可以显式给定,或者可以接受平台的默认字符集。
    2. BufferedReader:从字符输入流中读取文本,设置一个缓冲区来提高效率。BufferedReader是对InputStreamReader的封装,前者构造器的入参就是后者的一个实例对象。
    3. FileReader:用于读取字符文件的便利类,new FileReader(File file)等同于new InputStreamReader(new FileInputStream(file, true),"UTF-8"),但FileReader不能指定字符编码和默认字节缓冲区大小。
    4. PipedReader :管道字符输入流。实现多线程间的管道通信。
    5. CharArrayReader:从Char数组中读取数据的介质流。
    6. StringReader :从String中读取数据的介质流。

    WriterReader结构类似,方向相反,不再赘述。唯一有区别的是,Writer的子类PrintWriter

    2.4 序列化

    待续…

    3 IO流方法

    3.1 字节流方法

    字节输入流InputStream主要方法:

    • read() :从此输入流中读取一个数据字节。
    • read(byte[] b) :从此输入流中将最多 b.length 个字节的数据读入一个 byte 数组中。
    • read(byte[] b, int off, int len) :从此输入流中将最多 len 个字节的数据读入一个 byte 数组中。
    • close():关闭此输入流并释放与该流关联的所有系统资源。

    字节输出流OutputStream主要方法:

    • write(byte[] b) :将 b.length 个字节从指定 byte 数组写入此文件输出流中。
    • write(byte[] b, int off, int len) :将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此文件输出流。
    • write(int b) :将指定字节写入此文件输出流。
    • close() :关闭此输入流并释放与该流关联的所有系统资源。

    3.2 字符流方法

    字符输入流Reader主要方法:

    • read():读取单个字符。
    • read(char[] cbuf) :将字符读入数组。
    • read(char[] cbuf, int off, int len) : 将字符读入数组的某一部分。
    • read(CharBuffer target) :试图将字符读入指定的字符缓冲区。
    • flush() :刷新该流的缓冲。
    • close() :关闭此流,但要先刷新它。

    字符输出流Writer主要方法:

    • write(char[] cbuf) :写入字符数组。
    • write(char[] cbuf, int off, int len) :写入字符数组的某一部分。
    • write(int c) :写入单个字符。
    • write(String str) :写入字符串。
    • write(String str, int off, int len) :写入字符串的某一部分。
    • flush() :刷新该流的缓冲。
    • close() :关闭此流,但要先刷新它。

    另外,字符缓冲流还有两个独特的方法:

    • BufferedWriternewLine()写入一个行分隔符。这个方法会自动适配所在系统的行分隔符。
    • BufferedReaderreadLine() :读取一个文本行。

    4 附加内容

    4.1 位、字节、字符

    字节(Byte)是计量单位,表示数据量多少,是计算机信息技术用于计量存储容量的一种计量单位,通常情况下一字节等于八位。

    字符(Character)计算机中使用的字母、数字、字和符号,比如’A’、‘B’、’$’、’&'等。

    一般在英文状态下一个字母或字符占用一个字节,一个汉字用两个字节表示。

    字节与字符:

    • ASCII 码中,一个英文字母(不分大小写)为一个字节,一个中文汉字为两个字节。
    • UTF-8 编码中,一个英文字为一个字节,一个中文为三个字节。
    • Unicode 编码中,一个英文为一个字节,一个中文为两个字节。
    • 符号:英文标点为一个字节,中文标点为两个字节。例如:英文句号 . 占1个字节的大小,中文句号 。占2个字节的大小。
    • UTF-16 编码中,一个英文字母字符或一个汉字字符存储都需要 2 个字节(Unicode 扩展区的一些汉字存储需要 4 个字节)。
    • UTF-32 编码中,世界上任何字符的存储都需要 4 个字节。

    4.2 IO流效率对比

    首先,对比下普通字节流和缓冲字节流的效率:

    public class MyTest {
    	public static void main(String[] args) throws IOException {
    		File file = new File("C:/Mu/test.txt");
    		StringBuilder sb = new StringBuilder();
    
    		for (int i = 0; i < 3000000; i++) {
    			sb.append("abcdefghigklmnopqrstuvwsyz");
    		}
    		byte[] bytes = sb.toString().getBytes();
    
    		long start = System.currentTimeMillis();
    		write(file, bytes);
    		long end = System.currentTimeMillis();
    
    		long start2 = System.currentTimeMillis();
    		bufferedWrite(file, bytes);
    		long end2 = System.currentTimeMillis();
    
    		System.out.println("普通字节流耗时:" + (end - start) + " ms");
    		System.out.println("缓冲字节流耗时:" + (end2 - start2) + " ms");
    
    	}
    
    	// 普通字节流
    	public static void write(File file, byte[] bytes) throws IOException {
    		OutputStream os = new FileOutputStream(file);
    		os.write(bytes);
    		os.close();
    	}
    
    	// 缓冲字节流
    	public static void bufferedWrite(File file, byte[] bytes) throws IOException {
    		BufferedOutputStream bo = new BufferedOutputStream(new FileOutputStream(file));
    		bo.write(bytes);
    		bo.close();
    	}
    }
    

    运行结果:

    普通字节流耗时:250 ms
    缓冲字节流耗时:268 ms
    

    这个结果让我大跌眼镜,不是说好缓冲流效率很高么?要知道为什么,只能去源码里找答案了。翻看字节缓冲流的write方法:

    public synchronized void write(byte b[], int off, int len) throws IOException {
        if (len >= buf.length) {
            /* If the request length exceeds the size of the output buffer,
               flush the output buffer and then write the data directly.
               In this way buffered streams will cascade harmlessly. */
            flushBuffer();
            out.write(b, off, len);
            return;
        }
        if (len > buf.length - count) {
            flushBuffer();
        }
        System.arraycopy(b, off, buf, count, len);
        count += len;
    }
    

    注释里说得很明白:如果请求长度超过输出缓冲区的大小,刷新输出缓冲区,然后直接写入数据。这样,缓冲流将无害地级联。

    但是,至于为什么这么设计,我没有想明白,有哪位明白的大佬可以留言指点一下。

    基于上面的情形,要想对比普通字节流和缓冲字节流的效率差距,就要避免直接读写较长的字符串,于是,设计了下面这个对比案例:用字节流和缓冲字节流分别复制文件。

    public class MyTest {
    	public static void main(String[] args) throws IOException {
    		File data = new File("C:/Mu/data.zip");
    		File a = new File("C:/Mu/a.zip");
    		File b = new File("C:/Mu/b.zip");
    
    		StringBuilder sb = new StringBuilder();
    
    		long start = System.currentTimeMillis();
    		copy(data, a);
    		long end = System.currentTimeMillis();
    
    		long start2 = System.currentTimeMillis();
    		bufferedCopy(data, b);
    		long end2 = System.currentTimeMillis();
    
    		System.out.println("普通字节流耗时:" + (end - start) + " ms");
    		System.out.println("缓冲字节流耗时:" + (end2 - start2) + " ms");
    	}
    
    	// 普通字节流
    	public static void copy(File in, File out) throws IOException {
    		// 封装数据源
    		InputStream is = new FileInputStream(in);
    		// 封装目的地
    		OutputStream os = new FileOutputStream(out);
    		
    		int by = 0;
    		while ((by = is.read()) != -1) {
    			os.write(by);
    		}
    		is.close();
    		os.close();
    	}
    
    	// 缓冲字节流
    	public static void bufferedCopy(File in, File out) throws IOException {
    		// 封装数据源
    		BufferedInputStream bi = new BufferedInputStream(new FileInputStream(in));
    		// 封装目的地
    		BufferedOutputStream bo = new BufferedOutputStream(new FileOutputStream(out));
    		
    		int by = 0;
    		while ((by = bi.read()) != -1) {
    			bo.write(by);
    		}
    		bo.close();
    		bi.close();
    	}
    }
    

    运行结果:

    普通字节流耗时:184867 ms
    缓冲字节流耗时:752 ms
    

    这次,普通字节流和缓冲字节流的效率差异就很明显了,达到了245倍。

    再看看字符流和缓冲字符流的效率对比:

    public class IOTest {
    	public static void main(String[] args) throws IOException {
    		// 数据准备
    		dataReady();
    
    		File data = new File("C:/Mu/data.txt");
    		File a = new File("C:/Mu/a.txt");
    		File b = new File("C:/Mu/b.txt");
    		File c = new File("C:/Mu/c.txt");
    
    		long start = System.currentTimeMillis();
    		copy(data, a);
    		long end = System.currentTimeMillis();
    
    		long start2 = System.currentTimeMillis();
    		copyChars(data, b);
    		long end2 = System.currentTimeMillis();
    
    		long start3 = System.currentTimeMillis();
    		bufferedCopy(data, c);
    		long end3 = System.currentTimeMillis();
    
    		System.out.println("普通字节流1耗时:" + (end - start) + " ms,文件大小:" + a.length() / 1024 + " kb");
    		System.out.println("普通字节流2耗时:" + (end2 - start2) + " ms,文件大小:" + b.length() / 1024 + " kb");
    		System.out.println("缓冲字节流耗时:" + (end3 - start3) + " ms,文件大小:" + c.length() / 1024 + " kb");
    	}
    
    	// 普通字符流不使用数组
    	public static void copy(File in, File out) throws IOException {
    		Reader reader = new FileReader(in);
    		Writer writer = new FileWriter(out);
    
    		int ch = 0;
    		while ((ch = reader.read()) != -1) {
    			writer.write((char) ch);
    		}
    		reader.close();
    		writer.close();
    	}
    
    	// 普通字符流使用字符流
    	public static void copyChars(File in, File out) throws IOException {
    		Reader reader = new FileReader(in);
    		Writer writer = new FileWriter(out);
    
    		char[] chs = new char[1024];
    		while ((reader.read(chs)) != -1) {
    			writer.write(chs);
    		}
    		reader.close();
    		writer.close();
    	}
    
    	// 缓冲字符流
    	public static void bufferedCopy(File in, File out) throws IOException {
    		BufferedReader br = new BufferedReader(new FileReader(in));
    		BufferedWriter bw = new BufferedWriter(new FileWriter(out));
    
    		String line = null;
    		while ((line = br.readLine()) != null) {
    			bw.write(line);
    			bw.newLine();
    			bw.flush();
    		}
    
    		// 释放资源
    		bw.close();
    		br.close();
    	}
    
    	// 数据准备
    	public static void dataReady() throws IOException {
    		StringBuilder sb = new StringBuilder();
    		for (int i = 0; i < 600000; i++) {
    			sb.append("abcdefghijklmnopqrstuvwxyz");
    		}
    		OutputStream os = new FileOutputStream(new File("C:/Mu/data.txt"));
    		os.write(sb.toString().getBytes());
    
    		os.close();
    		System.out.println("完毕");
    	}
    }
    

    运行结果:

    普通字符流1耗时:1337 ms,文件大小:15234 kb
    普通字符流2耗时:82 ms,文件大小:15235 kb
    缓冲字符流耗时:205 ms,文件大小:15234 kb
    

    测试多次,结果差不多,可见字符缓冲流效率上并没有明显提高,我们更多的是要使用它的readLine()newLine()方法。

    4.3 NIO

    待续…

    展开全文
  • lua 字节流操作

    2018-10-22 11:30:46
    非常方便的字节操作插件 可用于网络消息解包压包,字节组装 协议传输
  • 字节流生成word文档

    2019-05-04 02:05:14
    NULL 博文链接:https://yuhuiblog695685688425687986842568269.iteye.com/blog/2433333
  • 字节流

    千次阅读 2021-02-15 20:40:26
    字节流 1. IO的分类 根据数据的流向分为:输入流和输出流。 输入流 :把数据从其他设备上读取到内存中的流。 输出流 :把数据从内存 中写出到其他设备上的流。 格局数据的类型分为:字节流和字符流。 字节流 :以...

    字节流

    根据数据的流向分为:输入流输出流

    • 输入流 :把数据从其他设备上读取到内存中的流。
    • 输出流 :把数据从内存 中写出到其他设备上的流。
      格局数据的类型分为:字节流字符流
    • 字节流 :以字节为单位,读写数据的流。
    • 字符流 :以字符为单位,读写数据的流。
    输入流输出流
    字节流字节输入流
    InputStream
    字节输出流
    OutputStream
    字符流字符输入流
    Reader
    字符输出流
    Writer

    1. 字节输出流OutputStream

    java.io.OutputStream抽象类是表示字节输出流的所有类的超类,将指定的字节信息写出到目的地。它定义了字节输出流的基本共性功能方法。

    • public void close() :关闭此输出流并释放与此流相关联的任何系统资源。
    • public void flush() :刷新此输出流并强制任何缓冲的输出字节被写出。
    • public void write(byte[] b):将 b.length字节从指定的字节数组写入此输出流。
    • public void write(byte[] b, int off, int len) :从指定的字节数组写入 len字节,从偏移量 off开始输出到此输出流。
    • public abstract void write(int b) :将指定的字节输出流。

    close方法,当完成流的操作时,必须调用此方法,释放系统资源。

    1.1 FileOutputStream extends OutputStream

    1.1.1 构造方法

    • public FileOutputStream(File file):创建文件输出流以写入由指定的 File对象表示的文件。
    • public FileOutputStream(String name): 创建文件输出流以指定的名称写入文件。
      当你创建一个流对象时,必须传入一个文件路径。该路径下,如果没有这个文件,会创建该文件。如果有这个文件,会清空这个文件的数据。

    未开始

    package com.itheima.demo01.OutputStream;
    
    import java.io.File;
    import java.io.FileOutputStream;
    import java.io.IOException;
    
    public class Demo01OutputStream {
        public static void main(String[] args) throws IOException {
            File file = new File("a.txt");
            FileOutputStream fos = new FileOutputStream(file);//同FileOutputStream fos = new FileOutputStream("a.txt");
            fos.write(97);
            fos.close();
        }
    }
    

    运行结果
    运行之后产生新文件
    将“a”写入新文件

    1.1.2 write

    1. write();
    2. write(byte[] b);
      未运行
    package com.itheima.demo01.OutputStream;
    
    import java.io.File;
    import java.io.FileOutputStream;
    import java.io.IOException;
    
    
    public class Demo02OutputStream {
        public static void main(String[] args) throws IOException {
            FileOutputStream fos = new FileOutputStream(new File("b.txt"));
            byte[] bytes = "你好,世界".getBytes();
            fos.write(bytes);
            fos.close();
        }
    }
    

    运行结果
    运行结果

    1. write(byte[] b,int off,int len);
    package com.itheima.demo01.OutputStream;
    
    import java.io.FileOutputStream;
    import java.io.IOException;
    
    public class Demo03OutputStream {
        public static void main(String[] args) throws IOException {
            FileOutputStream fos = new FileOutputStream("b.txt");
            byte[] bytes = {65, 66, 67, 68, 69};//A B C D E
            fos.write(bytes, 1, 2);//B C
            fos.close();
        }
    }
    

    运行结果
    运行结果

    1.1.3 数据追加续写

    • public FileOutputStream(File file, boolean append): 创建文件输出流以写入由指定的 File对象表示的文件。
    • public FileOutputStream(String name, boolean append): 创建文件输出流以指定的名称写入文件。

    这两个构造方法,参数中都需要传入一个boolean类型的值,true 表示追加数据,false 表示清空原有数据。
    未运行

    package com.itheima.demo01.OutputStream;
    
    import java.io.*;
    
    public class Demo04OutputStream {
        public static void main(String[] args) throws IOException {
            FileOutputStream fos = new FileOutputStream("c.txt", true);
            /*追加写10个"你好",并进行换行处理*/
            for (int i = 0; i < 10; i++) {
                fos.write("\n".getBytes());
                fos.write("你好".getBytes());
            }
        }
    }
    

    运行结果
    运行后

    2. 字节输入流InputStream

    java.io.InputStream抽象类是表示字节输入流的所有类的超类,可以读取字节信息到内存中。它定义了字节输入流的基本共性功能方法。

    • public void close() :关闭此输入流并释放与此流相关联的任何系统资源。
    • public abstract int read(): 从输入流读取数据的下一个字节。
    • public int read(byte[] b): 从输入流中读取一些字节数,并将它们存储到字节数组 b中 。

    close方法,当完成流的操作时,必须调用此方法,释放系统资源。

    2.1 FileInputStream extends InputStream

    2.1.1 构造方法

    1. FileInputStream(File file): 通过打开与实际文件的连接来创建一个 FileInputStream ,该文件由文件系统中的 File对象 file命名。
    2. FileInputStream(String name): 通过打开与实际文件的连接来创建一个 FileInputStream ,该文件由文件系统中的路径名 name命名。

    2.1.2 read

    1. read();
      读取字节,将解释为int,读取到-1结束
      运行前
    package com.itheima.demo02.InputStream;
    
    import java.io.FileInputStream;
    import java.io.IOException;
    
    public class Demo01InputStream {
        public static void main(String[] args) throws IOException {
            FileInputStream fis = new FileInputStream("d.txt");
            int len;
            while ((len = fis.read()) != -1) {
                System.out.print((char) len);
            }
            fis.close();
        }
    }
    

    运行结果

    The way you live is closely mirrored in the world you see.

    1. read(byte[] b);每次读取b的长度个字节到数组中,返回读取到的有效字节个数,读取到末尾时,返回-1读取原理
    package com.itheima.demo02.InputStream;
    
    import java.io.FileInputStream;
    import java.io.IOException;
    
    public class Demo02InputStream {
        public static void main(String[] args) throws IOException {
            FileInputStream fis = new FileInputStream("d.txt");
            byte[] bytes = new byte[2];
            int len;
            while ((len = fis.read(bytes)) != -1) {
                System.out.println(new String(bytes, 0, len));
            }
            fis.close();
        }
    }
    

    运行结果

    Th
    e
    wa
    y
    yo
    u
    li
    ve
    i
    s
    cl
    os
    el
    y
    mi
    rr
    or
    ed
    i
    n
    th
    e
    wo
    rl
    d
    yo
    u
    se
    e.

    使用数组读取,每次读取多个字节,减少了系统间的IO操作次数,从而提高了读写的效率,建议开发中使用。

    展开全文
  • Java实现字节流与图片的转化Java源码
  • 字节流和字符流详解

    千次阅读 多人点赞 2021-03-29 20:21:21
    1.流的概念 在编程中是一种抽象的概念,就好比“水流”,从一段流向另一端 在程序中所有的数据都是以流的方式进行传输或保存的,程序需要数据的时候要使用输入流...字节流: 它处理单元为1个字节(byte),操作字节和

    1.流的概念

    • 在编程中是一种抽象的概念,就好比“水流”,从一段流向另一端
    • 在程序中所有的数据都是以流的方式进行传输或保存的,程序需要数据的时候要使用输入流读取数据,而当程序需要将一些数据保存起来的时候,就要使用输出流完成。
    • 程序中的输入输出都是以流的形式保存的,流中保存的实际上全都是字节文件。

    2.流的分类

    按照流向可以分为:输入流(如:键盘,麦克风),输出流(如:显示器,音箱)
    按照传输单位可以分为:字节流和字符流

    3.什么是字节流,什么是字符流

    字节流: 它处理单元为1个字节(byte),操作字节和字节数组,存储的是二进制文件,如果是音频文件、图片、歌曲,就用字节流好点(1byte = 8位);

    字符流: 它处理的单元为2个字节的Unicode字符,分别操作字符、字符数组或字符串,字符流是由Java虚拟机将字节转化为2个字节的Unicode字符为单位的字符而成的,如果是关系到中文(文本)的,用字符流好点(1Unicode = 2字节 = 16位);

    所有文件的储存是都是字节(byte)的储存,在磁盘上保留的并不是文件的字符而是先把字符编码成字节,再储存这些字节到磁盘。在读取文件(特别是文本文件)时,也是一个字节一个字节地读取以形成字节序列。

    字节流可用于任何类型的对象,包括二进制对象,而字符流只能处理字符或者字符串; 2. 字节流提供了处理任何类型的IO操作的功能,但它不能直接处理Unicode字符,而字符流就可以。

    字节流是最基本的,所有的InputStrem和OutputStream的子类都是,主要用在处理二进制数据,它是按字节来处理的 但实际中很多的数据是文本,又提出了字符流的概念,它是按虚拟机的encode来处理,也就是要进行字符集的转化 这两个之间通过 InputStreamReader,OutputStreamWriter来关联,实际上是通过byte[]和String来关联 在实际开发中出现的汉字问题实际上都是在字符流和字节流之间转化不统一而造成的

    最简单的区分字节流和字符流

    万物皆文件,那就将文件在记事本里面打开,如果打开后能看的懂的就是字符流,如果看不懂那就是字节流

    问题:
    1.word.doc 数据字节流还是字符流?
    答:.doc数据字节流。
    2.Excel 数据字节流还是字符流?
    答:要根据保存的格式进行判断,如果是保存为.csv那么他就是字符流,如果是其他的则数据字节流。

    字符和字节操作

    在这里插入图片描述
    如何简单记住字节流和字符流

    • 字符流是以Reader,Writer结尾的
    • 字符节流是以InputStream或OutputStream结尾的

    4.字节流的使用

    字节流主要是操作byte类型数据,以byte数组为准,主要操作类就是OutputStream、InputStream。

    字节输出流:OutputStream,OutputStream是整个IO包中字节输出流的最大父类

    Closeable表示可以关闭的操作

    示例为:图片的复制

    步骤:
    1.读入二进制文件(输入流,FileInputStream)
    2.写入二进制文件(输出流,FileOutputStream)

    前请了解:try-with-resource,这是JDK1.7提供的新方法,让代码的可读性更高,但是并不是所有的对象都可以这样,当调用的类实现了closable接口就可以使用此种方式

    4.1.普通字节流的操作

    代码案例
    
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.IOException;
    
    /**
     * 复制D:\io_test下的加菲猫文件到D:\io_test这个目录下
     */
    
    public class IoDemo4 {
    
        public static void main(String[] args) throws IOException {
            //输入文件目录
            String srcFilePath = "D:\\io_test\\加菲猫.jpg";
            //输出文件目录(拷贝的路径)
            String destFilePath = "D:\\io_test\\加菲猫2.jpg";
            FileInputStream fileInputStream = null;
            FileOutputStream fileOutputStream = null;
            try {
                //输入流,传入路径
                fileInputStream = new FileInputStream(srcFilePath);
                //输出流
                 fileOutputStream = new FileOutputStream(destFilePath);
                byte[] bytes = new byte[1024];
                try {
                    int count = 0;
                    //如果不等于-1说明还没有读取完成,要继续读取
                    while((count = fileInputStream.read(bytes)) != -1){
                        //还有内容要读取,然后从0开始读取,上面count有读了多少个,那么就写多少个
                        fileOutputStream.write(bytes,0,count);
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
    
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }finally {
                //用完之后一定要关闭流,但是得判断不是空的时候才需要去关闭流
                if(fileInputStream != null){
                    fileInputStream.close();
                }
                if(fileOutputStream != null){
                    fileOutputStream.close();
                }
            }
        }
    }
    
    

    执行结果
    在这里插入图片描述

    注意:
    1.因为字节流主要操作byte类型数据,注意里面参数的含义,如果是读取的话,比较常用的是第二种
    在这里插入图片描述

    (FileOutputStream)也是一样,读取的时候一般用第一个
    在这里插入图片描述

    2.读取数据的返回结果(FileInputStream)
    在这里插入图片描述

    3.最后一定要关闭流

    • 因为每天计算机打开的文件的数量是有限的,以liunx为例,最大可以打开66533个文件,
    • 但是无论执行结果怎么样他都要关闭流,那么就需要将他放在finally里面,所有上面的声明也得放在外面
    • 如果传入的地址和目标地址都是错的,也就是找不到,如果传入的地址错了,那么还没有初始化就已经被调用关闭流了,所以要进行判断

    4.2.带有缓冲区的字节流的操作

    什么是缓存区?
    定义:缓存区相当于缓存,它是存在内存中的
    写操作:
    没有使用缓存区:CPU读取每个字节之后直接操作磁盘(性能比较底)进行写完,写操作的瓶颈就会出现,因为每个字节都会操作一次磁盘
    使用缓冲区:那么每次会将字符放入缓存区(内存),等缓冲区满了之后,才一次性写入磁盘
    因为内存的操作速度远远大于磁盘,因此带缓冲区的输入流和输出流实现的效率就非常高(比如扔垃圾,一次性扔完和一次次扔肯定消耗的时间是有很大差距的)

    案例实现:复制D:\io_test\下的加菲猫—>D:\io_test\下变成加菲猫3

    代码实现
    
    import java.io.BufferedInputStream;
    import java.io.BufferedOutputStream;
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    
    /**
     * 带有缓冲区的字节流操作:图片复制
     *
     */
    public class IoDemo5 {
        public static void main(String[] args) {
            //输入文件目录
            String srcFilePath = "D:\\io_test\\加菲猫.jpg";
            //输出文件目录(拷贝的路径)
            String destFilePath = "D:\\io_test\\加菲猫3.jpg";
            try {
                //因为带有缓存区的是基于原始的类进行操作的
                BufferedInputStream bufferedInputStream =
                        new BufferedInputStream(new FileInputStream(srcFilePath));
                BufferedOutputStream bufferedOutputStream =
                        new BufferedOutputStream(new FileOutputStream(destFilePath));
                {
                            byte[] bytes = new byte[1024];
                            int count = 0;
                            while ((count = bufferedInputStream.read(bytes)) != -1){
                                bufferedOutputStream.write(bytes,0,count);
                            }
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
    
    

    执行结果
    在这里插入图片描述

    5.字符流的使用

    5.1.普通的字符流操作

    在程序中一个字符等于两个字节,那么java提供了Reader、Writer两个专门操作字符流的类。

    字符输出流:Writer。
    字符输入流:Reader

    示例一:内容的写入:D:\io_test\1下创建一个text.txt文件,并写入内容“欢迎来到Java~”
    
    import java.io.FileWriter;
    import java.io.IOException;
    
    /**
     * 内容的写入:D:\io_test\1下创建一个text.txt文件,并写入内容
     */
    public class IoDemo7 {
        public static void main(String[] args) throws IOException {
            //定义文件地址
            String filePath = "D:\\io_test\\1\\text.txt";
            //写入内容
            String content = "欢迎来到Java~";
            //因为是写入文件,所以要使用FileWriter方法
            FileWriter fileWriter = null;
            try {
                fileWriter = new FileWriter(filePath);
                fileWriter.write(content);
            } catch (IOException e) {
                e.printStackTrace();
            }finally {
            //关闭流
                fileWriter.close();
            }
        }
    }
    

    **注意:**如果不关闭流,虽然也能创建文件成功,不报错,但是可能存在内容无法写入的情况

    示例二:但是上面这种操作如果是对于多行输入的话那么就回被覆盖
    因为这里的参数append会被默认成false,所以如果是多行写入的话
    需要手动设置成true
    

    在这里插入图片描述
    来看看在刚才那种被覆盖掉的情况
    在这里插入图片描述

    代码实现:那么来看看将append设置成true
    
    public class IoDemo7 {
        public static void main(String[] args) throws IOException {
            //定义文件地址
            String filePath = "D:\\io_test\\1\\text.txt";
            //写入内容
            String content = "欢迎来到java~,";
            //因为是写入文件,所以要使用FileWriter方法
            FileWriter fileWriter = null;
            try {
                fileWriter = new FileWriter(filePath,true);
                fileWriter.write(content);
            } catch (IOException e) {
                e.printStackTrace();
            }finally {
                fileWriter.close();
            }
        }
    }
    
    

    执行结果
    在这里插入图片描述

    示例三:文件的读取,比如将文件下的内容读取到控制台
    

    文件下的内容

    import java.io.File;
    import java.io.FileNotFoundException;
    import java.util.Scanner;
    
    /**
     * 读取文件内容
     */
    public class IoDemo8 {
        public static void main(String[] args) throws FileNotFoundException {
            String filePath = "D:\\io_test\\1\\tt.txt";
            Scanner scanner = new Scanner(new File(filePath));
            //因为读取的内容可能不止一条,所以加上while循环
            while (scanner.hasNext()){
                System.out.println(scanner.nextLine());
            }
        }
    }
    
    

    执行效果
    在这里插入图片描述

     示例四:将内容读取到内存中,如:将一个路径下的内容复制到另一个路径下
    

    代码实现

    import java.io.FileReader;
    import java.io.FileWriter;
    import java.io.IOException;
    
    /**
     *将一个文件的内容写入到另一个文件下
     * 如:D:\io_test\1\text.txt -> text2.txt
     */
    public class IoDemo9 {
        public static void main(String[] args) throws IOException {
            //读取文件的地址
            String srcFilePath = "D:\\io_test\\1\\text.txt";
            //目标文件的地址
            String destFilePath = "D:\\io_test\\1\\text2.txt";
            FileReader fileReader = null;
            FileWriter fileWriter = null;
            //先读后写
            try{
                 fileReader = new FileReader(srcFilePath);
                 fileWriter = new FileWriter(destFilePath);
                {
                    //读操作
                    char[] chars = new char[1024];
                    while (true){
                        int count = fileReader.read(chars);
                        //判断是否等于-1,如果等于-1,说明已经读取完了,跳出循环
                        if(count == -1){
                            break;
                        }
                        //写操作
                        fileWriter.write(chars,0,count);
                    }
                }
            }catch (Exception e){
                e.printStackTrace();
            }finally {
                fileReader.close();
                fileWriter.close();
            }
        }
    }
    
    

    执行结果
    在这里插入图片描述

    5.2.带有缓冲区的字符流操作

    示例:如上述的示例四
    

    代码实现

    import java.io.*;
    
    /**
     * 带有缓冲区的字符流操作
     * 如:内容的复制
     */
    public class IoDemo10 {
        public static void main(String[] args) throws IOException {
            String srcFilePath = "D:\\io_test\\1\\tt.txt";
            String destFilePath = "D:\\io_test\\1\\tt2.txt";
            BufferedReader bufferedReader = null;
            BufferedWriter bufferedWriter = null;
            //先读取,后写入
            try {
                 bufferedReader = new BufferedReader(new FileReader(srcFilePath));
                 bufferedWriter = new BufferedWriter(new FileWriter(destFilePath));
                {
                    char[] chars = new char[1024];
                    while (true){
                        int count = bufferedReader.read(chars);
                        if(count == -1){
                            break;
                        }
                        bufferedWriter.write(chars,0,count);
                    }
                }
            }catch (Exception e){
                e.printStackTrace();
            }finally {
                bufferedReader.close();
                bufferedWriter.close();
            }
        }
    }
    

    执行结果
    在这里插入图片描述

    6.总结对比字节流和字符流

    • 字节流操作的基本单元是字节;字符流操作的基本单元为Unicode码元。

    • 字节流在操作的时候本身不会用到缓冲区的,是与文件本身直接操作的;而字符流在操作的时候使用到缓冲区的。

    • 所有文件的存储都是字节(byte)的存储,在磁盘上保留的是字节。

    • 在使用字节流操作中,即使没有关闭资源(close方法),也能输出;而字符流不使用close方法的话,不会输出任何内容

    展开全文
  • IO流概述和分类 IO流分类: 按数据的流向: ...如果数据通过Windows自带的记事本软件打开,我们还可以读得懂里面的内容,那就是字符流,否则就是字节流。如果你不知道该用哪种类型的流,就是字节流 ...
  • Java实现字节流与图片的转化
  • 字符流与字节流的区别

    万次阅读 多人点赞 2019-03-25 14:03:47
    字符流与字节流的区别 (尊重劳动成果,转载请注明出处:https://blog.csdn.net/cynhafa/article/details/6882061陈江玉的博客) 字节流与和字符流的使用非常相似,两者除了操作代码上的不同之外,是否还有其他的...
  • 如何理解是 TCP 面向字节流协议?

    千次阅读 2022-03-13 13:49:53
    TCP 是面向字节流的协议,UDP 是面向报文的协议?这里的「面向字节流」和「面向报文」该如何理解。 如何理解字节流? 之所以会说 TCP 是面向字节流的协议,UDP 是面向报文的协议,是因为操作系统对 TCP 和 UDP ...
  • python字节流处理

    千次阅读 2020-12-29 22:45:08
    Python模块——struct(字节流,组包拆包实现)(2009-09-23 21:45:30) 标签:python struct 字符串 a2 format it 分类:Python 我们知道python只定义了6种数据类型,字符串,整数,浮点数,列表,元组,字典。...
  • 介于要设计游戏服务器和客户端逻辑,现在需要普及一下我在代码中用到的一些数据结构,这一篇讲一下字节流--- ByteStream。 字节流就是自己实现的一个数据存储区,可对基础数据和其他特定数据进行序列化和反序列化。...
  • java 字节流与字符流的区别

    千次阅读 多人点赞 2019-06-08 16:33:45
    字节流与和字符流的使用非常相似,两者除了操作代码上的不同之外,是否还有其他的不同呢? 实际上字节流在操作时本身不会用到缓冲区(内存),是文件本身直接操作的,而字符流在操作时使用了缓冲区,通过缓冲区再...
  • 普通方法上 和 字节流上传 struts2 文件上传
  • 本文将详细介绍字节流和字符流,剖析它们之间的本质区别,以及区别和对比。
  • Java------字节流和字符流(I)

    千次阅读 2021-02-28 18:07:47
    字节流:读写字节文件,通常使用字节流,如:二进制文件,.jpg,.mp3,.avi,.exe,.com,.dllwindows平台的执行文件:.exe,.com,.dll...字节流的概念传输的数据单位是字节,也意味着字节流能够处理任何一种文件字节流的...
  • Java--字节流和字节数组流

    千次阅读 2019-11-15 21:28:43
    一、IO流 A:什么是IO流: ...字节流字节流可以操作数据,计算机任何数据都是以字节的形式存储 字符流:字符流只能操作纯字符数据,方便操作数据 C:IO程序书写 使用前:导入IO包 使用时:进行I...
  • Java字节流与字符流及文件操作

    千次阅读 2020-07-21 13:29:34
    目录Java.io知识点梳理File类字节流OutputStream字节流InputStream字符流Writer字符流Reader字节流与字符流的转换(了解)字节流与字符流的区别?两者如何使用? Java.io知识点梳理 如果要进行所有的文件以及文件...
  • 一分钟看懂字节流

    千次阅读 多人点赞 2020-12-01 20:40:14
    1、字节流 字节流是什么: ​ 一切文件数据在存储时,都是以二进制数字的形式保存,都一个一个的字节,那么传输时一样如此。所以,字节流可以传输任意文件数据。在操作流的时候,我们要时刻明确,无论使用什么样的...
  • 杂谈——探秘字节流与字符流

    千次阅读 2018-12-02 19:58:05
    今天我们要认识的就是字节流和字符流这两个小兔崽子。 想要认识它们,我们就得先获得“流”这本秘籍,去看看“流”到底是什么。 1.流是什么呢? 要知道,在程序中所有的数据都是以流的方式进行传输或保存的,程序...
  • 字节流与字符流的区别

    千次阅读 2021-04-28 22:56:13
    1、字节流的组成:字节流是由字节组成的。 2、字符流的组成:字符流是由字符组成的。 二、两者的处理不同: 1、字节流的处理:主要用在处理二进制数据,它是按字节来处理的但实际中很多的数据是文本。 2、字符流的...
  • Java 字节流与字符流的区别详解

    万次阅读 多人点赞 2019-05-02 21:25:50
    1. 流的概念 在程序中所有的数据都是以流的方式进行传输或保存的,程序需要数据的时候要使用输入流读取数据,而当程序需要将一些数据保存起来的时候,就要使用输出...2. 字节流与字符流 在java.io包中操作文件内...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 706,939
精华内容 282,775
关键字:

字节流