117Java IO学习笔记

           Java IO学习笔记

1 文件

1.1 基本概念

1.1.1 什么是文件

​ 文件，对我们并不陌生，文件是保存数据的地方，比如大家经常使用的word文档，txt文件，Excel文件。

​ 它既可以保存一张图片，也可以保存视频，声音…。

1.1.2 文件流

​ 文件在程序中是以流的形式来操作的

好比：

​ 流：数据在数据源(文件)和程序(内存)之间经历的路径

​ 输入流：数据从数据源(文件)到程序(内存)的路径

​ 输出流：数据从程序(内存)到数据源(文件)的路径

1.2 创建文件对象

1.2.1 new File(String filepath)

new File(String filepathe) //根据目录+文件名创建一个File对象

File file1 = new File("H:\\117Java IO\\news1.txt");

1.2.2 new File(File parent,String filename)

new File(File parent,String filename) //根据父目录+文件名创建

File fileDirectory = new File("H:\\117Java IO");
File file2 = new File(fileDirectory, "news2.txt");

1.2.3 new File(String filepath,String filename)

new File(String filepath,String filename) //根据目录+文件名创建

File file3 = new File("H:\\117Java IO", "news3.txt");

1.2.4 createNewFile()

createNewFile() 创建新文件

File file1 = new File("H:\\117Java IO\\news1.txt");
file1.createNewFile();

1.2.5 应用案例

案例：请在E盘下，创建news1.txt、news2.txt、news3.txt，用三种不同的方式创建

package com.tangguanlin.io;
import java.io.File;
import java.io.IOException;
/**
 * 说明： 创建文件的三种方式
 * 作者：汤观林
 * 日期：2022年01月21日 21时
 */
public class FileCreate {
    public static void main(String[] args) throws IOException {

        //方式一  new File(String filepath)
        //创建file对象
        File file1 = new File("H:\\117Java IO\\news1.txt");
        //创建文件
        file1.createNewFile();
        System.out.println("方式一文件创建成功");

        //方式二 new File(File parent,String child)  根据父目录文件+子路径创建
        //文件目录
        File fileDirectory = new File("H:\\117Java IO");
        //这里的file对象，在java程序中，只是一个对象
        //只有执行了createNewFile方法，才会真正的，在磁盘创建该文件
        File file2 = new File(fileDirectory, "news2.txt");
        //真正创建文件  在硬盘上创建
        file2.createNewFile();
        System.out.println("方式二创建文件成功");


        //方式三 new File(String filepath,String filename)    //根据目录+文件名创建
        File file3 = new File("H:\\117Java IO", "news3.txt");
        file3.createNewFile();
        System.out.println("方式三创建文件成功");
    }
}

运行结果：

方式一文件创建成功
方式二创建文件成功
方式三创建文件成功

1.3 获取文件相关信息

1.3.1 file.getName()

file.getName() 获取文件的名称

File file = new File("H:\\117Java IO\\news1.txt");
//获取文件的名字
String filename = file.getName();

1.3.2 file.getAbsolutePath()

file.getAbsolutePath() 获取文件的绝对路径

File file = new File("H:\\117Java IO\\news1.txt");
String filepath = file.getAbsoluteFile();

1.3.3 file.getParent()

file. getParent() 获取文件的所在目录

File file = new File("H:\\117Java IO\\news1.txt");
String filepath = file.getParent();

1.3.4 file.length()

file.length() 获取文件的大小 有多少字节

File file = new File("H:\\117Java IO\\news1.txt");
long size = file.length()

1.3.5 file.exists()

file.exists() 判断文件是否存在，返回true或false

File file = new File("H:\\117Java IO\\news1.txt");
boolean flag = file.exists();

1.3.6 file.isFile()

file.isFile() 判断是不是一个文件，返回true或false

File file = new File("H:\\117Java IO\\news1.txt");
boolean flag = file.isFile();

1.3.7 isDirectorty()

file.isDirectory() 判断是不是一个目录，返回true或false

File file = new File("H:\\117Java IO\\news1.txt");
boolean flag = file.isDirectory();

1.3.8 应用案例

package com.tangguanlin.io;
import java.io.File;
import java.io.IOException;
/**
 * 说明： 获取文件信息
 * 作者：汤观林
 * 日期：2022年01月21日 22时
 */
public class FileInfo {
    public static void main(String[] args) throws IOException {

        //方式一  new File(String filepath)
        //创建file对象
        File file = new File("H:\\117Java IO\\news1.txt");

        //获取文件的名字
        System.out.println("获取文件的名字:"+file.getName());

        //获取文件的绝对路径
        System.out.println("文件的绝对路径："+file.getAbsoluteFile());

        //获取文件的目录
        System.out.println("获取文件的目录:"+file.getParent());

        //获取文件的大小
        System.out.println("获取文件的大小"+file.length());

        //文件是否存在
        System.out.println("文件是否存在:"+file.exists());

        //是不是一个文件
        System.out.println("是不是一个文件："+file.isFile());

        //是不是一个目录
        System.out.println("是不是一个目录:"+file.isDirectory());
    }
}

运行结果：

获取文件的名字:news1.txt
文件的绝对路径：H:\117Java IO\news1.txt
获取文件的目录:H:\117Java IO
获取文件的大小0
文件是否存在:true
是不是一个文件：true
是不是一个目录:false

1.4 目录操作和文件删除

. Java编程中，目录也看做是一个文件

1.4.1 file.delete()

delete() 删除空目录或文件,返回true或false

File file = new File("H:\\117Java IO\\news1.txt");
boolean flag = file.delete();

1.4.2 file.mkdir()

mkdir() 创建一级目录，返回true或false

File file2 = new File("H:\\117Java IO\\a");
boolean flag = file2.mkdir();

1.4.3 file.mkdirs()

mkdirs() 创建多级目录，返回true或false

File file2 = new File("H:\\117Java IO\\a\\b\\c");
boolean flag = file2.mkdirs();

1.4.4 应用实例1

案例1：判断H:\117Java IO\news1.txt是否存在，如果存在就删除

案例1：判断 H:\117Java IO\a\b\c目录是否存在，如果存在就提示存在，否则就创建

代码：

package com.tangguanlin.io;
import java.io.File;
/**
 * 说明：目录操作
 * 作者：汤观林
 * 日期：2022年01月21日 22时
 */
public class Directory {
    public static void main(String[] args) {

        //判断H:\117Java IO\news1.txt是否存在，如果存在就删除
        File file = new File("H:\\117Java IO\\news1.txt");
        if(file.exists()){
           if(file.delete()){
               System.out.println("删除成功");
           }else{
               System.out.println("删除失败");
           }
        }else{
            System.out.println("该文件不存在...");
        }

        //判断 H:\117Java IO\\a\\b\\c目录是否存在，如果存在就提示存在，否则就创建
        File file2 = new File("H:\\117Java IO\\a\\b\\c");
        if(file2.exists()){
            System.out.println("该目录存在");
        }else{
             if(file2.mkdirs()){
                 System.out.println("目录已经创建");
             }else {
                 System.out.println("目录创建失败");
             }
        }
    }
}

运行结果：

删除成功
目录已经创建

1.4.5 应用实例2

1.实现如下功能：

​ (1)在判断H:\117Java IO下是否有文件夹mytemp,如果没有就创建

​ (2)在H:\117Java IO\mytemp目录下，创建文件hello.txt

​ (3)如果hello.txt已经存在，提示该文件已经存在，就不要重复创建 了

​ (4)并且在hello.txt文件中，写入hello,world~

package com.tangguanlin.io.homework;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
/**
 * 说明：家庭作业1
 * 作者：汤观林
 * 日期：2022年01月23日 23时
 */
public class HomeworkTest1 {
    public static void main(String[] args) throws IOException {

        File file = new File("H:\\117Java IO\\mytemp");
        if(file.exists()){
            System.out.println("该文件夹已经存在");
        }else{
             file.mkdir();
        }

        File file1 = new File(file, "hello.txt");
        if(file1.exists()){
            System.out.println("该文件已经存在");
        }else{
            file1.createNewFile();
            System.out.println("文件创建完毕");
            FileOutputStream fileOutputStream = new FileOutputStream(file1);
            fileOutputStream.write("hello,world~".getBytes());

            fileOutputStream.close();
        }
    }
}

2 IO流原理和流的分类

2.1 Java IO流原理

​ 1.I/O是Input/Output的缩写，I/O技术是非常实用的技术，用于处理数据传输。

​ 如读/写文件，网络通讯等。

​ 2.Java程序中，对于数据的输入/输出操作从“流(stream)”的方式进行。

​ 3.java.io包下提供了各种"流"类和接口，用以获取不同种类的数据，并通过方法输入或输出数据。

​ 4.输入input：读取外部数据(磁盘，光盘等存储设备的数据)到程序(内存)中

​ 5.输出output:将程序(内存)数据输出到磁盘，光盘等存储设备中

2.2 IO流的分类

​ 1.按操作数据单位不同分为：

​ 字节流：(8bit) 二进制文件，声音，视频，word文档 字节流才不会损坏

​ 字符流：一个字符对应多个字节 文本文件

​ 2.按数据流的流向不同分为：

​ 输入流

​ 输出流

​ 3.按流的角色不同分为：

​ 节点流

​ 处理流/包装流

​

（抽象基类）	字节流	字符流
输入流	InputStream (abstract抽象类)	Reader (abstract抽象类)
输出流	OutputStream (abstract抽象类)	Writer (abstract抽象类)

​ (1) Java的IO流供涉及40多个类，实际上非常规则，都是从如上4个抽象基类派生的。

​ (2) 由这四个类派生出来的子类名称都是以其父类名作为子类后缀。

​ (3) InputStream,OutputStream,Reader，Writer都是抽象类，不能直接创建对象。

2.3 Java IO流的分类

3 节点流和处理流

3.1 基本介绍

1.节点流可以从一个特定的数据源读写数据，如FileReader，FileWriter。

2.处理流(也叫包装流)是“连接”在已存在的流(节点流或处理流)之上，为程序提供更为强大的读写功能，

​ 如果BufferedReader、BufferedWriter.用的装饰器模式

3.2 节点流和处理流一览图

二进制文件：图片,音频，视频

分类	字节输入流(二进制文件)	字节输出流(图片,音频，视频)	字符输入流(文本)	字符输出流(文本)
抽象基类	InputStream	OutputStream	Reader	Writer
		节点流(功能不是很强大)
访问文件	FileInputStream	FileOutputStream	FileReader	FileWriter
		处理流/包装流(功能更强大)
缓冲流/包装流	BufferedInputStream	BufferedOutputStream	BufferedReader	BufferedWriter
转换流			InputStreamReader	OutputStreamWriter
对象流	ObjectInputStream	ObjectOutputStream

总结：

​ 1.FileInputStream，FileOutputStream 主要用于二进制文件：图片文件，声音文件，视频文件

​ FileReader，FileWriter 主要用于处理 文本文件

​ 2.缓冲流/包装流 主要拥有缓存数组，更少频繁操作IO，数据处理更快，有更方便的方法调用

​ 3.转换流主要用于 指定编码格式 读取/写入 文件

​ 4.对象流主要用于对象的序列化 和 反序列化

​

3.3 节点流和处理流的区别和联系

节点流和处理流的区别和联系

​ 1.节点流是底层流,直接跟数据源相相接

​ 2.处理流(包装流)包装节点流，既可以消除不同节点流的实现差异，也可以提供更方便的方法来完成输入输出。

​ 3.处理流(包装流)对节点流进行包装，使用了装饰器模式，不会直接与数据源相连。

3.4 处理流的功能

处理流的功能主要体现在以下两个方面：

​ 1.性能的提高：主要以增加缓冲的方式来提高输入输出的效率

​ 2.操作的便捷：处理流可能提供了一系列便捷的方法来一次输入输出大批量的数据，使用更加灵活方便

4 节点流

​ FileInputStream和FileOutputStream 是字节流

​ FileReader和 FileWriter是字符流

4.1 FileInputStream字节输入流

FileInputStream: 文件输入流

4.1.1 new FileInputStream(String filepath)

​ 根据文件路径创建文件输入流

//创建FileInputStream对象，用于读取文件
FileInputStream fileInputStream = new FileInputStream("H:\\117Java IO\\hello.txt");

4.1.2 new FileInputStream(File file)

​ 根据文件对象创建文件输入流

File file = new File("H:\\117Java IO\\hello.txt");  //文件对象
FileInputStream fileInputStream = new FileInputStream(file); //根据文件对象创建文件输入流

4.1.3 FileInputStream.read()

​ 从FileInputStream输入流读取一个字节的数据

​ 如果返回-1，表示读取完毕

int readData=fileInputStream.read(); //读取的一个字节数据char对应的整数，本质是字节数据

​ 缺点：单个字节的读取，效率有点低 ，读取中文汉字，会乱码

​ 解决方案：fileInputStream.read(byte[]) 一次读取字节数组的最大长度，效率更高

package com.tangguanlin.io.inputsteam;
import java.io.FileInputStream;
import java.io.IOException;
/**
 * 说明：文件输入流FileInputStream 字节输入流 文件-->程序
 * 作者：汤观林
 * 日期：2022年01月22日 15时
 */
public class FileInputStreamTest1 {
    public static void main(String[] args) throws IOException {

        //创建FileInputStream对象，用于读取文件
        FileInputStream fileInputStream = new FileInputStream("H:\\117Java IO\\hello.txt");

        int readData = 0; 
        
        //readData=fileInputStream.read() 读取的一个字节数据char对应的整数，本质是字节数据
        while((readData=fileInputStream.read())!=-1){
            System.out.println((char)readData);  //转成char显示
        }

        //关闭文件流，释放资源
        fileInputStream.close();
    }
}

运行结果：

原文本文件内容：

h
e
l
l
o
é
Ÿ
©

4.1.4 FileInputStream.read(byte[] b)

​ 从文件输入流FileInputStream读数据到字节数组byte[]中

byte[] buffer = new byte[1024];     //一次读取1024个字节
intlength = fileInputStream.read(buffer);   //如果读取正常，返回实际读取的字节数length

总结：效率比较高，一次可以读取1024个字节，极端情况下，汉字读取会乱码

package com.tangguanlin.io.inputsteam;
import java.io.FileInputStream;
import java.io.IOException;
/**
 * 说明：文件输入流FileInputStream 字节输入流 文件-->程序
 * 作者：汤观林
 * 日期：2022年01月22日 15时
 */
public class FileInputStreamTest2 {
    public static void main(String[] args) throws IOException {

        //创建FileInputStream对象，用于读取文件
        FileInputStream fileInputStream = new FileInputStream("H:\\117Java IO\\hello.txt");

        int length = 0;  //如果读取正常，返回实际读取的字节数
        byte[] buffer = new byte[1024]; //一次读取1024个字节

        while((length=fileInputStream.read(buffer))!=-1){
            System.out.println(new String(buffer,0,length));
        }

        //关闭文件流，释放资源
        fileInputStream.close();
    }
}

​ 运行结果：

原文：hello,world

hello,world

4.1.5 FileInputStream.close()

​ 关闭文件输入流FileInputStream，释放资源

​ 有很多输入输出流绑定在文件上，不用的流要关闭，不然会导致文件绑定不了新的输入输出流。

4.2 FileOutputStream字节输出流

FileOutputStream 文件输出流

4.2.1 new FileOutputStream(String filepath)

​ 根据文件路径创建文件输出流

//创建FileOnputStream对象，用于读取文件
FileOutputStream fileOutputStream = new FileOutputStream("H:\\117Java IO\\hello.txt");

4.2.2 new FileOutputStream(File file)

​ 根据文件对象创建文件输出流

File file = new File("H:\\117Java IO\\hello.txt");  //文件对象
FileOutputStream fileOutputStream = new FileOutputStream(file); //根据文件对象创建文件输出流

4.2.3 FileOutputStream.write(int b)

​ 写入一个字节到文件中

​ 很少用

//得到FileOutputStream对象
 FileOutputStream fileOutputStream = new FileOutputStream("H:\\117Java IO\\a.txt");

//写入一个字节
fileOutputStream.write('a'); //字符  自动转为 int

4.2.4 FileOutputStream.write(byte[] b)

​ 写入字符串到文件中

​ 很少用，不能用于文件写入，写入时需要指定数组长度

​ 写入时，不能用这个方法，用这个方法会导致文件打不开，文件损坏

//得到FileOutputStream对象
FileOutputStream fileOutputStream = new FileOutputStream("H:\\117Java IO\\a.txt");

//写入字符串
fileOutputStream.write("hello,world".getBytes());  //字符串 转为 字节数组

4.2.5 FileOutputStream.write(byte[],int off,int length)

​ 写入字符串的指定长度到文件中

​ 写入时，一定要用这个方法，否则会导致文件打不开，文件损坏

//得到FileOutputStream对象
FileOutputStream fileOutputStream = new FileOutputStream("H:\\117Java IO\\a.txt");

String str = "hello,world";
//写入时，一定要用这个方法，否则会导致文件打不开，文件损坏
fileOutputStream.write(str.getBytes(),0,str.length()); 

4.2.6 FileOutputStream.close()

​ 关闭文件输出流FileOutputStream，释放资源

fileOutputStream.close();

4.2.7 应用实例1

要求：请使用FileOutputStream在a.txt文件中写入"hello,world"。

package com.tangguanlin.io.outputstream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
/**
 * 说明：文件输出流
 *      如果文件不存在，则会自动创建该文件
 * 作者：汤观林
 * 日期：2022年01月22日 16时
 */
public class FileOutputStreamTest1 {
    public static void main(String[] args) throws IOException {

        //得到FileOutputStream对象
        FileOutputStream fileOutputStream = new FileOutputStream("H:\\117Java IO\\a.txt");

        //写入一个字节
        //fileOutputStream.write('a'); //字符  自动转为 int
        //写入字符串
        //fileOutputStream.write("hello,world".getBytes());  //字符串 转为 字节数组
        //写入字符串 指定长度
        String str = "hello,world";
        fileOutputStream.write(str.getBytes(),0,str.length());

        //释放资源
        fileOutputStream.close();
    }
}

4.2.8 应用实例2

编程完成图片/音乐的拷贝

package com.tangguanlin.io.outputstream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
/**
 * 说明： 文件拷贝
 * 作者：汤观林
 * 日期：2022年01月22日 17时
 */
public class FileCopy {
    public static void main(String[] args) throws Exception{

        //1.创建文件输入流，将文件读到程序
        FileInputStream fileInputStream = new FileInputStream("H:\\117Java IO\\from\\koala.jpg");


        //2.创建文件输出流，将读取到的文件数据，写入到指定的文件
        FileOutputStream fileOutputStream = new FileOutputStream("H:\\117Java IO\\to\\koala2.jpg");

        int length = 0;
        byte[] bytes = new byte[1024];

        while((length=fileInputStream.read(bytes))!=-1){
            fileOutputStream.write(bytes,0,length); //一定要用这个方法写入，否则文件会打不开
        }

        //释放资源
        fileOutputStream.close();
        fileInputStream.close();
    }
}

运行结果：

4.3 FileReader字符输入流

FileReader是字符输入流，即按照字符来操作IO。

4.3.1 new FileReader(String filepath)

根据文件路径创建FileReader对象

//使用FileReader从story.txt读取内容，并显示
FileReader fileReader = new FileReader("H:\\117Java IO\\story.txt");

4.3.2 new FileReader(File file)

根据文件对象创建FileReader对象

//获取文件对象
File file = new File("H:\\117Java IO\\story.txt");
//创建FileReader对象
FileReader fileReader1 = new FileReader(file);

4.3.3 FileReader.read()

每次读取单个字符，返回该字符，如果到文件末尾返回 -1

按字符读取，就不会存在乱码了。

缺点：效率低

//单个字符读取
int data = 0;
while((data=fileReader.read())!=-1){
    System.out.println((char)data);
}

4.3.4 FileReader.read(byte[])

批量读取多个字符到数组，返回读取到的字符数，

如果到文件末尾返回 -1

优点：效率高

//多个字符读取
char[] buf = new char[128];
int length = 0;
//循环读取，使用read(buf)，返回的是实际读取到的字符数
//如果返回-1，说明到文件结束
while((length = fileReader.read(buf))!=-1){
    //一定要使用这个方法
    System.out.println(new String(buf,0,length));
}

4.3.5 FileReader.close()

关闭FileReader

//释放资源
fileReader.close();

4.3.6 new String(char[],int off,int length)

char[] buf = new char[128];
String str = new String(buf,0,buf.length);

4.3.7 应用实例

使用FileReader从story.txt读取内容，并显示

package com.tangguanlin.io.filereader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
/**
 * 说明：FileReader使用
 * 作者：汤观林
 * 日期：2022年01月22日 18时
 */
public class FileReaderTest1 {
    public static void main(String[] args) throws IOException {

        //使用FileReader从story.txt读取内容，并显示
        FileReader fileReader = new FileReader("H:\\117Java IO\\story.txt");

        //单个字符读取
        int data = 0;
        while((data=fileReader.read())!=-1){
            System.out.println((char)data);
        }

       //多个字符读取
        char[] buf = new char[128];
        int length = 0;
        //循环读取，使用read(buf)，返回的是实际读取到的字符数
        //如果返回-1，说明到文件结束
        while((length = fileReader.read(buf))!=-1){
            //一定要使用这个方法
            System.out.println(new String(buf,0,length));
        }

        //释放资源
        fileReader.close();
    }
}

运行结果：

空军张山在执行任务时，误入百慕大穿越到战国末期成一个农户子弟黑山。为了不在未来的战争中死去，他只能努力向上爬。 先献马蹄铁，使秦军战力飞升，最后手刃匈奴大单于。因功升任执金中尉，负责咸阳城防治安。献水轮车、造......纸术、印刷术，升爵为大良造，娶四公主
成为驸马，升任陶郡郡守。 在灭楚大战中，根据历史知识，准确预测战场形式，两次攻下彭城救出被困大军，升职为上将军，带六十万大军灭了楚国。 天下一统后，已经是镇南侯的张山，因主张与民休生养息，反对秦始皇大兴土木，出海求仙全家被流放在闽越。 秦始皇驾崩后，天下

4.4 FileWriter字符输出流

FileWriter是字符输出流，即按照字符来操作IO。

FileWriter使用后，必须要关闭(close)，或刷新(flush)，否则写入不到指定的文件！

4.4.1 new FileWriter(String filepath)

根据文件路径创建FileWriter对象

FileWriter fileWriter = new FileWriter("H:\\117Java IO\\note.txt");

4.4.2 new FileWriter(File file)

根据文件对象创建FileWriter对象

//创建文件对象
File file = new File("H:\\117Java IO\\note.txt");

//创建FileWriter对象
FileWriter fileWriter1 = new FileWriter(file);

4.4.3 FileWriter.write(int b)

写入单个字符

FileWriter fileWriter = new FileWriter("H:\\117Java IO\\note.txt");
String str = "风雨之后，定见彩虹";
char[] strArray = str.toCharArray();

//1.write(int) 写入单个字符
for(char c:strArray){
     fileWriter.write(c);
}

4.4.4 FileWriter.write(char[])

写入字符数组

FileWriter fileWriter = new FileWriter("H:\\117Java IO\\note.txt");
String str = "风雨之后，定见彩虹";
char[] strArray = str.toCharArray();

//2.write(char[]) 写入整个字符数组
fileWriter.write(strArray);

4.4.5 FileWriter.write(char[],off,len)

写入字符数组的指定部分

FileWriter fileWriter = new FileWriter("H:\\117Java IO\\note.txt");
String str = "风雨之后，定见彩虹";
char[] strArray = str.toCharArray();

//3.write(char[],off,len) 写入字符数组的指定部分
fileWriter.write(strArray,0,strArray.length);

4.4.6 FileWriter.write(String)

写入整个字符串

FileWriter fileWriter = new FileWriter("H:\\117Java IO\\note.txt");

//4.write(String) 写入整个字符串
fileWriter.write("风雨之后，定见彩虹");

4.4.7 FileWriter.write(String,off,len)

写入字符串的指定部分

FileWriter fileWriter = new FileWriter("H:\\117Java IO\\note.txt");
String str = "风雨之后，定见彩虹";

//5.write(Stirng,off,len) 写入字符串的指定部分
fileWriter.write(str,0,str.length());

4.4.8 FileWriter.close()

一定要关闭FileWriter流，或者flush才能真正的把数据写入到文件

//关闭fileWriter流
//对于FileWriter,一定要关闭流，或者flush才能真正的把数据写入到文件
fileWriter.close(); //真正的写入

4.4.9 String.toCharArray

将String转换成char[]

String str = "风雨之后，定见彩虹";
char[] strArray = str.toCharArray();

4.4.10 应用实例

使用FileWriter将“风雨之后，定见彩虹”写入到note.txt文件中，注意细节。

package com.tangguanlin.io.filewriter;
import java.io.FileWriter;
import java.io.IOException;
/**
 * 说明：FileWriter
 * 作者：汤观林
 * 日期：2022年01月22日 19时
 */
public class FileWriterTest1 {
    public static void main(String[] args) throws IOException {
        FileWriter fileWriter = new FileWriter("H:\\117Java IO\\note.txt");

        String str = "风雨之后，定见彩虹";
        char[] strArray = str.toCharArray();

        //1.write(int) 写入单个字符
        /*for(char c:strArray){
            fileWriter.write(c);
        }*/

        //2.write(char[]) 写入整个字符数组
        fileWriter.write(strArray);

        //3.write(char[],off,len) 写入字符数组的指定部分
        fileWriter.write(strArray,0,strArray.length);

        //4.write(String) 写入整个字符串
        fileWriter.write("风雨之后，定见彩虹");

        //5.write(Stirng,off,len) 写入字符串的指定部分
        fileWriter.write(str,0,str.length());

        //关闭fileWriter流
        //对于FileWriter,一定要关闭流，或者flush才能真正的把数据写入到文件
        fileWriter.close(); //真正的写入
    }
}

5 缓冲流

​ 关闭时，只需要关闭外层流即可，用的是装饰器模式，关闭外层流，实际上调用的是关闭节点流的关闭方法。

5.1 BufferedInputStream字节缓冲输入流

BufferedInputStream: 属于缓冲字节输入流，是按照字节来读取数据的，操作二进制文件：图片，声音，视频

5.1.1 new BufferedInputStream(InputStream)

根据InputStream对象创建BufferedInputStream缓冲流对象

BufferedInputStream bufferedInputStream = new BufferedInputStream(
                                                        new FileInputStream("H:\\117Java IO\\hello.txt"));

5.1.2 BufferedInputStream.read()

从BufferedInputStream缓冲流读取一个字节的数据

如果返回-1，表示读取完毕

BufferedInputStream bufferedInputStream = new BufferedInputStream(
                                                         new FileInputStream("H:\\117Java IO\\hello.txt"));

int data = 0;
while((data = bufferedInputStream.read())!=-1){
    System.out.println((char)data);
}

5.1.3 BufferedInputStream(byte[])

从缓冲输入流BufferedInputStream读数据到字节数组byte[]中

BufferedInputStream bufferedInputStream = new BufferedInputStream(
                                                         new FileInputStream("H:\\117Java IO\\hello.txt"));

int length = 0;
byte[] buff = new byte[1024];
while ((length = bufferedInputStream.read(buff))!=-1){
    System.out.println(new String(buff,0,length));
}

5.1.4 BufferedInputStream(byte[],int,int)

从缓冲输入流BufferedInputStream读数据到字节数组byte[]中

BufferedInputStream bufferedInputStream = new BufferedInputStream(
                                                         new FileInputStream("H:\\117Java IO\\hello.txt"));
int length = 0;
byte[] buff = new byte[1024];
while ((length = bufferedInputStream.read(buff,0,buff.length))!=-1){
    System.out.println(new String(buff,0,length));
}

5.1.5 BufferedInputStream.close()

关闭BufferedInputStream缓冲流

bufferedInputStream.close();

5.1.6 应用实例

package com.tangguanlin.io.buffer;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.IOException;
/**
 * 说明：BufferedInputStream
 * 作者：汤观林
 * 日期：2022年01月23日 00时
 */
public class BufferedInputStreamTest {
    public static void main(String[] args) throws IOException {

        BufferedInputStream bufferedInputStream = new BufferedInputStream(
            											new FileInputStream("H:\\117Java IO\\hello.txt"));

        /*int data = 0;
        while((data = bufferedInputStream.read())!=-1){
            System.out.println((char)data);
        }*/

        /* int length = 0;
         byte[] buff = new byte[1024];
         while ((length = bufferedInputStream.read(buff))!=-1){
             System.out.println(new String(buff,0,length));
         }*/

        int length = 0;
        byte[] buff = new byte[1024];
        while ((length = bufferedInputStream.read(buff,0,buff.length))!=-1){
            System.out.println(new String(buff,0,length));
        }

        //关闭流
        bufferedInputStream.close();
    }
}

5.2 BufferedOutputStream字节缓冲输出流

BufferedOutputStream: 属于缓存字节输出流，是按照字节来读取数据的，操作二进制文件：图片，声音，视频

​ 实现缓冲的输出流，可以将多个字节写入底层输出流中，而不必对每次字节写入调用底层系统。

5.2.1 new BufferedOutputStream(OutputStream)

根据OutputStream对象创建BufferedOutputStream输出缓冲流对象

 BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(
     													new FileOutputStream("H:\\117Java IO\\hello3.txt"));

5.2.2 BufferedOutputStream.write(int b)

写入单个字节到文件中

BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(
    												new FileOutputStream("H:\\117Java IO\\hello3.txt"));
String str = "快乐编程";
byte[] bytes = str.getBytes();

for(byte b:bytes){
    bufferedOutputStream.write(b);
}

5.2.3 BufferedOutputStream.write(byte[])

写入整个字节数组到文件中

BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(
            											new FileOutputStream("H:\\117Java IO\\hello3.txt"));
String str = "快乐编程";
byte[] bytes = str.getBytes();

bufferedOutputStream.write(bytes);

5.2.4 BufferedOutputStream.write(byte[],int,int)

写入字节数组指定内容到文件中

BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(
    												new FileOutputStream("H:\\117Java IO\\hello3.txt"));
String str = "快乐编程";
byte[] bytes = str.getBytes();

bufferedOutputStream.write(bytes,0,bytes.length);

5.2.5 BufferedOutputStream.close()

关闭BufferedOutputStream缓冲输出流

 bufferedOutputStream.close();

5.2.6 BufferedOutputStream.flush()

刷新BufferedOutputStream缓冲输出流

bufferedOutputStream.flush();

5.2.7 应用实例1

package com.tangguanlin.io.buffer;
import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/**
 * 说明：BufferedOutputStream
 * 作者：汤观林
 * 日期：2022年01月23日 01时
 */
public class BufferedOutputStreamTest {

    public static void main(String[] args) throws IOException {

        BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(
            											new FileOutputStream("H:\\117Java IO\\hello3.txt"));
        String str = "快乐编程";
        byte[] bytes = str.getBytes();

        //BufferedOutputStream.write(int b)方式
       /* for(byte b:bytes){
            bufferedOutputStream.write(b);
        }*/

        //BufferedOutputStream.write(byte[])方式
        //bufferedOutputStream.write(bytes);

        //BufferedOutputStream.write(byte[],int,int)方式
        bufferedOutputStream.write(bytes,0,bytes.length);

        //释放资源
        bufferedOutputStream.close();
    }
}

5.2.8 应用实例2

要求：字节缓冲流 拷贝文件

package com.tangguanlin.io.buffer;
import java.io.*;
/**
 * 说明： 字节缓冲流 拷贝文件
 * 作者：汤观林
 * 日期：2022年01月23日 01时
 */
public class BufferedStreamCopyTest {
    public static void main(String[] args) throws IOException {

        BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream("H:\\117Java IO\\from\\【韩顺平】Java IO流专题-p9-09_文件字符流说明.flv"));

        BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(new FileOutputStream("H:\\117Java IO\\to\\【韩顺平】Java IO流专题-p9-09_文件字符流说明.flv"));


        int length = 0;
        byte[] bytes = new byte[1024];

       while((length=bufferedInputStream.read(bytes))!=-1){
            bufferedOutputStream.write(bytes,0,length);
        }

        bufferedOutputStream.close();
        bufferedInputStream.close();
    }
}

5.3 BufferedReader字符缓冲输入流

​ BufferedReader属于字符流，是按照字符来读取数据的

​ 关闭处理流时，只需要关闭外层流即可

​ 关闭处理流的时候，会自动关闭被包装的节点流。

5.3.1 new BufferedReader(Reader)

​ 根据Reader对象创建BufferedReader处理流

//创建BufferedReader对象
BufferedReader bufferedReader = new BufferedReader(new FileReader("H:\\117Java IO\\hello.txt"));

5.3.2 BufferedReader.read()

​ 读取1个或多个字节，返回一个字符，当读取到文件末尾时，返回 -1

//创建BufferedReader对象
BufferedReader bufferedReader = new BufferedReader(new FileReader("H:\\117Java IO\\hello.txt"));

int readData = 0;
while ((readData=bufferedReader.read())!=-1){
    System.out.println((char)readData);
}

5.3.3 BufferedReader.read(char[])

将最多length个字符读入数组中，返回实际读入的字符个数，当读取到文件末尾时，返回 -1

int length = 0;
char[] charArray = new char[2];
while((length = bufferedReader.read(charArray))!=-1){
    System.out.println(new String(charArray,0,length));
}

5.3.4 BufferedReader.read(char[],int,int)

将最多length个字符读入数组中，返回实际读入的字符个数，当读取到文件末尾时，返回 -1

int length = 0;
char[] charArray = new char[1024];
while((length= bufferedReader.read(charArray, 0, charArray.length))!=-1){
    System.out.println(new String(charArray,0,length));
}

5.3.5 BufferedReader.readLine()

读一行文字并返回该行字符，若读到文件末尾，则返回null

//创建BufferedReader对象
BufferedReader bufferedReader = new BufferedReader(new FileReader("H:\\117Java IO\\hello.txt"));

//按行读取，效率高
//当返回null时，表示文件结束
String readLine;
while((readLine=bufferedReader.readLine())!=null){
    System.out.println(readLine);
}

5.3.6 BufferedReader.close()

关闭BufferedReader流

只需要关闭外层流bufferedReader即可,因为底层会自动关闭节点流

//释放资源
//只需要关闭外层流bufferedReader即可,因为底层会自动关闭节点流
bufferedReader.close();

5.3.7 应用实例1

1.使用BufferedReader读取文本文件，并显示在控制台

package com.tangguanlin.io.buffer;
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
/**
 * 说明：BufferedReader的使用
 * 作者：汤观林
 * 日期：2022年01月22日 22时
 */
public class BufferedReaderTest {
    public static void main(String[] args) throws IOException {

         //创建BufferedReader对象
        BufferedReader bufferedReader = new BufferedReader(new FileReader("H:\\117Java IO\\hello.txt"));

        //BufferedReader.read()方式
       /* int readData = 0;
        while ((readData=bufferedReader.read())!=-1){
            System.out.println((char)readData);
        }*/

       //BufferedReader.read(char[])方式
       /* int length = 0;
        char[] charArray = new char[2];
        while((length = bufferedReader.read(charArray))!=-1){
            System.out.println(new String(charArray,0,length));
        }*/

       //BufferedReader.read(char[],int,int)方式
      /* int length = 0;
       char[] charArray = new char[1024];
       while((length= bufferedReader.read(charArray, 0, charArray.length))!=-1){
           System.out.println(new String(charArray,0,length));
       }*/

        //BufferedReader.readLine()方式
        //按行读取，效率高
        //当返回null时，表示文件结束
        String readLine;
        while((readLine=bufferedReader.readLine())!=null){
            System.out.println(readLine);
        }

        //释放资源
        //只需要关闭外层流bufferedReader即可,因为底层会自动关闭节点流
        bufferedReader.close();
    }
}

5.3.8 应用实例2

要求：使用BufferedReader读取一个文本文件，为每行加上行号，在连同内容一并输出到屏幕上。

package com.tangguanlin.io.homework;
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
/**
 * 说明：
 * 作者：汤观林
 * 日期：2022年01月24日 00时
 */
public class HomeworkTest2 {
    public static void main(String[] args) throws IOException {

        //要求：使用BufferedReader读取一个文本文件，为每行加上行号，在连同内容一并输出到屏幕上。
        BufferedReader bufferedReader =new BufferedReader(new InputStreamReader(new FileInputStream("H:\\117Java IO\\mysql.properties"),"gbk"));

        String readLine;
        int i = 0;
        while((readLine=bufferedReader.readLine())!=null){
            i++;
            System.out.println(i+"  "+readLine);
        }
        bufferedReader.close();
    }
}

5.4 BufferedWriter字符缓冲输出流

BufferedWriter属于字符流，是按照字符来读取数据的

关闭处理流时，只需啊哟关闭外层流即可

5.4.1 new BufferedWriter(Writer)

根据Writer对象创建BufferedWriter处理流对象

BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("H:\\117Java IO\\hello2.txt"));

5.4.2 BufferedWriter.write(int)

写入单个字符

BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("H:\\117Java IO\\hello2.txt"));

String str = "hello,韩顺平教育";
char[] charArray =  str.toCharArray();

for(char c:charArray){
    bufferedWriter.write(c);
}

5.4.3 BufferedWriter.write(char[],int,int)

写入字符数组的指定长度内容

BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("H:\\117Java IO\\hello2.txt"));

String str = "hello,韩顺平教育";
char[] charArray =  str.toCharArray();

bufferedWriter.write(charArray,0,charArray.length);

5.4.4 BufferedWriter.write(String)

写入整个字符串

BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("H:\\117Java IO\\hello2.txt"));

String str = "hello,韩顺平教育";
bufferedWriter.write(str);

5.4.5 BufferedWriter.write(String,int,int)

写入字符串指定的长度内容

BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("H:\\117Java IO\\hello2.txt"));

String str = "hello,韩顺平教育";

bufferedWriter.write(str,0,5);

5.4.6 BufferedWriter.newLine()

插入换行符

bufferedWriter.newLine(); //插入一个换行符

5.4.7 BufferedWriter.close()

关闭BufferedWriter流

关闭外层流即可，传入的new FileWriter(),会在底层关闭

//释放资源
//关闭外层流即可，传入的new FileWriter(),会在底层关闭
 bufferedWriter.close();

5.4.8 BufferedWriter.flush()

刷新BufferedWriter流，和关闭流效果是一样的

bufferedWriter.flush();

5.4.9 应用实例1

使用BufferedWriter将“hello,韩顺平教育”,写入到文件中

package com.tangguanlin.io.buffer;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.io.OutputStreamWriter;
/**
 * 说明：BufferedWriter
 * 作者：汤观林
 * 日期：2022年01月22日 23时
 */
public class BufferWriterTest {
    public static void main(String[] args) throws IOException {

        BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("H:\\117Java IO\\hello2.txt"));

        String str = "hello,韩顺平教育";
        char[] charArray =  str.toCharArray();

        //BufferedWriter.write(int)方式
        /*
          for(char c:charArray){
            bufferedWriter.write(c);
        }*/

        //BufferedWriter.write(char[],int,int)方式
        //bufferedWriter.write(charArray,0,charArray.length);


        //BufferedWriter.write(String)方式
        //bufferedWriter.write(str);

        //BufferedWriter.write(String,int,int)方式
        bufferedWriter.write(str,0,5);

        bufferedWriter.newLine(); //插入一个换行符
        
        //释放资源
        //关闭外层流即可，传入的new FileWriter(),会在底层关闭
        bufferedWriter.close();
    }
}

5.4.10 应用实例2

综合使用BufferedReader和BufferedWriter完成文本文件拷贝，注意文件编码

package com.tangguanlin.io.buffer;
import java.io.*;
/**
 * 说明：Buffered文件复制
 * 作者：汤观林
 * 日期：2022年01月23日 00时
 */
public class BufferCopyTest {
    public static void main(String[] args) throws IOException {

        BufferedReader bufferedReader = new BufferedReader(
            									new FileReader("H:\\117Java IO\\from\\koala.jpg"));

        BufferedWriter bufferedWriter = new BufferedWriter(
            									new FileWriter("H:\\117Java IO\\to\\koala.jpg"));

        String readLine;
        while((readLine=bufferedReader.readLine())!=null){
            bufferedWriter.write(readLine);
            //bufferedWriter.newLine();
        }

        bufferedWriter.close();
        bufferedReader.close();
    }
}

6 对象流

对象流：ObjectOutputStream和ObjectInputStream

看一个需求：

​ 1.将Dog dog = new Dog(“小黄”,3)这个dog对象保存到文件中，并且能够从文件恢复

​ 2.上面的要求，就是能够将基本数据类型或者对象进行 序列化和反序列化操作

序列化和反序列化：

​ 1.序列化就是在保存数据时，保存数据的值和数据类型

​ 2.反序列化就是在恢复数据时，恢复数据的值和数据类型

​ 3.需要让某个对象支持序列化机制，则必须让其类是可序列化的，为了让某个类是可序列化的，

​ 该类必须实现如下两个接口之一：

​ 。Serializable //这是一个标记接口,没有方法，我们一般用这个接口

​ 。Externalizable //该接口有方法需要实现，我们一般不用这个接口

​ ObjectInputStream和ObjectOutputStream

​ 1.功能：提供了对基本类型或对象类型的序列化和反序列化的方法

​ 2.ObjectOutputStream提供了序列化功能

​ 3.ObjectInputStream提供了反序列化的功能

​ 注意事项和细节说明：

​ 1.读写顺序要一致

​ 2.要求实现序列化或反序列化对象，需要实现Serializable

​ 3.序列化的类中建议添加SerialVersionUID,为了提高版本的兼容性

//serialVersionUID 序列化的版本号，可以提供兼容性
private static  final  long serialVersionUID = 1L;

​ 4.序列化对象时，默认将里面所有属性都进行了序列化，但除了static或transient修饰的成员

​ 5.序列化对象时，要求里面属性(子对象)的类型也需要实现序列化接口

​ 6.序列化具备可继承性，也就是如果某类已经实现了序列化，则它的所有子类也默认实现了序列化。

6.1 ObjectOutputStream对象输出流

6.1.1 new ObjectOutputStream(OutputStream)

根据OutputStream对象创建ObjectOutputStream对象输出流实例

ObjectOutputStream objectOutputStream = new ObjectOutputStream(
    													new FileOutputStream("H:\\117Java IO\\data.dat"));

6.1.2 ObjectOutputStream.writeInt(int)

将整数写入到文件

objectOutputStream.writeInt(100);  //int -->Integer(实现了Serializable)

6.1.3 ObjectOutputStream.writeUTF(String)

将字符串写入到文件

objectOutputStream.writeUTF("韩顺平"); //string (实现了Serializable)

6.1.4 ObjectOutputStream.writeObject(Object)

将对象写入到文件

//保存一个dog对象
Dog dog = new Dog("小黄",3);
objectOutputStream.writeObject(dog);

6.1.5 ObjectOutputStream.close()

关闭对象输出流ObjectOutputStream

//关闭流
objectOutputStream.close();

6.1.6 ObjectOutputStream.flush()

刷新对象输出流ObjectOutputStream

objectOutputStream.flush();

6.1.7 应用实例

1.使用ObjectOutputStream序列化 基本数据类型和一个Dog对象(name,age)，并保存到data.dat文件中

package com.tangguanlin.io.objectstream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
/**
 * 说明：对象输出流
 * 作者：汤观林
 * 日期：2022年01月23日 14时
 */
public class ObjectOutputStreamTest {
        public static void main(String[] args) throws IOException {

            ObjectOutputStream objectOutputStream = new ObjectOutputStream(
                										new FileOutputStream("H:\\117Java IO\\data.dat"));

            //序列化数据到H:\117Java IO\data.dat中
            //序列化后，保存的文件格式，不是文本格式，而是按照它的格式来保存
            objectOutputStream.writeInt(100);  //int -->Integer(实现了Serializable)

            objectOutputStream.writeBoolean(true); //boolean -->Boolean (实现了Serializable)

            objectOutputStream.writeChar('a'); //char --> Character (实现了Serializable)

            objectOutputStream.writeDouble(9.42); //double-->Double (实现了Serializable)

            objectOutputStream.writeUTF("韩顺平"); //string (实现了Serializable)

            //保存一个dog对象
            Dog dog = new Dog("小黄",3);
            objectOutputStream.writeObject(dog);

            //关闭流
            objectOutputStream.close();
            System.out.println("数据保存完毕(序列化形式)");
        }
}

6.2 ObjectInputStream对象输入流

ObjectInputStream: 对象字节输入流

读取(反序列化)的顺序需要和你保存的数据(序列化)的顺序一致,否则会出现异常

6.2.1 new ObjectInputStream(InputStream)

根据InputStream对象创建对象输入流实例

ObjectInputStream objectInputStream = new ObjectInputStream(
    													new FileInputStream("H:\\117Java IO\\data.dat"));

6.2.2 ObjectInputStream.readInt()

从文件中读取整数

int num = objectInputStream.readInt();

6.2.3 ObjectInputStream.readUTF()

从文件中读取字符串

String str = objectInputStream.readUTF();

6.2.4 ObjectInputStream.readObject()

从文件中读取对象

Ojbect object = objectInputStream.readObject();

6.2.5 ObjectInputStream.close()

关闭对象输入流

//关闭流，只需关闭外层流，底层会关闭FileInputStream流
objectInputStream.close();

6.2.6 应用实例

1.使用ObjectInputStream读取data.dat并反序列化恢复数据

package com.tangguanlin.io.objectstream;
import java.io.FileInputStream;
import java.io.ObjectInputStream;
/**
 * 说明：ObjectInputStream
 * 作者：汤观林
 * 日期：2022年01月23日 15时
 */
public class ObjectInputStreamTest {
    public static void main(String[] args) throws Exception {

        ObjectInputStream objectInputStream = new ObjectInputStream(
            											new FileInputStream("H:\\117Java IO\\data.dat"));

        //读取数据
        //1.读取(反序列化)的顺序需要和你保存的数据(序列化)的顺序一致,否则会出现异常

        System.out.println(objectInputStream.readInt());
        System.out.println(objectInputStream.readBoolean());

        System.out.println(objectInputStream.readChar());
        System.out.println(objectInputStream.readDouble());
        System.out.println(objectInputStream.readUTF());
        System.out.println(objectInputStream.readObject());

        //关闭流，只需关闭外层流，底层会关闭FileInputStream流
        objectInputStream.close();
    }
}

运行结果：

100
true
a
9.42
韩顺平
Dog(name=小黄, age=3)

7 转换流

转换流 InputStreamReader 和 OutputStreamWriter

​ 字节流 转换为 字节流 ，并指定编码

​ 转换流的作用 主要是指定编码格式去读取/写入文件，这样就能解决乱码问题。

。先看一个文件乱码问题，引出学习转换流的必要性

文件内容和格式：

package com.tangguanlin.io.transformation;
import java.io.*;
/**
 * 说明： 默认情况下，读取文件是按照utf-8编码
 *       当文件不是utf-8编码时，会出现乱码
 * 作者：汤观林
 * 日期：2022年01月23日 17时
 */
public class CodeQuestion {
    public static void main(String[] args) throws IOException {

        BufferedReader bufferedReader = new BufferedReader(new FileReader("H:\\117Java IO\\hello.txt"));

        String readLine = bufferedReader.readLine();
        System.out.println("读取到的内容:"+readLine);

        bufferedReader.close();

    }
}

运行结果：

读取到的内容:hello,��˳ƽ

基本介绍：

​ 1.InputStreamReader：Reader的子类，可以将InputStream(字节流)转换成Reader(字符流)

​ 2.OutputStreamWriter：Writer的子类，可以将OutputStream(字节流)转换成Writer(字符流)

​ 3.当处理文本数据时，如果使用字符流效率更高，并且可以有效解决中文问题，

​ 所以建议将字节流转换成字符流

​ 4.可以在使用时指定编码格式(比如：utf-8,gbk,gb2312,ISO-8859-1等)

7.1 InputStreamReader输入转换流

应用实例：

1.编程将 字节流FileInputStream转换成字符流InputSreamReader，对文件进行读取(按照utf-8,gbk格式)，进而转换成BufferedReader.

package com.tangguanlin.io.transformation;
import java.io.*;
/**
 * 说明：使用InputStreamReader 转换流 解决中文乱码问题
 *      将字节流FileInputStream 转换成 InputStreamReader，指定编码格式 gbk/utf-8
 * 作者：汤观林
 * 日期：2022年01月23日 19时
 */
public class InputStreamReaderTest {
    public static void main(String[] args) throws IOException {

        //1.将FileInputStream 转换为 InputStreamReader  指定编码 gbk
        //InputStreamReader inputStreamReader = new InputStreamReader(
            								new FileInputStream("H:\\117Java IO\\hello.txt"), "gbk");

        //2.InputStreamReader 传入 BufferedReader
        //BufferedReader bufferedReader = new BufferedReader(inputStreamReader);

        //第1和2合并
        BufferedReader bufferedReader1 = new BufferedReader(new InputStreamReader(
                                                 new FileInputStream("H:\\117Java IO\\hello.txt"), "gbk"));
        
        String readLine = bufferedReader.readLine();
        System.out.println(readLine);

        bufferedReader.close();

        //关闭外层流
        bufferedReader.close();
    }
}

运行结果：

hello,韩顺平

7.2 OutputStreamWriter输出转换流

应用实例2：

2.编程将字节流FileOutputStream转换成字符流OutputStreamWriter,对文件进行写入(按照gbk格式，也可以指定其他，比如utf-8)。

package com.tangguanlin.io.transformation;
import java.io.FileOutputStream;
import java.io.OutputStreamWriter;
/**
 * 说明：OutputStreamWriter
 *      把FileOutputStream字节流 转成 字符流 OutputStreamWriter，同时制定编码格式为gbk/utf-8
 * 作者：汤观林
 * 日期：2022年01月23日 18时
 */
public class OutputStreamWriterTest {
    public static void main(String[] args) throws Exception {

        OutputStreamWriter outputStreamWriter = new OutputStreamWriter(
            									new FileOutputStream("H:\\117Java IO\\hsp.txt"),"utf-8");

        outputStreamWriter.write("hi,韩顺平教育");

        outputStreamWriter.close();
    }
}

8 标准输入输出流

​ 类型 默认设备

System.in 标准输入 InputStream 键盘

System.out 标准输出 PrintStream 显示器

应用实例1：

	传统方法 System.out.println("");    //是使用out对象 将数据输出到显示器

应用案实例2:

	传统方法，Scanner是从标准输入 键盘接收数据

代码：

package com.tangguanlin.io.standard;
import java.util.Scanner;
/**
 * 说明： 标准输入输出流
 * 作者：汤观林
 * 日期：2022年01月23日 16时
 */
public class InputAndOutputTest {
    public static void main(String[] args) {

        //System.in  编译类型    InputStream
        //System.in  运行类型    BufferedInputStream
        //表示的是标准输入   键盘
        System.out.println(System.in.getClass());
        System.out.println("请输入内容：");

        Scanner scanner = new Scanner(System.in);  //从键盘输入
        String inputStr = scanner.next();


        //System.out 编译类型   PrintStream
        //System.out 运行类型   PrintStream
        //表示标准输出   显示器
        System.out.println(System.out.getClass());

        System.out.println(inputStr);  //输出到显示器
    }
}

运行结果：

class java.io.BufferedInputStream
请输入内容：
北京欢迎你
class java.io.PrintStream
北京欢迎你

9 打印流

。打印流：PrintStream 和 PrintWriter

​ 打印流只有输出流，没有输入流

PrintStream 是字节打印流，父类是OutputStream

PrintWriter 是字符打印流， 父类是Writer

8.1 PrintStream字节打印流

package com.tangguanlin.io.print;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.PrintStream;
/**
 * 说明： PrintStream 字节打印流
 * 作者：汤观林
 * 日期：2022年01月23日 21时
 */
public class PrintStreamTest {
    public static void main(String[] args) throws FileNotFoundException {

        //在默认情况下，PrintStream输出数据的位置是标准输出，即显示器
        PrintStream printStream = System.out;

        //改变输出位置  方式一 输出到文件
        PrintStream printStream1 = new PrintStream("H:\\117Java IO\\hello.txt");
        //改变输出位置 方式二 
        System.setOut(new PrintStream("H:\\117Java IO\\hello.txt"));

        printStream1.print("john,hello");

        //关闭流
        printStream1.close();

    }
}

8.2 PrintWriter字符打印流

package com.tangguanlin.io.print;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
/**
 * 说明：PrintWriter字符打印流
 * 作者：汤观林
 * 日期：2022年01月23日 21时
 */
public class PrintWriterTest {
    public static void main(String[] args) throws IOException {

        //打印到显示器
        PrintWriter printWriter = new PrintWriter(System.out);
        //改变打印位置
        PrintWriter printWriter1 = new PrintWriter(new FileWriter("H:\\117Java IO\\hello.txt"));

        printWriter1.println("hi,北京你好~");

        //关闭流,只有关闭流，才会将数据写入到文件
        printWriter1.close();
    }
}

10 Properties类

10.1 看一个需求

如下一个配置文件 mysql.properties

ip=192.168.0.13
user=root
pwd=12345

请编程读取ip、user和pwd的值是多少

分析：

​ 1.传统的方法

​ 2.使用Properties类可以方便实现

10.2 传统方法

package com.tangguanlin.io.properties;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
/**
 * 说明：用传统方法读取Properties配置文件的值
 * 作者：汤观林
 * 日期：2022年01月23日 21时
 */
public class PropertiesTest1 {
    public static void main(String[] args) throws IOException {

        //每次可以读取一行(配置文件)
        BufferedReader bufferedReader = new BufferedReader(
            								   new FileReader("src\\main\\resources\\mysql.properties"));

        String readLine;
        while ((readLine = bufferedReader.readLine())!=null){
            System.out.println("读到一行的内容:"+readLine);
            String[] split = readLine.split("=");
            System.out.println(split[0]+":"+split[1]);
            //遍历,才能找到ip,user和pwd
        }

        bufferedReader.close();
    }
}

运行结果：

ip:192.168.0.13
user:root
pwd:12345

10.3 Properties类方法

​ 1.专门用于读写配置文件的集合类

​ 配置文件的格式：键值对

键=值
键=值

2.注意：键值对不需要空格，值不需要用引号起来，默认类型是String

3.Properties的常见方法：

​ 。load： 加载配置文件的键值对到Properties对象

​ 。list：将数据显示到指定设备/文件(流对象)

​ 。getProperty(key)：根据键获取值

​ 。setProperty(key,value)：设置键值对到Properties对象

​ 如果该文件没有这个key,就是创建

​ 如果该文件有这个key,就是修改

​ 。store(Writer,null)：将Properties中的键值对存储到配置文件中，

​ 在idea中，保存信息到配置文件，如果含有中文，会存储为unicode码

应用实例:

​ 1.使用Properties类完成对mysql.properties的读取

package com.tangguanlin.io.properties;
import java.io.FileInputStream;
import java.io.PrintWriter;
import java.util.Properties;
/**
 * 说明：Properties方式读取配置文件
 * 作者：汤观林
 * 日期：2022年01月23日 22时
 */
public class PropertiesTest {
    public static void main(String[] args) throws Exception {

        //1.创建Properties对象
        Properties properties = new Properties();

        //2.加载配置文件
        properties.load(new FileInputStream("src\\main\\resources\\mysql.properties"));

        //3.获取到key的值
        properties.list(System.out); //输出到控制台

        String ip = properties.getProperty("ip");
        System.out.println(ip);

        String user = properties.getProperty("user");
        System.out.println(user);

        String pwd = properties.getProperty("pwd");
        System.out.println(pwd);

    }
}

​

​ 2.使用Properties类添加key-value到新文件，mysql2.properties中

package com.tangguanlin.io.properties;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Properties;
/**
 * 说明：创建Propeties文件
 * 作者：汤观林
 * 日期：2022年01月23日 23时
 */
public class PropertiesTest2 {
    public static void main(String[] args) throws IOException {

        //创建Properties对象
        Properties properties = new Properties();

        //设置key-value值
        properties.setProperty("charset","utf8");
        properties.setProperty("user","汤姆22");
        properties.setProperty("pwd","abc111");

        //写入到文件中
        properties.store(new FileWriter("src\\main\\resources\\mysql2.properties"),null);
    }
}

​ 3.使用Properties类完成对mysql.properties的读取，并修改某个key-value

package com.tangguanlin.io.properties;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.util.Properties;
/**
 * 说明：Properties方式读取配置文件,并修改
 *      Properties底层是HashTable
 * 作者：汤观林
 * 日期：2022年01月23日 22时
 */
public class PropertiesTest3 {
    public static void main(String[] args) throws Exception {

        //1.创建Properties对象
        Properties properties = new Properties();

        //2.加载配置文件
        properties.load(new FileInputStream("src\\main\\resources\\mysql.properties"));

        //3.设置新值
        properties.setProperty("user","admin");
        properties.setProperty("servername","xydDB");

        //4.更新到配置文件中
        properties.store(new FileOutputStream("src\\main\\resources\\mysql.properties"),null);
    }
}

​ 4.编程题

​ (1)要编写一个dog.properties

name = tom
age = 5
color = red

​ (2)编写Dog类(name,age,color),创建一个dog对象，

​ 读取dog.properties用相应的内容完成属性初始化，并输出

​ (3) 将创建的Dog对象，序列化到文件dog.dat文件

​ (4) 从dog.dat文件中反序列化dog对象

package com.tangguanlin.io.homework;
import java.io.*;
import java.util.Properties;
/**
 * 说明：
 * 作者：汤观林
 * 日期：2022年01月24日 00时
 */
public class HomeworkTest3 {
    public static void main(String[] args) throws IOException, ClassNotFoundException {

        Properties properties =  new Properties();

        properties.setProperty("name","tom");
        properties.setProperty("age","5");
        properties.setProperty("color","red");

        properties.store(new FileWriter("H:\\117Java IO\\dog.properties"),null);

        Dog dog = new Dog();
        properties.load(new FileReader("H:\\117Java IO\\dog.properties"));

        dog.setName(properties.getProperty("name"));
        dog.setAge(Integer.valueOf(properties.getProperty("age")));
        dog.setColor(properties.getProperty("color"));

        ObjectOutputStream objectOutputStream = new ObjectOutputStream(
            											new FileOutputStream("H:\\117Java IO\\dog.dat"));
        objectOutputStream.writeObject(dog);

        ObjectInputStream objectInputStream = new ObjectInputStream(
            											new FileInputStream("H:\\117Java IO\\dog.dat"));
        Object object = objectInputStream.readObject();

        System.out.println(object);

        objectInputStream.close();
        objectOutputStream.close();
    }
}