Java:字符集、IO流 --黑马笔记

时间:2024-02-11 22:48:19 标签:  字符集  

一、字符集

1.1 字符集的来历

我们知道计算机是美国人发明的,由于计算机能够处理的数据只能是0和1组成的二进制数据,为了让计算机能够处理字符,于是美国人就把他们会用到的每一个字符进行了编码(所谓编码,就是为一个字符编一个二进制数据)。

美国人常用的字符有英文字母、标点符号、数字以及一些特殊字符,这些字符一共也不到128个,所以他们用1个字节来存储1字符就够了。 美国人把他们用到的字符和字符对应的编码总结成了一张码表,这张码表叫做ASCII码表(也叫ASCII字符集)。

其实计算机只在美国用是没有问题的,但是计算机慢慢的普及到全世界,当普及到中国的时候,在计算机中想要存储中文,那ASCII字符集就不够用了,因为中文太多了,随便数一数也有几万个字符。

于是中国人为了在计算机中存储中文,也编了一个中国人用的字符集叫做GBK字符集,这里面包含2万多个汉字字符,GBK中一个汉字采用两个字节来存储,为了能够显示英文字母,GBK字符集也兼容了ASCII字符集,在GBK字符集中一个字母还是采用一个字节来存储

1.2 汉字和字母的编码特点

讲到这里,可能有同学有这么一个疑问: 如果一个文件中既有中文,也有英文,那计算机怎么知道哪几个字节表示一个汉字,哪几个字节表示一个字母呢?

其实这个问题问当想当有水平,接下来,就带着同学们了解一下,计算机是怎么识别中文和英文的。

比如:在文件中存储一个我a你,底层其实存储的是这样的二进制数据。

需要我们注意汉字和字母的编码特点:

1. 如果是存储字母,采用1个字节来存储,一共8位,其中第1位是0

2. 如果是存储汉字,采用2个字节来存储,一共16位,其中第1位是1

当读取文件中的字符时,通过识别读取到的第1位是0还是1来判断是字母还是汉字

如果读取到第1位是0,就认为是一个字母,此时往后读1个字节。如果读取到第1位是1,就认为是一个汉字,此时往后读2个字节。

1.3 Unicode字符集

咱们国家可以用GBK字符集来表示中国人使用的文字,那世界上还有很多其他的国家,他们也有自己的文字,他们也想要自己国家的文字在计算机中处理,于是其他国家也在搞自己的字符集,就这样全世界搞了上百个字符集,而且各个国家的字符集互不兼容。 这样其实很不利于国际化的交流,可能一个文件在我们国家的电脑上打开好好的,但是在其他国家打开就是乱码了。

为了解决各个国家字符集互不兼容的问题,由国际化标准组织牵头,设计了一套全世界通用的字符集,叫做Unicode字符集。在Unicode字符集中包含了世界上所有国家的文字,一个字符采用4个字节存储。

在Unicode字符集中,采用一个字符4个字节的编码方案,又造成另一个问题:如果是说英语的国家,他们只需要用到26大小写字母,加上一些标点符号就够了,本身一个字节就可以表示完,用4个字节就有点浪费。

于是又对Unicode字符集中的字符进行了重新编码,一共设计了三种编码方案。分别是UTF-32、UTF-16、UTF-8; 其中比较常用的编码方案是UTF-8

下面我们详细介绍一下UTF-8这种编码方案的特点。

1.UTF-8是一种可变长的编码方案,共分为4个长度区
2.英文字母、数字占1个字节兼容(ASCII编码)
3.汉字字符占3个字节
4.极少数字符占4个字节

1.4 字符集小结

最后,我们将前面介绍过的字符集小结一下:

ASCII字符集:《美国信息交换标准代码》,包含英文字母、数字、标点符号、控制字符
    特点:1个字符占1个字节

GBK字符集:中国人自己的字符集,兼容ASCII字符集,还包含2万多个汉字
    特点:1个字母占用1个字节;1个汉字占用2个字节

Unicode字符集:包含世界上所有国家的文字,有三种编码方案,最常用的是UTF-8
    UTF-8编码方案:英文字母、数字占1个字节兼容(ASCII编码)、汉字字符占3个字节

1.5 编码和解码

其实String类中就提供了相应的方法,可以完成编码和解码的操作。

编码:把字符串按照指定的字符集转换为字节数组

解码:把字节数组按照指定的字符集转换为字符串

public class Test {public static void main(String[] args) throws Exception {// 1、编码String data = "a我b";byte[] bytes = data.getBytes(); // 默认是按照平台字符集(UTF-8)进行编码的。System.out.println(Arrays.toString(bytes));// 按照指定字符集进行编码。byte[] bytes1 = data.getBytes("GBK");System.out.println(Arrays.toString(bytes1));// 2、解码String s1 = new String(bytes); // 按照平台默认编码(UTF-8)解码System.out.println(s1);String s2 = new String(bytes1, "GBK");System.out.println(s2);}
}

二、IO流(字节流)

2.1 IO流概述

在前面我们已经学习过File类。但是我们知道File只能操作文件,但是不能操作文件中的内容。我们也学习了字符集,不同的字符集存字符数据的原理是不一样的。有了前面两个知识的基础,接下来我们再学习IO流,就可以对文件中的数据进行操作了。

IO流的作用:就是可以对文件或者网络中的数据进行读、写的操作。

把数据从磁盘、网络中读取到程序中来,用到的是输入流。

把程序中的数据写入磁盘、网络中,用到的是输出流。

简单记:输入流(读数据)、输出流(写数据)。

IO流在Java中有很多种,不同的流来干不同的事情。Java把各种流用不同的类来表示,这些流的继承体系如下图所示:

IO流分为两大派系:
    1.字节流:字节流又分为字节输入流、字节输出流
    2.字符流:字符流由分为字符输入流、字符输出流

2.2 FileInputStream读取一个字节

接下来我们学习字节流中的字节输入流,用InputStream来表示。但是InputStream是抽象类,我们用的是它的子类,叫FileInputStream。

需要用到的方法如下图所示:有构造方法、成员方法

使用FileInputStream读取文件中的字节数据,步骤如下:

第一步:创建FileInputStream文件字节输入流管道,与源文件接通。
第二步:调用read()方法开始读取文件的字节数据。
第三步:调用close()方法释放资源

代码如下:

public class FileInputStreamTest1 {public static void main(String[] args) throws Exception {// 1、创建文件字节输入流管道,与源文件接通。InputStream is = new FileInputStream(("file-io-app\\src\\itheima01.txt"));// 2、开始读取文件的字节数据。// public int read():每次读取一个字节返回,如果没有数据了,返回-1.int b; // 用于记住读取的字节。while ((b = is.read()) != -1){System.out.print((char) b);}//3、流使用完毕之后,必须关闭!释放系统资源!is.close();}
}

这里需要注意一个问题:由于一个中文在UTF-8编码方案中是占3个字节,采用一次读取一个字节的方式,读一个字节就相当于读了1/3个汉字,此时将这个字节转换为字符,是会有乱码的。

2.3 FileInputStream读取多个字节

在上一节我们学习了FileInputStream调用read()方法,可以一次读取一个字节。但是这种读取方式效率太太太太慢了。 为了提高效率,我们可以使用另一个read(byte[] bytes)的重载方法,可以一次读取多个字节,至于一次读多少个字节,就在于你传递的数组有多大。

使用FileInputStream一次读取多个字节的步骤如下:

第一步:创建FileInputStream文件字节输入流管道,与源文件接通。
第二步:调用read(byte[] bytes)方法开始读取文件的字节数据。
第三步:调用close()方法释放资源

代码如下:

public class FileInputStreamTest2 {public static void main(String[] args) throws Exception {// 1、创建一个字节输入流对象代表字节输入流管道与源文件接通。InputStream is = new FileInputStream("file-io-app\\src\\itheima02.txt");// 2、开始读取文件中的字节数据:每次读取多个字节。// public int read(byte b[]) throws IOException// 每次读取多个字节到字节数组中去,返回读取的字节数量,读取完毕会返回-1.// 3、使用循环改造。byte[] buffer = new byte[3];int len; // 记住每次读取了多少个字节。 abc 66while ((len = is.read(buffer)) != -1){// 注意:读取多少,倒出多少。String rs = new String(buffer, 0 , len);System.out.print(rs);}// 性能得到了明显的提升!!// 这种方案也不能避免读取汉字输出乱码的问题!!is.close(); // 关闭流}
}

需要我们注意的是:read(byte[] bytes)它的返回值,表示当前这一次读取的字节个数。

假设有一个a.txt文件如下:

abcde

每次读取过程如下:

也就是说,并不是每次读取的时候都把数组装满,比如数组是 byte[] bytes = new byte[3];
第一次调用read(bytes)读取了3个字节(分别是97,98,99),并且往数组中存,此时返回值就是3
第二次调用read(bytes)读取了2个字节(分别是99,100),并且往数组中存,此时返回值是2
第三次调用read(bytes)文件中后面已经没有数据了,此时返回值为-1

还需要注意一个问题:采用一次读取多个字节的方式,也是可能有乱码的。因为也有可能读取到半个汉字的情况。

2.4 FileInputStream读取全部字节

我们可以一次性读取文件中的全部字节,然后把全部字节转换为一个字符串,就不会有乱码了。

// 1、一次性读取完文件的全部字节到一个字节数组中去。
// 创建一个字节输入流管道与源文件接通
InputStream is = new FileInputStream("file-io-app\\src\\itheima03.txt");// 2、准备一个字节数组,大小与文件的大小正好一样大。
File f = new File("file-io-app\\src\\itheima03.txt");
long size = f.length();
byte[] buffer = new byte[(int) size];int len = is.read(buffer);
System.out.println(new String(buffer));//3、关闭流
is.close(); 

// 1、一次性读取完文件的全部字节到一个字节数组中去。
// 创建一个字节输入流管道与源文件接通
InputStream is = new FileInputStream("file-io-app\\src\\itheima03.txt");//2、调用方法读取所有字节,返回一个存储所有字节的字节数组。
byte[] buffer = is.readAllBytes();
System.out.println(new String(buffer));//3、关闭流
is.close(); 

最后,还是要注意一个问题:一次读取所有字节虽然可以解决乱码问题,但是文件不能过大,如果文件过大,可能导致内存溢出。

2.5 FileOutputStream写字节

各位同学,前面我们学习了使用FIleInputStream读取文件中的字节数据。然后有同学就迫不及待的想学习往文件中写入数据了。

往文件中写数据需要用到OutputStream下面的一个子类FileOutputStream。写输入的流程如下图所示:

使用FileOutputStream往文件中写数据的步骤如下:

第一步:创建FileOutputStream文件字节输出流管道,与目标文件接通。
第二步:调用wirte()方法往文件中写数据
第三步:调用close()方法释放资源

代码如下:

public class FileOutputStreamTest4 {public static void main(String[] args) throws Exception {// 1、创建一个字节输出流管道与目标文件接通。// 覆盖管道:覆盖之前的数据  这个是写入到开头,会覆盖内容的// OutputStream os =//    new FileOutputStream("file-io-app/src/itheima04out.txt");// 追加数据的管道 若第二个参数为真,则意味着会写入字节到文件的末尾,意味着追加内容,若为假,则是写入字节到文件的开头,意味着是覆盖内容OutputStream os =new FileOutputStream("D:\\code\\javasepro\\helloworld-app\\src\\itheima04out.txt",true);// 2、开始写字节数据出去了os.write(97); // 97就是一个字节,代表aos.write('b'); // 'b'也是一个字节//os.write('磊'); //默认只能写出去一个字节,所以这个汉字会乱码byte[] bytes = "我爱你中国abc".getBytes();os.write(bytes);//我爱你中国abcos.write(bytes, 0, 15);//我爱你中国// 换行符os.write("\r\n".getBytes());  //回车和换行os.close(); // 关闭流}
}

2.6 字节流复制文件

比如:我们要复制一张图片,从磁盘D:/resource/meinv.png的一个位置,复制到C:/data/meinv.png位置。

复制文件的思路如下图所示:

1.需要创建一个FileInputStream流与源文件接通,创建FileOutputStream与目标文件接通
2.然后创建一个数组,使用FileInputStream每次读取一个字节数组的数据,存如数组中
3.然后再使用FileOutputStream把字节数组中的有效元素,写入到目标文件中

public class CopyTest5 {public static void main(String[] args) throws Exception {// 需求:复制照片。// 1、创建一个字节输入流管道与源文件接通InputStream is = new FileInputStream("D:\\resource\\1.jpg");// 2、创建一个字节输出流管道与目标文件接通。OutputStream os = new FileOutputStream("D:\\data\\1.jpg");//System.out.println(10 / 0); //这里不注释会报异常// 3、创建一个字节数组,负责转移字节数据。byte[] buffer = new byte[1024]; // 1KB.// 4、从字节输入流中读取字节数据,写出去到字节输出流中。读多少写出去多少。int len; // 记住每次读取了多少个字节。while ((len = is.read(buffer)) != -1){os.write(buffer, 0, len);}os.close();is.close();System.out.println("复制完成!!");}
}

三、IO流资源释放

各位同学,前面我们已经学习了字节流,也给同学们强调过,流使用完之后一定要释放资源。但是我们之前的代码并不是很专业。

 我们现在知道这个问题了,那这个问题怎么解决呢? 在JDK7以前,和JDK7以后分别给出了不同的处理方案。

3.1 JDK7以前的资源释放

在JDK7版本以前,我们可以使用try...catch...finally语句来处理。格式如下:

try{//有可能产生异常的代码
}catch(异常类 e){//处理异常的代码
}finally{//释放资源的代码//finally里面的代码有一个特点,不管异常是否发生,finally里面的代码都会执行。
}

改造上面的代码:

public class Test2 {public static void main(String[] args) {InputStream is = null;OutputStream os = null;try {System.out.println(10 / 0);// 1、创建一个字节输入流管道与源文件接通is = new FileInputStream("file-io-app\\src\\itheima03.txt");// 2、创建一个字节输出流管道与目标文件接通。os = new FileOutputStream("file-io-app\\src\\itheima03copy.txt");System.out.println(10 / 0);// 3、创建一个字节数组,负责转移字节数据。byte[] buffer = new byte[1024]; // 1KB.// 4、从字节输入流中读取字节数据,写出去到字节输出流中。读多少写出去多少。int len; // 记住每次读取了多少个字节。while ((len = is.read(buffer)) != -1){os.write(buffer, 0, len);}System.out.println("复制完成!!");} catch (IOException e) {e.printStackTrace();} finally {// 释放资源的操作try {if(os != null) os.close();} catch (IOException e) {e.printStackTrace();}try {if(is != null) is.close();} catch (IOException e) {e.printStackTrace();}}}
}

代码写到这里,有很多同学就已经看不下去了。是的,我也看不下去,本来几行代码就写完了的,加上try...catch...finally之后代码多了十几行,而且阅读性并不高。

3.2 JDK7以后的资源释放

刚才很多同学已经发现了try...catch...finally处理异常,并释放资源代码比较繁琐。Java在JDK7版本为我们提供了一种简化的释放资源的操作,它会自动释放资源。代码写起来也想当简单。

格式如下:

try(资源对象1; 资源对象2;){使用资源的代码
}catch(异常类 e){处理异常的代码
}//注意:注意到没有,这里没有释放资源的代码。它会自动释放资源

代码如下:

public class Test3 {public static void main(String[] args) {try (// 1、创建一个字节输入流管道与源文件接通InputStream is = new FileInputStream("D:/resource/meinv.png");// 2、创建一个字节输出流管道与目标文件接通。OutputStream os = new FileOutputStream("C:/data/meinv.png");){// 3、创建一个字节数组,负责转移字节数据。byte[] buffer = new byte[1024]; // 1KB.// 4、从字节输入流中读取字节数据,写出去到字节输出流中。读多少写出去多少。int len; // 记住每次读取了多少个字节。while ((len = is.read(buffer)) != -1){os.write(buffer, 0, len);}System.out.println(conn);System.out.println("复制完成!!");} catch (Exception e) {e.printStackTrace();}}
}

四、字符流

前面我们学习了字节流,使用字节流可以读取文件中的字节数据。但是如果文件中有中文,使用字节流来读取,就有可能读到半个汉字的情况,这样会导致乱码。虽然使用读取全部字节的方法不会出现乱码,但是如果文件过大又不太合适。

所以Java专门为我们提供了另外一种流,叫字符流,字符流是专门为读取文本数据而生的。

4.1 FileReader类

先来学习字符流中的FileReader类,这是字符输入流,用来将文件中的字符数据读取到程序中来。

FileReader读取文件的步骤如下:

第一步:创建FileReader对象与要读取的源文件接通
第二步:调用read()方法读取文件中的字符
第三步:调用close()方法关闭流

需要用到的方法:先通过构造器创建对象,再通过read方法读取数据(注意:两个read方法的返回值,含义不一样

public class FileReaderTest1 {public static void main(String[] args) {try (// 1、创建一个文件字符输入流管道与源文件接通Reader fr = new FileReader("io-app2\\src\\itheima01.txt");){// 2、一个字符一个字符的读(性能较差)
//      int c; // 记住每次读取的字符编号。
//      while ((c = fr.read()) != -1){
//        System.out.print((char) c);
//      }// 每次读取一个字符的形式,性能肯定是比较差的。// 3、每次读取多个字符。(性能是比较不错的!)char[] buffer = new char[3];int len; // 记住每次读取了多少个字符。while ((len = fr.read(buffer)) != -1){// 读取多少倒出多少System.out.print(new String(buffer, 0, len));}} catch (Exception e) {e.printStackTrace();}}
}

4.2 FileWriter类

接下来,我们就要学习FileWriter了,它可以将程序中的字符数据写入文件。

FileWriter往文件中写字符数据的步骤如下:

第一步:创建FileWirter对象与要读取的目标文件接通
第二步:调用write(字符数据/字符数组/字符串)方法读取文件中的字符
第三步:调用close()方法关闭流

需要用到的方法如下:构造器是用来创建FileWriter对象的,有了对象才能调用write方法写数据到文件。

接下来,用代码演示一下:

public class FileWriterTest2 {public static void main(String[] args) {try (// 0、创建一个文件字符输出流管道与目标文件接通。// 覆盖管道// Writer fw = new FileWriter("io-app2/src/itheima02out.txt");// 追加数据的管道Writer fw = new FileWriter("io-app2/src/itheima02out.txt", true);){// 1、public void write(int c):写一个字符出去fw.write('a');fw.write(97);//fw.write('磊'); // 写一个字符出去fw.write("\r\n"); // 换行// 2、public void write(String c)写一个字符串出去fw.write("我爱你中国abc");fw.write("\r\n");// 3、public void write(String c ,int pos ,int len):写字符串的一部分出去fw.write("我爱你中国abc", 0, 5);fw.write("\r\n");// 4、public void write(char[] buffer):写一个字符数组出去char[] buffer = {'黑', '马', 'a', 'b', 'c'};fw.write(buffer);fw.write("\r\n");// 5、public void write(char[] buffer ,int pos ,int len):写字符数组的一部分出去fw.write(buffer, 0, 2);fw.write("\r\n");} catch (Exception e) {e.printStackTrace();}}
}

4.3 FileWriter写的注意事项

FileWriter写完数据之后,必须刷新或者关闭,写出去的数据才能生效。

加上了flush()方法之后,数据就会立即到目标文件中去。

//1.创建FileWriter对象
Writer fw = new FileWriter("io-app2/src/itheima03out.txt");//2.写字符数据出去
fw.write('a');
fw.write('b');
fw.write('c');//3.刷新
fw.flush(); 

下面的代码,调用了close()方法,数据也会立即到文件中去。因为close()方法在关闭流之前,会将内存中缓存的数据先刷新到文件,再关流。

//1.创建FileWriter对象
Writer fw = new FileWriter("io-app2/src/itheima03out.txt");//2.写字符数据出去
fw.write('a');
fw.write('b');
fw.write('c');//3.关闭流
fw.close(); //会先刷新,再关流

五、缓冲流

我们还是先来认识一下缓存流,再来说一下它的作用。缓冲流有四种,如下图所示:

缓冲流的作用:可以对原始流进行包装,提高原始流读写数据的性能。

5.1 缓冲字节流

我们先来学习字节缓冲流是如何提高读写数据的性能的,原理如下图所示。是因为在缓冲流的底层自己封装了一个长度为8KB(8129byte)的字节数组,但是缓冲流不能单独使用,它需要依赖于原始流。

读数据时:它先用原始字节输入流一次性读取8KB的数据存入缓冲流内部的数组中(ps: 先一次多囤点货),再从8KB的字节数组中读取一个字节或者多个字节(消耗屯的货)。

写数据时:它是先把数据写到缓冲流内部的8KB的数组中(ps: 先攒一车货),等数组存满了,再通过原始的字节输出流,一次性写到目标文件中去(把囤好的货,一次性运走)。 

在创建缓冲字节流对象时,需要封装一个原始流对象进来。构造方法如下:

如果我们用缓冲流复制文件,代码写法如下:

public class BufferedInputStreamTest1 {public static void main(String[] args) {try (InputStream is = new FileInputStream("io-app2/src/itheima01.txt");// 1、定义一个字节缓冲输入流包装原始的字节输入流InputStream bis = new BufferedInputStream(is);OutputStream os = new FileOutputStream("io-app2/src/itheima01_bak.txt");// 2、定义一个字节缓冲输出流包装原始的字节输出流OutputStream bos = new BufferedOutputStream(os);){byte[] buffer = new byte[1024];int len;while ((len = bis.read(buffer)) != -1){bos.write(buffer, 0, len);}System.out.println("复制完成!!");} catch (Exception e) {e.printStackTrace();}}
}

5.2 字符缓冲流

接下来,我们学习另外两个缓冲流——字符缓冲流。它的原理和字节缓冲流是类似的,它底层也会有一个8KB的数组,但是这里是字符数组。字符缓冲流也不能单独使用,它需要依赖于原始字符流一起使用。

BufferedReader读数据时:它先原始字符输入流一次性读取8KB的数据存入缓冲流内部的数组中(ps: 先一次多囤点货),再从8KB的字符数组中读取一个字符或者多个字符(把消耗屯的货)。

创建BufferedReader对象需要用到BufferedReader的构造方法,内部需要封装一个原始的字符输入流,我们可以传入FileReader。

而且BufferedReader还要特有的方法,一次可以读取文本文件中的一行:

使用BufferedReader读取数据的代码如下:

public class BufferedReaderTest2 {public static void main(String[] args) {try (Reader fr = new FileReader("io-app2\\src\\itheima04.txt");// 创建一个字符缓冲输入流包装原始的字符输入流BufferedReader br = new BufferedReader(fr);){String line; // 记住每次读取的一行数据while ((line = br.readLine()) != null){System.out.println(line);}} catch (Exception e) {e.printStackTrace();}}
}

BufferedWriter写数据时:它是先把数据写到字符缓冲流内部的8BK的数组中(ps: 先攒一车货),等数组存满了,再通过原始的字符输出流,一次性写到目标文件中去(把囤好的货,一次性运走)。如下图所示:

创建BufferedWriter对象时需要用到BufferedWriter的构造方法,而且内部需要封装一个原始的字符输出流,我们这里可以传递FileWriter。

而且BufferedWriter新增了一个功能,可以用来写一个换行符:

接下来,用代码演示一下,使用BufferedWriter往文件中写入字符数据。

public class BufferedWriterTest3 {public static void main(String[] args) {try (Writer fw = new FileWriter("io-app2/src/itheima05out.txt", true);// 创建一个字符缓冲输出流管道包装原始的字符输出流BufferedWriter bw = new BufferedWriter(fw);){bw.write('a');bw.write(97);bw.write('磊');bw.newLine();bw.write("我爱你中国abc");bw.newLine();} catch (Exception e) {e.printStackTrace();}}
}

5.3 缓冲流性能分析

我们说缓冲流内部多了一个数组,可以提高原始流的读写性能。讲到这一定有同学有这么一个疑问,它和我们使用原始流,自己加一个8KB数组不是一样的吗? 缓冲流就一定能提高性能吗?先告诉同学们答案,缓冲流不一定能提高性能

下面我们用一个比较大文件(889MB)复制,做性能测试,分别使用下面四种方式来完成文件复制,并记录文件复制的时间。

① 使用低级流一个字节一个字节的复制

② 使用低级流按照字节数组的形式复制

③ 使用缓冲流一个字节一个字节的复制

④ 使用缓冲流按照字节数组的形式复制

低级流一个字节复制: 慢得简直让人无法忍受
低级流按照字节数组复制(数组长度1024): 12.117s
缓冲流一个字节复制: 11.058s
缓冲流按照字节数组复制(数组长度1024): 2.163s
【注意:这里的测试只能做一个参考,和电脑性能也有直接关系】

经过上面的测试,我们可以得出一个结论:默认情况下,采用一次复制1024个字节,缓冲流完胜。

但是,缓冲流就一定性能高吗?我们采用一次复制8192个字节试试。

低级流按照字节数组复制(数组长度8192): 2.535s
缓冲流按照字节数组复制(数组长度8192): 2.088s

经过上面的测试,我们可以得出一个结论:一次读取8192个字节时,低级流和缓冲流性能相当。相差的那几毫秒可以忽略不计。

继续把数组变大,看一看缓冲流就一定性能高吗?现在采用一次读取1024*32个字节数据试试

低级流按照字节数组复制(数组长度8192): 1.128s
缓冲流按照字节数组复制(数组长度8192): 1.133s

经过上面的测试,我们可以得出一个结论:数组越大性能越高,低级流和缓冲流性能相当。相差的那几秒可以忽略不计。

继续把数组变大,看一看缓冲流就一定性能高吗?现在采用一次读取1024*6个字节数据试试

低级流按照字节数组复制(数组长度8192): 1.039s
缓冲流按照字节数组复制(数组长度8192): 1.151s

此时你会发现,当数组大到一定程度,性能已经提高了多少了,甚至缓冲流的性能还没有低级流高。

最终总结一下:缓冲流的性能不一定比低级流高,其实低级流自己加一个数组,性能其实是不差。只不过缓冲流帮你加了一个相对而言大小比较合理的数组 。

六、转换流

前面我们学习过FileReader读取文件中的字符,但是同学们注意了,FileReader默认只能读取UTF-8编码格式的文件。如果使用FileReader读取GBK格式的文件,可能存在乱码,因为FileReader它遇到汉字默认是按照3个字节来读取的,而GBK格式的文件一个汉字是占2个字节,这样就会导致乱码。

Java给我们提供了另外两种流InputStreamReader,OutputStreamWriter,这两个流我们把它叫做转换流。它们可以将字节流转换为字符流,并且可以指定编码方案。

6.1 InputStreamReader类

接下来,我们先学习InputStreamReader类,你看这个类名就比较有意思,前面是InputStream表示字节输入流,后面是Reader表示字符输入流,合在一起意思就是表示可以把InputStream转换为Reader,最终InputStreamReader其实也是Reader的子类,所以也算是字符输入流。

InputStreamReader也是不能单独使用的,它内部需要封装一个InputStream的子类对象,再指定一个编码表,如果不指定编码表,默认会按照UTF-8形式进行转换。

需求:我们可以先准备一个GBK格式的文件,然后使用下面的代码进行读取,看是是否有乱码。

public class InputStreamReaderTest2 {public static void main(String[] args) {try (// 1、得到文件的原始字节流(GBK的字节流形式)InputStream is = new FileInputStream("io-app2/src/itheima06.txt");// 2、把原始的字节输入流按照指定的字符集编码转换成字符输入流Reader isr = new InputStreamReader(is, "GBK");// 3、把字符输入流包装成缓冲字符输入流BufferedReader br = new BufferedReader(isr);){String line;while ((line = br.readLine()) != null){System.out.println(line);}} catch (Exception e) {e.printStackTrace();}}
}

执行完之后,你会发现没有乱码。

6.2 OutputStreamWriter类

接下来,我们先学习OutputStreamWriter类,你看这个类名也比较有意思,前面是OutputStream表示字节输出流,后面是Writer表示字符输出流,合在一起意思就是表示可以把OutputStream转换为Writer,最终OutputStreamWriter其实也是Writer的子类,所以也算是字符输出流。

OutputStreamReader也是不能单独使用的,它内部需要封装一个OutputStream的子类对象,再指定一个编码表,如果不指定编码表,默认会按照UTF-8形式进行转换。

需求:我们可以先准备一个GBK格式的文件,使用下面代码往文件中写字符数据。

public class OutputStreamWriterTest3 {public static void main(String[] args) {// 指定写出去的字符编码。try (// 1、创建一个文件字节输出流OutputStream os = new FileOutputStream("io-app2/src/itheima07out.txt");// 2、把原始的字节输出流,按照指定的字符集编码转换成字符输出转换流。Writer osw = new OutputStreamWriter(os, "GBK");// 3、把字符输出流包装成缓冲字符输出流BufferedWriter bw = new BufferedWriter(osw);){bw.write("我是中国人abc");bw.write("我爱你中国123");} catch (Exception e) {e.printStackTrace();}}
}

七、打印流

接下来,我们学习打印流,其实打印流我们从开学第一天就一直再使用,只是没有学到你感受不到而已。打印流可以实现更加方便,更加高效的写数据的方式。

7.1 打印流基本使用

打印流,这里所说的打印其实就是写数据的意思,它和普通的write方法写数据还不太一样,一般会使用打印流特有的方法叫print(数据)或者println(数据),它打印啥就输出啥。

打印流有两个,一个是字节打印流PrintStream,一个是字符打印流PrintWriter,如下图所示:

PrintStream和PrintWriter的用法是一样的,所以这里就一块演示了。

public class PrintTest1 {public static void main(String[] args) {try (// 1、创建一个打印流管道
//        PrintStream ps =
//            new PrintStream("io-app2/src/itheima08.txt", Charset.forName("GBK"));
//        PrintStream ps =
//            new PrintStream("io-app2/src/itheima08.txt");PrintWriter ps =new PrintWriter(new FileOutputStream("D:\\code\\javasepro\\helloworld-app\\src\\itheima08.txt", true));){ps.print(97);	//文件中显示的就是:97ps.print('a'); //文件中显示的就是:aps.println("我爱你中国abc");	//文件中显示的就是:我爱你中国abcps.println(true);//文件中显示的就是:trueps.println(99.5);//文件中显示的就是99.5//print和println区别:后者会换行,前者不会换行ps.write(97); //文件中显示a。} catch (Exception e) {e.printStackTrace();}}
}

7.2 重定向输出语句

其实我们一开始,就给同学们讲过System.out.println()这句话表示打印输出,但是至于为什么能够输出,其实我们一直不清楚。

以前是因为知识储备还不够,无法解释,到现在就可以给同学们揭晓谜底了,因为System里面有一个静态变量叫out,out的数据类型就是PrintStream,它就是一个打印流,而且这个打印流的默认输出目的地是控制台,所以我们调用System.out.pirnln()就可以往控制台打印输出任意类型的数据,而且打印啥就输出啥。

而且System还提供了一个方法,可以修改底层的打印流,这样我们就可以重定向打印语句的输出目的地了。我们玩一下, 直接上代码。

public class PrintTest2 {public static void main(String[] args) {System.out.println("老骥伏枥");System.out.println("志在千里");try ( PrintStream ps = new PrintStream("io-app2/src/itheima09.txt"); ){// 把系统默认的打印流对象改成自己设置的打印流System.setOut(ps);System.out.println("烈士暮年");	System.out.println("壮心不已");//这里打印到文件中} catch (Exception e) {e.printStackTrace();}}
}

此时打印语句,将往文件中打印数据,而不在控制台。

八、数据流

同学们,接下我们再学习一种流,这种流在开发中偶尔也会用到。比如,我们想把数据和数据的类型一并写到文件中去,读取的时候也将数据和数据类型一并读出来。这就可以用到数据流,有两个DataInputStream和DataOutputStream。

8.1 DataOutputStream类

我们先学习DataOutputStream类,它也是一种包装流,创建DataOutputStream对象时,底层需要依赖于一个原始的OutputStream流对象。然后调用它的writeXxx方法,写的是特定类型的数据。

代码如下:往文件中写整数、小数、布尔类型数据、字符串数据

public class DataOutputStreamTest1 {public static void main(String[] args) {try (// 1、创建一个数据输出流包装低级的字节输出流DataOutputStream dos =new DataOutputStream(new FileOutputStream("io-app2/src/itheima10out.txt"));){dos.writeInt(97);dos.writeDouble(99.5);dos.writeBoolean(true);dos.writeUTF("黑马程序员666!");} catch (Exception e) {e.printStackTrace();}}
}

8.2 DataInputStream类

学习完DataOutputStream后,再学习DataIntputStream类,它也是一种包装流,创建DataInputStream对象时,底层需要依赖于一个原始的InputStream流对象。然后调用它的readXxx()方法就可以读取特定类型的数据。

代码如下:读取文件中特定类型的数据(整数、小数、字符串等)

public class DataInputStreamTest2 {public static void main(String[] args) {try (DataInputStream dis =new DataInputStream(new FileInputStream("io-app2/src/itheima10out.txt"));){int i = dis.readInt();System.out.println(i);double d = dis.readDouble();System.out.println(d);boolean b = dis.readBoolean();System.out.println(b);String rs = dis.readUTF();System.out.println(rs);} catch (Exception e) {e.printStackTrace();}}
}

九、序列化流

序列化流是干什么用的呢? 我们知道字节流是以字节为单位来读写数据、字符流是按照字符为单位来读写数据、而对象流是以对象为单位来读写数据。也就是把对象当做一个整体,可以写一个对象到文件,也可以从文件中把对象读取出来。

这里有一个新词:序列化,第一次听同学们可能还比较陌生,我来给同学们解释一下

序列化:意思就是把对象写到文件或者网络中去。(简单记:写对象)
反序列化:意思就是把对象从文件或者网络中读取出来。(简单记:读对象)

9.1 ObjectOutputStraem类

接下来,先学习ObjectOutputStream流,它也是一个包装流,不能单独使用,需要结合原始的字节输出流使用。

代码如下:将一个User对象写到文件中去

第一步:先准备一个User类,必须让其实现Serializable接口。

// 注意:对象如果需要序列化,必须实现序列化接口。
public class User implements Serializable {private String loginName;private String userName;private int age;// transient 这个成员变量将不参与序列化。private transient String passWord;public User() {}public User(String loginName, String userName, int age, String passWord) {this.loginName = loginName;this.userName = userName;this.age = age;this.passWord = passWord;}@Overridepublic String toString() {return "User{" +"loginName='" + loginName + '\'' +", userName='" + userName + '\'' +", age=" + age +", passWord='" + passWord + '\'' +'}';}
}

第二步:再创建ObjectOutputStream流对象,调用writeObject方法对象到文件。

public class Test1ObjectOutputStream {public static void main(String[] args) {try (// 2、创建一个对象字节输出流包装原始的字节 输出流。ObjectOutputStream oos =new ObjectOutputStream(new FileOutputStream("io-app2/src/itheima11out.txt"));){// 1、创建一个Java对象。User u = new User("admin", "张三", 32, "666888xyz");// 3、序列化对象到文件中去oos.writeObject(u);System.out.println("序列化对象成功!!");} catch (Exception e) {e.printStackTrace();}}
}

注意:写到文件中的对象,是不能用记事本打开看的。因为对象本身就不是文本数据,打开是乱码 怎样才能读懂文件中的对象是什么呢?这里必须用反序列化,自己写代码读。

9.2 ObjectInputStream类

接下来,学习ObjectInputStream流,它也是一个包装流,不能单独使用,需要结合原始的字节输入流使用。

接着前面的案例,文件中已经有一个User对象,现在要使用ObjectInputStream读取出来。称之为反序列化。

public class Test2ObjectInputStream {public static void main(String[] args) {try (// 1、创建一个对象字节输入流管道,包装 低级的字节输入流与源文件接通ObjectInputStream ois = new ObjectInputStream(new FileInputStream("io-app2/src/itheima11out.txt"));){User u = (User) ois.readObject();System.out.println(u);//User{loginName='admin', username='张三', age=32, password='null'}} catch (Exception e) {e.printStackTrace();}}
}

十、补充知识:IO框架

我们只学习了IO流对文件复制,能不能复制文件夹呀?

当然是可以咯,但是如果让我们自己写复制文件夹的代码需要用到递归,还是比较麻烦的。为了简化对IO操作,由apache开源基金组织提供了一组有关IO流小框架,可以提高IO流的开发效率。

这个框架的名字叫commons-io:其本质是别人写好的一些字节码文件(class文件),打包成了一个jar包。我们只需要把jar包引入到我们的项目中,就可以直接用了。

这里给同学们介绍一个jar包中提供的工具类叫FileUtils,它的部分功能如下,很方便,你一看名字就知道怎么用了。

在写代码之前,先需要引入jar包,具体步骤如下:

1.在模块的目录下,新建一个lib文件夹
2.把jar包复制粘贴到lib文件夹下
3.选择lib下的jar包,右键点击Add As Library,然后就可以用了。

代码如下:

public class CommonsIOTest1 {public static void main(String[] args) throws Exception {//1.复制文件FileUtils.copyFile(new File("io-app2\\src\\itheima01.txt"), new File("io-app2/src/a.txt"));//2.复制文件夹FileUtils.copyDirectory(new File("D:\\resource\\私人珍藏"), new File("D:\\resource\\私人珍藏3"));//3.删除文件夹FileUtils.deleteDirectory(new File("D:\\resource\\私人珍藏3"));// Java提供的原生的一行代码搞定很多事情Files.copy(Path.of("io-app2\\src\\itheima01.txt"), Path.of("io-app2\\src\\b.txt"));System.out.println(Files.readString(Path.of("io-app2\\src\\itheima01.txt")));}
}
来源:分享自作者个人站点/博客

智能推荐

一、字符集 1.1 字符集的来历 我们知道计算机是美国人发明的,由于计算机能够处理的数据只能是0和1组成的二进制数据,为了让计算机能够处理字符,于是美国人就把他们会用到的每一个字符进行了编码(所谓编码,就是为一个字符编一个二进制数据)。 美国人常用的字符有英文字母、标点符号、数字以及一些特殊字符,这些字符一共也不到128个,所以他们用1个字节来存储1字符就够了。 美国人把他们用到的字符和字符对应的编码总结成了一张码表,这张码表叫做ASCII码表(也叫ASCII

标签:字符集  

1.API 1.1API概述 什么是API API (Application Programming Interface) :应用程序编程接口        简单理解:API就是别人已经写好的东西,我们不需要自己编写,直接使用即可

标签:字符串  

一、集合概述和分类 1.1 集合的分类 除了ArrayList集合,Java还提供了很多种其他的集合,如下图所示: 我想你的第一感觉是这些集合好多呀!但是,我们学习时会对这些集合进行分类学习,如下图所示:一类是单列集合元素是一个一个的,另一类是双列集合元素是一对一对的。

标签:进阶  

数组 变量存在栈中,变量值存放在堆中。 数组反转

标签:黑马  

目录 1.ArrayList 集合和数组的优势对比:

标签:黑马  

一、 StringBuilder类 StringBuilder代表可变字符串对象,相当于是一个容器,它里面的字符串是可以改变的,就是用来操作字符串的。 好处:StringBuilder比String更合适做字符串的修改操作,效率更高,代码也更加简洁。 接下来我们用代码演示一下StringBuilder的用法: package com.itheima.test01;public class Test2 {public static void main(String[] args)

标签:黑马  

字符流 FileReader

标签:详解  

代码: //import java.util.Scanner;public class practice{public static void main(String[] args) {int arr [] = {1,2,3,4};String str = arrToString(arr);System.out.println(s

标签:字符串  

一、IO流概述IO:指的是输入/输出(Input/Output)流:是一种抽象概念,对数据传输的总称。即数据在设备间的传输为流,本质是数据传输IO流:用来处理设备间数据传输问题的,常见的应用有文件上传、下载、复制

标签:字节  基础  java  IO  

本篇学习笔记文档对应B站视频: 同学们,在前两天我们学习了Linux操作系统的常见命令以及如何在Linux上部署一个单体项目。大家想一想自己最大的感受是什么? 我相信,除了个别天赋异禀的同学以外,大多数同学都会有相同的感受,那就是麻烦。核心体现在三点: 命令太多了,记不住 软件安装包名字复杂,不知道去哪里找 安装和部署步骤复杂,容易出错 其实上述问题不仅仅是新手&#xff0c

标签:黑马  

什么是JavaScript? JavaScript(简称:JS) 是一门跨平台、面向对象的脚本语言。是用来控制网页行为的,它能使网页可交互。 JavaScript 和 J

标签:黑马  

什么是HTML ? 标记语言:由标签构成的语言。 注意:HTML标签都是预定义好的,HTML代码直接在浏览器中运行,HTML标签由浏览器解析。 什么是

标签:黑马  

目录 一、设计模式概述 1.1、23种设计模式有哪些?

标签:黑马  

JAVA基础学习笔记-day15-File类与IO流 1. java.io.File类的使用1.1 概述1.2 构造器1.3 常用方法

标签:学习笔记  

我是南城余!阿里云开发者平台专家博士证书获得者! 欢迎关注我的博客!一同成长! 一名从事运维开发的worker,记录分享学习。 专注于AI,运维开发,windows Linux 系统领域的分享! 知识库链接: Java基础入门 · 语雀 1. 编程语言发展历史 机器语言-》汇编语言-》高级语言 Java

标签:黑马  

js基础 软件第一天第二天 第三天第四天第五天

标签:黑马  

什么是 Web ? Web:全球广域网,也

标签:黑马  

IO流的基本介绍:IO流的概述:i 表示intput,是数据从硬盘文件读入到内存的过程,称之输入,负责读。o 表示output,是内存程序的数据从内存到写出到硬盘文件的过程,称之输出,负责写。IO流的分类:按方向分类:

标签:详细介绍  字节  java  IO  

目录 1.类和对象 1.2 类的定义 1.1 类和对象的理解

标签:黑马  

一、字符缓冲流BufferedWriter:文本写入字符输出流,缓冲字符,以提供单个字符,数组和字符串的高效写入。可以指定缓冲区大小,或者可以接受默认大小。 默认值足够大,可用于大多数用途。构造方法:

标签:字符  基础  java  

 高级流       高级流(或者称为包装流)是基于原始字节流和字符流之上的一层流式处理机制。它们提供了更高级别的功能,使得流的使用更加方便和灵活。      高级流的主要作用有以下几点: 提供更方便的操作:高级流提供了一些方便的方法和功能,使得对流的操作更加直观和简单。例如,BufferedInputStream和BufferedOutputStream可以提供缓冲区功能,可以一次读取或写入多个字节&

标签:高级  

设计对象并使用:

标签:黑马  

拼图小游戏(GUI) AWT包会有些兼容问题,不支持某些中文 在本次游戏的GUI开发中,我们将使用Swing包 一、主界面分析

标签:小游戏  

一、学生管理系统 学生管理系统 需求: 采取控制台的方式去书写学生管理系统。 loop:while(true){         for(){         break loop;//给while循环取名loop,break loop;可以跳出w

标签:管理系统  

猜你喜欢

CHARINDEX--IndexOf查询指定的字符在源字符串的起始位置:位置从1开始计算,如果找不到就返回第一个参数是指你需要查询的字符串第二个参数是源字符串,第三个参数是指定的查询起始位置 1 SELECT CHARINDEX(

标签:字符串  函数  笔记  

旦选准自己要走的道路,就勇敢地走下去,再难也要坚持,再远也不要放弃。一分耕耘未必有一分收获,但九分耕耘一定会有一分收获!天道酬勤!越努力,越幸运!LC每日一题,参考1032.stream-of-characters,难度分1970。题目设计一个算法:接收一个字符流,并检查这些字符的后缀是否是字符串数组 words 中的一个字符串。例如,words = [abc, xyz] 且字符流中逐个依次加入 4 个字符 a、x、y 和 z ,你所设计的算法应当可以检测到 axyz 的后缀 xyz 与 words 中的字符串 xyz 匹配。

标签:字符  

大家好我是苏麟 , 今天聊聊IO流 . 资料来源黑马程序员 . IO概述 生活中,你肯定经历过这样的场景。当你编辑一个文本文件,忘记了ctrl+s ,可能文件就白白编辑了。当你电脑上插入一个U盘,可以把一个视频,拷贝到你的电脑硬盘里。那么数据都是在哪些设备上的呢?键盘、内存、硬盘、外接设备等等。 我们把这种数据的传输,可以看做是一种数据的流动,按照流动的方向,以内存为基准&

标签:基础知识  

人画圆:画圆这个方法应该定义在园这个类里面。 人关门:是人给了门一个作用力,然后门自己关上了门,所以关门的方法是在门

标签:黑马  

static案例代码: 代码: public class Stu

标签:进阶  

文件IO流程用户进程read、write在高速缓冲块上读写数据,高速缓冲块和块设备交换数据。什么时机将磁盘块数据读到缓冲块?什么时机将缓冲块数据刷到磁盘块?函数调用关系read/write(c库函数,通过int 80调用sys_read/sys_

标签:源码  流程  文件  笔记  linux  

python字符串面试笔试题1: 以下代码的输出是?s = foot = barprint(barf in 2 * (s + t))A.TrueB.Fasle+运算符连接字符串,而*运算符创

标签:字符串  试题  python  

InputStream字节输入流 InputStrean InputStream 就是Java 标准库提供的最基本的输入流。它位于java.io这个包里。InputStream 不是一个接口,而是一个抽象类,它是所

标签:操作  

File 文件对象 文件 在计算机中,文件是非常重要的存储方式,JAVA的标准库java.io提供了File对象来操作文件和目录。要构建一个Fil

标签:操作  

SDS 简单动态字符串。SDS的结构:struct sdshdr{int len;//记录BUF数组中已使用字节的数量 ,等于SDS所

标签:字符串  学习笔记  Redis  SDS  

缓冲字符流 缓冲字符输入流:java.io.BufferedReader       是一个高级的字符流,特点是块读文本数据,并且可以按行读取字符串。 package io;import java.io.*;/*** 使用java.io.BufferedReader按行读取文本数据*/public class BRDemo {public static void main(String[] args) throws IOException {//将当前源程序读取出来并输出到控制台上FileInputStream fis = new FileInput

标签:字符  

一. 集合 { }    set 1. 定义: 是一种容器型数据类型; { } 作为容器的标志,里面多个元素用逗号隔开 {数据1,数据2,数据3,......... }集合是可变的、是无序的 print({10,20,30} =={30,10,20})#True 集合的元素:

标签:字符串  

MySQL字符集包括 基字符集(CHARACTER)与校对规则(COLLATION)这两个概念: latin1支持西欧字符、希腊字符等gbk支持中文简体字符big5支持中文繁体字符utf8几乎支持世界所有国家的字符utf8mb4是真正意义上的utf-8 查看当前数据库默认的字符集:SHOW VARIABLES like 'character%';

标签:字符集  

一、Arrays类 1.1 Arrays基本使用 Arrays是操作数组的工具类,它可以很方便的对数组中的元素进行遍历、拷贝、排序等操作。 下面我们用代码来演示一下:遍历、拷贝、排序等操作。需要用到的方法如下: public cla

标签:表达式  

1、对输入输出流、字符字节流的学习,以之前做的批量下载功能为例 批量下载指的是,将多个文件打包到zip文件中,然后下载该zip文件。 1.1下载网络上的文件 代码参考如下: import java.io.*;import java.net.URL;import java.net.URLConnection;import java.util.zip.ZipEntry;import java.util.zip.ZipOutputStream;public class MultiDownloadByUrlTest {public static voi

标签:字节  

这是以前没有赋值的时候,在()里面是空的:

标签:黑马  

1.static静态变量    静态变量是随着类的加载而加载的,优先与对象出现的

标签:进阶  

所有的文档和源代码都开源在GitHub: https://github.com/kun213/JavaNotes上了。希望我们可以一起加油,一起学习,一起交流day12【IO流】@目录day12【IO流】一、常用的编码表1.1 可以说出常用的编码表二、转换流2.1 如何使用OutputStreamWriter写数据到文件2.1.1 构造方法2

标签:线路  java  IO  

创作不易&#xff0c;本篇文章如果帮助到了你&#xff0c;还请点赞 关注支持一下♡>&#x16966;<)!! 主页专栏有更多知识&#xff0c;如有疑问欢迎大家指正讨论&#xff0c;共同进步&#xff01; 更多

标签:字符串  

final final关键字是最终的意思&#xff0c;可以修饰类、方法、变量修饰类&#xff1a;该类被称为最终类&#xff0c;特点是不能被继承了修饰方法&#xff1a;该方法被称为最终方法&#xff0c;特点是不能被重写了修饰变量&#xff1a;该变量只能被赋值一次 就相当于给类、方法、变量做了一个绝育手术  示例&#xff1a; final修饰类&#xff1a;

标签:学习笔记  

IO流概述IO:Input(输入),Output(输出),往一个文件中输出内容或从一个文件中读取内容

标签:IO  

例题&#xff1a; 代码&#xff1a;

标签:黑马  

一个比特(bit)可以是0,或者是1,8个比特(bit),组成一个字节(byte)。全为0时代表数字0,全为1时代表数字255。一个字节可以表示256个数字,两个字节可以表示65536个数字。

标签:字符集  

LDD学习笔记 -- Linux字符设备驱动 虚拟文件系统 VFS设备号相关Kernel APIs动

标签:学习笔记  

相关问题

相关文章

热门文章

推荐文章

相关标签