韩顺平 Java IO流自学笔记

一.文件基础知识

1.文件基础知识铺垫

2.创建文件的三种方式

3.获取文件信息

4.目录操作

二.IO流原理及流的分类

1.IO流的原理

2.流的分类

三.InputStream字节输入流

1.InputStream的简介

2.FileInputStream类方法

四.OutputSteam字节输出流

1.OutputSteam类的简介

2..FileOutPutStream类

五.writer字符输出流

1.writer简介

2. FileWriter类

六.reader字符输入流

1.reader类的简介

2.FileReader类

七.节点流和处理流

1.相关概念

2.处理流的设计模式

3.处理流BufferReader和BufferWriter

4.对象处理流ObjectOutputStream和ObjectInputStream 序列化与反序列化

5.标准输入与输出流System.in 和System.out

6.转换流InputStreamReader和OutputStreamWriter

7.打印流PrintStream和PrintWriter

七.配置文件Properties

1.引出配置文件

2.基本的使用编辑

八.家庭作业

1.家庭作业一

2.家庭作业二

3.家庭作业三

一.文件基础知识

前情提要：Io最主要的是区分不同流的作用和使用规范

1.文件基础知识铺垫

1.1什么是文件

文件就是保存数据的地方，图片，音乐，视频等等。

1.2文件流的概念

输入与输出是针对内存的，磁盘内容输入到java程序当中，Java程序处理的结果输出到磁盘当中。

类比：

IO流的整个类图

2.创建文件的三种方式

案例

代码

package com.file;import org.junit.jupiter.api.Test;import java.io.File;
import java.io.IOException;public class FileCrate {public static void main(String[] args) {}@Testpublic void create01(){
//        指定文件的路径String filePath = "d:\\one.txt";
//      还没有进行创建，相当于对文件进行声明File file = new File(filePath);
//        进行创建try {file.createNewFile();System.out.println("文件创建成功！");} catch (IOException e) {e.printStackTrace();}}@Test
//     方法二，通过父文件和子路径来进行创建  参数为File，String  File有三种创建对象的构造器public void create02(){File parentFile = new File("d:\\");String path = "next.txt";
//      在java程序（内存）当中创建的对象，使用方法，将内存当中的对象，输出到硬盘上File file = new File(parentFile, path);
//      创建文件try {file.createNewFile();System.out.println("文件创建成功");} catch (IOException e) {e.printStackTrace();}}
//    public File(String parent, String child) 第三种方法@Testpublic void create03(){String parent = "d:\\";String path = "next01.txt";
//      在java程序（内存）当中创建的对象，使用方法，将内存当中的对象，输出到硬盘上File file = new File(parent, path);
//      创建文件try {file.createNewFile();System.out.println("文件创建成功");} catch (IOException e) {e.printStackTrace();}}
}

运行结果

指定路径下就会出现我们想要的文件了

3.获取文件信息

常用的方法

案例演示

代码

package com.file;import java.io.File;
import java.io.IOException;public class FileInformation {public static void main(String[] args) {
//        先创建文件File file = new File("d:\\no1.txt");try {file.createNewFile();} catch (IOException e) {e.printStackTrace();}
//        调用相应的方法得到相应的信息System.out.println("文件的名字  "+file.getName());System.out.println("文件的父级目录  "+file.getParent());System.out.println("文件的绝对路径  "+file.getPath());System.out.println("文件的大小（字节）  "+file.length());System.out.println("文件是否存在  "+file.exists());System.out.println("是不是一个文件  "+file.isFile());System.out.println("是不是一个目录  "+file.isDirectory());}
}

运行结果

文件的名字 no1.txt
文件的父级目录 d:\
文件的绝对路径 d:\no1.txt
文件的大小（字节） 6

4.目录操作

用到的方法

代码

package com.file;import org.junit.jupiter.api.Test;import java.io.File;public class Directory_ {public static void main(String[] args) {}
//    判断m1是否存在，存在就删除@Testpublic void m1(){String filePath = "d:\\no1.txt";File file = new File(filePath);if (file.exists()){if (file.delete()){System.out.println(filePath+"文件删除成功");}else {System.out.println(filePath+"文件删除失败");}}else {System.out.println("该文件不存在");}}//    判断demo01.txt是否存在，不存在打印不存在  在java当中，目录也被当成一种文件
@Test
public void m2(){String filePath = "d:\\demo01";File file = new File(filePath);if (file.exists()){if (file.delete()){System.out.println(filePath+"文件删除成功");}else {System.out.println(filePath+"文件删除失败");}}else {System.out.println("该文件不存在");}
}
//  判断文件夹有没有，没有就创建文件夹
@Test
public void m3(){String filePath = "d:\\demo01";File file = new File(filePath);if (file.exists()){System.out.println(filePath+"文件存在");}else {
//        创建一个目录if (file.mkdirs()){System.out.println(filePath+"文件夹创建成功。");}else{System.out.println(filePath+"文件夹创建失败。");}}
}
}

m3运行结果

二.IO流原理及流的分类

1.IO流的原理

2.流的分类

三.InputStream字节输入流

1.InputStream的简介

类图结构

2.FileInputStream类方法

代码

package com.inputstream;import org.junit.jupiter.api.Test;import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;public class FileInputStream_ {public static void main(String[] args) {}
//    单个读取的效率太低，使用public int read(byte b[])方法。@Testpublic void readFile01() throws IOException {String filePath = "d:\\hello.txt";int read =0 ;
//        创建输入流FileInputStream fileInputStream = null;try {fileInputStream = new FileInputStream(filePath);
//            对数据进行循环的读取，当返回值为-1时，表示读取完毕while ((read = fileInputStream.read())!=-1){System.out.print((char)read);}} catch (FileNotFoundException e) {e.printStackTrace();}finally {
//            关闭流，进行资源的释放fileInputStream.close();}}@Testpublic void readFile02() throws IOException {String filePath = "d:\\hello.txt";int readLen =0 ;
//        创建字节数组，一次读取八个字节byte[] bytes = new byte[8];
//        创建输入流FileInputStream fileInputStream = null;try {fileInputStream = new FileInputStream(filePath);//          方法进行优化while ((readLen = fileInputStream.read(bytes))!=-1){
//            讲字节转化为字符串进行输出System.out.print(new String(bytes,0,readLen));}} catch (FileNotFoundException e) {e.printStackTrace();}finally {
//            关闭流，进行资源的释放fileInputStream.close();}}
}

Test2对读取的方式进行了优化

四.OutputSteam字节输出流

1.OutputSteam类的简介

类图

2..FileOutPutStream类

常用的方法

应用实例1

在代码指定的位置创建文件

代码

package com.outputstream;import org.junit.jupiter.api.Test;import java.io.FileOutputStream;
import java.io.IOException;public class FileOutputStream01 {public static void main(String[] args) {}/** 使用FileOutputStream将文件写入内存当中*/@Testpublic void writeFile()  {String filePath = "d:\\a.txt";
//        创建文件输出流对象FileOutputStream fileOutputStream = null;try {
//            new FileOutputStream(filePath)写入内容时会覆盖原来的内容
//            new FileOutputStream(filePath,true)进行追加而不是覆盖fileOutputStream = new FileOutputStream(filePath,true);
//            write方法的三种使用//        1.输出数据  单个字符数据fileOutputStream.write('H');
//            2.写入字符串数据String str = "hello.word!";
//            将String变成byte数组的形式在传入   使用string自带的方法fileOutputStream.write(str.getBytes());
//            3.写入一段字符串  public void write(byte b[], int off, int len)  off为开始截取的位置，len为截取的长度fileOutputStream.write(str.getBytes(),0,3);} catch (Exception e) {e.printStackTrace();}finally {try {fileOutputStream.close();} catch (IOException e) {e.printStackTrace();}}}}

运行结果：指定文件当中的文本内容被修改

注意：new FileOutputStream(filePath,true)这样创建的流，在下次运行的时候不会清空文件当中的文本，而是进行末尾的追加。

应用实例2拷贝文件

要求

大体的思路

代码

package com.outputstream;import org.junit.jupiter.api.Test;import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;public class FileCopy {public static void main(String[] args) {}@Testpublic void FileCopy(){
//        字节数组  一个一个字节数组读取byte[] bytes = new byte[8];
//        读取文件的路径String filePath = "d:\\1.jpg";
//        输出文件的路径String aimPath = "src\\1.jpg";FileOutputStream fileOutputStream = null;FileInputStream fileInputStream = null;try {
//        1.输入到内存当中
//fileInputStream = new FileInputStream(filePath);//        输出到硬盘当中fileOutputStream =new FileOutputStream(aimPath);//            定义一个数组提高读取的效率byte[] bytes1 = new byte[1024];int readLen =0;while ((readLen = fileInputStream.read(bytes1))!=-1){
//                一遍读一边写fileOutputStream.write(bytes1,0,readLen);//一定要使用这个方法，不然：最后面数据达不到1024个字节，就是出现文件损失}} catch (Exception e) {e.printStackTrace();}finally {try {
//                关闭输入流和输出流if (fileOutputStream!=null){fileOutputStream.close();}if (fileOutputStream!=null){fileInputStream.close();}} catch (IOException e) {e.printStackTrace();}}}
}

运行前：

运行后：

提示：转移到c盘，需要管理员的权限，会出现警告。

java.io.FileNotFoundException: c:\1.jpg (拒绝访问。)

五.writer字符输出流

1.writer简介

类图

2. FileWriter类

继承关系

常用方法

案例练习

代码

package com.writer_;import java.io.FileWriter;
import java.io.IOException;public class FileWriter_ {public static void main(String[] args) {String path = "src\\node.txt";
//        创建文件
//        File file = new File(path);
//        try {
//            file.createNewFile();
//        } catch (IOException e) {
//            e.printStackTrace();
//        }char[] chars = {'a','b','c'};FileWriter fileWriter = null;try {fileWriter = new FileWriter(path);
//            写入单个字符fileWriter.write('A');
//            写入字符数组fileWriter.write(chars);
//            写入字符数组指定的部分fileWriter.write("你好，世界！".toCharArray(),0,3);
//            写入整个字符串 较为常用fileWriter.write("我爱你中国。");fileWriter.write("风雨之后，定见彩虹！！");
//            写入字符串的指定部分 较为常用fileWriter.write("最终的胜利一定属于英勇的人民！！",0,5);
//            在数据量大的情况下可以使用循环操作} catch (IOException e) {e.printStackTrace();}finally {
//            只有关闭流之后才可以将文件真正的写入if (fileWriter!=null){try {
//                    关闭文件流等价于flush+关闭fileWriter.close();
//                    close源码，到底是什么原理} catch (IOException e) {e.printStackTrace();}}}}
}

运行结果

补充：为什么close之后写入数据才算完成数据的传输

在close方法的最后，调用FileOutputStream，才将数据写入 ,字符流的底层是字节流

六.reader字符输入流

1.reader类的简介

类图

2.FileReader类

七.节点流和处理流

1.相关概念

涉及到的类

节点流使用场景

注意：节点流是比较底层的数据流没有进行过多的封装，功能性并不是很强大，如图：操作文件与操作数组需要使用两种不同的类。

writer的类图

多样的类，使得BufferWriter拥有了更多的功能，更加灵活的使用方法。

处理流的功能相对更强大一些

注意：BufferReader当中有一个Reader属性，BufferReader可以拥有Reader所有子类的功能，例如FileReader，BufferWriter一样可以实现Writer所有子类的功能。

节点流和处理流的区别

2.处理流的设计模式

代码举例

抽象类

package com.reader_;public abstract class Reader_ {public void readString(){}public void readFile(){}
//     也可以使用read方法进行统一的管理，通过传入的子类对象不同，调用不同的子类实现方法
}

根据功能划分的抽象类的子类

FileReader_类

package com.reader_;public class FileReader_ extends Reader_{public void readFile(){System.out.println("读取文件......");}
}

StringReader_类

package com.reader_;public class StringReader_ extends Reader_{public void readString(){System.out.println("读取字符串。。。。");}
}

使用子类来处理数据的包装类

package com.reader_;public class BufferReader_ extends Reader_{private Reader_ reader_;public Reader_ getReader_() {return reader_;}
//  穿传入子类也可以public BufferReader_(Reader_ reader_) {this.reader_ = reader_;}
//    让方法更加的灵活，多次读取文件public void readFiles(int num){
//        这里调用的是子类的方法for (int i =0;i<num;i++){reader_.readFile();}}
//    多次读取字符串
public void readStrings(int num){
//        通过方法来调用  而不是直接通过对象调用for (int i =0;i<num;i++){reader_.readString();}
}
//  读取一次public void readString(){
//        通过方法来调用  而不是直接通过对象调用reader_.readString();}
}

实际使用，传入抽象类的子类，指定使用的方法

package com.reader_;public class Test_ {public static void main(String[] args) {BufferReader_ bufferReader_ = new BufferReader_(new FileReader_());bufferReader_.readFiles(10);BufferReader_ bufferReader_1 = new BufferReader_(new StringReader_());bufferReader_1.readString();}
}

运行结果

读取文件......
读取文件......
读取文件......
读取文件......
读取文件......
读取文件......
读取文件......
读取文件......
读取文件......
读取文件......
读取字符串。。。。

3.处理流BufferReader和BufferWriter

当然这两也是字符流

真正处理数据还是节点流，处理流是将处理流进行了包装

应用案例1 读取指定文件当中的文本到程序当中

代码

package com.reader_;import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;public class BufferReader01 {public static void main(String[] args) {String path = "d:\\story.txt";BufferedReader bufferedReader =null;try {
//            字符流在处理一些二进制文件的时候可能会出现文件的损失bufferedReader = new BufferedReader(new FileReader(path));String string ;
//            按行进行文件的读取  读取完后返回nullwhile ((string =bufferedReader.readLine())!=null) {System.out.println(string);}} catch (Exception e) {e.printStackTrace();}finally {if (bufferedReader!=null){try {
//                    不用关闭节点流，因为包装流底层会自动关闭节点流bufferedReader.close();} catch (IOException e) {e.printStackTrace();}}}}
}

运行结果

　　21世纪历史爱好者林枫，熬夜刷历史小说突然猝死，然后穿越到东汉末年，成为了玉门关守将。
　　作为一个穿越者，林枫正在想自己未来出路在何方的时候，拥有各种功能的逆天系统出现了。
　　人口功能：可以兑换无数人口、..

将指定文件的内容以字符的形式打印到了控制台

应用案例2 使用字符流，将文本输入到指定文件

代码

package com.writer_;import java.io.BufferedWriter;
import java.io.FileWriter;public class BufferReader01 {public static void main(String[] args) throws Exception {String path = "d:\\story.txt";
//      在节点流上写true进行追加  最终执行的还是节点流的代码 处理流只是方便我们使用节点流创建的工具 类似于工具箱BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(path));bufferedWriter.write("韩顺平教育。");
//        插入一个换行符bufferedWriter.newLine();bufferedWriter.write("你好，我正在向文本当中书写内容。");bufferedWriter.close();}
}

执行结果

应用案例3 使用字符流拷贝文件

代码

package com.writer_;import java.io.*;public class BufferCopy {public static void main(String[] args) throws IOException {String path = "d:\\story.txt";
//        写入文件的时候，如果找不到文件，他会自动的创建文件String aimPath = "src\\test01.txt";BufferedWriter bufferedWriter = null;BufferedReader bufferedReader = null;bufferedReader = new BufferedReader(new FileReader(path));bufferedWriter = new BufferedWriter(new FileWriter(aimPath));String len = "";while ((len = bufferedReader.readLine())!=null){
//            读一行写一行bufferedWriter.write(len);
//            写完之后记得换行bufferedWriter.newLine();}if (bufferedWriter!=null){bufferedWriter.close();}if (bufferedReader!=null){bufferedReader.close();}}
}

运行结果

在创建文档的时候将文本写入

注意：doc，pdf，word文档都属于二进制文档

案例4 使用字节流拷贝文件

使用的是BufferInputString和BufferOutputStream

代码

package com.buffer_;import java.io.*;public class BufferCopy01 {public static void main(String[] args) throws IOException {//        读取文件的路径String filePath = "d:\\01.jpg";
//        输出文件的路径String aimPath = "src\\01.jpg";BufferedInputStream bufferedInputStream = null;BufferedOutputStream bufferedOutputStream =null;bufferedInputStream = new BufferedInputStream(new FileInputStream(filePath));bufferedOutputStream = new BufferedOutputStream(new FileOutputStream(aimPath));byte[] bytes = new byte[1024];int readLen = 0;while ((readLen = bufferedInputStream.read(bytes))!=-1){
//            三个参数的含义  数据 数据开始读取位置 数据结束读取位置bufferedOutputStream.write(bytes,0,readLen);}if (bufferedInputStream!=null){bufferedInputStream.close();}if (bufferedOutputStream!=null){bufferedOutputStream.close();}}
}

运行结果

图片文件拷贝成功

字节流什么文件都可以拷贝，因为计算机上的所有文件的底层都是由二级制源码构成的。可能效率上比较低一些。处理流和节点流的使用方式是差不多的，只是封装了的处理流，使用起来更加的方便一些，效率也更高一些。

4.对象处理流ObjectOutputStream和ObjectInputStream 序列化与反序列化

对象处理流的作用

保存java数据到文件当中，并且能从文件当中取出，转化为java形式的文件

保存值外加保存数据类型

两个对象流属于处理流和字节流

ObjectInputStream类图结构

ObjectOutputStream类图

序列化ObjectOutputStream

案例

代码

package com.outputstream;import java.io.*;public class ObjectOutputStream_ {public static void main(String[] args) throws Exception {
//        序列化之后，保存的文件格式不是纯文本的形式，而是按照他的格式来保存的String filePath = "d:\\data.dat";ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream(filePath));//        序列化文件到指定路径objectOutputStream.write(100);  //会进行自动的装箱  类型为Integer 并且实现了序列化接口objectOutputStream.writeBoolean(true);objectOutputStream.writeChar('a');objectOutputStream.writeUTF("韩顺平教育");
//        保存一个对象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;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}public String  getName() {return name;}public void setName(String name) {this.name = name;}
}

运行结果

反序列化ObjectInputStream

创建公共类Dog

package com.outputstream;import java.io.Serializable;public class Dog implements Serializable{private int age;private String name;public Dog(int age, String  name) {this.age = age;this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}public String  getName() {return name;}public void setName(String name) {this.name = name;}@Overridepublic String toString() {return "Dog{" +"age=" + age +", name='" + name + '\'' +'}';}
}

ObjectInputStream_类

package com.inputstream;import com.outputstream.Dog;import java.io.FileInputStream;
import java.io.ObjectInputStream;public class ObjectInputStream_ {public static void main(String[] args) throws Exception {
//        指定反序列化的文件String filePath = "d:\\data.dat";ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(filePath));//        注意，读取的顺序应当与序列化的顺序是一致的  因为是一一对应的关系
//        在反序列化之前，一定要将方法重新执行一边 不然可能会不匹配System.out.println(objectInputStream.readInt());System.out.println(objectInputStream.readBoolean());System.out.println(objectInputStream.readChar());System.out.println(objectInputStream.readUTF());Object dog  = objectInputStream.readObject();//        重要的细节  如果我们想要执行类当中的方法 应当将类拷贝到可以引用的地方  存放的类最好是公开的Dog dog1 = (Dog)dog;System.out.println(dog1.getName());System.out.println(dog.getClass());System.out.println(dog);objectInputStream.close();}
}

运行结果

100
true
a
韩顺平教育
旺财
class com.outputstream.Dog
Dog{age=10, name='旺财'}

注意事项

1.顺序不一致，会导致类型不一致，会报错

2. 兼容性，类修改之后，仍旧会被当成一个类来进行处理

3.static和transient不会被序列化，但是transient不能被序列化不是绝对的

4.对一个对象进行序列化，要求对象的所有属性都可以被序列化

5.序列化具有可继承性

transient关键字详解https://www.runoob.com/w3cnote/java-transient-keywords.html

5.标准输入与输出流System.in 和System.out

属于字节流。代表着两个流，一个对应的位置是键盘，一个对应的位置是显示器

代码

package com.standard;import java.util.Scanner;public class InputAndOutput {public static void main(String[] args) {
//      System 当中的in属性    public final static InputStream in = null;
//        编译类型为InputStream运行类型为BufferInputStream  表示标准输出键盘System.out.println(System.in.getClass());
//      运行类型和编译类型都是PrintStream  表示标准输出显示器System.out.println(System.out.getClass());System.out.println("韩顺平教育~~~~~~");
//      键盘输入的内容Scanner scanner = new Scanner(System.in);String next = scanner.next();System.out.println(next);}
}

运行结果

class java.io.BufferedInputStream
class java.io.PrintStream
韩顺平教育~~~~~~
nihao
nihao

6.转换流InputStreamReader和OutputStreamWriter

运行类型是字符流，

转换流的作用，将字节流转化为字符流

解决读取文件乱码问题

代码

package com.transformation;import java.io.*;public class CodeQuestion {public static void main(String[] args) throws Exception {
//        读取指定路径的文件到程序当中String path = "d:\\test.txt";
//        创建流进行指定文件当中信息的读取BufferedReader bufferedReader = null;bufferedReader = new BufferedReader(new FileReader(path));String s = bufferedReader.readLine();
//      输出的文件没有任何的问题  默认情况下是按照UTF-8进行解析的  使用其他编码表可能会出现问题System.out.println(s);
//      出现乱码的根本问题是因为你没有指定解析你密码的格式}
}

结果

为这世间的一切献上美好的祝福

没有问题是因为使用的编码表是UTF-8

进行格式更换

再次运行程序

Ϊ��һ��õ�ף��

出现乱码

转换流可以指定编码的形式

介绍

InputStreamReader类

类图

案例

代码

package com.transformation;import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.InputStreamReader;public class InputStreamReader_ {public static void main(String[] args) throws Exception {
//      将FileInputStream字节流转化为InputStreamReader字符流   字符流处理文本的效率更b高String path = "d:\\test.txt";InputStreamReader jbk = new InputStreamReader(new FileInputStream(path), "gbk");//      最后还是用处理流BufferedReader进行信息的处理  进行了两次包装  一次指定编码表  一次指定信息处理的处理流BufferedReader bufferedReader = new BufferedReader(jbk);//        bufferedReader = new BufferedReader(new InputStreamReader(new FileInputStream(path)));
//        可以将上面的代码合成一句话，因为InputStreamReader是Reader的子类//        进行读取String s = bufferedReader.readLine();System.out.println(s);}
}

运行结果

璁╂垜浠潵璧炵編杩欎釜涓栫晫鐨勭編濂藉惂

第一次为乱码，当我们修改txt文件的编码表为我们指定的时候，输出

让我们来赞美这个世界的美好吧

正常输出

OutputStreamWriter

类图

案例

代码

package com.transformation;import java.io.FileOutputStream;
import java.io.OutputStreamWriter;public class OutputStreamWriter_ {public static void main(String[] args) throws Exception {String path = "d:\\test.txt";String charSet = "gbk";OutputStreamWriter outputStreamWriter = new OutputStreamWriter(new FileOutputStream(path),charSet);outputStreamWriter.write("你好，艾莉西亚");outputStreamWriter.close();}
}

运行结果

7.打印流PrintStream和PrintWriter

字节流PrintStream

类图

构造方法

可以将文件打印到一个指定的文件当中

代码

package com.printStream_;import java.io.IOException;
import java.io.PrintStream;public class PrintStream_ {public static void main(String[] args) throws IOException {PrintStream ps = System.out;
//      默认情况下PrintStream输出的位置是控制台也就是显示器ps.print("如果真爱有颜色那么一定是蓝色的。");
//        因为print底层使用的是write所以我们可以直接使用write进行输出ps.write("感觉不如惠".getBytes());ps.close();//        修改文本输出的位置System.setOut(new PrintStream("d:\\test.txt"));System.out.println("薇尔莉特是世界上最好看的女性");}
}

前两句输出的位置

修改输出路径之后的情况

字符流PrintWriter

类图

构造方法

案例

package com.printStream_;import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;public class PrintWriter_ {public static void main(String[] args) throws IOException {String path = "d:\\test01.txt";PrintWriter printWriter = new PrintWriter(new FileWriter(path));printWriter.write("世界上最美好的语言是谎言。");printWriter.close();  //这里边才是真正写数据的}
}

运行结果

依旧是close的时候真正的输出完成信息

之前追过这个方法

七.配置文件Properties

1.引出配置文件

代码

package com.propertise;import java.io.BufferedReader;
import java.io.FileReader;public class Properties_ {public static void main(String[] args) throws Exception {//        传统的方式比较麻烦BufferedReader bufferedReader = new BufferedReader(new FileReader("src\\mysql.properties"));String lin = "";while ((lin = bufferedReader.readLine())!=null){String[] split = lin.split("=");System.out.println(split[0]+"的值是："+split[1]);}bufferedReader.close();}
}

运行结果

ip 的值是： 192.127.100.100
user 的值是： root
pwd 的值是：12345

获取信息不是很方便 properties当中的属性

以后会有个更方便的xml实现方法

2.基本的使用

使用方法

应用案例1 读文件

package com.propertise;import java.io.FileReader;
import java.util.Properties;public class Properties01 {public static void main(String[] args) throws Exception {Properties properties = new Properties();properties.load(new FileReader("src\\mysql.properties"));
//      将k-v显示到控制台properties.list(System.out);
//        根据key获得对应的值String user = properties.getProperty("user");System.out.println(user);}
}

运行结果

-- listing properties --
user=root
pwd=12345
ip=192.127.100.100
root

应用案例2 写文件

代码

package com.propertise;import java.io.FileOutputStream;
import java.util.Properties;public class Properties02 {public static void main(String[] args) throws Exception {Properties properties = new Properties();//        进行添加信息  如果key存在就替换  底层的父类是HashCodeproperties.setProperty("charSet","utf-8");properties.setProperty("user","tom");properties.setProperty("pwd","abc111");//        将内容写入文件   后面的参数是文件得注释properties.store(new FileOutputStream("src\\mysql01.properties"),null);System.out.println("保存配置文件成功。。。");}
}

运行结果

八.家庭作业

1.家庭作业一

代码

package com.homework;import java.io.*;public class HomeWork01 {public static void main(String[] args) throws IOException {
//        创建文件夹String directoryPath = "d:\\mytemp";File file = new File(directoryPath);if (!file.exists()){if (file.mkdirs()){System.out.println(directoryPath+"创建成功");}else {System.out.println(directoryPath+"创建失败");}}String filePath = directoryPath+"\\hello.txt";file =new File(filePath);
//        不存在的话  返回trueif (!file.exists()){
//            创建文件夹if (file.createNewFile()){System.out.println(filePath + "文件创建文件");BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(filePath));bufferedWriter.write("你好，但愿我能看见世界的美好。。");bufferedWriter.close();}else {System.out.println(filePath + "文件创建失败");}}else {System.out.println(filePath + "已经存在，不再重复的创建");}}
}

控制台输出结果

d:\mytemp创建成功
d:\mytemp\hello.txt文件创建文

文件

2.家庭作业二

代码

package com.homework;import java.io.BufferedReader;
import java.io.FileReader;public class HomeWork02 {public static void main(String[] args) throws Exception {String filePath = "d:\\test.txt";BufferedReader bufferedReader = null;String lin = " ";int i = 0;bufferedReader = new BufferedReader(new FileReader(filePath));while ((lin = bufferedReader.readLine())!=null){System.out.println(++i+":"+lin);}if (bufferedReader!=null){bufferedReader.close();}}
}

运行结果

1:如果天空总是黑暗的，那就摸黑生存；
2:如果发出声音是危险的，那就保持沉默；
3:如果自觉无力发光，那就蜷伏于墙角。
4:但不要习惯了黑暗就为黑暗辩护；
5:也不要为自己的苟且而得意；
6:不要嘲讽那些比自己更勇敢的人们。
7:我们可以卑微如尘土，但不可扭曲如蛆虫。

修改文件存储的编码，利用转换流进行转化，才能正常输出

package com.homework;import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.InputStreamReader;public class HomeWork02 {public static void main(String[] args) throws Exception {String filePath = "d:\\test.txt";BufferedReader bufferedReader = null;String lin = " ";int i = 0;
//      修改编码之后的操作bufferedReader = new BufferedReader(new InputStreamReader(new FileInputStream(filePath),"gbk"));while ((lin = bufferedReader.readLine())!=null){System.out.println(++i+":"+lin);}if (bufferedReader!=null){bufferedReader.close();}}
}

3.家庭作业三

代码

package com.homework;import java.io.*;
import java.util.Properties;public class HomeWork03 {public static void main(String[] args) throws Exception {String filePath = "src\\dog.properties";Properties properties = new Properties();properties.load(new FileReader(filePath));String name = properties.get("name")+" ";int age = Integer.parseInt(properties.get("age")+"");String color = properties.get("color")+" ";Dog dog = new Dog(name, age, color);System.out.println(dog);String serFilePath = "d:\\dog.dat";ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream(serFilePath));objectOutputStream.writeObject(dog);objectOutputStream.close();System.out.println("dog序列化完成。。");}
}class Dog implements Serializable{private String  name;private int age;private String color;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;}@Overridepublic String toString() {return "Dog{" +"name='" + name + '\'' +", age=" + age +", color='" + color + '\'' +'}';}
}

运行结果

Dog{name='tom ', age=5, color='red '}

dat文件