字节流与字符流的区别
《Java基础入门》_课后习题答案大一计算机专业7
《Java基础入门》课后习题答案第7章IO(输入输出)一、填空题1、Java中的I/O流,按照传输数据不同,可分为:字节流、字符流2.在Buffer与Channel交互时,数据从:Channel、读取到Buffer 中,或从Buffer入到Channel 中。
3.用于将字节流转换为字符流的是:InputStreamReader、OutputStreamWriter2、NIO主要有三大核心部分:Buffer、Channel、Selector5、Java中提供了一个类:RandomAccesseFile,它不但具有读写文件的功能,而且可以随机地从文件的任何位置开始执行读写数据的操作。
二、判断题1. 如果一个File表示目录下有文件或者子目录,调用delete()方法也可以将其删除。
错2.对象序列化是指将一个Java 对象转换成一个I/0 流中字节序列的过程。
对3.Channel 是一个接口对象,它类似于传统的流对象。
对4.InputStream类的close()方法是用于关闭流并且释放流所占的系统资源。
对5,BufferedInputStream 和BufferedOutputStream 不是字节缓冲流。
错三、选择题1.下面选项中,哪些是标准输人输出流?(多选) (AB)A. System.InB.System. OutC.InputStreamD.OutputStream2.File类中以字符串形式返回文件绝对路径的方法是哪一项?(C)A. getParent()B. getNamel)C. getAbsolutePathOD. getPath()3.以下创建RandomAccessFile类实例对象的代码,哪些是正确的?(多选)(AB)A.new RandomAccessFile(new File("D:\\itcast\\dirl\test. java"),”rw”);B.new RandomAccessFile("D:\\itcast\\dirl\test. java","r");C. new RandomAccessFile("D:\\itcast\\dir1\\test.java");D. new RandomAccessFile("D:\\itcast\\dir1\\test.java","wr")4.以下选项中,哪个流中使用了缓冲区技术? (A)A. BufferedOutputStreamB. FileInputStreamC. DataOutputStreamD. FileReader5.以下选项中,关于Java NIO 中Buffer类的常用说法正确的是哪一项?(B)A.clearO方法会清除缓冲区数据,并将position 设置为0.limit 设置为capacity OB.fip()方法先将limit 设置为当前position 位置,然后再将pson设置为0C.mark()方法用于设置Buffer 的标记(mark),其能在0 与limi 之间做标记D.rewind()方法将position 设置为0,并设置mark 标记四、简答题1、简述I/O 流的概念。
java字节流和字符流的区别介绍
字节流和字符流在整个IO包中,流的操作分为两种:·字节流|·字节输出流OutputStream、字节输入流InputStream ·字符流:一个字符= 两个字节|·字节输出流Writer,字节输入流ReaderIO操作的基本步骤:1、使用File找到一个文件2、使用字节流或字符流的子类为OutputStream、InputStream、Writer、Reader进行实例化操作3、进行读写的操作4、关闭:close(),在流的操作中最终必修进行关闭。
字节输出流:OutputStream在Java io中OutputStream是字节输出流的最大父类。
此类是一个抽象类,所以使用时修要依靠子类进行实例化操作。
如果此时要完成文件的输出操作,则使用FileOutputStream为OutputStream进行实例化操作:OutputStream out = new FileOutputStream(File f) OutputStream提供了一下的写入数据的方法:·写入全部字节数组:pubic void writer (byte[] b)throws IOException·写入部分字节数组:public void writer(byte[] b ,int off,int len)throws IOException·写入一个数据:public abstract void writer (int b)throws IOException如果要向文件中追加内容则需要调用FileOutputStream类的另外一个构造方法:pubic OutputStream(File file ,booleam append) throws FileNotFoundException,如果将append的内容设置为true,则表示增加内容。
字节输入流:InputStream使用InputStream可以读取输入流的内容此类也是一个抽象类,同样需要使用子类对象进行实例化,如果现在是文件操作则使用FileInputStream,·FileInputStream的构造方法:public FileInputStream(File file) throws FileNotFoundException ·将内容读入字节数组中:pubic int read(byte[] b)throws IOException ·每次读入一个数据:public abstract void read (int b)throws IOException范例:将文件中的内容读取进来以上是一种比较常见的读取形式,但是以上的代码有一个缺点,会受到开辟空间大小的限制,如果想动态的开辟数组空间,则可以根据文件的大小来决定。
Java基础:IO流之字节流和字符流
本文由我司收集整编,推荐下载,如有疑问,请与我司联系Java 基础:IO 流之字节流和字符流2016/10/15 9461. 流的概念流(stream)的概念源于UNIX 中管道(pipe)的概念。
在UNIX 中,管道是一条不间断的字节流,用来实现程序或进程间的通信,或读写外围设备、外部文件等。
一个流,必有源端和目的端,它们可以是计算机内存的某些区域,也可以是磁盘文件,甚至可以是Internet 上的某个URL。
流的方向是重要的,根据流的方向,流可分为两类:输入流和输出流。
用户可以从输入流中读取信息,但不能写它。
相反,对输出流,只能往输入流写,而不能读它。
实际上,流的源端和目的端可简单地看成是字节的生产者和消费者,对输入流,可不必关心它的源端是什么,只要简单地从流中读数据,而对输出流,也可不知道它的目的端,只是简单地往流中写数据。
形象的比喻——水流,文件======程序,文件和程序之间连接一个管道,水流就在之间形成了,自然也就出现了方向:可以流进,也可以流出.便于理解,这么定义流:流就是一个管道里面有流水,这个管道连接了文件和程序。
2. IO 流概述大多数应用程序都需要实现与设备之间的数据传输,例如键盘可以输入数据,显示器可以显示程序的运行结果等。
在Java 中,将这种通过不同输入输出设备(键盘,内存,显示器,网络等)之间的数据传输抽象的表述为“流”,程序允许通过流的方式与输入输出设备进行数据传输。
Java 中的“流”都位于Java.io 包中,称之为IO(输入输出)流。
IO 流:即InputOutput 的缩写。
输入流和输出流相对于内存设备而言。
将外设中的数据读取到内存中:输入。
将内存的数写入到外设中:输出。
IO 流的特点:IO 流用来处理设备间的数据传输。
Java 对数据的操作是通过流的方式。
Java 用于操作流的对象都在IO 包中。
流按操作数据分为两种:字节流和字符流。
流按流向。
java字节流和字符流
java字节流和字符流文章分类:Java编程Java流操作对于我们常用的GBK中,英文是占用1个字节,中文是2个对于UTF-8,英文是1个,中文是3个对于Unicode,英文中文都是2个Java的流操作分为字节流和字符流两种。
1、字节流所有的读操作都继承自一个公共超类java.io.InputStream类。
所有的写操作都继承自一个公共超类java.io.OutputStream类。
InputStream和OutputStream都是抽象类。
InputStream有6个低级输入流:低级流流的用途ByteArrayInputStream从内存数组中读取数据字节FileInputStream从本地文件系统中读取数据字节PipedInputStream从线程管道中读取数据字节StringBufferInputStream从字符串中读取数据字节SequenceInputStream从两个或多个低级流中读取数据字节,当到达流的末尾时从一个流转到另一个流System.in从用户控制台读取数据字节InputStream还有一个子类:过滤器流java.io.FilterInputStream。
过滤器流即能把基本流包裹起来,提供更多方便的用法。
FilterInputStream 类的构造方法为FilterInputStream(InputStream),在指定的输入流之上,创建一个输入流过滤器。
FilterInputStream的常用的子类如下:过滤器输入流流的用途BufferedInputStream缓冲区对数据的访问,以提高效率DataInputStream从输入流中读取基本数据类型,如int、float、double或者甚至一行文本LineNumberInputStream在翻译行结束符的基础上,维护一个计数器,该计数器表明正在读取的是哪一行。
PushbackInputStream允许把数据字节向后推到流的首部OutputStream(略)OutputStream的结构基本和InputStream是一样的。
Java中的流、字符流和字节流
本文由我司收集整编,推荐下载,如有疑问,请与我司联系Java 中的流、字符流和字节流2012/03/22 0 一、什么是流:流是一个抽象的概念。
当Java 程序需要从数据源读取数据时,会开启一个到数据源的流。
数据源可以是文件,内存或者网络等。
同样,当程序需要输出数据到目的地时也一样会开启一个流,数据目的地也可以是文件、内存或者网络等。
流的创建是为了更方便地处理数据的输入输出。
流分为字节流和字符流。
字节流也称为原始数据,需要用户读入后进行相应的编码转换。
而字符流的实现是基于自动转换的,读取数据时会把数据按照JVM 的默认编码自动转换成字符。
字节流由InputStream 和OutputStream 处理,而字符流由Reader 和Writer 处理。
Reader 和Writer 是Java 后加入的处理类,出于让数据的处理更方便的目的。
二、字节流和字符流如果数据流中最小的数据单元是字节,那么称这种流为字节流;如果数据流中最小的数据单元是字符,那么称这种流为字符流。
在Java 的IO 系统中,java.io.InputStream 和java.io.OutputStream 分别表示字节输入流和字节输出流,java.io.Reader 和java.io.Writer 分别表示字符输入流和字符输出流。
I/O 流的层次1.字节流:从InputStream 和OutputStream 派生出来的一系列类。
这类流以字节(byte)为基本处理单位。
◇InputStream、OutputStream◇FileInputStream、FileOutputStream◇PipedInputStream、PipedOutputStream◇ByteArrayInputStream、ByteArrayOutputStream◇FilterInputStream、FilterOutputStream。
IO字符流与字节流
IO流1.字符流和字节流:字节流两个基类:InputStreamOutputStream字符流两个基类:ReaderWriter先学习一下字符流的特点。
既然IO流是用于操作数据的,那么数据的最常见体现形式是:文件。
那么先以操作文件为主来演示。
/*1.写入数据*/找到一个专门用于操作文件的Writer子类对象。
FileWriter。
后缀名是父类名。
前缀名是该流对象的功能。
import java.io.*;class FileWriterDemo{public static void main(String[] args) throws IOException {//创建一个FileWriter对象。
该对象一被初始化就必须要明确被操作的文件。
//而且该文件会被创建到指定目录下。
如果该目录下已有同名文件,将被覆盖。
//其实该步就是在明确数据要存放的目的地。
FileWriter fw = new FileWriter("demo.txt");//调用write方法,将字符串写入到流中。
fw.write("abcde");//刷新流对象中的缓冲中的数据。
//将数据刷到目的地中。
//fw.flush();//关闭流资源,但是关闭之前会刷新一次内部的缓冲中的数据。
//和flush区别:flush刷新后,流可以继续使用,close刷新后,会将流关闭。
fw.close();}}/*2.IO异常的处理方式。
*/import java.io.*;class FileWriterDemo2{public static void main(String[] args){FileWriter fw = null;建立引用try{fw = new FileWriter("demo.txt");fw.write("abcdefg");}catch (IOException e){System.out.println("catch:"+e.toString());}finally{try{if(fw!=null)fw.close();}catch (IOException e){System.out.println(e.toString());}}}}3.演示对已有文件的数据续写。
IO流分类,应用(使用)场景,字节流和字符流区别?
IO流分类,应⽤(使⽤)场景,字节流和字符流区别?IO流的分类?分为字节流和字符流,字节流⼜分为字节输⼊流和字节输出流,字符流⼜分为字符输⼊流和字符输出流输⼊和输出分别是指的什么?输⼊流,指的是将硬盘、键盘中数据输⼊到内存中。
输出流,指的是将内存中的数据输出到硬盘、显⽰器中。
为什么要弄个输⼊流和输出流出来呢?因为计算机的运⾏过程就是⼀个获取外界的数据,通过计算之后,然后输出结果的过程。
这个过程中,必然是⼈们通过电脑外设,输⼊数据,计算机处理这⼀批数据,然后输出到显⽰器或者其他外设中。
字节流和字符流的区别?不多说,直接上图:IO流应⽤场景?1、从硬盘中读取⽂件内容到内存中,然后把这些数据发送到其他接⼝进⾏处理2、将路径A中的⽂件A复制到路径B中的⽂件B存在的问题实际开发中,并不知道各种流的原理、使⽤场景,以及优缺点,当拿到⼀个开发需求的时候,通常都是借鉴,⽽不知道为什么这样使⽤,所以很有必要梳理⼀下。
IO流常见问题字节流相关1、 InputStream(字节输⼊流)、OutputStream(字节输出流)都是顶级⽗类(抽象类),其他IO流相关的类,都需要实现它们2、FileInputStream(⽂件字节输⼊流)基于字节流的⽂件操作,⽤于读取⼀个⽂件,打开⼀个实际的⽂件链接,并创建⼀个⽂件输出流3、FileOutputStream(⽂件字节输出流)⽤于将数据写⼊⽂件,创建⼀个向⽂件写数据的⽂件输出流4、BufferInputStream(缓冲字节输⼊流)普通的字节流增加的缓冲功能。
缓冲功能出现的原因:内存读写快,磁盘读写慢,所以⼆者数据传输会堵塞,所以建⽴缓冲区,提⾼⽂件存取效率,不管是读还是取,都是把⽂件先保存到缓冲区,再⼀次性保存到对应区域。
优点:复制所⽤的时间更少。
缓冲流的关闭顺序:根据依赖关系进⾏关闭,被依赖的后关闭,也就是先开后关。
5、BufferOutputStream(缓冲字节输出流)与缓冲输⼊流作⽤类似6、DataInputStream(数据过滤输⼊流)数据输⼊流允许应⽤程序以与机器⽆关⽅式从底层输⼊流中读取基本 Java 数据类型。
字节流与字符流的区别详解
字节流与字符流的区别详解先来看⼀下流的概念:在程序中所有的数据都是以流的⽅式进⾏传输或保存的,程序需要数据的时候要使⽤输⼊流读取数据,⽽当程序需要将⼀些数据保存起来的时候,就要使⽤输出流完成。
程序中的输⼊输出都是以流的形式保存的,流中保存的实际上全都是字节⽂件。
字节流与字符流在java.io包中操作⽂件内容的主要有两⼤类:字节流、字符流,两类都分为输⼊和输出操作。
在字节流中输出数据主要是使⽤OutputStream完成,输⼊使的是InputStream,在字符流中输出主要是使⽤Writer类完成,输⼊流主要使⽤Reader类完成。
(这四个都是抽象类)java中提供了专⽤于输⼊输出功能的包Java.io,其中包括:InputStream,OutputStream,Reader,WriterInputStream 和OutputStream,两个是为字节流设计的,主要⽤来处理字节或⼆进制对象,Reader和 Writer.两个是为字符流(⼀个字符占两个字节)设计的,主要⽤来处理字符或字符串.字符流处理的单元为2个字节的Unicode字符,分别操作字符、字符数组或字符串,⽽字节流处理单元为1个字节,操作字节和字节数组。
所以字符流是由Java虚拟机将字节转化为2个字节的Unicode字符为单位的字符⽽成的,所以它对多国语⾔⽀持性⽐较好!如果是⾳频⽂件、图⽚、歌曲,就⽤字节流好点,如果是关系到中⽂(⽂本)的,⽤字符流好点所有⽂件的储存是都是字节(byte)的储存,在磁盘上保留的并不是⽂件的字符⽽是先把字符编码成字节,再储存这些字节到磁盘。
在读取⽂件(特别是⽂本⽂件)时,也是⼀个字节⼀个字节地读取以形成字节序列字节流可⽤于任何类型的对象,包括⼆进制对象,⽽字符流只能处理字符或者字符串; 2. 字节流提供了处理任何类型的IO操作的功能,但它不能直接处理Unicode字符,⽽字符流就可以字节流是最基本的,所有的InputStrem和OutputStream的⼦类都是,主要⽤在处理⼆进制数据,它是按字节来处理的但实际中很多的数据是⽂本,⼜提出了字符流的概念,它是按虚拟机的encode来处理,也就是要进⾏字符集的转化这两个之间通过InputStreamReader,OutputStreamWriter来关联,实际上是通过byte[]和String来关联在实际开发中出现的汉字问题实际上都是在字符流和字节流之间转化不统⼀⽽造成的==================我们还可以看到:============Reader类的read()⽅法返回类型为int :作为整数读取的字符(占两个字节共16位),范围在0 到 65535 之间 (0x00-0xffff),如果已到达流的末尾,则返回 -1inputStream的read()虽然也返回int,但由于此类是⾯向字节流的,⼀个字节占8个位,所以返回 0 到 255范围内的 int 字节值。
IO流、字节流和字符流分别是什么?
一:IO流的分类1)按流向分:输入流:读取数据,把持久设备的数据读取到内存中。
输出流:写出数据,把内存的数据写出到持久设备。
2)按数据类型分:计算机中一切数据都:字节数据。
字符数据:底层还字节数据,但可以根据某些规则,把字节变成人们认识的文字、符号等等。
字节流:数据在持久设备上都以二进制形式保存的。
二进制就字节数据。
Java 就给出了字节流可以直接操作字节数据。
字节输入流:InputStream子类:FileInputStream字节输出流:OutputStream子类:FileOutputStream字符流:读取字符数据。
数据在设备上以二进制形式表示,但有些二进制合并在可以表示一些字符数据。
字符输入流:Reader子类:FileReader字符输出流:Writer子类:FileWriter注意:1)字节流可以对任意类型的文件按照字节进行读和写的操作;例如:图片、、文本文件、word文档、mp3等。
2)字符流只能对文本类型的文件进行操作;例如:.java文件、.txt等文件。
二:字节流1)字节输出流OutputStreampublicvoidclose():关闭此输出流并释放与此流相关联的任何系统资源。
publicvoidwrite(byte[]byte):把这个byte字节数组中的所有数据写到关联的设备中(设备包括文件、网络或者其他任何地方)。
publicvoidwrite(byte[]b,intoff,intlen):把b字节中的数据从下标off位置始往出写,共计写len个。
publicabstractvoidwrite(intb):把这个b数据写到关联的设备中。
注意:close方法,当完成流的操作时,必须调用此方法,释放系统资源。
2)字节输入流InputStreampublicvoidclose():关闭此输入流并释放与此流相关联的任何系统资源。
publicabstractintread():调用一次read,就可以从关联的文件中读取一个字节数据,并返回这个字节数据。
IO常用案例整理(File类、字节流、字符流)
IO常⽤案例整理(File类、字节流、字符流) 本篇⽂章主要是通过案例实现⼀些常见的需求来对IO知识进⾏整理: 这⾥不再介绍流的概念,直接上菜字节流和字符流的区别:1. 字节流操作的基本单元是字节,⽽字符流操作的基本单元是Unicode码元。
2. 字节流操作的是⽂件本⾝,没有使⽤到缓冲区(可以简单理解为⼀段内存区域)。
⽽字符流使⽤到了缓冲区,通过缓冲区操作⽂件(这个后⾯可以写个案列进⾏说明)3. 字节流通常⽤于处理⼆进制数据,实际上可以处理任意类型的数据。
但是它不⽀持直接读写Unicode码元。
字符流通常⽤于处理⽂本数据。
⽤字节流好还是字符流好? 两者相⽐较⽽⾔,字节流更加的通⽤,硬盘上的⽂件都是以字节的形式进⾏存储和传输,⽽字符只会在内存中才会形成,字符数组、字符串。
在开发中,字节流的应⽤更加⼴泛。
需求案例需求1:创建⼀个新的⽂件/*** 新建⽂件*/@Testvoid test1() {//直接在D盘下新建⽂件String fileName = "D:" + File.separator + "Hello.txt";//如果需要在指定的⽂件夹 upload 中创建⽂件//String fileName = "D:" + File.separator +upload+File.separator+ "Hello.txt";System.out.println(fileName);File file = new File(fileName);try {file.createNewFile();System.out.println("已创建了新⽂件");} catch (IOException e) {e.printStackTrace();}}需求2:删除⽂件/*** 删除⽂件*/@Testvoid test2() {String fileName = "D:" + File.separator + "Hello.txt";File file = new File(fileName);if (file.exists()) {file.delete();System.out.println("删除了该⽂件");} else {System.out.println("该⽂件不存在");}}需求3:创建⼀个新的⽂件夹/*** 创建⼀个⽂件夹*/@Testvoid test3() {String fileName = "D:" + File.separator + "Java";File file = new File(fileName);if (!file.exists()) {file.mkdirs();System.out.println("创建了⽂件夹");} else {System.out.println("已经存在该⽂件夹");}}需求4:删除⽂件夹/*** 删除⼀个⽂件夹*/@Testvoid test4() {String fileName = "D:" + File.separator + "Java";File file = new File(fileName);if (file.exists()) {file.delete();System.out.println("删除了⽂件夹");} else {System.out.println("该⽂件夹不存在");}}需求5:字节流-----向⽂件中写⼊字符串/*** 向⽂件中写⼊字符串*/@Testvoid test5() throws IOException {File file = new File("E:" + File.separator + "Hello.txt");if (file.exists()) {//如果⽂件存在,则向该⽂件中写⼊内容(直接覆盖⽂件中以前的内容)FileOutputStream fileOutputStream = new FileOutputStream(file);//如果希望是向⽂件中追加内容// FileOutputStream fileOutputStream1 = new FileOutputStream(file, true);String str = "这⾥是向⽂件中写⼊的内容";byte[] bytes = str.getBytes();fileOutputStream.write(bytes);fileOutputStream.close();System.out.println("写⼊内容成功");} else {System.out.println("不存在该⽂件");}}需求6:字节流-----读取⽂件内容 使⽤字节流读取内容的时候,这⾥记录了两种⽅式,最主要的区别就是⽅式⼀中,我们预先申请了⼀个指定⼤⼩的内存空间,但是这个空间在实际使⽤的过程中,可能会存在偏⼤或者偏⼩的情况,所以提倡使⽤⽅式⼆。
IO流之字节流和字符流详解-推荐下载
} } } }
我们如何对数据进行续写?我们就要使用到 FileWriter 的另一个构造方法。 FileWriter(String fileName, boolean append):根据给定的文件名以及指示是否附加写入数据 的 boolean 值来构造 FileWriter 对象。 创建的时候即 new FileWriter(“数据目的地”,“true”);
public static void main(String[] args) {
//我们首先创建类型的变量并作用于整个域 FileWriter fw=null; try{
fw=new FileWriter("k://demo.txt"); fw.write("xixi"); }catch(IOException e){ //此处是对异常的处理 System.out.println("catch:"+e); }finally{ try{
IO 流之字节流和字符流详解
IO(Input output)流,分为两种:字节流和字符流 字节流的两个基类: InputStream(读)OutStream(写) 字符流的两个基类: Reader(读) Writer(写)
字符流
写(FileWriter)和读(FileReader)
写(FileWriter)
//调用读取对象的 read 方法 //read():一次读一个字符,而且会自动往下读。 //fr.read()
字符流、字节流的使用与区别经验总结
1、因为文件都是以字节的形式保存的,而且网络上文件传输也是以字节形式传输的所以最好还是用字节流2、读或输入:就是将文件读到程序中,即input.read(程序变量)写或输出:就是将程序写进文件中,即out.writer(程序变量)3、读/写、输入/输出:都有以下四步,只有程序变量在传入或close后是否需要转换不同实例化文件类、实例化类、对象.方法(程序变量)、对象.close() 4、字符流:读/写因为FileReader继承InputStreamReader,InputStreamReader继承Reader且InputStreamReader能够将字节转化为字符所以Reader input=new FileReader(文件); input.reader(字符数组);读的是字节,但读到程序中的是字符数组因为FileWriter继承OutputStreamWriter,OutputStreamWriter继承Writer且OutputStreamWriter能够将字符转化为字节所以Writer out=new FileWriter(文件);out.writer(字符串);写的是字符数组或字符串,但写进文件的是字节File f= new File("d:" + File.separator + "test.txt");Reader input=new FileReader(f)char c[]=new char[1024];但不能是字符串input.read(c);input.close();String s=new String(c);File f= new File("d:" + File.separator + "test.txt");Writer out=new FileWriter(f);char c[]={‘a’,’b’,’c’};或字符串out.writer(c);out.close();5、字节流:输入/输出File f= new File("d:" + File.separator + "test.txt");InputStream input= new FileInputStream(f);byte b[] = new byte[1024];input.read(b);input.close();String s=new String(b);读的、读到程序中的、写的、写进文件的一直都是字节File f= new File("d:" + File.separator + "test.txt");OutputStream out=new FileOutputStream(f);String str = "Hello World!!!";byte b[] = str.getBytes();out.write(b);out.close();6、向文件中写入:out = new FileWriter(f)、out = new FileOutputStream(f)向文件中追加:out = new FileWriter(f,true)、out = new FileOutputStream(f,true)。
字符串流与字节流区别
JAVA 字符流与字节流的区别Java 流在处理上分为字符流和字节流。
字符流处理的单元为2 个字节的Unicode 字符,分别操作字符、字符数组或字符串,而字节流处理单元为 1 个字节,操作字节和字节数组。
Java 内用Unicode 编码存储字符,字符流处理类负责将外部的其他编码的字符流和java 内Unicode 字符流之间的转换。
而类InputStreamReader 和OutputStreamWriter 处理字符流和字节流的转换。
字符流(一次可以处理一个缓冲区)一次操作比字节流(一次一个字节)效率高。
( 一)以字节为导向的stream------InputStream/OutputStreamInputStream 和OutputStream 是两个abstact 类,对于字节为导向的stream 都扩展这两个鸡肋(基类^_^ );1、InputStream1.1ByteArrayInputStream -- 把内存中的一个缓冲区作为InputStream 使用 .construct---(A)ByteArrayInputStream(byte[]) 创建一个新字节数组输入流(ByteArrayInputStream ),它从指定字节数组中读取数据(使用byte 作为其缓冲区数组)(B)---ByteArrayInputStream(byte[], int, int) 创建一个新字节数组输入流,它从指定字节数组中读取数据。
---mark:: 该字节数组未被复制。
1.2StringBufferInputStream -- 把一个String 对象作为InputStream .construct---StringBufferInputStream(String) 据指定串创建一个读取数据的输入流串。
注释:不推荐使用StringBufferInputStream 方法。
此类不能将字符正确的转换为字节。
【120期】JavaIO:字节流、字符流、缓冲流
【120期】JavaIO:字节流、字符流、缓冲流2020年百日百更原创Java最全面试题库之往期回顾【000期】Java最全面试题库思维导图【020期】JavaSE系列面试题汇总(共18篇)【028期】JavaWeb系列面试题汇总(共10篇)【042期】JavaEE系列面试题汇总(共13篇)【049期】数据库系列面试题汇总(共6篇)【053期】中间件系列面试题汇总(共3篇)【065期】数据结构与算法面试题汇总(共11篇)【076期】分布式面试题汇总(共10篇)【100期】综合面试题系列汇总(共23篇)【102期】Synchronized 同步方法的八种使用场景【103期】线上服务平均响应时间太长,怎么排查?【104期】innodb下的记录锁,间隙锁,next-key锁【105期】MySQL主从复制的几种方式【106期】数据库实现缓存最终一致性的一些方法【107期】SimpleDateFormat 的线程安全问题与解决方案【108期】单点登录的三种实现方式【109期】SOA架构和微服务架构的区别【110期】说说MySQL分区【111期】线程池中多余的线程是如何回收的?【112期】利用装饰者模式在不改变原有对象的基础上扩展功能【113期】MySQL/InnoDB的加锁过程【114期】反射是如何影响性能的,它到底慢在哪里?【115期】分布式事务问题的几种方案【116期】在项目中,如何应对高并发流量【117期】HashMap 面试二十一问!【118期】方法重载和方法重写的原理【119期】Spring是怎么解决循环依赖的?IO流是Java中的一个重要构成部分,也是我们经常打交道的。
这篇关于Java IO的博文干货满满,堪称全网前三(请轻喷!)下面几个问题(问题还会继续补充),如果你能对答如流,那么恭喜你,IO知识掌握得很好,可以立即关闭文章。
反之,你可以在后面得文章中寻找答案。
1.Java IO流有什么特点?2.Java IO流分为几种类型?3.字节流和字符流的关系与区别?4.字符流是否使用了缓冲?5.缓冲流的效率一定高吗?为什么?6.缓冲流体现了Java中的哪种设计模式思想?7.为什么要实现序列化?如何实现序列化?8.序列化数据后,再次修改类文件,读取数据会出问题,如何解决呢?1 初识Java IOIO,即in和out,也就是输入和输出,指应用程序和外部设备之间的数据传递,常见的外部设备包括文件、管道、网络连接。
字符流和字节流的区别
字符流和字节流的区别
字符流和字节流的区别:
1、读写单位不同:字节流以字节(8bit)为单位,字符流以字符为单位,根据码表映射字符,⼀次可能读多个字节。
2、处理对象不同:字节流能处理所有类型的数据(如图⽚、avi等),⽽字符流只能处理字符类型的数据。
3、处理⽅式不同:
Java的字节流
InputStream是所有字节输⼊流的祖先
OutputStream是所有字节输出流的祖先。
Java的字符流
Reader是所有读取字符串输⼊流的祖先
writer是所有输出字符串的祖先。
结论:只要是处理纯⽂本数据,就优先考虑使⽤字符流。
除此之外都使⽤字节流。
16.IO流(字节流,字符流,数据流、对象流)
16.IO流(字节流,字符流,数据流、对象流)I/O框架1. IO框架介绍I:inputO:output流:按数据流向划分:输⼊流、输出流按处理单元划分:字节流,字符流2. File类2.1 File类构造⽅法File类提供了⽤于操作⽂件和获取⽂件信息的⼀系列⽅法1.File类的构造⽅法:File(String pathname) :File(File parent, String child): 根据⽗类路径名与⼦类路径名字字符串创建新的file实例(便于先处理⽗类路径);File(String parent, String child): 与上式类似2.2 File类常⽤⽅法(增删改查)1.创建:createNewFile()mkdir() 创建⽂件夹mkdirs() 创建多级⽂件夹,⽤\\或/隔开renameTo(File dest) 重命名⽂件或⽂件夹,如果⽬标⽂件与源⽂件是在同⼀个路径下,那么renameTo的作⽤是重命名,如果⽬标⽂件与源⽂件不是在同⼀个路径下,那么renameTo的作⽤就是剪切,⽽且还不能操作⽂件夹。
注:separatorChar:⽬录分隔符separator包含⼀个separatorChar,字符串形式。
均是静态,File类直接调⽤new File("C:" + File.separator + "a.txt");2.删除:delete() 删除⽂件或⼀个空⽂件夹(⾮空不能删),有返回值deleteOnExit() 保证程序异常时创建的临时⽂件也可以被删除,⽆返回值,⼀般⽤于删除临时⽂件3.判断exists()isFile()isDirectory()isAbsolute() 测试此抽象路径名是否为绝对路径名。
4.获取getName()getPath()getAbsolutePath()length()lastModified() 获取最后⼀次被修改的时间(毫秒值)。
java的IO学习,字节流与字符流的编码讲解
java的IO学习,字节流与字符流的编码讲解字节流与字符流字节流可以处理所有类型的数据(图⽚、视频等),在java中对应的类都为“stream”结尾1字节=8位⼆进制=具体存储空间字符流仅能处理纯⽂本的数据,在java中对应的类都是以“reader”或者“writer”结尾如汉字,符号等import org.junit.Test;public class IOTest {/*** BufferedInputStream BufferedOutputStream* 利⽤字节缓冲流实现⽂件的复制* @throws IOException* */@Testpublic void bufferedInputStreamAndbufferedOutputStream() throws IOException{//新建字节的输⼊输出InputStream in = new FileInputStream("hellow.txt");BufferedInputStream bStream = new BufferedInputStream(in);OutputStream out = new FileOutputStream("hellow2.txt");BufferedOutputStream bOutputStream = new BufferedOutputStream(out);//创建缓冲数组byte[] bytes = new byte[100];//进⾏复制int len = 0;while((len = bStream.read(bytes))!= -1){bOutputStream.write(bytes, 0, len);}//关闭流bStream.close();bOutputStream.close();}/*** bufferdeReader And bufferedWriter* 利⽤缓冲流实现⽂件的复制* @throws IOException* **/@Testpublic void bufferdeReaderAndbufferedWriter() throws IOException {// 新建字符的输⼊输出Reader in = new FileReader("hellow.txt");BufferedReader bReader = new BufferedReader(in);Writer out = new FileWriter("hellow2.txt");BufferedWriter bWriter = new BufferedWriter(out);// 进⾏复制String line = null;int i = 0;while ((line = bReader.readLine()) != null) {if (i != 0)bWriter.write("\n");bWriter.write(line, 0, line.length());i++;}// 关闭流bReader.close();bWriter.close();}/***reader writer* 利⽤字符输⼊输出流, 完成 hello.txt ⽂件的复制.* 把该⽂件复制为 hello2.txt*/@Testpublic void readerAndwriter() throws IOException {//新建字符的输⼊输出Reader reader = new FileReader("hellow.txt");Writer writer = new FileWriter("hellow2.txt");//定义数组,⽤于读写⽂件char[] cbuf = new char[100];//读写⽂件int len;while((len = reader.read(cbuf)) != -1){writer.write(cbuf, 0, len);}//关闭流reader.close();writer.close();}/***InputStream OutputStream* 利⽤字节输⼊输出流, 完成 hello.txt ⽂件的复制.* 把该⽂件复制为 hello2.txt* @throws IOException*/@Testpublic void testCopyFile() throws IOException{//1. 创建定位到 hello.txt 的⽂件的输⼊流InputStream in = new FileInputStream("枚举类.avi");//2. 创建定位到 hello2.txt 的⽂件输出流OutputStream out = new FileOutputStream("枚举类2.avi"); //3. 创建⼀个 byte 数组, ⽤于读写⽂件byte [] buffer = new byte[1024 * 10];int len = 0;//4. 读写⽂件://in.read(buffer); out.write(buffer, 0, len);while((len = in.read(buffer)) != -1){out.write(buffer);}//5. 关闭流资源.out.close();in.close();}/*** 测试字节输出流 OutputStream* @throws IOException*/@Testpublic void testOutputStream() throws IOException{ OutputStream out = new FileOutputStream("abcd.txt"); String content = "\nHello Java!";out.write(content.getBytes());out.close();}/*** 测试字符输⼊流. Reader* @throws IOException*/@Testpublic void testReader() throws IOException{//利⽤字符输⼊流读取 hello.txt ⽂档的内容, 输出到控制台. Reader reader = new FileReader("hello.txt");char [] buffer = new char[10];int len = 0;while((len = reader.read(buffer)) != -1){for(int i = 0; i < len; i++){System.out.print(buffer[i]);}}reader.close();}/*** 测试字节输⼊流 InputStream* @throws IOException*/@Testpublic void testInputStream() throws IOException{//1. 创建了⼀个字节输⼊流.InputStream in = new FileInputStream("hello.txt");//2. 读取⽂件的内容//2.1 第⼀读取⼀个字节. 效率很低, 不建议这样读. -1 表⽰读取到⽂件的结尾处// int result = in.read();//// while(result != -1){// System.out.print((char)result);// result = in.read();// }//2.2 ⼀次读取⼀组: ⼀组字符.//返回⼀次实际读取的字节数, 若为 -1 表⽰读取到⽂件的结尾// byte [] buffer = new byte[10];// int len = 0;//// while((len = in.read(buffer)) != -1){// for(int i = 0; i < len; i++){// System.out.print((char)buffer[i]);// }// }//2.3 把内容读取到字节数组的部分连续的元素中.byte [] result = new byte[1024 * 10];in.read(result, 10, in.available());//3. 关闭流资源in.close();}/*** File: 代表物理的意义的⽂件或⽬录* @throws IOException*/@Testpublic void testFile() throws IOException{//1. 创建 File 对象File file = new File("hello.txt");//2. 测试 File 对象的⽅法.//2.1 ⽂件名相关的⽅法String fileName = file.getName();System.out.println(fileName);//2.2 访问⽂件的绝对路径String path = file.getAbsolutePath();System.out.println(path);//2.3 为⽂件重命名//file.renameTo(new File("d:\\hello.txt"));//3. ⽂件检测相关的⽅法System.out.println(file.exists());File dir = new File("atguigu");System.out.println(dir.isFile());//4. 获取⽂件的常规信息System.out.println(file.length());//5. ⽂件操作相关.File file2 = new File("abcd.txt");file2.createNewFile();}}。
字节和字符的区别【转】
字节和字符的区别【转】(⼀)“字节”的定义字节(Byte)是⼀种计量单位,表⽰数据量多少,它是计算机信息技术⽤于计量存储容量的⼀种计量单位。
(⼆)“字符”的定义字符是指计算机中使⽤的⽂字和符号,⽐如1、2、3、A、B、C、~!·#¥%……—*()——+、等等。
(三)“字节”与“字符”它们完全不是⼀个位⾯的概念,所以两者之间没有“区别”这个说法。
不同编码⾥,字符和字节的对应关系不同:①ASCII码中,⼀个英⽂字母(不分⼤⼩写)占⼀个字节的空间,⼀个中⽂汉字占两个字节的空间。
⼀个⼆进制数字序列,在计算机中作为⼀个数字单元,⼀般为8位⼆进制数,换算为⼗进制。
最⼩值0,最⼤值255。
②UTF-8编码中,⼀个英⽂字符等于⼀个字节,⼀个中⽂(含繁体)等于三个字节。
③Unicode编码中,⼀个英⽂等于两个字节,⼀个中⽂(含繁体)等于两个字节。
符号:英⽂标点占⼀个字节,中⽂标点占两个字节。
举例:英⽂句号“.”占1个字节的⼤⼩,中⽂句号“。
”占2个字节的⼤⼩。
④UTF-16编码中,⼀个英⽂字母字符或⼀个汉字字符存储都需要2个字节(Unicode扩展区的⼀些汉字存储需要4个字节)。
⑤UTF-32编码中,世界上任何字符的存储都需要4个字节。
==============================================================================package com.suypower.chengyu.test;public class ByteTest {/*** byte 8 bits -128 - + 127* 1 bit = 1 ⼆进制数据* 1 byte = 8 bit* 1 字母 = 1 byte = 8 bit(位)* 1 汉字 = 2 byte = 16 bit*/public static void main(String[] args) {// TODO Auto-generated method stubbyte b1 = 127;byte b2 = -128;byte b3 = 'a';byte b4 = 'A'; // ⼀个字母 = 1 byte = 8 bit// byte b5 ='aa'; 这就错了// byte b6 ='中'; 这就错了⼀个汉字 2个字节 16bitshort s1 = '啊'; // ⼀个汉字 2个字节 16bit short 是 16 bit位的// short s2 = '汉字'; // 2个汉字 4个字节 32 bit int 是32 bit的// int i1 = '汉字'; 但是 int 是数字类型的 , char 是 16 bit的 = 2 byte = ⼀个汉字char c1 = '汗';// byte 转换 stringString string = "中⽂";byte by[] = string.getBytes();String str = new String(by);System.out.println("str="+str);}}==================================================================================[Java-原创] bit、byte、位、字节、汉字、字符bit、byte、位、字节、汉字的关系1 bit = 1 ⼆进制数据1 byte = 8 bit1 字母 = 1 byte = 8 bit1 汉字 =2 byte = 16 bit1. bit:位⼀个⼆进制数据0或1,是1bit;2. byte:字节存储空间的基本计量单位,如:MySQL中定义 VARCHAR(45) 即是指 45个字节;1 byte = 8 bit3. ⼀个英⽂字符占⼀个字节;1 字母 = 1 byte = 8 bit4. ⼀个汉字占2个字节;1 汉字 =2 byte = 16 bit5. 标点符号A>. 汉字输⼊状态下,默认为全⾓输⼊⽅式;B>. 英⽂输⼊状态下,默认为半⾓输⼊⽅式;C>. 全⾓输⼊⽅式下,标点符号占2字节;D>. 半⾓输⼊⽅式下,标点符号占1字节;故:汉字输⼊状态下的字符,占2个字节 (但不排除,⾃⼰更改了默认设置);英⽂输⼊状态下的字符,占1个字节 (但不排除,⾃⼰更改了默认设置);⽼美在发明电脑时,肯定以⾃⼰的英⽂字母--即他们⾃认为的字符为最⼩的存储计量单位,于是也就有了不规范的1字符=1byte,岂不知还有我们伟⼤的汉字计量单位,NND,⼀个汉字也是⼀个字符,我们的1汉字字符就等于2byte,后来,他们可能意识到这个尴尬的问题,于是⼜标榜为:⼀个字母为⼀个标准字符,去球吧,谁整天没事说个字符还“标准字符”,所以啊,个⼈认为:字符,不能⽤于标准的计量单位。
day09【字节流、字符流】-笔记
day09【字节流、字符流】主要内容IO流字节流字符流异常处理Properties教学目标能够说出IO流的分类和功能能够使用字节输出流写出数据到文件能够使用字节输入流读取数据到程序能够理解读取数据read(byte[])方法的原理能够使用字节流完成文件的复制能够使用FileWirter写数据到文件能够说出FileWriter中关闭和刷新方法的区别能够使用FileWriter写数据的5个方法能够使用FileWriter写数据实现换行和追加写能够使用FileReader读数据能够使用FileReader读数据一次一个字符数组能够使用Properties的load方法加载文件中配置信息第一章 IO概述1.1 什么是IO生活中,你肯定经历过这样的场景。
当你编辑一个文本文件,忘记了ctrl+s,可能文件就白白编辑了。
当你电脑上插入一个U盘,可以把一个视频,拷贝到你的电脑硬盘里。
那么数据都是在哪些设备上的呢?键盘、内存、硬盘、外接设备等等。
我们把这种数据的传输,可以看做是一种数据的流动,按照流动的方向,以内存为基准,分为输入input和输出output,即流向内存是输入流,流出内存的输出流。
Java中I/O操作主要是指使用java.io包下的内容,进行输入、输出操作。
输入也叫做读取数据,输出也叫做作写出数据。
1.2 IO的分类根据数据的流向分为:输入流和输出流。
输入流:把数据从其他设备上读取到内存中的流。
输出流:把数据从内存中写出到其他设备上的流。
格局数据的类型分为:字节流和字符流。
字节流:以字节为单位,读写数据的流。
字符流:以字符为单位,读写数据的流。
1.3 IO的流向说明图解1.4 顶级父类们输入流输出流字节流字节输入流字节输出流InputStream OutputStream字符流字符输入流字符输出流Reader Writer第二章字节流2.1 一切皆为字节一切文件数据(文本、图片、视频等)在存储时,都是以二进制数字的形式保存,都一个一个的字节,那么传输时一样如此。
字节流与字符流
字节流与字符流
InputStream和OutputStream的子类都是字节流 -字符输入流 FileReader -主要处理字符或字符串,字符流处理单元为2个字节。 -字节输出流 FileOutputStream -字节流将读取到的字节数据,去指定的编码表中获取对应文字。 从数据流编码格式上划分为
-可以读写二进制-字文件符,主输要出处理流音频、Fi图l片e、W歌r曲it、e字r节流,处理单元为1个字节。
从数据流编码格式上划分为 -字节输出流 FileOutputStream InputStream和OutputStream的子类都是字节流 -字节流将读取到的字节数据,去指定的编码表中获取对应文字。 InputStream和OutputStream的子类都是字节流
Reader和Writer-的字子类节都是输字出符流流 FileOutputStream
从数据流编码格式上划分为 -主要处理字符或字符串,字符流处理单元为2个字节。 -字节流将读取到的字节数据,去指定的编码表中获取对应文字。 InputStream和OutputStream的子类都是字节流 -主要处理字符或字符串,字符流处理单元为2个字节。
字节流中常用类 -字节流将读取到的字节数据,去指定的编码表中获取对应文字。
Reader和Writer的子类都是字符流 从数据流编码格式上划分为
-字节输出流 Fil-eO字utp节utSt输ream入流 FileInputStream
-可以读写二进制文件,主要处理音频、图片、歌曲、字节流,处理单元为1个字节。 -字节流将读取到的字节数据,去指定的编码表中获取对应文字。
字节流与字符流
字节流与字符流
从数据流编码格式上划分为
-字节流 -字符流
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
76、字节流与字符流的区别
要把一片二进制数据数据逐一输出到某个设备中,或者从某个设备中逐一读取一片二进制数据,不管输入输出设备是什么,我们要用统一的方式来完成这些操作,用一种抽象的方式进行描述,这个抽象描述方式起名为IO流,对应的抽象类为OutputStream和InputStream ,不同的实现类就代表不同的输入和输出设备,它们都是针对字节进行操作的。
在应用中,经常要完全是字符的一段文本输出去或读进来,用字节流可以吗?计算机中的一切最终都是二进制的字节形式存在。
对于“中国”这些字符,首先要得到其对应的字节,然后将字节写入到输出流。
读取时,首先读到的是字节,可是我们要把它显示为字符,我们需要将字节转换成字符。
由于这样的需求很广泛,人家专门提供了字符流的包装类。
底层设备永远只接受字节数据,有时候要写字符串到底层设备,需要将字符串转成字节再进行写入。
字符流是字节流的包装,字符流则是直接接受字符串,它内部将串转成字节,再写入底层设备,这为我们向IO设别写入或读取字符串提供了一点点方便。
字符向字节转换时,要注意编码的问题,因为字符串转成字节数组,
其实是转成该字符的某种编码的字节形式,读取也是反之的道理。
讲解字节流与字符流关系的代码案例:
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.InputStreamReader;
import java.io.PrintWriter;
public class IOTest {
public static void main(String[] args) throws Exception {
String str = "中国人";
/*FileOutputStream fos = new FileOutputStream("1.txt");
fos.write(str.getBytes("UTF-8"));
fos.close();*/
/*FileWriter fw = new FileWriter("1.txt");
fw.write(str);
fw.close();*/
PrintWriter pw = new PrintWriter("1.txt","utf-8");
pw.write(str);
pw.close();
/*FileReader fr = new FileReader("1.txt");
char[] buf = new char[1024];
int len = fr.read(buf);
String myStr = new String(buf,0,len);
System.out.println(myStr);*/
/*FileInputStream fr = new FileInputStream("1.txt"); byte[] buf = new byte[1024];
int len = fr.read(buf);
String myStr = new String(buf,0,len,"UTF-8"); System.out.println(myStr);*/
BufferedReader br = new BufferedReader(
new InputStreamReader(
new FileInputStream("1.txt"),"UTF-8"
)
);
String myStr = br.readLine();
br.close();
System.out.println(myStr);
}
}。