Java基础-IO流

1.文件

1.基本介绍

2.常用的文件操作

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

代码实例

package IO_;import java.io.File;
import java.io.IOException;/*** @author 孙显圣* @version 1.0*/
public class FileCreate {public static void main(String[] args) {//使用三种方式在e盘下创建三个文件// new File(String pathname)String path1 = "e:\\file1.txt";File file = new File(path1); //在内存中创建文件对象//调用方法在磁盘中创建文件try {file.createNewFile();System.out.println("创建文件1成功！");} catch (IOException e) {throw new RuntimeException(e);}// new File(File parent, String child)File file1 = new File("e:\\"); //父文件对象String child = "file2.txt"; //子文件路径File file2 = new File(file1, child);try {file2.createNewFile();System.out.println("创建文件2成功");} catch (IOException e) {throw new RuntimeException(e);}// new File(String parent, String child)String parent = "e:\\"; //父路径String child_ = "file3.txt";File file3 = new File(parent, child_);try {file3.createNewFile();System.out.println("文件3创建成功");} catch (IOException e) {throw new RuntimeException(e);}}
}

结果

2.获取文件相关信息

代码实例

package IO_;import java.io.File;/*** @author 孙显圣* @version 1.0*/
public class FileInfo {public static void main(String[] args) {File file = new File("e:\\file1.txt"); //创建文件对象System.out.println("文件绝对路径 " + file.getAbsolutePath());System.out.println("文件名字 " + file.getName());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.目录的删除和文件删除

代码实例

package IO_;import java.io.File;/*** @author 孙显圣* @version 1.0*/
public class FileMkdir {public static void main(String[] args) {// 判断e:\\file1.txt是否存在，如果存在则删除File file = new File("e:\\file1.txt");if (file.exists()) {file.delete();System.out.println("删除成功");}else {System.out.println("删除失败");}// 判断e:\\demo02是否存在，存在就删除，否则提示不存在String path = file.getParent() + "demo02"; //路径拼接File file1 = new File(path);if (file1.exists()) {file1.delete();System.out.println("删除成功");}else {System.out.println("删除失败");}// 判断e:\\demo\\a\\b\\c是否存在，如果不存在则创建File file2 = new File("e:\\demo\\a\\b\\c");if (file2.exists()) {System.out.println("已经存在");}else {file2.mkdirs();System.out.println("文件不存在，已经自动创建");}}
}

2.IO流原理及分类

IO流原理

IO流就相当于是外卖小哥，用来传输数据

IO流分类

3.FileInputStream

1.类图

2.代码实例

package IO_;import org.junit.jupiter.api.Test;import java.io.FileNotFoundException;
import java.io.IOException;/*** @author 孙显圣* @version 1.0*/
public class FileInputStream {//逐个字节读取@Testpublic void one() {String path = "e:\\hello.txt"; //1.文件路径int readData = 0;java.io.FileInputStream fileInputStream = null;try {fileInputStream = new java.io.FileInputStream(path); //2.根据文件路径，创建输入流的对象//3.逐个字节读取while ((readData = fileInputStream.read()) != -1) { //返回读取的字节，如果返回-1则到文件末尾System.out.print((char) readData); //将字节转换成char类型并输出}} catch (FileNotFoundException e) {throw new RuntimeException(e);} catch (IOException e) {throw new RuntimeException(e);}finally {//4.关闭字节流try {fileInputStream.close();} catch (IOException e) {throw new RuntimeException(e);}}}//按照字节数组读取public static void main(String[] args) {String path = "e:\\hello.txt"; //1.文件路径byte[] bytes = new byte[8]; //3.8个容量的字节数组int readData = 0;java.io.FileInputStream fileInputStream = null;try {fileInputStream = new java.io.FileInputStream(path); //2.字节流对象//4.按照字节数组读取while ((readData = fileInputStream.read(bytes)) != -1) { //会将字节读进字节数组中，返回读进的字节数System.out.print(new String(bytes, 0, readData)); //将字节数组转换成String类型并且输出}} catch (FileNotFoundException e) {throw new RuntimeException(e);} catch (IOException e) {throw new RuntimeException(e);} finally {//5.关闭字节流try {fileInputStream.close();} catch (IOException e) {throw new RuntimeException(e);}}}
}

3.结果

4.FileOutputStream

1.类图

2.案例

代码实例

package IO_;import java.io.FileOutputStream;
import java.io.IOException;/*** @author 孙显圣* @version 1.0*/
public class FileOutputStream01 {public static void main(String[] args) {//输出流如果没有那个文件，会自动创建String path = "e:\\a.txt"; //1.文件路径FileOutputStream fileOutputStream = null; //2.获取文件输出流引用try {
//            fileOutputStream = new FileOutputStream(path); //3.获取文件输出流fileOutputStream = new FileOutputStream(path, true); //8.设置该文件输出流的写入位置为文件末尾（不覆盖原来的文件）//5.输出单个字符fileOutputStream.write('h');//6.输出字符串String a = "hello,world";fileOutputStream.write(a.getBytes()); //使用字符串的getBytes来将字符串转化成字节数组//7.输出部分字符串String b = "hsp,java";fileOutputStream.write(b.getBytes(), 0, 3);} catch (IOException e) {throw new RuntimeException(e);} finally {//4.关闭文件输出流try {fileOutputStream.close();} catch (IOException e) {throw new RuntimeException(e);}}}
}

3.综合案例—文件拷贝

代码实例

package IO_;import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;/*** @author 孙显圣* @version 1.0*/
public class FileCopy {public static void main(String[] args) {//文件源路径String src = "C:\\Users\\86156\\Desktop\\images\\1.png";//文件目标路径String dest = "e:\\1.png";//文件输入流FileInputStream fileInputStream = null;//文件输出流FileOutputStream fileOutputStream = null;byte[] bytes = new byte[1024]; //用来存储文件输入的字节数组int readLength = 0; //记录读取的字节数try {//获取文件输入流fileInputStream = new FileInputStream(src);//获取文件输出流fileOutputStream = new FileOutputStream(dest);//将文件读取到字节数组中while ((readLength = fileInputStream.read(bytes)) != -1) {fileOutputStream.write(bytes, 0, readLength); //将读取到的部分写入目标文件}System.out.println("拷贝成功！");} catch (IOException e) {throw new RuntimeException(e);} finally {//关闭两个流try {fileInputStream.close();fileOutputStream.close();} catch (IOException e) {throw new RuntimeException(e);}}}
}

5.FileReader

1.类图

2.基本介绍

3.案例

代码实例

package IO_;import org.junit.jupiter.api.Test;import java.io.FileReader;
import java.io.IOException;/*** @author 孙显圣* @version 1.0*/
public class FileReader_ {//按照单个字符读取public static void main(String[] args) {//读取路径String src = "e:\\a.txt";//获取字符输入流引用FileReader fileReader = null;int readData = 0; //接收输入的字符try {//获取字符输入流fileReader = new FileReader(src);//按照字符，循环读取while ((readData = fileReader.read()) != -1) { //这里返回的是单个字符但是，是以int形式返回的System.out.print(((char)readData));}} catch (IOException e) {throw new RuntimeException(e);} finally {//关闭字符输入流try {fileReader.close();} catch (IOException e) {throw new RuntimeException(e);}}}//按照字符数组读取@Testpublic void readMore() {//读取路径String src = "e:\\a.txt";//获取字符输入流引用FileReader fileReader = null;char[] chars = new char[100]; //用来接收读取的数据int redLen = 0; //记录读取长度try {//获取字符输入流fileReader = new FileReader(src);//按照字符，循环读取while ((redLen = fileReader.read(chars)) != -1) { //这里是将内容读取到char数组，返回的是读取的长度System.out.print(new String(chars, 0, redLen)); //将读取到的部分转化成String，并输出}} catch (IOException e) {throw new RuntimeException(e);} finally {//关闭字符输入流try {fileReader.close();} catch (IOException e) {throw new RuntimeException(e);}}}
}

6.FileWriter

1.类图

2.基本介绍

3.案例

代码实例

package IO_;import java.io.FileWriter;
import java.io.IOException;/*** @author 孙显圣* @version 1.0*/
public class FileWriter_ {public static void main(String[] args) {//写入文件地址String path = "e:\\a.txt";//获取输出字符流引用FileWriter fileWriter = null;try {fileWriter = new FileWriter(path); //获取输出字符流对象//写入单个字符fileWriter.write('a');//写入字符数组char[] a = new char[]{'1','2','3'};fileWriter.write(a);//写入指定字符数组的指定部分fileWriter.write("你好，世界".toCharArray(),3,2); //注意这里面的指定位置指的是off（开始位置）len（长度），这里我就是，从3开始2个位置所以是世界//写入字符串fileWriter.write("字符串");//写入部分字符串fileWriter.write("韩顺平，java",0, 3);} catch (IOException e) {throw new RuntimeException(e);} finally {//关闭字符流try {fileWriter.close();} catch (IOException e) {throw new RuntimeException(e);}}}
}

7.节点流与处理流

1.基本介绍

简单来说，就是节点流的处理局限性太强，java设计者就设计了处理流，处理流中有一个属性，这个属性是一个类的引用，而这个类是各种节点流的父类，通过将其他节点流的对象赋值给这个属性，就可以向上转型，从而使用这个属性来调用各种节点流的方法

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

1. 节点流式底层流，直接跟数据源相接
2. 处理流（包装类 ）包装节点流，既可以消除不同节点流的实现差异，也可以对提供更方便的方法来完成输入输出
3. 处理流对节点流进行包装，使用了修饰器设计模式，不会与数据源直接相连
4. 重点就是：处理流有一个属性，这个属性是很多子类型的父类，也就是说可以接收很多子类型的对象，接受的谁的对象，掉用的就是谁的方法

8.BufferedReader

代码实例

package IO_;import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;/*** @author 孙显圣* @version 1.0*/
public class BufferReader_ {public static void main(String[] args) {//读取的路径String path = "e:\\a.txt";//BufferedReader的引用BufferedReader bufferedReader = null;//接受读取的内容String readData = null;try {bufferedReader = new BufferedReader(new FileReader(path)); //由于要对文件进行操作，所以传入FileReaderwhile ((readData = bufferedReader.readLine()) != null) { //按行读取System.out.println(readData);}} catch (FileNotFoundException e) {throw new RuntimeException(e);} catch (IOException e) {throw new RuntimeException(e);} finally {try {bufferedReader.close();} catch (IOException e) {throw new RuntimeException(e);}}}
}

9.BufferedWriter

案例

代码实例

package IO_;import java.io.FileWriter;
import java.io.IOException;/*** @author 孙显圣* @version 1.0*/
public class BufferedWriter {public static void main(String[] args) throws IOException {String path = "e:\\a.txt";java.io.BufferedWriter bufferedWriter = new java.io.BufferedWriter(new FileWriter(path, true));//以追加的方式写入bufferedWriter.write("韩顺平教育，，，java");bufferedWriter.close(); //关闭外层流}
}

10.Buffered拷贝

代码实例

package IO_;import java.io.*;
import java.io.BufferedWriter;/*** @author 孙显圣* @version 1.0*/
public class BufferedCopy {public static void main(String[] args) throws IOException {//源地址String src = "e:\\a.txt";//目标地址String dest = "e:\\b.txt";String readData = null; //存储读取信息//获取输入流BufferedReader bufferedReader = new BufferedReader(new FileReader(src));//获取输出流BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(dest));//按行读取信息while ((readData = bufferedReader.readLine()) != null) {//写入bufferedWriter.write(readData);bufferedWriter.newLine(); //写入一行}//关闭bufferedWriter.close();bufferedReader.close(); }
}

11.Buffered字节处理流

1.基本介绍

2.字节处理流拷贝（图片/音乐）

代码实例

package IO_;import java.io.*;
import java.io.FileInputStream;/*** @author 孙显圣* @version 1.0*/
public class BufferedCopy02 {public static void main(String[] args) throws IOException {//源地址String src = "e:\\1.png";//目标地址String dest = "e:\\3.png";//存储读取到的字节数组byte[] bytes = new byte[1024];//存储读取长度int readLen = 0;//获取输入字节流BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream(src));//获取输出字节流BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(new FileOutputStream(dest));//循环读取while ((readLen = bufferedInputStream.read(bytes)) != -1) {bufferedOutputStream.write(bytes, 0, readLen);}//关闭字节流bufferedInputStream.close();bufferedOutputStream.close();}
}

3.字节处理流和字符处理流比较

1. 字节处理流主要用于处理二进制文件（视频、图片等），也能处理二进制文件
2. 字符处理流主要用于处理文本文件（效率高），不能处理二进制文件
3. 字节处理流可以写一个字节、字节数组、部分字节数组
4. 字符处理流可以写一个字符、一个字符数组、一个字符串、部分字符数组、部分字符串
5. 简单来说，字节处理的是单个字节，字节数组，字符处理的是单个字符，字符数组，字符串

12.对象处理流（读写对象）

1.序列化和反序列化

介绍

1. 序列化就是在保存数据的时候，保存数据的值和数据类型
2. 反序列化就是在回复数据时，恢复数据的值和数据类型
3. 需要让某个对象支持序列化机制，则必须让其类是可序列化的，为了让某个类是可序列化的，该类必须实现如下两个接口之一
   1. Serializable(推荐) 这是一个标记接口，里面没有任何方法
   2. Externalizable

2.ObjectOutputStream

类图

案例

package IO_;import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.io.Serializable;/*** @author 孙显圣* @version 1.0*/
public class ObjectOutputStream_ {public static void main(String[] args) throws IOException {//输出文件路径String path = "e:\\data.dat"; //注意序列化的文件是dat格式的//获取对象输出流ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream(path));//保存objectOutputStream.writeInt(100); // IntegerobjectOutputStream.writeBoolean(true);objectOutputStream.writeChar('a');objectOutputStream.writeDouble(10.2);objectOutputStream.writeUTF("adf");objectOutputStream.writeObject(new Dog("jack",12));//关闭objectOutputStream.close();}
}
class Dog implements Serializable {private String name;private int age;public Dog(String name, int age) {this.name = name;this.age = age;}@Overridepublic String toString() {return "Dog{" +"name='" + name + '\'' +", age=" + age +'}';}
}

3.ObjectInputStream

类图

案例

package IO_;import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;/*** @author 孙显圣* @version 1.0*/
public class ObjectInputStream_ {public static void main(String[] args) throws IOException, ClassNotFoundException {//输入的地址String path = "e:\\data.dat";//获取对象处理流ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(path));// 按照之前序列化的次序来获取对象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());Object o = objectInputStream.readObject();System.out.println(o.getClass());System.out.println(o);//关闭对象处理流objectInputStream.close();}
}

对象处理流使用细节

1. 在修改了对象处理流的文件之后，需要重新运行一遍程序，保持版本一致性
2. 如果是自定义的对象，要保证该输入流文件可以引入
3. 读写顺序需要一致
4. 序列化或者反序列化对象必须实现Serializable接口
5. 序列化中的类建议添加SerialVersionUID,为了提高版本的兼容性
6. 序列化对象时，默认将里面所有属性都进行序列化，但除了static或transient修饰的成员
7. 序列化对象时，要求里面的属性也需要实现序列化接口
8. 序列化具备可继承性，也就是如果某类已经实现了序列化，则它的所有子类也默认实现了序列化

13.标准输入输出流

System.in

1. 编译类型：InputStream
2. 运行类型：BufferedInputStream（可以处理所有输入，只需要传入相应的InputStream子类即可）
3. 表示的是标准输入 键盘

System.out

1. 编译类型：PrintStream
2. 运行类型：PrintStream
3. 表示的是标准输出 显示器

new Scanner(System.in)

1. 这个就相当于给扫描器传入了接受键盘输入的数据

14.转换流（字节流转换成字符流并指定编码）

1.字符流出现乱码引出转换流

1. 将文件类型改成非utf-8，然后使用字符流读取
2. 如果想解决这个问题，就只能将字符流转换成字节流并且指定编码，然后再转回来

2.InputStreamReader

解决乱码问题

代码实例

package IO_;import org.junit.jupiter.api.Test;import java.io.FileInputStream;
import java.io.*;/*** @author 孙显圣* @version 1.0*/
public class CodeQuestion {public static void main(String[] args) throws IOException {//使用字符流读取文件内容String url = "e:\\a.txt";//获取字符处理流BufferedReader bufferedReader = new BufferedReader(new FileReader(url));//读取一行内容String s = bufferedReader.readLine();System.out.println(s);}//字节流转换成字符流@Testpublic void test() throws IOException {String url = "e:\\a.txt";//这里是使用文件字节流读取信息，并传入编码，会返回一个字符流的实例InputStreamReader inputStreamReader = new InputStreamReader(new FileInputStream(url), "gbk");//        //使用节点流的方式去读
//        char[] chars = new char[100];
//        int readLen;
//        while ((readLen = inputStreamReader.read(chars)) != -1) { //读到字符数组中并返回读取的长度
//            System.out.println(new String(chars, 0, readLen)); //根据读取的长度取出数组内的长度
//        }//使用BufferedReader的方式去读String re = null;BufferedReader bufferedReader = new BufferedReader(inputStreamReader);while ((re = bufferedReader.readLine()) != null) {System.out.println(re);}}
}

3.OutputStreamWriter

案例

代码示例

package IO_;import java.io.*;
import java.io.BufferedWriter;/*** @author 孙显圣* @version 1.0*/
public class FileOutputStream02 {public static void main(String[] args) throws IOException {//使用OutputStreamWriter 将字节流转换成字符流指定utf-8并且执行//要写入的urlString url = "e:\\a.txt";BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(url), "utf-8"));//这里使用OutputStreamWriter将字节流转化为字符流并且指定编码，并且使用BufferedWriter来操作这个字符流bufferedWriter.write("世界，你好！");bufferedWriter.close();}
}

15.打印流

PrintStream(字节打印流)

代码实例

package IO_;import java.io.FileNotFoundException;
import java.io.PrintStream;/*** @author 孙显圣* @version 1.0*/
public class PrintStream_ {public static void main(String[] args) throws FileNotFoundException {//使用字节打印流在屏幕打印PrintStream out = System.out;out.println("你好，世界");//修改打印位置为文件中的位置System.setOut(new PrintStream("e:\\a.txt"));System.out.println("dsfasdfs");}
}

PrintWrite（字符打印流）

代码实例

package IO_;import java.io.*;/*** @author 孙显圣* @version 1.0*/
public class PrintWriter_ {public static void main(String[] args) throws IOException {PrintWriter printWriter = new PrintWriter(System.out); //传入了一个标准输出到屏幕的对象PrintWriter printWriter1 = new PrintWriter(new FileWriter("e:\\a.txt")); //传入了一个输入到文件的对象printWriter1.print("辅导费");printWriter1.close();printWriter.println("dagasdg");printWriter.close();}
}

16.IO流总结

1.示意图

字节流

• InputStream
  • FileInputStream(节点流)
  • BufferedInputStream(处理流)（System.in 标准输入 键盘）
  • ObjectInputStream(对象处理流，反序列化)
• OutputStream
  • FileOutputStream(节点流)
  • BufferedOutputStream(处理流)
  • ObjectOutputStream(对象处理流，序列化)
  • PrintStream(字节打印流)（System.out 标准输出 显示器）

字符流

• Reader
  • FileReader(节点流)
  • BufferedReader(处理流)
  • InputStreamReader(转换流)
• Writer
  • FileWriter(节点流)
  • BufferedWriter(处理流)
  • OutputStreamWriter(转换流)
  • PrintWriter(字符打印流)

2.细节说明

1.字节流和字符流处理的数据

1. 字节流：处理单个字节（字符）、字节数组，一般处理二进制文件时使用
2. 字符流：处理单个字符、字符数组、字符串（可写），一般处理文本文件时使用

2.处理流的说明

1. 字符处理流可以读写String类型，并且 可以读一行，字节处理流还是只能读字节或者字节数组
2. 由于节点流的处理局限性太强，所以产生了处理流
3. 处理流使用了修饰器模式，就是使用一个其他节点流的父类型的属性，通过构造方法来接收其他节点流的实例，接受了谁的实例，这个属性调用的方法就是谁的方法，也就是处理哪个节点
4. 处理流可以处理基类的所有节点子类

3.转换流的说明

1. 为了指定文本文件的编码，又想使用字符流，就产生了转换流
2. 转换流可以接收字节流的实例，用于读写和设置编码，然后返回一个转换流，由于这个转换流也是两大基类节点子类，所以一般使用处理流来处理

4.打印流

1. System.out：默认指向标准输出 显示器的打印流，使用System.setOut可以接收输出到文件的PrintStream类
2. PrintWriter:它的构造方法可以接收一个System.out（指向一个标准输出到显示器的实例），也可以接收一个输出到文件的FileWriter

5.常用的流

1. 一般使用处理流Buffered。。。来进行处理
2. 字节处理流，读写字节数组，需要字节数组缓冲区和计数器，循环条件是不等于-1
3. 字符处理流，读写字符串，可以读一行，需要字符串缓冲区，循环条件是不等于null

17.Properties处理配置文件

1.实际需求引出properties配置文件

在开发中操作数据库需要用户名和密码，如果在程序中写死，则一但更换了数据库则需要修改源代码，所以一般将其写在配置文件中，在代码中使用Properties类来读取

2.使用Properties读取配置文件信息

package IO_;import java.io.FileReader;
import java.io.IOException;
import java.util.Properties;/*** @author 孙显圣* @version 1.0*/
public class Properties_ {public static void main(String[] args) throws IOException {//1.创建实例Properties properties = new Properties();//2.使用流的方式加载配置文件properties.load(new FileReader("src\\mysql.properties"));//3.以打印流的方式展示所有文件properties.list(System.out); //这里传入一个标准打印流 屏幕//4.根据key，获取value信息String username = properties.getProperty("username");String password = properties.getProperty("password");System.out.println("username:" + username);System.out.println("password:" + password);}
}

3.使用Properties创建配置文件并且修改配置文件信息

package IO_;import java.io.FileWriter;
import java.io.IOException;
import java.util.Properties;/*** @author 孙显圣* @version 1.0*/
public class Properties_1 {public static void main(String[] args) throws IOException {//使用properties来创建一个文件赋值并且修改//1.创建实例Properties properties = new Properties();//2.为其设置几个值properties.setProperty("username","12344");properties.setProperty("password","9999");//3.将其存储到配置文件中properties.store(new FileWriter("src\\mysql1.properties"), "这个是文档开头注释");//4.修改配置文件properties.setProperty("username","111111");properties.store(new FileWriter("src\\mysql1.properties"),null);}
}

18.本章作业

作业一

题目

代码

package IO_;import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;/*** @author 孙显圣* @version 1.0*/
public class HomeWork01 {public static void main(String[] args) throws IOException {//创建文件对象File file = new File("e:\\mytemp");//判断是否是文件夹，如果不是则创建if (!file.isDirectory()) {file.mkdirs();}//在e盘刚才创建的目录下创建文件hello.txt,如果存在则输出内容File file1 = new File(file, "hello.txt");if (file1.exists()) {System.out.println("文件已经存在");//写入内容BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(file1));bufferedWriter.write("你好世界");//关闭bufferedWriter.close();}file1.createNewFile();}
}

作业二

题目

代码

package IO_;import org.junit.jupiter.api.Test;import java.io.*;
import java.io.FileInputStream;/*** @author 孙显圣* @version 1.0*/
public class HomeWork02 {public static void main(String[] args) throws IOException {File file = new File("e:\\mytemp\\hello.txt");//创建对象BufferedReader bufferedReader = new BufferedReader(new FileReader(file));//存储数据String re = null;int num = 0; //记录行号while ((re = bufferedReader.readLine()) != null) { //按行读取num ++;//加上行号之后重新输出System.out.println(num + re);//读取出来}//关闭bufferedReader.close();}//将文件改成gbk码则需要使用转换流@Testpublic void test() throws IOException {File file = new File("e:\\mytemp\\hello.txt");//使用转换流BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(new FileInputStream(file), "gbk"));String re = null;while ((re = bufferedReader.readLine()) != null) {System.out.println(re);}//关闭转换流bufferedReader.close();}
}

作业三

题目

代码

package IO_;import org.junit.jupiter.api.Test;import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Properties;/*** @author 孙显圣* @version 1.0*/
public class HomeWork03 {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 FileOutputStream("src\\dog.properties"), null);}
}
class Dog_ {//读取配置文件并且初始化并输出@Testpublic void test() throws IOException {Properties properties = new Properties();//加载文件properties.load(new FileInputStream("src\\dog.properties"));//完成初始化properties.setProperty("name","jack");//输出文件properties.list(System.out);}
}