IO流概述与流的分类以及IO流的体系结构
1、英文和数字占一个字节;
2、中文占一个字符,也就是两个字节;
3、一字节等于8bit。
4、字节流处理图片，字符流处理文本。
IO流的体系结构（加蓝框的较为重要）
FileReader 和 FileWriter
FileReader读入数据的基本操作
（ 本节在 FileReaderWriterTest.java中的main（）方法和testFileReader()中进行讲解。）
// ★程序在内存中运行，文件在磁盘上，把文件从磁盘上读入内存中来，这就需要输入流。
// ★反之，把内存中的数据写到磁盘上的文件里就需要输出流。
// ★Java 里的输入流与输出流是针对内存而言的，它是从内存中读写。FileReader中使用read(char[] cbuf)读取数据
（本节在 FileReaderWriterTest.java中的testFileReader1()中进行讲解。）
//read(char[] cbuf):返回每次读入cbuf数组中的字符的个数。如果达到文件末尾，返回-1，
// 比如helloworld123，第一次读hello，返回5，第二次读world，返回5，第三次读123，返回3，第四次返回-1。FileWriter写出数据的操作
（本节在 FileReaderWriterTest.java中的testFileWriter()中进行讲解。）
//写出数据，FileWriter，
//从内存中写出数据到硬盘的文件里,叫写出，。使用FileReader和FileWriter实现文本的复制
（本节在 FileReaderWriterTest.java中的testFileReaderFileWriter（）中进行讲解。）
FileReaderWriterTest.java代码
hello.txt
helloworld123hello1.txt
I have a dream!
you need to have a dream!hello2.txt
helloworld123FileReaderWriterTest.java
package com.atguigu.java;
import org.junit.Test;
import java.io.*;
/**
*
* 一、流的分类：
* 1.操作数据单位：字节流、字符流
* 2.数据的流向：输入流、输出流
* 3.流的角色：节点流（直接操作文件的）、处理流（间接操作文件的）
*
* 二、流的体系结构
* 抽象基类 节点流（或文件流） 缓冲流（处理流的一种）
* InputStream FileInputStream (read(byte[] buffer)) BufferedInputStream (read(byte[] buffer))
* OutputStream FileOutputStream (write(byte[] buffer,0,len) BufferedOutputStream (write(byte[] buffer,0,len) /处理流的输出流都内置flush()
* Reader FileReader (read(char[] cbuf)) BufferedReader (read(char[] cbuf) / readLine())
* Writer FileWriter (write(char[] cbuf,0,len) BufferedWriter (write(char[] cbuf,0,len) / 处理流的输出流都内置flush()
*
*
*
*/
public class FileReaderWriterTest {
public static void main(String[] args) {
File file = new File("hello.txt");//在main（）方法直接写文件名会被认为是 相较于当前工程
//由于hello.txt和javaproject1之间还有一个day09，如果贸然直接相对当前工程，略过day09，写hello.txt的文件名，可能找不到。
System.out.println(file.getAbsolutePath());//D:\javaproject1\hello.txt
File file1 = new File("day09\\hello.txt");
System.out.println(file1.getAbsolutePath());//D:\javaproject1\day09\hello.txt
}
/*
代码要实现的目标：将day09下的hello.txt文件内容读入程序（内存）中，并输出到控制台
说明点：
1. read()的理解：返回读入的一个字符。如果达到文件末尾，返回-1
2. 异常的处理：为了保证流资源一定可以执行关闭操作。需要使用try-catch-finally处理
// new FileReader(file)； fr.read(); fr.close();三处都可能抛出异常，
// 如果异常处理选择在方法名后边抛出异常，那么当fr.read()出现异常时，它直接抛出异常到方法外，fr.close()就不能执行了，
// 就会发生泄露，泄露的意思就是没有归还。
// 如果我们选择try-catch处理异常，那么就不会出现上述情况。
3. 读入的文件一定要存在，否则就会报FileNotFoundException。
*/
//程序在内存中运行，文件在磁盘上，把文件从磁盘上读入内存中来，这就需要输入流。
// 反之，把内存中的数据写到磁盘上的文件里就需要输出流。
// Java 里的输入流与输出流是针对内存而言的，它是从内存中读写，写入内存是输入，读出内存是输出。
@Test
public void testFileReader(){
FileReader fr = null;
try {
//1.实例化File类的对象，指明要操作的文件
//把文本内容读出，所以是字符流；把数据从file输出到程序中，对于程序来说是输入流。
File file = new File("hello.txt");//在test测试直接写文件名会被认为是相较于当前Module
//2.提供具体的流
fr = new FileReader(file);
//3.数据的读入
//read():返回读入的一个字符。如果达到文件末尾，返回-1
//方式一：
// int data = fr.read(); //以int值的方式存的字符char类型的
// while(data != -1){
// System.out.print((char)data);
// data = fr.read(); //继续读下一个
// }
//方式二：语法上针对于方式一的修改
int data;
while((data = fr.read()) != -1){
//(data = fr.read()) != -1运行顺序，先给data赋值fr.read()，在判断data是否!= -1 ；
System.out.print((char)data);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
//4.流的关闭操作
// try {
// if(fr != null)
// fr.close();
// } catch (IOException e) {
// e.printStackTrace();
// }
//或//if(fr != null)写上下两种情况一个try外一个try内都可以。
if(fr != null){//可能前面new FileReader(file)出现异常，fr=null没有变，所以这再判断一次防止异常。
try {
fr.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
//对read()操作升级：使用read的重载方法
@Test
public void testFileReader1() {
FileReader fr = null;
try {
//1.File类的实例化
File file = new File("hello.txt");
//2.FileReader流的实例化
fr = new FileReader(file);
//3.读入的操作
//read(char[] cbuf):返回每次读入cbuf数组中的字符的个数。如果达到文件末尾，返回-1，
// 比如helloworld123，第一次读hello，返回5，第二次读world，返回5，第三次读123，返回3，第四次返回-1。
char[] cbuf = new char[5];
int len;
while((len = fr.read(cbuf)) != -1){
//假如我们读取的是 helloworld123
//方式一：
//错误的写法
// for(int i = 0;i < cbuf.length;i++){
// System.out.print(cbuf[i]);
// }//输出helloworld123ld，之所以有ld，是因为123只覆盖了cbuf数组前三个，后两个没覆盖。
//正确的写法
// for(int i = 0;i < len;i++){
// System.out.print(cbuf[i]);
// }//输出helloworld123
//方式二：
//错误的写法,对应着方式一的错误的写法
//new String(cbuf);char型数组通过String构造器转换成String类型。
// String str = new String(cbuf);
// System.out.print(str); //输出helloworld123ld
//正确的写法
String str = new String(cbuf,0,len);
System.out.print(str);//输出helloworld123
}
} catch (IOException e) {
e.printStackTrace();
} finally {
if(fr != null){
//4.资源的关闭
try {
fr.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
/*
从内存中写出数据到硬盘的文件里。
说明：
1. 输出操作，对应的File可以不存在的。并不会报异常
2.
File对应的硬盘中的文件如果不存在，在输出的过程中，会自动创建此文件。
File对应的硬盘中的文件如果存在：
如果流使用的构造器是：FileWriter(file,false) / FileWriter(file):对原有文件的覆盖
如果流使用的构造器是：FileWriter(file,true):不会对原有文件覆盖，而是在原有文件基础上追加内容
*/
@Test
public void testFileWriter() {
FileWriter fw = null;
try {
//1.提供File类的对象，指明写出到的文件
File file = new File("hello1.txt");
//2.提供FileWriter的对象，用于数据的写出
fw = new FileWriter(file,false);
//3.写出的操作
fw.write("I have a dream!\n".toCharArray());//.toCharArray()方法能吧String类型换成char[]类型
fw.write("you need to have a dream!");
} catch (IOException e) {
e.printStackTrace();
} finally {
//4.流资源的关闭
if(fw != null){
try {
fw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
@Test
public void testFileReaderFileWriter() {
FileReader fr = null;
FileWriter fw = null;
try {
//1.创建File类的对象，指明读入和写出的文件
File srcFile = new File("hello.txt");//从hello.txt读
File destFile = new File("hello2.txt");//写入hello2.txt
//★不能使用 字符流 来处理图片等 字节数据
// File srcFile = new File("爱情与友情.jpg");
// File destFile = new File("爱情与友情1.jpg");
//2.创建输入流和输出流的对象
fr = new FileReader(srcFile);//输入到内存的流，读srcFile进内存，即输入流
fw = new FileWriter(destFile);//输出到destFile的流，把内存数据写到destFile，即输出流
//3.数据的读入和写出操作
char[] cbuf = new char[5];
int len;//记录每次读入到cbuf数组中的字符的个数
while((len = fr.read(cbuf)) != -1){
//每次写出len个字符
fw.write(cbuf,0,len);//每次写出角标0到len的数据。
}
} catch (IOException e) {
e.printStackTrace();
} finally {
//4.关闭流资源
try {
if(fw != null)
fw.close();//如果这里出异常了，不影响下面的try-catch执行。
} catch (IOException e) {
e.printStackTrace();
}
try {
if(fr != null)
fr.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}FileInputStream和FileOutputStream
使用FileInputStream不能读取文本文件的测试
（本节在 FileInputOutputStreamTest.java中的testFileInputStream() 中进行讲解。）
使用FileInputStream和FileOutputStream读写非文本文件
（本节在 FileInputOutputStreamTest.java中的testFileInputOutputStream() 中举例说明。）
使用FileInputStream和FileOutputStream复制文件的方法测试
（本节在 FileInputOutputStreamTest.java中的 public void copyFile(String srcPath,String destPath) 和public void testCopyFile()中举例说明。）
FileInputOutputStreamTest.java代码
hello.txt
helloworld123中国人FileInputOutputStreamTest.java
package com.atguigu.java;
import org.junit.Test;
import java.io.*;
/**
* 测试FileInputStream和FileOutputStream的使用
*
* 结论：
* 1. 对于文本文件(.txt,.java,.c,.cpp)，使用字符流处理
* 2. 对于非文本文件(.jpg,.mp3,.mp4,.avi,.doc,.ppt,...)，使用字节流处理
*
* 文本文件如果只是想复制一下，用字节流也行，就是不要在内存层面去读（比如下面的每五个读一次）
* 非文本文件无论如何也不能用字符流。
*/
public class FileInputOutputStreamTest {
//使用字节流FileInputStream处理文本文件，可能出现乱码。
//例1：下面这个代码，如果hello.txt是helloworld123中国人，那么输出是helloworld123��国���，
// 一个汉字在utf-8中占三个字节。
// 因为第一次读取hello，第二次读world，第三次读123加中的前两个字符，
// 第四次读取中的第三个字符，国的3个字符和人的第一个字符，第五次读人的后两个字符，所以只有 国 能解码读出来。
//例2：byte的范围是-128到127。一个英文字符占一个字节，况且helloworld123都在byte范围内，所以仍然能输出helloworld123
@Test
public void testFileInputStream() {
FileInputStream fis = null;
try {
//1. 造文件
File file = new File("hello.txt");
//2.造流
fis = new FileInputStream(file);
//3.读数据
byte[] buffer = new byte[5];
int len;//记录每次读取的字节的个数
while((len = fis.read(buffer)) != -1){
String str = new String(buffer,0,len);
System.out.print(str);
//这里是每搬五个字节，就看一次这五个字节，所以才会报错；
// 如果搬了最后一起看，就不会出现乱码
}
} catch (IOException e) {
e.printStackTrace();
} finally {
if(fis != null){
//4.关闭资源
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
/*
实现对图片的复制操作
*/
@Test
public void testFileInputOutputStream() {
FileInputStream fis = null;
FileOutputStream fos = null;
try {
//1、造文件
File srcFile = new File("爱情与友情.jpg");
File destFile = new File("爱情与友情2.jpg");
//2、造流
fis = new FileInputStream(srcFile);
fos = new FileOutputStream(destFile);
//复制的过程
byte[] buffer = new byte[5];
int len;
while((len = fis.read(buffer)) != -1){
fos.write(buffer,0,len);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
if(fos != null){
//
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(fis != null){
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
//指定路径下文件的复制
public void copyFile(String srcPath,String destPath){
FileInputStream fis = null;
FileOutputStream fos = null;
try {
//
File srcFile = new File(srcPath);
File destFile = new File(destPath);
//
fis = new FileInputStream(srcFile);
fos = new FileOutputStream(destFile);
//复制的过程
byte[] buffer = new byte[1024];
int len;
while((len = fis.read(buffer)) != -1){
fos.write(buffer,0,len);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
if(fos != null){
//
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(fis != null){
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
@Test
public void testCopyFile(){
long start = System.currentTimeMillis();
String srcPath = "C:\\Users\\Administrator\\Desktop\\01-视频.avi";
String destPath = "C:\\Users\\Administrator\\Desktop\\02-视频.avi";
// String srcPath = "hello.txt";
// String destPath = "hello3.txt";
copyFile(srcPath,destPath);
long end = System.currentTimeMillis();
System.out.println("复制操作花费的时间为：" + (end - start));// 花费时间是 618
//以上代码能实现对指定路径下的文件的复制，能复制出一个新文件
}
}缓冲流
flush()刷新缓冲区
java在使用流时,都会有一个缓冲区,按一种它认为比较高效的方法来发数据:把要发的数据先放到缓冲区,缓冲区放满以后再一次性发过去,而不是分开一次一次地发.
而flush()表示强制将缓冲区中的数据发送出去,不必等到缓冲区满.
缓冲流（字节流）实现非文本文件的复制
（本节在 BufferedTest.java中的BufferedStreamTest() 中举例说明。）
缓冲流和节点流读写速度对比
（本节在 BufferedTest.java中的copyFileWithBuffered(String srcPath,String destPath)和测试testCopyFileWithBuffered()中举例说明。）
缓冲流（字符流）实现文本文件的复制
（本节在 BufferedTest.java中的 testBufferedReaderBufferedWriter()中举例说明。）
BufferedTest.java代码
byte类型占1byte，8bit，
char类型占2bytes，16bit。
BufferedTest.java
package com.atguigu.java;
import org.junit.Test;
import java.io.*;
/**
* 处理流之一：缓冲流的使用
*
* 1.缓冲流：
* BufferedInputStream
* BufferedOutputStream
* BufferedReader
* BufferedWriter
*
* 2.作用：提供流的读取、写入的速度
* 提高读写速度的原因：内部提供了一个缓冲区
*
* 3. 处理流，就是“套接”在已有的流（已有的流可能是节点流，也可能是处理流）的基础上。
*
*/
public class BufferedTest {
/*
缓冲流（字节流）实现非文本文件的复制
*/
@Test
public void BufferedStreamTest() throws FileNotFoundException {
BufferedInputStream bis = null;
BufferedOutputStream bos = null;
try {
//1.造文件
File srcFile = new File("爱情与友情.jpg");
File destFile = new File("爱情与友情3.jpg");
//2.造流
//2.1 造节点流
FileInputStream fis = new FileInputStream((srcFile));
FileOutputStream fos = new FileOutputStream(destFile);
//2.2 造缓冲流
bis = new BufferedInputStream(fis);
bos = new BufferedOutputStream(fos);
//3.复制的细节：读取、写入
byte[] buffer = new byte[10];
int len;
while((len = bis.read(buffer)) != -1){//bis把数据读到buffer当中
bos.write(buffer,0,len);//bos把buffer的数据写到目的文件
// bos.flush();//刷新缓冲区，
// 之所以不需要flush（）是因为上面bos.write（）中调用了flush（）；
// 之后也大多不需要调用flush（）,有的在BufferedWriter的close()的调用了flush（）;
}
} catch (IOException e) {
e.printStackTrace();
} finally {
//4.资源关闭
//要求：先关闭外层的流，再关闭内层的流
if(bos != null){
try {
bos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(bis != null){
try {
bis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
//说明：关闭外层流的同时，内层流也会自动的进行关闭。关于内层流的关闭，我们可以省略.
//fos.close();
//fis.close();
}
}
//缓冲流和节点流读写速度对比(节点流在FileInputOutputStreamTest.java中的
// testCopyFile()，花费时间是618)
//实现文件复制的方法(和上面都是实现的文件复制，且代码一样)
public void copyFileWithBuffered(String srcPath,String destPath){
BufferedInputStream bis = null;
BufferedOutputStream bos = null;
try {
//1.造文件
File srcFile = new File(srcPath);
File destFile = new File(destPath);
//2.造流
//2.1 造节点流
FileInputStream fis = new FileInputStream((srcFile));
FileOutputStream fos = new FileOutputStream(destFile);
//2.2 造缓冲流
bis = new BufferedInputStream(fis);
bos = new BufferedOutputStream(fos);
//3.复制的细节：读取、写入
byte[] buffer = new byte[1024];
int len;
while((len = bis.read(buffer)) != -1){
bos.write(buffer,0,len);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
//4.资源关闭
//要求：先关闭外层的流，再关闭内层的流
if(bos != null){
try {
bos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(bis != null){
try {
bis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
//说明：关闭外层流的同时，内层流也会自动的进行关闭。关于内层流的关闭，我们可以省略.
// fos.close();
// fis.close();
}
}
@Test
public void testCopyFileWithBuffered(){
long start = System.currentTimeMillis();
String srcPath = "C:\\Users\\Administrator\\Desktop\\01-视频.avi";
String destPath = "C:\\Users\\Administrator\\Desktop\\03-视频.avi";
copyFileWithBuffered(srcPath,destPath);
long end = System.currentTimeMillis();
System.out.println("复制操作花费的时间为：" + (end - start));//节点流花费时间是 618 ，如今缓冲流 花费时间是 176 ，缩短了时间
}
/*
缓冲流（字符流）实现文本文件的复制
使用BufferedReader和BufferedWriter实现文本文件的复制
*/
@Test
public void testBufferedReaderBufferedWriter(){
BufferedReader br = null;
BufferedWriter bw = null;
try {
//创建文件和相应的流
br = new BufferedReader(new FileReader(new File("dbcp.txt")));
bw = new BufferedWriter(new FileWriter(new File("dbcp1.txt")));
//读写操作
//方式一：使用char[]数组
// char[] cbuf = new char[1024];
// int len;
// while((len = br.read(cbuf)) != -1){
// bw.write(cbuf,0,len);
//
// }
//方式二：使用String
// readLine()，一次读一行，如果没读到就返回null
String data;
while((data = br.readLine()) != null){
//方法一（用\n添加换行符）：
// bw.write(data + "\n");//data中不包含换行符。
//方法二：
bw.write(data);//data中不包含换行符
bw.newLine();//提供换行的操作（println（）不能在文件中换行，只能在这个idea中显示时换行）
}
} catch (IOException e) {
e.printStackTrace();
} finally {
//关闭资源
if(bw != null){
try {
bw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(br != null){
try {
br.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}缓冲流课后练习
1、图片加密
package com.atguigu.exer;
import org.junit.Test;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/**
* 图片加密
*/
public class PicTest {
//图片的加密
@Test
public void test1() {
FileInputStream fis = null;
FileOutputStream fos = null;
try {
//fis = new FileInputStream(new File("爱情与友情.jpg"));
// 以下 “ ”能把 爱情与友情.jpg 包装成文件，相当于和上面一样。
fis = new FileInputStream("爱情与友情.jpg");
fos = new FileOutputStream("爱情与友情secret.jpg");
byte[] buffer = new byte[20];
int len;
while ((len = fis.read(buffer)) != -1) {
//字节数组进行修改
for (int i = 0; i < len; i++) {
buffer[i] = (byte) (buffer[i] ^ 5);//给buffer数组中每个字节进行了异或运算
}
fos.write(buffer, 0, len);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
if (fos != null) {
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (fis != null) {
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
//图片的解密
@Test
public void test2() {
FileInputStream fis = null;
FileOutputStream fos = null;
try {
fis = new FileInputStream("爱情与友情secret.jpg");
fos = new FileOutputStream("爱情与友情4.jpg");
byte[] buffer = new byte[20];
int len;
while ((len = fis.read(buffer)) != -1) {
//字节数组进行修改
for (int i = 0; i < len; i++) {
buffer[i] = (byte) (buffer[i] ^ 5);//数据异或两次等于本来的数据
}
fos.write(buffer, 0, len);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
if (fos != null) {
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (fis != null) {
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}2、获取文本上字符出现的次数,把数据写入文件
map中，key存字符，value存次数
package com.atguigu.exer;
import org.junit.Test;
import java.io.*;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
/**
* 练习2:获取文本上字符出现的次数,把数据写入文件
*
* 思路：
* 1.遍历文本每一个字符
* 2.字符出现的次数存在Map中
*
* Map<Character,Integer> map = new HashMap<Character,Integer>();
* map.put('a',18);
* map.put('你',2);
*
* 3.把map中的数据写入文件
*
*/
public class WordCount {
/*
说明：如果使用单元测试，文件相对路径为当前module
如果使用main()测试，文件相对路径为当前工程
*/
@Test
public void testWordCount() {
FileReader fr = null;
BufferedWriter bw = null;
try {
//1.创建Map集合
Map<Character, Integer> map = new HashMap<Character, Integer>();
//2.遍历每一个字符,每一个字符出现的次数放到map中
fr = new FileReader("dbcp.txt");
int c = 0;
while ((c = fr.read()) != -1) {
//int 还原 char
char ch = (char) c;
// 判断char是否在map中第一次出现
if (map.get(ch) == null) {
map.put(ch, 1);
} else {
map.put(ch, map.get(ch) + 1);
}
}
//3.把map中数据存在文件count.txt
//3.1 创建Writer
bw = new BufferedWriter(new FileWriter("wordcount.txt"));
//3.2 遍历map,再写入数据
Set<Map.Entry<Character, Integer>> entrySet = map.entrySet();
for (Map.Entry<Character, Integer> entry : entrySet) {
switch (entry.getKey()) {
case ' ':
bw.write("空格=" + entry.getValue());
break;
case '\t'://\t表示tab 键字符
bw.write("tab键=" + entry.getValue());
break;
case '\r'://
bw.write("回车=" + entry.getValue());
break;
case '\n'://
bw.write("换行=" + entry.getValue());
break;
default:
bw.write(entry.getKey() + "=" + entry.getValue());
break;
}
bw.newLine();
}
} catch (IOException e) {
e.printStackTrace();
} finally {
//4.关流
if (fr != null) {
try {
fr.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (bw != null) {
try {
bw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}转换流
InputStreamReaderTest.java
package com.atguigu.java;
import org.junit.Test;
import java.io.*;
/**
* 处理流之二：转换流的使用
* 1.转换流：属于字符流
* InputStreamReader：（看后缀Reader字符输入流）将一个字节的输入流转换为字符的输入流
* OutputStreamWriter：（看后缀Writer字符输出流）将一个字符的输出流转换为字节的输出流
*
* 2.作用：提供字节流与字符流之间的转换
*
* 3. 解码（看不懂的到看得懂的）：字节、字节数组 --->字符数组、字符串
* 编码：字符数组、字符串 ---> 字节、字节数组
*
*
* 4.字符集
*ASCII：美国标准信息交换码。
用一个字节的7位可以表示。
ISO8859-1：拉丁码表。欧洲码表
用一个字节的8位表示。
GB2312：中国的中文编码表。最多两个字节编码所有字符
GBK：中国的中文编码表升级，融合了更多的中文文字符号。最多两个字节编码
Unicode：国际标准码，融合了目前人类使用的所有字符。为每个字符分配唯一的字符码。所有的文字都用两个字节来表示。
UTF-8：变长的编码方式，可用1-4个字节来表示一个字符
Unicode字符集只是定义了字符的集合和唯一编号，并没有具体落地编码方案。
Unicode编码，则是对UTF-8、UCS-2/UTF-16等具体编码方案的统称而已，
并不是具体的编码方案
*
*
*/
//# InputStreamReader的使用
public class InputStreamReaderTest {
/*
此时处理异常的话，仍然应该使用try-catch-finally
InputStreamReader的使用，实现字节的输入流到字符的输入流的转换
*/
@Test
public void test1() throws IOException {
//FileInputStream字节输入流
FileInputStream fis = new FileInputStream("dbcp.txt");
//InputStreamReader字符输入流 转换流
//InputStreamReader isr = new InputStreamReader(fis);//只有一个参数，使用系统默认的字符集
//参数2指明了字符集，具体使用哪个字符集，取决于文件dbcp.txt保 存 时使用的字符集
InputStreamReader isr = new InputStreamReader(fis,"UTF-8");
char[] cbuf = new char[20];
int len;
while((len = isr.read(cbuf)) != -1){
String str = new String(cbuf,0,len);
System.out.print(str);
}
isr.close();
}
// # 轮换流实现文件的读入和写出
/*
此时处理异常的话，仍然应该使用try-catch-finally，
综合使用InputStreamReader和OutputStreamWriter
*/
@Test
public void test2() throws Exception {
//1.造文件、造流
File file1 = new File("dbcp.txt");
File file2 = new File("dbcp_gbk.txt");
FileInputStream字节输入流,FileOutputStream字节输出流
FileInputStream fis = new FileInputStream(file1);
FileOutputStream fos = new FileOutputStream(file2);
InputStreamReader isr = new InputStreamReader(fis,"utf-8");//以utf-8解码
OutputStreamWriter osw = new OutputStreamWriter(fos,"gbk");//以gbk编码
//2.读写过程
char[] cbuf = new char[20];
int len;
while((len = isr.read(cbuf)) != -1){
osw.write(cbuf,0,len);
}
//3.关闭资源
isr.close();
osw.close();
}
}标准的输入输出流、打印流、数据流
OtherStreamTest.java
package com.atguigu.java;
import org.junit.Test;
import java.io.*;
/**
* 其他流的使用
* 1.标准的输入、输出流
* 2.打印流
* 3.数据流
*
*
*/
public class OtherStreamTest {
/*
1.标准的输入、输出流
1.1
System.in:标准的输入流，默认从键盘输入
System.out:标准的输出流，默认从控制台输出
1.2
System类的setIn(InputStream is) / setOut(PrintStream ps)方式重新指定输入和输出的流。
1.3练习：
从键盘输入字符串，要求将读取到的整行字符串转成大写输出。然后继续进行输入操作，
直至当输入“e”或者“exit”时，退出程序。
方法一：使用Scanner实现，调用next()返回一个字符串
方法二：使用System.in实现。System.in ---> 转换流 ---> BufferedReader的readLine()
用BufferedReader是因为只有read Line（）这个方法可以一次读一行，
因为你要使用BufferReader的readLine()方法，而BufferReader要传入一个Reader，
System.in是通过字节输入流InputStream定义的，可以作为转换流实例化时的参数。、
即system是字节输入流，所以要转化成字符输入流才可以包装进bufferreader里面调readline方法
*/
//以下是方法二 的实现
public static void main(String[] args) {
BufferedReader br = null;
try {
InputStreamReader isr = new InputStreamReader(System.in);
br = new BufferedReader(isr);
while (true) {
System.out.println("请输入字符串：");
String data = br.readLine();
if ("e".equalsIgnoreCase(data) || "exit".equalsIgnoreCase(data)) {
System.out.println("程序结束");
break;
}
String upperCase = data.toUpperCase();
System.out.println(upperCase);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
if (br != null) {
try {
br.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
/*
2. 打印流：PrintStream 和PrintWriter
2.1 提供了一系列重载的print() 和 println()
2.2 练习：test2
*/
@Test
public void test2() {
PrintStream ps = null;
try {
//可以这么理解不 本来是输出到控制台上的 setout这个方法就提前把原来默认到控制台输出转换到这个文件输出
FileOutputStream fos = new FileOutputStream(new File("D:\\IO\\text.txt"));//定义一个输出流
// 创建打印输出流,设置为自动刷新模式(写入换行符或字节 '\n' 时都会刷新输出缓冲区)
ps = new PrintStream(fos, true);//打印输出流 会输出到参数fos文件中
if (ps != null) {
System.setOut(ps);// 把标准输出流(从控制台输出)改成 输出到文件
}
for (int i = 0; i <= 255; i++) { // 输出ASCII字符
System.out.print((char) i);
if (i % 50 == 0) { // 每50个数据一行
System.out.println(); // 换行
}
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} finally {
if (ps != null) {
ps.close();
}
}
}
/*
3. 数据流
3.1 DataInputStream 和 DataOutputStream
3.2 作用：用于读取或写出基本数据类型的变量或字符串
练习：将内存中的字符串、基本数据类型的变量写出到文件中。test3是写进data.txt的过程，test4是从data.txt读出的过程。
（将内存中的字符串、基本数据类型的变量写出到文件data.txt中）
注意：处理异常的话，仍然应该使用try-catch-finally.
*/
@Test
public void test3() throws IOException {
//1.造好数据输出流 //处理流DataOutputStream包住节点流FileOutputStream
DataOutputStream dos = new DataOutputStream(new FileOutputStream("data.txt"));
//2.
dos.writeUTF("龙龙");
dos.flush();//刷新操作，将内存中的数据写入文件
dos.writeInt(23);
dos.flush();
dos.writeBoolean(true);
dos.flush();
//3.
dos.close();
}
/*
将文件中存储的基本数据类型变量和字符串读取到内存中，保存在变量中。
注意点：读取不同类型的数据的顺序要与当初写入文件时，保存的数据的顺序一致！
写的顺序是utf，int，boolean，所以读的顺序也是utf，int，boolean
*/
@Test
public void test4() throws IOException {
//1.
DataInputStream dis = new DataInputStream(new FileInputStream("data.txt"));
//2.
String name = dis.readUTF();
int age = dis.readInt();
boolean isMale = dis.readBoolean();
System.out.println("name = " + name);
System.out.println("age = " + age);
System.out.println("isMale = " + isMale);
//name = 龙龙
//age = 23
//isMale = true
//3.
dis.close();
}
}
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
