0基础学java-day19(IO流)

一、文件

1 什么是文件

2.文件流

3.常用的文件操作

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

package com.hspedu.file;

import org.junit.jupiter.api.DynamicTest;
import org.junit.jupiter.api.Test;

import java.io.File;
import java.io.IOException;

/**
 * @author 林然
 * @version 1.0
 * 创建文件演示
 */
public class FileCreate {
    public static void main(String[] args) {

    }
    //方式 1 new File(String pathname)
    @Test
    public void create01(){
        String filePath="e:\\news.txt";
        File file = new File(filePath);//这时候只有一个file对象在内存中，但是在硬盘中没有创建
        try {
            file.createNewFile();
            System.out.println("文件创建成功");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    //方式2 new File(File parent,String child) //根据父目录文件+子路径构建
    //e:\\news2.txt
    @Test
    public void create02(){
        File parentfile =new File("e:\\");
        String filename = "news2.txt";
        //这里的 file 对象，在 java 程序中，只是一个对象
//只有执行了 createNewFile 方法，才会真正的，在磁盘创建该文件
        File file =new File(parentfile,filename);
        try {
            file.createNewFile();
            System.out.println("文件创建成功");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    //方式 3 new File(String parent,String child) //根据父目录+子路径构建
    @Test
    public void create03(){
        String parentpath="e:\\";
        String childpath="news3.txt";
        File file = new File(parentpath, childpath);
        try {
            file.createNewFile();
            System.out.println("文件创建成功");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}

3.2 获取文件的相关信息

3.3 应用案例演示

import org.junit.jupiter.api.Test;

import java.io.File;
/**
 * @author 林然
 * @version 1.0
 */
public class FileInformation {
    public static void main(String[] args) {

    }
    @Test
    public void info(){
        //获取文件信息
        File file=new File("e:\\news.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.4 目录的操作和文件删除

3.5 应用案例演示

package com.hspedu.file;

import org.junit.jupiter.api.Test;

import java.io.File;
import java.io.IOException;

/**
 * @author 林然
 * @version 1.0
 */
public class Directory_ {
    public static void main(String[] args) {

    }
    //判断 d:\\news1.txt是否存在，如果存在就删除
    @Test
    public  void m1(){
        String filePath ="D:\\news1.txt";
        File file =new File(filePath);
        try {
            file.createNewFile();
        } catch (IOException e) {
            e.printStackTrace();
        }
        if(file.exists()){
            if (file.delete()){
                System.out.println("删除成功");
            }
            else {
                System.out.println("删除失败");
            }

        }else {
            System.out.println("文件不存在");
        }
    }
    //判断d:\\demo02是否存在，存在就删除，否则提示不存在
    //在java编程中，目录被当成特殊的文件
    @Test
    public 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是否存在，存在就提示已经存在，否则就创建
    @Test
    public void m3(){
        String filePath ="d:\\\\demo\\\\a\\\\b\\\\c";
        File file =new File(filePath);
        if(file.exists()){
            System.out.println("目录存在");

        }else {
            file.mkdirs();
        }
    }

}

二、IO流

1.IO 流原理及流的分类

1.1 Java IO 流原理

1.2 流的分类

2.IO 流体系图-常用的类

2.1 IO 流体系图

2.2 文件 VS 流

3.InputStream字节输入流

3.1 FileInputStream

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

package com.hspedu.inputstream_;

import org.junit.jupiter.api.Test;

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

/**
 * @author 林然
 * @version 1.0
 * 演示 FileInputStream 的使用(字节输入流 文件--> 程序)
 */
public class FileInputStream_ {
    public static void main(String[] args) {
        /**
         * 演示读取文件... * 单个字节的读取，效率比较低
         * -> 使用 read(byte[] b)
         */
    }
    @Test
    public void readFile01(){
        String filePath="e:\\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);//转成char显示
            }


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


        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            //关闭文件流，释放资源.
            try {
                fileInputStream_.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

4.FileOutputStream

4.1 实例一

要求 : 请使用 FileOutputStream 在 a.txt 文件，中写入 “ hello ， world ” . [ 老师代码演示 ], 如果文件不存在，会创建文件( 注意：前提是目录已经存在 .)

package com.hspedu.outputstream_;

import org.junit.jupiter.api.Test;

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

/**
 * @author 林然
 * @version 1.0
 */
public class outputstream_ {
    public static void main(String[] args) {

    }
    /**
     * 演示使用 FileOutputStream 将数据写到文件中, * 如果该文件不存在，则创建该文件
     */
    @Test
    public void writeFile(){
        //创建 FileOutputStream 对象
        FileOutputStream fileOutputStream =null;
        String filePath="e:\\\\a.txt";
        try {
            fileOutputStream = new FileOutputStream(filePath,true);
            //写入一个字节
            //fileOutputStream.write('a');
            //写入字符串
            String str = "hello,word";
            //str.getBytes() 可以把 字符串-> 字节数组
            fileOutputStream.write(str.getBytes());
            //1. new FileOutputStream(filePath) 创建方式，当写入内容是，会覆盖原来的内容
            //2. new FileOutputStream(filePath, true) 创建方式，当写入内容是，是追加到文件后面
            /*
            write(byte[] b, int off, int len) 将 len 字节从位于偏移量 off 的指定字节数组写入此文件输出流
            */
            fileOutputStream.write(str.getBytes(), 0, 3);
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                fileOutputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

4.2 实例二

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

package com.hspedu.outputstream_;

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

/**
 * @author 林然
 * @version 1.0
 */
public class FileCopy {
    public static void main(String[] args) {
        //完成文件拷贝将 e:\\jmq.jpg 拷贝 c:\\
        //思路分析
        //1.创建的文件输入流，将文件读取到内存
        //2.创建文件的输出流，将读取到的文件数据，写入到指定的文件.
        String srcfilePath="e:\\jmq.jpg";
        String destfilePath="d:\\jmq.jpg";
        FileOutputStream fileOutputStream =null;
        FileInputStream fileInputStream =null;
        try {
            fileInputStream = new FileInputStream(srcfilePath);
            fileOutputStream =new FileOutputStream(destfilePath);
            //定义一个字节数组,提高读取效果
            byte [] buf = new byte[1024];
            int readLen =0;
            while ((readLen=fileInputStream.read(buf))!=-1){
                //读取到后，就写入到文件 通过 fileOutputStream
                //即，是一边读，一边写
                fileOutputStream.write(buf,0,readLen);//一定要使用这个方法
            }
            System.out.println("拷贝成功");
        } 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

5.1 FileReader 相关方法

5.2 FileWriter 常用方法

5.3 FileReader 应用案例

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

package com.hspedu.reader_;

import org.junit.jupiter.api.Test;

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

/**
 * @author 林然
 * @version 1.0
 */
public class FileReader_ {
    public static void main(String[] args) {

    }
    @Test
    public void readFile01(){
        //1.建一个FileRead对象
        String filePath ="E:\\story.txt";
        int data=0;
        FileReader fileReader =null;
        try {
            fileReader =new FileReader(filePath);
            //循环读取，使用read返回：
            //读取的字符，如果已到达流的末尾，则返回 -1
            while ((data=fileReader.read())!=-1){
                System.out.print((char)(data));
            }

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if(fileReader!=null){
                    fileReader.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    @Test
    public void readFile02(){
        //1.建一个FileRead对象
        String filePath ="E:\\story.txt";
        int data_len=0;
        char [] buf =new char[8];
        FileReader fileReader =null;
        try {
            fileReader =new FileReader(filePath);
            //循环读取，使用read返回：
            //读取的字符，如果已到达流的末尾，则返回 -1
            while ((data_len=fileReader.read(buf))!=-1){
                System.out.println(new String(buf,0,data_len));
            }

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

5.4 FileWriter 应用案例

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

package com.hspedu.writer_;

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

/**
 * @author 林然
 * @version 1.0
 */
public class FileWriter_ {
    public static void main(String[] args) {
        String filePath ="e:\\note.txt";
        FileWriter fileWriter =null;
        char [] chars ={'a','b','c'};
        try {
            fileWriter = new FileWriter(filePath);//默认是覆盖写入[]覆盖是新的流覆盖
            // 3) write(int):写入单个字符
            fileWriter.write('H');
            // 4) write(char[]):写入指定数组
            fileWriter.write(chars);
            // 5) write(char[],off,len):写入指定数组的指定部分
            fileWriter.write("林然加油".toCharArray(),0,3);
            // 6) write（string）：写入整个字符串
            fileWriter.write(" 你好北京~");
            fileWriter.write("风雨之后，定见彩虹");
            // 7) write(string,off,len):写入字符串的指定部分
            fileWriter.write("上海天津", 0, 2);
//在数据量大的情况下，可以使用循环操作.

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //对应的FileWriter一定要关闭流或者flush才能真正的把数据写入
            try {
                fileWriter.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

三、节点流和处理流

1 基本介绍

【节点流】

【处理流】

模拟代码如下

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

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

4.处理流-BufferedReader

package com.hspedu.reader_;

import java.io.BufferedReader;
import java.io.FileReader;

/**
 * @author 林然
 * @version 1.0
 * * 演示 bufferedReader 使用
 */
public class BufferedReader_ {
    public static void main(String[] args) throws Exception{
        String filePath ="e:\\note.txt";
        //创建bufferedReader
        BufferedReader bufferedReader = new BufferedReader(new FileReader(filePath));
        //读取
        String line;//按行读取
        //说明
        //1. bufferedReader.readLine() 是按行读取文件
        //2. 当返回 null 时，表示文件读取完毕
        while ((line=bufferedReader.readLine())!=null){
            System.out.println(line);
        }
        //关闭流,这里注意，只需要关闭 BufferedReader ，因为底层会自动的去关闭 节点流
        bufferedReader.close();
        //FileReader。
            /*
            public void close() throws IOException {
                synchronized (lock) {
                    if (in == null)
                        return;
                    try {
                        in.close();//in 就是我们传入的 new FileReader(filePath), 关闭了. } 
                    finally {
                        in = null;
                        cb = null;
                    }
                }
            }
            */

    }
}

5.BufferedWriter

package com.hspedu.writer_;

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

/**
 * @author 林然
 * @version 1.0
 */
public class BufferedWriter_ {
    public static void main(String[] args) throws Exception{
        String filePath="e://note.txt";
        BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(filePath));
        //1. new FileWriter(filePath, true) 表示以追加的方式写入
        //2. new FileWriter(filePath) , 表示以覆盖的方式写入
        String str="林然，加油哦";
        bufferedWriter.write(str);
        bufferedWriter.newLine();
        bufferedWriter.write(str);
        bufferedWriter.newLine();
        bufferedWriter.write(str);
        bufferedWriter.close();
        //说明：关闭外层流即可 ， 传入的 new FileWriter(filePath) ,会在底层关闭
    }
}

6.综合案例

package com.hspedu.writer_;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;

/**
 * @author 林然
 * @version 1.0
 */
public class BufferedCopy_ {
    public static void main(String[] args) throws Exception{
        String src_filePath ="e:\\note.txt";
        String dest_filePath ="e:\\note2.txt";
        //1. BufferedReader 和 BufferedWriter 是安装字符操作
        //2. 不要去操作 二进制文件[声音，视频，doc, pdf ], 可能造成文件损坏
        BufferedReader bufferedReader = new BufferedReader(new FileReader(src_filePath));
        BufferedWriter bufferedWriter =new BufferedWriter(new FileWriter(dest_filePath));
        //读取
        //写入
        String line;
        while ((line=bufferedReader.readLine())!=null){
            bufferedWriter.write(line);//读取一行就写入
            //说明: readLine 读取一行内容，但是没有换行
            bufferedWriter.newLine();
        }
        bufferedReader.close();
        bufferedWriter.close();

    }
}

7.BufferedInputStream&&BufferedOutputStream

7.1 BufferedInputStream

7.2 BufferedOutputStream

7.3 应用案例

package com.hspedu.outputstream_;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;

/**
 * @author 林然
 * @version 1.0
 * 演示使用 BufferedOutputStream 和 BufferedInputStream 使用
 * 使用他们，可以完成二进制文件拷贝. * 思考：字节流可以操作二进制文件，可以操作文本文件吗？当然可以
 */
public class BufferedCopy02 {
    public static void main(String[] args) throws Exception{
        String src_filePath="e:\\jmq.jpg";
        String dest_filePath="e:\\jmq_copy.jpg";
        //因为 FileInputStream 是 InputStream 子类
        //创建 BufferedOutputStream 对象 BufferedInputStream 对象
        BufferedInputStream bufferedInputStream =new BufferedInputStream(new FileInputStream(src_filePath));
        BufferedOutputStream bufferedOutputStream =new BufferedOutputStream(new FileOutputStream(dest_filePath));
        //循环的读取文件，并写入到 destFilePath
        byte [] buff =new byte[1024];
        int length=0;
        while ((length=bufferedInputStream.read(buff))!=-1){
            bufferedOutputStream.write(buff,0,length);
        }
        //关闭流 , 关闭外层的处理流即可，底层会去关闭节点流
        bufferedInputStream.close();
        bufferedOutputStream.close();

    }
}

8.对象流-ObjectInputStream 和 ObjectOutputStream

8.1 对象流介绍

8.2 案例 1

package com.hspedu.outputstream_;

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

/**
 * @author 林然
 * @version 1.0
 * 演示 ObjectOutputStream 的使用, 完成数据的序列化
 */
public class ObjectOutStream_ {
    public static void main(String[] args) throws Exception{
        //序列化后，保存的文件格式，不是存文本，而是按照他的格式来保存
        String filePath ="e:\\data.txt";
        ObjectOutputStream objectOutputStream =new ObjectOutputStream(new FileOutputStream(filePath));
        //序列化数据到 e:\data.dat
        objectOutputStream.writeInt(100);//int -> Integer (实现了 Serializable)
        objectOutputStream.writeBoolean(true);// boolean -> Boolean (实现了 Serializable)
        objectOutputStream.writeChar('A');//char -> Character (实现了 Serializable)
        objectOutputStream.writeDouble(2.99);//double -> Double (实现了 Serializable)
        objectOutputStream.writeUTF("林然");//String
        objectOutputStream.writeObject(new Dog(10,"旺财"));
        objectOutputStream.close();

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

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

8.3 案例2

package com.hspedu.inputstream_;

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

/**
 * @author 林然
 * @version 1.0
 */
public class ObjectInputStream_ {
    public static void main(String[] args) throws Exception{
        //指定反序列文件
        String filePath ="e:\\data.txt";
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(filePath));
        // 2.读取， 注意读取的顺序要和文件中被序列化的顺序一致
        System.out.println(ois.readInt());
        System.out.println(ois.readBoolean());
        System.out.println(ois.readChar());
        System.out.println(ois.readDouble());
        System.out.println(ois.readUTF());
        System.out.println(ois.readObject());
        // 3.关闭
        ois.close();
        System.out.println("以反序列化的方式读取(恢复)ok~");


    }
}

8.4 注意事项与细节

9.标准输入输出流

package com.hspedu.standard;

/**
 * @author 林然
 * @version 1.0
 */
public class InputAndOutput {
    public static void main(String[] args) {
        //System.in类的public static final InputStream in = null;
        //编译类型 InputStream
        //运行类型 BufferedInputStream
        //表示的是标准输入 键盘
        System.out.println(System.in.getClass());
        //System.out类的public static final PrintStream out = null;
        //编译类型 PrintStream
        //运行类型 PrintStream
        //表示标准输出显示器
        System.out.println(System.out.getClass());
    }
}

10.转换流-InputStreamReader 和 OutputStreamWriter

package com.hspedu.transformation;

import java.io.BufferedReader;
import java.io.FileReader;

/**
 * @author 林然
 * @version 1.0
 * 看一个中文乱码问题
 */
public class CodeQuestion {
    public static void main(String[] args) throws Exception{
        //读取 e:\\note.txt 文件到程序
        //思路
        //1. 创建字符输入流 BufferedReader [处理流]
        //2. 使用 BufferedReader 对象读取 a.txt
        //3. 默认情况下，读取文件是按照 utf-8 编码【如果编码不是UTF那么就很有可能会出现乱码】
        String filePath ="e:\\note.txt";
        BufferedReader bufferedReader =new BufferedReader(new FileReader(filePath));
        String s=bufferedReader.readLine();
        System.out.println("读取到的内容+"+s);
        bufferedReader.close();
    }
}

10.1 案例

package com.hspedu.transformation;

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.InputStream;
import java.io.InputStreamReader;

/**
 * @author 林然
 * @version 1.0
 * 演示使用 InputStreamReader 转换流解决中文乱码问题
 * * 将字节流 FileInputStream 转成字符流 InputStreamReader, 指定编码 gbk/utf-8
 */
public class InputStreamReader_ {
    public static void main(String[] args) throws Exception{
        String filePath = "e:\\note.txt";
        //解读
        //1. 把 FileInputStream 转成 InputStreamReader
        //2. 指定编码 gbk
        //InputStreamReader isr = new InputStreamReader(new FileInputStream(filePath), "gbk");

        InputStreamReader inputStreamReader =new InputStreamReader(new FileInputStream(filePath),"UTF-8");
        //3. 把 InputStreamReader 传入 BufferedReader
        //BufferedReader br = new BufferedReader(isr);
        BufferedReader bufferedReader =new BufferedReader(inputStreamReader);
        //4. 读取
        String s = bufferedReader.readLine();
        System.out.println("读取内容=" + s);
        //5. 关闭外层流
        bufferedReader.close();


    }
}

10.2 案例2

package com.hspedu.transformation;

import java.io.FileOutputStream;
import java.io.OutputStreamWriter;

/**
 * @author 林然
 * @version 1.0
 * 演示OutputStreamWriter使用
 * 把FileOutputStream字节流转换成字符流
 * 指定编码方式gbk/utf-8
 */
public class OutputStreamWriter_ {
    public static void main(String[] args) throws Exception{
        String filePath ="e:\\linran.txt";
        OutputStreamWriter outputStreamWriter =new OutputStreamWriter(new FileOutputStream(filePath),"gbk");
        outputStreamWriter.write("林然加油");
        outputStreamWriter.close();
        System.out.println("保存文件按照GBK格式");
    }
}

11.打印流-PrintStream 和 PrintWriter

package com.hspedu.printstream;

import java.io.IOException;
import java.io.PrintStream;

/**
 * @author 林然
 * @version 1.0
 * 演示 PrintStream （字节打印流/输出流）
 */
public class PrintStream_ {
    public static void main(String[] args) throws IOException {
        PrintStream out = System.out;
        //在默认情况下，PrintStream 输出数据的位置是 标准输出，即显示器
        out.println("林然加油");
        /*
        public void print(String s) {
                    if (s == null) {
                    s = "null";
                }
                write(s);
                }
         */
        //因为 print 底层使用的是 write , 所以我们可以直接调用 write 进行打印/输出
        out.write("林然,你好".getBytes());
        out.close();
        //我们可以去修改打印流输出的位置/设备
            //1. 输出修改成到 "e:\\f1.txt"
            //2. "hello, 林然~" 就会输出到 e:\f1.txt
            //3. public static void setOut(PrintStream out) {
            // checkIO();
            // setOut0(out); // native 方法，修改了 out
            // }
        System.setOut(new PrintStream("e:\\note.txt"));//修改输出位置
        System.out.println("hello, 林然~");
    }
}

package com.hspedu.printstream;

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

/**
 * @author 林然
 * @version 1.0
 * 演示 PrintWriter 使用方式
 */
public class PrintWriter_ {
    public static void main(String[] args) throws IOException {
        //PrintWriter printWriter = new PrintWriter(System.out);
        //printWriter.println("林然");//会被打印到显示器
        PrintWriter printWriter = new PrintWriter(new FileWriter("e:\\note.txt"));
        printWriter.println("广西大学");
        printWriter.println("广西大学");
        //不关闭的话，并不会写入文件中
        printWriter.close();
    }
}

四、Properties 类

1 看一个需求

【如果要求指定得到某个值还是比较麻烦的，例如我只需要ip】

package com.hspedu.properties_;

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

/**
 * @author 林然
 * @version 1.0
 */
public class Properties01 {
    public static void main(String[] args) throws IOException {
        //读取 mysql.properties 文件，并得到 ip, user 和 pwd
       BufferedReader bufferedReader = new BufferedReader(new FileReader("src\\mysql.properties"));
       String line  ="";
       while ((line=bufferedReader.readLine())!=null){
           String [] split =line.split("=");
           System.out.println(split[0] + "值是: " + split[1]);
       }
       bufferedReader.close();
    }
}

2 基本介绍

3.应用案例

package com.hspedu.properties_;

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

/**
 * @author 林然
 * @version 1.0
 */
public class Properties02 {
    public static void main(String[] args) throws IOException {
        //使用 Properties 类来读取 mysql.properties 文件
        //1. 创建 Properties 对象
        Properties properties = new Properties();
        //2. 加载指定配置文件
        properties.load(new FileReader("src\\mysql.properties"));
        //3. 把 k-v 显示控制台
        properties.list(System.out);
        //4. 根据 key 获取对应的值
        String user = properties.getProperty("user");
        String pwd = properties.getProperty("pwd");
        System.out.println("用户名=" + user);
        System.out.println("密码是=" + pwd);
    }
}

package com.hspedu.properties_;

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

/**
 * @author 林然
 * @version 1.0
 */
public class Properties03 {
    public static void main(String[] args) throws IOException {
        //使用 Properties 类来创建 配置文件, 修改配置文件内容
        Properties properties = new Properties();
        //创建
        //1.如果该文件没有 key 就是创建
        //2.如果该文件有 key ,就是修改
        properties.setProperty("charset", "utf8");
        properties.setProperty("users", "汤姆");//注意保存时，是中文的 unicode 码值
        //将 k-v 存储文件中即可
        properties.store(new FileOutputStream("src\\mysql2.properties"), null);//第二个参数是注解
        System.out.println("保存配置文件成功~");
    }
}

五、本章作业

1.作业一

package com.hspedu.homework;

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

/**
 * @author 林然
 * @version 1.0
 */
public class homwork01 {
    public static void main(String[] args) throws IOException {
        File file =new File("e:\\mytemp");
        file.mkdir();
        File file1 =new File("e:\\mytemp\\hello.txt");
        if(file1.exists()){
            System.out.println("文件已存在");
        }else {
            file1.createNewFile();

        }
        FileWriter fileWriter =new FileWriter("e:\\mytemp\\hello.txt");
        fileWriter.write("hello,world~");
        fileWriter.close();

    }


}

2.作业二

package com.hspedu.homework;

import java.io.*;

/**
 * @author 林然
 * @version 1.0
 */
public class homework02 {
    public static void main(String[] args) throws IOException {
        String filePath="e:\\note.txt";
        InputStreamReader inputStreamReader =new InputStreamReader(new FileInputStream(filePath),"utf-8");
        BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
        String len="";
        int count=1;
        while ((len=bufferedReader.readLine())!=null){
            System.out.println(count+len);
            count++;
        }
        bufferedReader.close();
    }
}

3.作业三

package com.hspedu.homework;

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

/**
 * @author 林然
 * @version 1.0
 */
public class homework3 {
    public static void main(String[] args) throws IOException {
        Properties properties =new Properties();
        properties.setProperty("name","tom");
        properties.setProperty("age","5");
        properties.setProperty("color","red");
        properties.store(new FileWriter("src//properties3.properties"),null);
        properties.load(new FileReader("src//properties3.properties"));
        String name=properties.getProperty("name");
        int age =Integer.parseInt(properties.getProperty("age"));
        String color =properties.getProperty("color");

        Dog dog =new Dog(name,age,color);
        System.out.println(dog);
        ObjectOutputStream objectOutputStream =new ObjectOutputStream(new FileOutputStream("src\\dog.dat"));
        objectOutputStream.writeObject(dog);
        objectOutputStream.close();

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

    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", 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;
    }

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