目录

第一章 文件

1.什么是文件

2.文件流

3.常用文件操作

1.创建文件对象相关构造器和方法

2.获取文件的相关信息

3.目录的操作和文件删除

第二章 IO流原理及流的分类

1.Java IO流原理

2.流的分类

3.常用的类（FileInputStream和FileOutputStream）

1.InputStream（抽象类）

 2.FileInputStream

3.FileOutStream

4.文件拷贝

5.常用的类（FileReader和FileWriter）

1.FileReader

2.FileWriter

6.节点流和处理流

1.基本介绍

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

3.BufferedReader

4.BufferedWriter

4.使用BufferedReader和BufferedWriter完成文件拷贝

5.BufferedInputStream

6.BufferedOutputStream

7.使用BufferedInputStream和BufferedOutputStream完成图片/音乐的拷贝

7.对象流

1.序列化与反序列化

2.对象流介绍

3.ObjectOutStream

4.ObjectInputStream

5.对象处理流使用细节

8.标准输入输出流

9.转换流

1.转换流介绍

2.InputStreamReader

3.OutputStreamWriter

10.打印流

1.基本介绍

2.PrintStream

第三章 Properties类

1.基本介绍

2.应用案例

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

2.使用Properties类添加key-val到新文件mysql02.properties中

第四章 练习

1.练习一

2.练习二

3.练习三

第一章 文件

1.什么是文件

        文件是保存数据的地方，比如大家经常使用的word文档，txt文件，excel文件...都是文件。它既可以保存一张图片，也可以保存视频，声音...

2.文件流

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

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

输入流：数据从数据源（文件）到程序（内存）的路径

输出流：数据从程序（内存）到数据源（文件）的路径

3.常用文件操作

1.创建文件对象相关构造器和方法

        new File(String，pathname)：根据路径构建一个File对象

        new File(File parent，String child)：根据父类目录文件+子路径构建

        new File(String parent，String child)：根据父目录+子路径构建

        createNewFile：创建新文件

2.获取文件的相关信息

        getName:文件的名称

        getAbsolutePath：文件的绝对路径

        getParent：文件的父级目录

        length：文件的大小（字节）

        exists：文件是否存在

        isFile：是不是一个文件

        isDirectory：是不是一个目录

代码演示：

package com.shangma.java;

import java.io.File;


public class FileInformation {
    public static void main(String[] args) {
        info();
    }

    public static void info(){
        //创建文件对象
        File file = new File("d:\news01.txt");

        System.out.println("文件名称：" + file.getName());

        System.out.println("文件的绝对路径：" + file.getAbsolutePath());

        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());
    }
}

3.目录的操作和文件删除

        mkdir创建一级目录，mkdirs创建多级目录，delete删除空目录或文件 

代码演示：

package com.shangma.java;

import java.io.File;


public class Directory {

    public static void main(String[] args) {
//          m1();
//          m2();
            m3();
    }


    //判断d:\news01.txt是否存在，如果存在就删除
    public static void m1(){
        String filePath = "d:\news01.txt";
        File file = new File(filePath);
        if (file.exists()){
            if (file.delete()){
                System.out.println("删除成功");
            }else {
                System.out.println("删除失败");
            }
        }else {
            System.out.println("文件不存在");
        }
    }

    //判断d:\demo2是否存在，如果存在就删除,否则提示不存在
    //在java编程中，目录也被当作文件
    public static void m2(){
        String filePath = "d:\demo02";
        File file = new File(filePath);
        if (file.exists()){
            if (file.delete()){
                System.out.println("删除成功");
            }else {
                System.out.println("删除失败");
            }
        }else {
            System.out.println("该目录不存在");
        }
    }

    //判断d:\demo\a\b\c是否存在，如果存在就提示已经存在,否则创建目录
    public static void m3(){
        String directoryPath = "d:\demo\a\b\c";
        File file = new File(directoryPath);
        if (file.exists()){
            System.out.println(directoryPath+"该目录已存在");
        }else {
            if (file.mkdirs()){//创建多级目录
                System.out.println("目录创建成功");
            }else {
                System.out.println("目录创建失败");
            }
        }
    }
}

第二章 IO流原理及流的分类

1.Java IO流原理

        1.I/O是Input和Output的缩写，I/O技术是非常实用的技术，用于处理数据传输。如读写/写文件，网络通讯等

        2.Java程序中，对于数据的输入/输入操作以“流（stream）”的方式进行。

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

        4.输入input：读取外部数据（磁盘、光盘等存储设备的数据）到程序（内存）中

        5.输入output：将程序（内存）数据输出到磁盘、光盘等存储设备中

2.流的分类

        按操作数据单位不同分为：字节流（8bit，适合二进制文件），字符流（按字符，适合文本文件）

        按数据流的流向不同分为：输入流，输出流

        按流的角色不同分为：字节流，处理流/包装流

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

         （2）由这四个类派生出来的子类名称都是以其父类名作子类名后缀

IO流体系图

 

3.常用的类（FileInputStream和FileOutputStream）

1.InputStream（抽象类）

        InputStream抽象类是所有类字节输入流的超类

        InputStream常用子类

        1.FileInputStream：文件输入流

        2.BufferedInputStream：缓冲字节输入流

        3.ObjectInputStream：对象字节输入流

 

 2.FileInputStream

        要求：请使用FileInputStream读取hello.txt文件，并将文件内容显示到控制台

package com.shangma.java.inputstream_;


import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;


public class FileInputStream_ {

    public static void main(String[] args) {
//        readFile01();
//        readFile02();
    }


    
    public static void readFile01(){
        String filePath = "d:\hello.txt";
        int readData = 0;
        FileInputStream fileInputStream = null;
        try {
            //创建FileInputStream对象，用于读取文件
            fileInputStream = new FileInputStream(filePath);
            //从该输入流读取一个字节的数据，如果没有输入可用，此方法将阻止
            //如果返回-1，表示读取完毕
            while ((readData = fileInputStream.read()) != -1){
                System.out.print((char)readData);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                //关闭文件流，释放资源
                fileInputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    
    public static void readFile02(){
        String filePath = "d:\hello.txt";
        byte[] buf = new byte[8];//一次读取八个字节
        int readLength = 0;
        FileInputStream fileInputStream = null;
        try {
            //创建FileInputStream对象，用于读取文件
            fileInputStream = new FileInputStream(filePath);
            //从输入流读取最多buf.length字节的数据到字节数组。此方法将阻塞，直到某些输入可用
            //如果返回-1，表示读取完毕
            //如果读取正常，返回实际读取的字节数
            while ((readLength = fileInputStream.read(buf)) != -1){
                System.out.println(new String(buf,0,readLength));
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                //关闭文件流，释放资源
                fileInputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

3.FileOutStream

        要求：使用FileOutStream在a.txt文件中写入”hello，world“，如果文件不存在，会创建文件（前提是目录已存在）

代码演示：

package com.shangma.java.outputstream_;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;


public class FileOutputStream01 {

    public static void main(String[] args) {
        writeFile();
    }

    
    public static void writeFile(){

        //创建FileOutputStream对象
        String filePath = "d:\a.txt";
        FileOutputStream fileOutputStream = null;

        try {
            //1.new FileOutputStream(filePath)创建方式，当写入内容，会覆盖原来的内容
            //2.new FileOutputStream(filePath,true)创建方式，当写入内容时，是追加到文件后面
            fileOutputStream = new FileOutputStream(filePath,true);
            //写入一个字节
//            fileOutputStream.write('H');

            String str = "hello,world";//写入字符串
            //str.getBytes()，可以把字符串转为byte数组
            //write(byte[] b,int off,int len)从off位开始，写入len个字节
            fileOutputStream.write(str.getBytes());
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                fileOutputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

4.文件拷贝

        编程完成文件的拷贝

代码演示：

package com.shangma.java.outputstream_;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;


public class FileCopy {
    public static void main(String[] args) {

        //完成文件拷贝将d:\picture.jpg 拷贝到d:\picture02.jpg
        //1.创建文件的输入流，将文件读入到程序
        //2.创建文件的输出流，将读取到的文件数据，写入指定的文件
        FileInputStream fileInputStream = null;
        FileOutputStream fileOutputStream = null;
        String inputFilePath = "d:\picture.jpg";//输入路径
        String outputFilePath = "d:\picture02.jpg";//输入路径

        try {
            fileInputStream = new FileInputStream(inputFilePath);
            fileOutputStream = new FileOutputStream(outputFilePath);
            //定义一个数组，提高读取效率
            byte[] buf = new byte[1024];
            int readData = 0;
            while ((readData = fileInputStream.read(buf))!=-1){
                //读取到位后，使用fileOutputStream写入文件
                //既一边读，一边写
                fileOutputStream.write(buf,0,readData);//一定要使用这个方法
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                if (fileInputStream != null){
                    fileInputStream.close();
                }
                if (fileOutputStream != null){
                    fileOutputStream.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
}

5.常用的类（FileReader和FileWriter）

        FileReader和FileWriter是字符流，既按照字符来操作io

1.FileReader

        FileReader相关方法：

                （1）new FileReader(File/String)

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

                （3）read( char[] )：将char[]转成String

        相关API：

                （1）new String( char[] )：将char[]转换成String

                （2）new String(char[],off,len)：将char{]的指定部分转换成String

代码演示：

package com.shangma.java.filereader_;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;


public class FileReaderDemo {
    public static void main(String[] args) {

//        readFile02();
//        readFile01();
    }

    
    public static void readFile01(){

        String filePath = "d:\story.txt";
        FileReader fileReader = null;

        try {
            int data = 0;
            //1.创建FileReader对象
            fileReader = new FileReader(filePath);
            //循环读取，使用read，返回一个字符
            while ((data = fileReader.read())!=-1){
                System.out.print((char) data);
            }

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (fileReader != null){
                try {
                    fileReader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    
    public static void readFile02(){

        String filePath = "d:\story.txt";
        FileReader fileReader = null;

        try {
            int readLen = 0;
            char[] buf = new char[8];
            //1.创建FileReader对象
            fileReader = new FileReader(filePath);
            //循环读取，使用read(buf)，返回的是实际读取到的字符数
            //如果返回-1，说明文件结束
            while ((readLen = fileReader.read(buf))!=-1){
                System.out.print(new String(buf,0,readLen));

            }

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (fileReader != null){
                try {
                    fileReader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

2.FileWriter

         FileWriter常用方法

                （1）new FileWriter(File/String)：覆盖模式，相当于流的指针在首端

                （2）new FileWriter(File/String，true)：追加模式，相当于流的指针在尾端

                （3）writer(int)：写入单个字符

                （4）writer(chat[])：写入指定数组

                （5）writer(char[],off,len)：写入指定数组的指定部分

                （6）writer(String)：写入整个字符串

                （7）writer(String，off，len)：写入字符串的指定部分

        

         相关API：

                String类：toCharArray：将String转换为char[]

        注意：

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

 

代码演示：

package com.shangma.java.filewriter_;

import java.io.FileWriter;
import java.io.IOException;


public class FileWriterDemo {
    public static void main(String[] args) {

        String filePath = "d:\note.txt";
        //创建FileWriter对象
        FileWriter fileWriter = null;

        try {
            fileWriter = new FileWriter(filePath);
            fileWriter.write("风雨之后，定见彩虹~");
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (fileWriter != null){
                try {
                    //对应FileWriter，一定要关闭流，或者flush才能真正的把 数据写入文件
                    //fileWriter.close()等价于flush() + 关闭
                    fileWriter.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

6.节点流和处理流

1.基本介绍

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

 

        2.处理流（也叫包装流）是连接在已存在的流（节点流或处理流）之上，为程序提供更为强大的读写功能，如BufferedReader、BufferedWriter

 

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

        1.节点流是底层流/低级流，直接跟数据源相连接

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

        3.处理流（也叫包装流）对节点流进行包装，使用修饰器模式，不会直接与数据源相连

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

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

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

3.BufferedReader

        使用BufferedReader，读取d盘中的文件

代码演示：

package com.shangma.java.reader_;

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;


public class BufferedReader_ {
    public static void main(String[] args) {

        String filePath = "d:\story.txt";
        BufferedReader bufferedReader = null;
        try {
            bufferedReader = new BufferedReader(new FileReader(filePath));

            String line;
            while ((line =  bufferedReader.readLine())!=null){
                System.out.println(line);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (bufferedReader != null){
                try {
                    //关闭流，这里注意，只需要关闭BufferedReader，因为底层会自动的去关闭节点流
                    bufferedReader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

4.BufferedWriter

        使用BufferedWriter，向d盘中写入文字

代码演示：

package com.shangma.java.writer_;

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;


public class BufferedWriter_ {
    public static void main(String[] args) {

        String filePath = "d:\hello.txt";
        BufferedWriter bufferedWriter = null;
        String str = "救赎之道，就在其中~";
        try {
            bufferedWriter = new BufferedWriter(new FileWriter(filePath,true));
            bufferedWriter.write(str);
            bufferedWriter.newline();//插入一个换行符
            bufferedWriter.write(str);
            bufferedWriter.write(str);
            System.out.println("写入成功！");
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (bufferedWriter != null){
                try {
                    bufferedWriter.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

4.使用BufferedReader和BufferedWriter完成文件拷贝

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

代码演示：

package com.shangma.java.writer_;

import java.io.*;


public class BufferedCopy_ {
    public static void main(String[] args) {

        //注意
        //1.BufferedReader和BufferedWriter是按照字符操作的
        //2.不要去操作二进制文件，可能造成文件损坏

        String sourceFilePath = "d:\story.txt";//源文件路径
        String destFilePath = "d:\dest.txt";//目的地文件路径

        BufferedReader bufferedReader = null;
        BufferedWriter bufferedWriter = null;

        try {
            bufferedReader = new BufferedReader(new FileReader(sourceFilePath));
            bufferedWriter = new BufferedWriter(new FileWriter(destFilePath));
            String line;
            while ((line = bufferedReader.readLine()) != null){
                //每读入一行，就写入一行
                bufferedWriter.write(line);
                //换行
                bufferedWriter.newline();
            }
            System.out.println("文件拷贝成功！");
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            //关闭输入输出流
            try {
                if (bufferedReader != null){
                    bufferedReader.close();
                }
                if (bufferedWriter != null){
                    bufferedWriter.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

5.BufferedInputStream

        BufferedInputStream是字节流，在创建BufferedInputStream时，会创建一个内部缓冲数组

 

6.BufferedOutputStream

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

 

7.使用BufferedInputStream和BufferedOutputStream完成图片/音乐的拷贝

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

代码演示：

package com.shangma.java.outputstream_;

import java.io.*;


public class BufferedCopy02_ {
    public static void main(String[] args) {

        String sourceFilePath = "d:\picture.jpg";
        String destFilePath = "d:\picture02.jpg";

        BufferedInputStream bufferedInputStream = null;
        BufferedOutputStream bufferedOutputStream = null;

        try {
            bufferedInputStream = new BufferedInputStream(new FileInputStream(sourceFilePath));
            bufferedOutputStream = new BufferedOutputStream(new FileOutputStream(destFilePath));

            //循环读取文件，并写入到destFilePath
            byte[] buf = new byte[1024];
            int readLength = 0;
            //当返回-1，就表示文件读取完毕
            while((readLength = bufferedInputStream.read(buf)) != -1){
                bufferedOutputStream.write(buf);
            }
            System.out.println("拷贝完毕~~~");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                if (bufferedInputStream != null){
                    bufferedInputStream.close();
                }
                if (bufferedOutputStream != null){
                    bufferedOutputStream.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

7.对象流

1.序列化与反序列化

        看一个需求：

                1.将int num = 100，这个int数据保存到文件中，注意不是数字，而是int 100，并且，能够从文件中直接恢复int 100

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

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

        序列化和反序列化

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

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

                3.需要让某个对象支持序列化机制，则必须让其类时可序列化的，为了让某个类是可序列化的，该类必须实现如下两个接口之一：              

                        Serializable：这是一个标记接口，没有方法

                        Externalizable：该接口有方法需要实现，因此我们一般实现上面的Serializable接口

 

 

2.对象流介绍

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

        2.ObjectOutStream提供了序列化功能

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

 

3.ObjectOutStream

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

代码演示：

package com.shangma.java.outputstream_;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.io.Serializable;


public class ObjectOutputStream_ {
    public static void main(String[] args) {
        //序列化后，保存的文件格式，不是存文本，而是按照他的格式来保存
        String destFilePath = "d:\data.dat";

        ObjectOutputStream objectOutputStream = null;

        try {
            objectOutputStream = new ObjectOutputStream(new FileOutputStream(destFilePath));
            //序列化数据到 e：\data.dat
            objectOutputStream.writeInt(100);//int -> Integer(实现了 Serializable接口)
            objectOutputStream.writeBoolean(true);//boolean -> Boolean(实现了 Serializable接口)
            objectOutputStream.writeChar('a');//char -> Character(实现了 Serializable接口)
            objectOutputStream.writeDouble(9.5);double -> Double(实现了 Serializable接口)
            objectOutputStream.writeUTF("哈哈");//String(实现了 Serializable接口)

            //保存一个dog对象
            objectOutputStream.writeObject(new Dog("旺财",12));

            System.out.println("数据保存完毕(序列化形式)");
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (objectOutputStream != null){
                try {
                    objectOutputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

//如果需要序列化某个类的对象，实现Serializable接口
class Dog implements Serializable{
    private String name;
    private int age;

    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

4.ObjectInputStream

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

代码演示：

package com.shangma.java.inputstream_;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;


public class ObjectInputStream_ {
    public static void main(String[] args) {

        String filePath = "d:\data.dat";
        ObjectInputStream objectInputStream = null;


        try {
            objectInputStream = new ObjectInputStream(new FileInputStream(filePath));

            //读取
            //1.读取（反序列化）的顺序需要和你保存数据（序列化）的顺序一样
            //2.否则就会出现异常
            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());

        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

5.对象处理流使用细节

        1.读写顺序要一致

        2.要求实现序列化或反序列化

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

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

        5.序列化对象时，要求里边属性的类型也需要序列化接口

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

8.标准输入输出流

                                        类型                        默认设备

        System.in                InputStream            键盘

        System.out              OutputStream          显示器

package com.shangma.java;


public class InputAndOutput {
    public static void main(String[] args) {
        //标准输入流
        //1.System类的 public final static InputStream in = null;
        //2.System.in的编译类型 InputStream
        //3.System.in的编译类型 BufferedInputStream
        //4.表示的是标准输入（键盘）
        System.out.println(System.in.getClass());

        
        //标准输出流
        //1.System类的 public final static PrintStream out = null;
        //2.编译类型 PrintStream
        //3.运行类型 PrintStream
        //4.表示标准输出（显示器）
        System.out.println(System.out.getClass());


    }
}

9.转换流

1.转换流介绍

        1.InputStreamReader：Reader的子类，可以将InputStream（字节流）包装成Reader（字符流）

        2.OutputStreamWriter：Writer的子类，实现将OutputStream（字节流）包装成Wrtier（字符流）

        3.当处理纯文本数据时，如果使用字符流效率更高，并且可以有效解决中文问题，所以建议将字节流转换为字符流

        4.可以在使用时指定编码格式（utf-8、gbk、gb2312、ISO8859-1等）

InputStreamReader

 

OutStreamWriter

2.InputStreamReader

        编程将字节流FileInputStream包装成（转换成）字符流InputStreamReader，对文件进行读取（按照utf-8格式），进而包装成BufferedReader 

package com.shangma.java.inputstream_;

import java.io.*;


public class InputStreamReader_ {
    public static void main(String[] args) {

        String filePath = "d:\hello.txt";

        InputStreamReader inputStreamReader = null;
        BufferedReader bufferedReader = null;
        try {
            //1.将FileInputStream转为 InputStreamReader
            //2.指定编码
            //inputStreamReader = new InputStreamReader(new FileInputStream(filePath),"utf-8");
            //3.把InputStreamReader传入 BufferedReader
            //bufferedReader = new BufferedReader(inputStreamReader);

            //简写，将第2步和第三步合在一起
            bufferedReader = new BufferedReader(new InputStreamReader(new FileInputStream(filePath),"utf-8"));

            //4.读取
            String line;
            while ((line = bufferedReader.readLine()) != null){
                System.out.println(line);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                //5.关闭流
                if (inputStreamReader != null){
                    inputStreamReader.close();
                }
                if (bufferedReader != null){
                    bufferedReader.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

3.OutputStreamWriter

        编程将字节流FileOutputStream包装成（转化成）字符流OutputStreamWtiter，对文件进行写入（比如utf-8），进而包装成BufferedWriter

代码演示：

package com.shangma.java.outputstream_;

import java.io.*;


public class OutputStreamWriter_ {

    public static void main(String[] args) {

        BufferedWriter bufferedWriter = null;
        String destFilePath = "d:\hi.txt";
        String str = "风雨之后，定见彩虹~";
        try {
            bufferedWriter = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(destFilePath),"utf-8"));
            bufferedWriter.write(str);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (bufferedWriter != null){
                try {
                    bufferedWriter.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

10.打印流 1.基本介绍

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

 体系图：

PrintStream

PrintWriter

 

 

2.PrintStream

package com.shangma.java.inputstream_;

import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.PrintStream;
import java.lang.reflect.Proxy;


public class PrintStream_ {
    public static void main(String[] args) throws FileNotFoundException {

        PrintStream printStream = System.out;

        printStream.print("hello,tom");

        //因为print底层使用的是writer，所以我们可以直接调用writer打印/输出
        try {
            printStream.write("你好，tom".getBytes());
        } catch (IOException e) {
            e.printStackTrace();
        }
        printStream.close();

        //我们可以修改打印流输出的位置/设备
        //1.修改输出路径到"d:\a.txt"
        //2."hello world~"就会输出到"d:\a.txt"
        System.setOut(new PrintStream("d:\a.txt"));
        System.out.println("hello world~");
    }
}

3.PrintWrtiter

package com.shangma.java.outputstream_;

import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;


public class PrintWriter_ {
    public static void main(String[] args) {

        //PrintWriter printWriter = new PrintWriter(System.out);
        String destFilePath = "d:\f1.txt";
        PrintWriter printWriter = null;
        try {
            printWriter = new PrintWriter(new FileWriter(destFilePath));
            printWriter.write("hello world~");
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (printWriter != null) {
                printWriter.close();//flush + 关闭流，才会把数据写入文件
            }
        }


    }
}

第三章 Properties类 1.基本介绍

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

             配置文件的格式：

                                键=值

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

       

        3.Properties的常见方法

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

                list：将数据显示到指定设备

                getProperty(key)：根据键获取值

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

                store：将Properties中的键值对存储到配置文件，在idea中，保存信息到配置文件，如果含有中文，会存储为Unicode码

        

2.应用案例

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

package com.shangma.java.properties_;

import java.io.FileReader;
import java.io.IOException;
import java.util.Properties;


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

        //1.创建Properties对象
        Properties properties = new Properties();
        //2.加载指定配置文件
        properties.load(new FileReader("mysql.properties"));
        //3.把k-v显示控制台
        properties.list(System.out);
        //4.根据key获取对应的值
        String username = properties.getProperty("username");
        
    }
}

2.使用Properties类添加key-val到新文件mysql02.properties中

package com.shangma.java;

import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Properties;


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

        Properties properties = new Properties();

        //创建
        //1.如果该文件没有key，就是创建
        //2.如果该文件有key，就是修改
        
        properties.setProperty("username","汤姆");
        properties.setProperty("password","123456");

        //将k-v储存文件即可
        //如果使用的是字节流是unicode编码
        //properties.store(new FileOutputStream("src\mysql02.properties"),null);//unicode编码

        properties.store(new FileWriter("src\mysql02.properties"),"mysqlPropertiesFile");//中文
        System.out.println("保存配置文件成功~");
    }
}

第四章 练习

1.练习一

        1.判断e盘下是否有文件夹mytemp，如果没有就创建mytemp

        2.在e：\mytemp目录下，创建文件hello.txt

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

        4.并且在hello.txt文件中，写入hello world~

代码演示：

package com.shangma.java.exercise;



import java.io.File;

import java.io.IOException;

public class Exercise01 {
    public static void main(String[] args) throws IOException {
//        1.判断e盘下是否有文件夹mytemp，如果没有就创建mytemp
//        2.在e：\mytemp目录下，创建文件hello.txt
//        3.如果hello.txt已经存在，提示该文件已经存在，就不要再重复创建了
//        4.并且在hello.txt文件中，写入hello world~

        String directory = "d:\mytemp";
        File file = new File(directory);

        if (!file.exists()){
            //创建目录
            if (file.mkdirs()){
                System.out.println("目录创建成功");
            }else {
                System.out.println("目录创建失败");
            }
        }

        String filePath = directory + "\hello.txt";//d:mytemphello.txt
        file = new File(filePath);

        if (!file.exists()){
            //创建文件
            if (file.createNewFile()){
                System.out.println("文件创建成功");

                //如果文件存在，我们使用BufferedWriter
            }else {
                System.out.println("文件创建失败");
            }
        }else{
            System.out.println( filePath + "文件已存在");
        }
    }
}

2.练习二

        使用BufferedReader读取一个文本文件，为每句话加上行号，再连同内容一并输出到屏幕

代码演示：

package com.shangma.java.exercise;

import java.io.*;

public class Exercise02 {
    public static void main(String[] args) throws FileNotFoundException, UnsupportedEncodingException {

        //使用BufferedReader读取一个文本文件，为每句话加上行号，再连同内容一并输出到屏幕
        String filePath = "d:\story.txt";
        BufferedReader bufferedReader = null;
        try {
            //防止文件乱码
            bufferedReader = new BufferedReader(new InputStreamReader(new FileInputStream(filePath),"utf-8"));
            int lineNum = 0;
            String line;
            while ((line = bufferedReader.readLine()) != null){
                lineNum++;
                System.out.println("行号"+ lineNum + line);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (bufferedReader != null){
                try {
                    bufferedReader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

3.练习三

        1.编写一个dog.properties

                name=tom

                age=5

                color=yellow

        2.编写Dog类(name,age,color)创建一个dog对象，读取dog.properties用相应的内容完成属性初始化，并输出

        3.将dog对象序列化存入dog.dat

        4.反序列化dog对象

代码演示：

package com.shangma.java.exercise;


import java.io.*;
import java.util.Properties;

public class Exercise03 {
    public static void main(String[] args) throws IOException, ClassNotFoundException {

        
        createPropertiesFile();//创建dog.properties文件

        Properties properties = new Properties();//创建Properties对象
        String filePath = "src\dog.properties";//文件路径

        properties.load(new FileReader(filePath));

        //根据key获取value
        String name = properties.getProperty("name");
        String age = properties.getProperty("age");
        Integer integer = Integer.valueOf(age);
        String color = properties.getProperty("color");

        Dog dog = new Dog(name,integer,color);
        System.out.println(dog);
        

        
        String destFilePath = "d:\dog.dat";
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream(destFilePath));

        objectOutputStream.writeUTF(dog.getName());
        objectOutputStream.writeInt(dog.getAge());
        objectOutputStream.writeUTF(dog.getColor());
        //注意存入对象，确定实现了Serializable接口
        //否则就会报错
        objectOutputStream.writeObject(dog);
        objectOutputStream.close();//关流

        
        ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(destFilePath));

        //注意：必须按存入的顺序取出
        String name2 = objectInputStream.readUTF();
        int age2 = objectInputStream.readInt();
        String color2 = objectInputStream.readUTF();
        Object o = objectInputStream.readObject();
        System.out.println("反序列化取出的对象：" + o);
        Dog dog2 = new Dog(name2, age2, color2);
        System.out.println("dog2: " + dog2);
        
        objectInputStream.close();//关流
    }

    
    public static void createPropertiesFile() throws IOException {

        Properties properties = new Properties();
        properties.setProperty("name","tom");
        properties.setProperty("age","5");
        properties.setProperty("color","yellow");

        String filePath = "src\dog.properties";//要创建的文件路径

        properties.store(new FileWriter(filePath),null);
    }
}

class Dog implements Serializable{
    private String name;
    private int age;
    private String color;

    public Dog() {
    }

    public Dog(String name, int age, String color) {
        this.name = name;
        this.age = age;
        this.color = color;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + ''' +
                ", age=" + age +
                ", color='" + color + ''' +
                '}';
    }
}