网站表单提交,wordpress福利源码,七七鱼竞价托管,wordpress 地图菜单一、字符集
1.1 字符集的来历
我们知道计算机是美国人发明的#xff0c;由于计算机能够处理的数据只能是0和1组成的二进制数据#xff0c;为了让计算机能够处理字符#xff0c;于是美国人就把他们会用到的每一个字符进行了编码#xff08;所谓编码#xff0c;就是为一个…一、字符集
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 缓冲字节流
我们先来学习字节缓冲流是如何提高读写数据的性能的原理如下图所示。是因为在缓冲流的底层自己封装了一个长度为8KB8129byte的字节数组但是缓冲流不能单独使用它需要依赖于原始流。
读数据时它先用原始字节输入流一次性读取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给我们提供了另外两种流InputStreamReaderOutputStreamWriter这两个流我们把它叫做转换流。它们可以将字节流转换为字符流并且可以指定编码方案。
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里面有一个静态变量叫outout的数据类型就是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{loginNameadmin, username张三, age32, passwordnull}} 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)));}
}
