精华内容
下载资源
问答
  • JAVA两种流,字符流和字节流
    2020-06-20 00:47:58

    Java中的流分为两种,一种是字节流,另一种是字符流,分别由四个抽象类来表示(每种流包括输入和输出两种所以一共四个):InputStream,OutputStream,Reader,Writer。Java中其他多种多样变化的流均是由它们派生出来的.
    字符流和字节流是根据处理数据的不同来区分的。字节流按照8位传输,字节流是最基本的,所有文件的储存是都是字节(byte)的储存,在磁盘上保留的并不是文件的字符而是先把字符编码成字节,再储存这些字节到磁盘。
    1.字节流可用于任何类型的对象,包括二进制对象,而字符流只能处理字符或者字符串;
    2. 字节流提供了处理任何类型的IO操作的功能,但它不能直接处理Unicode字符,而字符流就可以。
    读文本的时候用字符流,例如txt文件。读非文本文件的时候用字节流,例如mp3。理论上任何文件都能够用字节流读取,但当读取的是文本数据时,为了能还原成文本你必须再经过一个转换的工序,相对来说字符流就省了这个麻烦,可以有方法直接读取。
    字符流处理的单元为2个字节的Unicode字符,分别操作字符、字符数组或字符串,而字节流处理单元为1个字节, 操作字节和字节数组。所以字符流是由Java虚拟机将字节转化为2个字节的Unicode字符为单位的字符而成的,所以它对多国语言支持性比较好!

    从源码可以看出
    OutputStream的write里使用的是byte[]字节数组
    而Writer的write里使用的是char[]字符数组

    ObjectInputStream是装饰流,不能直接处理数据源。必须装饰其他实体流才能一起使用,他是用来序列化的。
    字节流是由InputStream或者OutputStream派生的。
    字节流是由reader和writer派生的子类。
    ObjectInputStream是一个装饰流,装饰流不能直接处理数据源,它必须和其他的装饰流或实体流一起使用,ObjectInputStream是用来实现反序列化的。
    凡是流,都是一对一对出现的,比如FileInputStream相对的就是FileOutputStream
    ObjectInputStream相对的是ObjectOutputStream
    字符流是Reader和Writer所派生下来的子类,字节流是InputStream和OutputStream所派生下来的子类,其中总怕有几十个类,不必全记住。只需要知道流的分类
    按内容分:字符流、字节流
    按功能分:输入流、输出流
    按形式分:实体流、装饰流

    1.Java的字节流

    InputStream是所有字节输入流的祖先,而OutputStream是所有字节输出流的祖先。

    2.Java的字符流

    Reader是所有读取字符串输入流的祖先,而writer是所有输出字符串的祖先。
      InputStream,OutputStream,Reader,writer都是抽象类。所以不能直接new。
      字节流是最基本的,所有的InputStream和OutputStream的子类都是,主要用在处理二进制数据,它是按字节来处理的。但实际中很多的数据是文本,又提出了字符流的概念,它是按虚拟机的encode来处理,也就是要进行字符集的转化。这两个之间通过 InputStreamReader,OutputStreamWriter来关联,实际上是通过byte[]和String来关联。
      在实际开发中出现的汉字问题实际上都是在字符流和字节流之间转化不统一而造成的。在从字节流转化为字符流时,实际上就是byte[]转化为String时,public String(byte bytes[], String charsetName)
    有一个关键的参数字符集编码,通常我们都省略了,那系统就用操作系统的lang。而在字符流转化为字节流时,实际上是String转化为byte[]时,byte[] String.getBytes(String charsetName)也是一样的道理。至于java.io中还出现了许多其他的流,按主要是为了提高性能和使用方便,如BufferedInputStream,PipedInputStream等。

    注:
      在Java中,它的内核使用 Unicode,也就是说它记住了每个字符的Unicode 内部编码。与ANSI码不兼容。
      按照ANSI编码标准,标点符号、数字、大小写字母都占一个字节,汉字占2个字节。按照UNICODE标准所有字符都占2个字节。
      因为在Java当中字符是采用Unicode编码标准的,所以“学Java”这个字符串在Java语言中占10个字节。

    更多相关内容
  • 主要为大家详细介绍了Java中字符流字节流的区别,这两个的概念易混淆,今天就为大家进行详细区分,感兴趣的小伙伴们可以参考一下
  • Java 流在处理上分为字符流和字节流字符流处理的单元为 2 个字节的 Unicode 字符,分别操作字符、字符数组或字符串,而字节流处理单元为 1 个字节,操作字节字节数组。 Java 内用 Unicode 编码存储字符,字符流...
  • 本篇文章主要介绍了Java的IO流分为字符流(Reader,Writer)和字节流(InputStream,OutputStream),字节流顾名思义字节流就是将文件的内容读取到字节数组,对初学者很有用,有需要的朋友可以了解一下。
  • 字节流和字符流

    2020-12-22 09:36:14
    字节流字符流在java.io包中操作文件内容的主要有两大类:字节流字符流,两类都分为输入输出操作。在字节流中输出数据主要是使用OutputStream完成,输入使的是InputStream,在字符流中输出主要是使用Writer类...
  • 【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

    待续…

    展开全文
  • 字节流和字符流详解

    千次阅读 2021-03-29 20:21:21
    1.流的概念 在编程中是一种抽象的概念,就好比“水流”,从一段流向另一端 ...按照传输单位可以分为字节流和字符流 3.什么字节流什么字符流 字节流: 它处理单元为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方法的话,不会输出任何内容

    展开全文
  • 本文将详细介绍字节流和字符流,剖析它们之间的本质区别,以及区别对比。

    Java IO——字节流和字符流详解&区别对比


    概述

    大多数应用程序都需要实现与设备之间的数据传输,在Java中,将这种通过不同输入输出设备(例如:输入设备、内存、显示器、网络等)之间的数据传输抽象的表述为“流”,程序允许通过流的方式与输入输出设备进行数据传输。Java中的“流”都位于Java.io包中,称之为IO(输入输出)流。 IO流,即InputOutput的缩写。

    Java IO库有两个支系:

    1. 面向字节流的InputStream和OutputStream
    2. 面向字符的Reader和Writer

    java流在处理上分为字符流和字节流。实际上字节流的InputStream和OutputStream是一切的基础。实际总线中流动的只有字节流。需要对字节流做特殊解码才能得到字符流。Java中负责从字节流向字符流解码的桥梁是:InputStreamReader和InputStreamWriter。

    字节流&字符流

    大多数情况下,字节是数据最小的基本单位,1 byte = 8 bit,而 1 char = 2 byte = 16 bit。

    在程序中所有的数据都是以流的方式进行传输或保存的,程序需要数据的时候要使用输入流读取数据,而当程序需要将一些数据保存起来的时候,就要使用输出流完成。程序中的输入输出都是以流的形式保存的,流中保存的实际上全都是字节文件。

    Java中的流是对字节序列的抽象,我们可以想象有一个水管,只不过现在流动在水管中的不再是水,而是字节序列。和水流一样,Java中的流也具有一个“流动的方向”,通常可以从中读入一个字节序列的对象被称为输入流;能够向其写入一个字节序列的对象被称为输出流。

    输入流是相对程序而言的,外部传入数据给程序需要借助输入流,而程序把数据传输到外部需要借助输出流。

    字节流

    Java中的字节流处理的最基本单位为单个字节,它通常用来处理二进制数据。Java中最基本的两个字节流类是InputStream和OutputStream,它们分别代表了最基本的输入字节流和输出字节流。InputStream是所有字节输入流的祖先,而OutputStream是所有字节输出流的祖先,它们都是抽象类。

    字节流在默认情况下是不支持缓存的,字节流在操作时本身不会用到缓冲区(内存),是文件本身直接操作的,这意味着每调用一次read方法都会请求操作系统来读取一个字节,这往往会伴随着一次磁盘IO,因此效率会比较低。要使用内存缓冲区以提高读取的效率,我们应该使用BufferedInputStream。

    需注意,使用BufferedOutputStream输出数据时如果没有关闭流,数据也是不会输出到文件当中的,即并不是所有字节流都不用到缓冲区,输入缓冲字节流BufferedInputStream和输出缓冲字节流BufferedOutputStream还是要用到缓冲区的。

    字符流

    Java中的字符流处理的最基本的单元是Unicode码元(大小2字节),它通常用来处理文本数据,例如字符、字符数组或字符串。Java中的String类型默认就把字符以Unicode规则编码而后存储在内存中。存储在磁盘上的数据通常有着各种各样的编码方式,不同的编码方式最终输出的字节内容是不同的,所以,字节流的读取和写入都要设置相应的编码方式。

    由于字符流在输出前实际上是要完成Unicode码元序列到相应编码方式的字节序列的转换,所以它会使用内存缓冲区来存放转换后得到的字节序列,等待都转换完毕再一同写入磁盘文件中。

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

    字节流和字符流的区别

    字节流操作的基本单元为字节;字符流操作的基本单元为Unicode码元。
    字节流默认不使用缓冲区;字符流使用缓冲区。
    字节流在操作的时候本身是不会用到缓冲区的,是与文件本身直接操作的,所以字节流在操作文件时,即使不关闭资源,文件也能输出;字符流在操作的时候是使用到缓冲区的。如果字符流不调用close或flush方法,则不会输出任何内容。
    字节流通常用于处理二进制数据,实际上它可以处理任意类型的数据,但它不支持直接写入或读取Unicode码元;字符流通常处理文本数据,它支持写入及读取Unicode码元。
    字节流可用于任何类型的对象,包括二进制对象,而字符流只能处理字符或者字符串; 字节流提供了处理任何类型的IO操作的功能,但它不能直接处理Unicode字符,而字符流就可以。

    字节流和字符流的转换

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

    字符流处理的单元为2个字节的Unicode字符,分别操作字符、字符数组或字符串,而字节流处理单元为1个字节,操作字节和字节数组。所以字符流是由Java虚拟机将字节转化为2个字节的Unicode字符为单位的字符而成的,所以它对多国语言支持性比较好!如果是音频文件、图片、歌曲,就用字节流好点,如果是关系到中文(文本)的,用字符流好点。所有文件的储存是都是字节(byte)的储存,在磁盘上保留的并不是文件的字符而是先把字符编码成字节,再储存这些字节到磁盘。在读取文件(特别是文本文件)时,也是一个字节一个字节地读取以形成字节序列。

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

    字节流与字符流主要的区别是他们的的处理方式。

    展开全文
  • 字符流和字节流是根据处理数据的不同来区分的。字节流按照8位传输,字节流是最基本的,所有文件的储存是都是字节(byte)的储存,在磁盘上保留的并不是文件的字符而是先把字符编码成字节,再储存这些字节到磁盘。 1...
  • java中字节流和字符流有哪些区别

    千次阅读 2021-02-12 20:33:27
    java中字节流和字符流的区别有:1、定义不同;2、结尾不同;3、处理方式不同;4、缓冲区不同;5、编码方式不同字节流默认不使用缓冲区,而字符流使用缓冲区。字节流采用ASCII编码,字符流采用unicode编码。流是一...
  • 字节流字符流(精细讲解)

    千次阅读 2021-02-25 13:56:09
    字节流字符流 1.1 什么是IO 生活中,你肯定经历过这样的场景。当你编辑一个文本文件,忘记了ctrl+s ,可能文件就白白编辑了。当你电脑上插入一个U盘,可以把一个视频,拷贝到你的电脑硬盘里。那么数据都是在哪些...
  • 1:字符流和字节流是流的一种划分,按照处理流的方式进行的划分。 两类都分为输入输出操作。 2:在字节流中输出数据主要是使用 OutputStream 完成,输入使用的是 InputStream。 在字符流中输出主要是使用 Writer ...
  • Java字节流和字符流,是时候总结一下IO流了

    千次阅读 多人点赞 2021-04-12 12:39:41
    字节流和字符流:为什么字符流需要 flush
  • •按照操作单元划分,可以划分为字节流和字符流; •按照流的角色划分为节点流处理流。 Java Io流共涉及40多个类,这些类看上去很杂乱,但实际上很有规则,而且彼此之间存在非常紧密的联系, Java I0流的40多个...
  • Java基础:IO流之字节流和字符流

    万次阅读 多人点赞 2016-10-15 00:23:44
    一、的概念(stream)的概念源于UNIX中管道(pipe)的概念。在UNIX中,管道是一条不间断的...的方向是重要的,根据的方向,流可分为两类:输入流和输出。用户可以从输入中读取信息,但不能写它。相反,对输出
  • JAVA 流分为 字节流 字符流

    千次阅读 2020-07-31 09:25:46
    字符流处理的是以2个字节为单元的unicode字符 字符数组 字符串 字节流处理的是 字节 字节数组 字节流一次操作一个字节 字符流一次操作一个缓冲区
  • 先来看一下流的概念: 在程序中所有的数据都是以流的方式进行传输或保存的,程序需要数据的时候要使用输入流读取数据,而当程序需要将一些数据保存起来的时候,就要使用输出流...字节流字符流 在java.io
  • 根据读写操作/数据流动的方向不同分为:输入 输出(站在程序的角度)。 其中输入就是指读取文件中的内容输入到程序中的,也就是读文件。 其中输出就是指将程序中的内容输出到文件中的,也就是写文件。...
  • 杂谈——探秘字节流字符流

    千次阅读 2018-12-02 19:58:05
    今天我们要认识的就是字节流和字符流这两个小兔崽子。 想要认识它们,我们就得先获得“流”这本秘籍,去看看“流”到底是什么。 1.流是什么呢? 要知道,在程序中所有的数据都是以流的方式进行传输或保存的,程序...
  • Java字节流和字符流的区别 首先我们先大概总结一下前面学习的内容,可分为以下几点: 以 Stream 结尾都是字节流,Reader Writer 结尾都是字符流。 InputStream 是所有字节输入流的父类,OutputStream 是所有字节...
  • 1.字节: 字(Byte)节是长度单位。位(bit)也是长度单位。 因为计算机通信存储的时候都是以010101这样的二进制数据为基础的,这儿的一个01占的地方就叫bit(位),即一个二进制位。 1Byte=8bit 1KB=1024B 1MB=1024...
  • 字节流和字符流的用法

    千次阅读 2018-09-13 21:03:41
    字节流 作用:字节流可以将文字图片音频等等文件转成字节进行数据传输 分为: OutputStream: 输出流,写文件 InputStream: 输入流,读文件 输出流的使用实例: // 创建一个字节输出流,写文件,设置文件路径,如果...
  • Java中的“流”是什么? 一个Java I/O对象叫做数据流。读取数据到内存的对象叫做输入流,内存写出数据的对象叫做输出流。...按照处理数据的单位不同分为字节流和字符流。表示以字节为单位从stream中读取或往str...
  • Java 字节流 字符流 转换流

    万次阅读 2015-05-10 13:55:16
    我们知道Java中的流分为字符流和字节流,其中字符流主要针对字符文本进行处理,而字节流处理范围更为广泛,毕竟图片、电影等只要是文件都是以二进制的形式存在的,而不是字符。 字符流: FileReader FileWriter。 ...
  • Java IO 3-字节流字符流的区别

    千次阅读 2018-05-23 19:58:10
    java以流的形式操纵IO,又将流分为两种:字节流字符流,对JavaIO流操作不清楚的可以参考 Java IO 2-字节流字符流字节流字符流之间又有什么区别呢 区别 字节流用于操作文件数据,网络传输等场景,...
  • Java字节流字符流的区别详解

    千次阅读 2016-05-28 15:54:44
    字节流字符流 先来看一下流的概念: ...在程序中所有的数据都是以流的方式进行传输或保存的,程序需要数据的时候要使用输入流...在Java.io包中操作文件内容的主要有两大类:字节流字符流,两类都分为输入
  • Java 字节流字符流的区别详解

    万次阅读 多人点赞 2019-05-02 21:25:50
    1. 流的概念 在程序中所有的数据都是以流的方式进行传输或保存的,程序需要数据的时候要使用输入流读取数据,而当程序需要将一些数据保存起来的时候,就要使用输出...2. 字节流字符流 在java.io包中操作文件内...
  • 流可以分为两种,字节流和字符流,传输的对象分别是字节字符。 根据数据不同的流向也可以分为输入流输出流。 Inputstream(字节输入流)Reader(字符输入流)都是读取,相当于从外部文件中的数据读取到程序...
  • 字节流 InputStream OutputStream  字符流 Reader Writer  他们都是抽象类  具体实现  字节流 FileInputStream FileOutputStream  字符流 FileReader FileWriter   字符流处理的单元为2个字节的Unicode字符...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 117,348
精华内容 46,939
关键字:

按照什么的不同,流可分为字节流和字符流