JavaSe基础---IO流

# 1 - File 类

# 1.1 - 基本概念

java.io.File类用于描述文件和目录的路径信息，可以获取文件大小等相关属性。

# 1.2 - 构造方法

方法名 说明
File(String pathname) 通过给定的路径名转换为 File 对象
File(String parent,String child) 从父类的路径名和子类的文件名来创建一个 File 对象
File(File parent,String child) 从父类的 Flie 目录和子类的文件名来创建一个 File 对象 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
import java.io.File;

/**
 * @author ly_smith
 * @Description #TODO  File对象的构造器
 */
public class Demo02 {
    public static void main(String[] args) {
//        相对路径与绝对路径
        /*
        相对路径：相对于当前目录的某一级目录
        当前路径表示为：  ./   (Idea)默认从项目根目录开始查找
        上一级目录表示为：../
        上一级的上一级目录表示为：../../

        绝对路径：从磁盘根目录开始查找
        E:\\workingspace\\bjpn2209\\com.bjpowernode.day06.file\\src\\Demo02.java
        E:/workingspace/bjpn2209/com.bjpowernode.day06.file/src/Demo02.java
        * */

        //与文件向关联，并不会创建或获取文件
        File file = new File("./myTest.txt");
        System.out.println(file);

        //第一个参数是路径，第二个参数是要操作的目标文件名
        File file1 = new File("./", "myTest.txt");
        System.out.println(file1);

        File file2 = new File("./");//将路径构造成File对象
        File file3 = new File(file2, "myTest.txt");
        System.out.println(file3);
    }
}

# 1.3 - File 类的创建功能

方法名 说明
boolean createNewFile() 创建文件
boolean mkdir() 创建目录（单个）
boolean mkdirs() 创建目录（多级） 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
import java.io.File;
import java.io.IOException;

/**
 * @author ly_smith
 * @Description #TODO File类的创建功能
 */
public class Demo03 {
    public static void main(String[] args) throws IOException {
        //创建文件前需要与文件相关联
        File file = new File("./myTest.txt");
        if (file.createNewFile()){
            System.out.println("文件创建成功！");
        }else{
            System.out.println("文件创建失败！");
        }

        //创建单个目录，先构造File对象，与目录相关联
        File myDir = new File("./", "myDir");
        //创建多级目录的方式可以创建单个目录
        if (myDir.mkdirs()){
            System.out.println("目录创建成功！");
        }else{
            System.out.println("目录创建失败！");
        }

        File file1 = new File("./H/E/L/L/O");
        //创建单个目录的方式不能创建多级目录的
//        if (file1.mkdir()){
        if (file1.mkdirs()){
            System.out.println("多级目录创建成功~");
        }else{
            System.out.println("多级目录创建失败~");
        }
    }
}

# 1.4 - File 类的常用功能

方法名 说明
boolean isDirectory() 判断一个 File 对象指向的是否是一个目录
boolean isFile() 判断一个 File 对象指向的是否是一个文件
boolean exists() 判断一个 File 对象指向的文件或目录是否存在，存在则返回 true
String getAbsolutePath() 获取 File 对象指向的文件或目录的绝对路径
String getPath() 获取创建 File 对象时候使用的路径和文件名
String getName() 获取创建 FIle 对象的文件名
String getParent（） 获取创建 File 对象所在的目录名
File[] listFiles() 获取 File 对象中所有的文件（File 对象形式）
long lastModified() 获取到 File 对象中文件最后被修改的时间 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
import java.io.File;
import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * @author ly_smith
 * @Description #TODO  File类中的常用功能
 */
public class Demo04 {
    public static void main(String[] args) {
        //先构造一些File对象与目录或文件向关联
        File file = new File("./");
        File file1 = new File("./a.txt");
        File file2 = new File("./myTest.txt");
        File file3 = new File("./myDir");

        //判断是否是目录
        System.out.println(file.isDirectory());//true
        System.out.println(file1.isDirectory());
        System.out.println(file2.isDirectory());
        System.out.println(file3.isDirectory());//true
        System.out.println("----------------------------------------------");
        //判断是否是文件
        System.out.println(file.isFile());//false
        System.out.println(file1.isFile());//false,因为文件不存在，所以并不能确定是文件
        System.out.println(file2.isFile());//true
        System.out.println(file3.isFile());//false
        System.out.println("----------------------------------------------");
        //判断是否存在
        System.out.println(file.exists());
        System.out.println(file1.exists());//false
        System.out.println(file2.exists());
        System.out.println(file3.exists());
        System.out.println("----------------------------------------------");
        //获取绝对路径
        System.out.println(file.getAbsolutePath());
        System.out.println(file1.getAbsolutePath());
        System.out.println(file2.getAbsolutePath());
        System.out.println(file3.getAbsolutePath());
        System.out.println("----------------------------------------------");
        //获取相对路径，会根据构造FIle对象时参数决定的
        System.out.println(file.getPath());
        System.out.println(file1.getPath());
        System.out.println(file2.getPath());
        System.out.println(file3.getPath());
        System.out.println("----------------------------------------------");
        //获取文件后目录名
        System.out.println(file.getName());
        System.out.println(file1.getName());
        System.out.println(file2.getName());
        System.out.println(file3.getName());
        System.out.println("----------------------------------------------");
        //获取当前文件所在的目录
        System.out.println(file.getParent());
        System.out.println(file1.getParent());
        System.out.println(file2.getParent());
        System.out.println(file3.getParent());
        System.out.println("----------------------------------------------");
        //listFiles，查看目录中的所有文件
        File[] files = file.listFiles();
        for (int i = 0; i < files.length; i++) {
            System.out.println(files[i]);
        }

        System.out.println("----------------------------------------------");
        //获取文件最后被修改的时间
        Date date = new Date(file2.lastModified());//将long的毫秒数构造成Date对象
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//构造格式化输出的对象
        String format = sdf.format(date);//将date对象按照调用对象的格式进行格式化输出，并以字符串形式返回
        System.out.println(format);
    }
}

# 1.5 - File 类的删除功能

方法名 说明
boolean delete() 删除文件或（空）目录 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
import java.io.File;

/**
 * @author ly_smith
 * @Description #TODO  File类的删除功能
 */
public class Demo05 {
    public static void main(String[] args) {
//        File file = new File("./a.txt");//构造一个不存在的文件对象
//        File file = new File("./myTest.txt");//构造一个存在的文件
//        File file = new File("./myDir");//构造一个存在的空目录
        File file = new File("./H");//构造了一个多级目录的

        //删除文件之前需要先判断文件是否存在
        if(file.exists()){
            if (file.delete()){
                System.out.println(file.getName() + "删除成功！");
            }else{
                System.out.println(file.getName() + "删除失败！");
            }
        }else{
            System.out.println(file.getName() + "不存在！");
        }
    }
}

# 1.6 - 目录的递归删除

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
import java.io.File;

/**
 * @author ly_smith
 * @Description #TODO  目录的递归删除
 */
public class Demo06 {
    public static void main(String[] args) {
        final String SRC = "./H";//被删除的目录存储成常量
        File file = new File(SRC);//构造File对象，与H目录相关联
        delDir(file);//调用方法删除H多级目录
    }

    /**
     * 递归删除目录
     * @param file 要删除的File对象
     */
    private static void delDir(File file) {//H
        //获取当前目录中的文件列表
        File[] files = file.listFiles();
        //判断数组的长度，可以直到目录中是否有内容，如果没有则直接删除
        if(files.length > 0){//有内容，则遍历内部文件对象
            for (int i = 0; i < files.length; i++) {
                if(files[i].isDirectory()){//遍历文件中的对象，并判断是否是目录
                    delDir(files[i]);//如果是目录，需要在调用递归，打开并查看目录
                }else{
                    files[i].delete();//如果是文件可以直接删除文件
                }
            }
        }
        file.delete();//如果没有内容则之间删除目录即可
    }
}

# 1.7 - 修改文件后缀名

  • 将指定目录下的所有文件后缀名为 txt 统一修改成 md 为结尾的文件。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
import java.io.File;

/**
 * @author ly_smith
 * @Description #TODO 将指定目录下的所有文件后缀名为txt统一修改成md为结尾的文件
 */
public class Demo07 {
    public static void main(String[] args) {
        File file = new File("./dir");//构造file对象与dir目录相关联
        renameFile(file);
    }

    private static void renameFile(File file) {
        if(file.exists()){//判断file对象指向的目录是否存在
            //取出dir目录中的所有内容，一file对象形式返回
            File[] files = file.listFiles();
            for (File f : files) {//遍历数组中的文件
                if(f.isFile()){//判断是否是文件
                    if(f.getName().endsWith("txt")){//判断文件名是否以txt为结尾
                        String parent = f.getParent();//当前文件所在的目录名
                        String name = f.getName();//获取当前文件名

                        //修改文件后缀名  name  abc.txt
                        String newName = name.substring(0, name.lastIndexOf(".")) + ".md";
                        File file1 = new File(parent, newName);//将新的文件名构造成file对象
                        f.renameTo(file1);//使用renameTo方式实现文件重命名
                    }
                }else{
                    renameFile(f);//如果是目录就递归调用自己
                }
            }
        }
    }
}

思考题

递归实现查看指定目录中的所有文件以及目录的绝对路径

# 2 - I/O 字节流

# 2.1 - I/O 分类

I/O : Input (输入) / Output (输出)

流：是一种抽象的概念，表示数据传输的总称，就是说数据在设备之间的传输称之为流，流的本质就是传输

  • 根据数据的流向

    • 输入流：读数据
    • 输出流：写数据

站在内存的角度，以内存为基准去理解

  • 根据数据类型

    • 字节流（万能流）：所有通过文本编译器打开之后看不懂的都是字节流

      • 字节输入流
      • 字节输出流

    • 字符流：通过文本编译器打开之后能看懂的都是字符流

      • 字符输入流
      • 字符输出流

# 2.2 - 字节流写数据

  • OutputStream - 字节输出流
方法名 说明
FileOutputStream(String name) 根据参数指定的路径来构造对象并关联起来
FileOutputStream(String name,boolean append) 以追加的方式构造对象
void write(int b) 用于将参数指定的单个字节写入到输出流中
void write(byte[] bytes) 用于将参数指定的字节数组内容全部写入到输出流中
void write(byte[] bytes, int off , int len) 用于将数组中的一部分内容写入到输出流中
void close() 关闭流并释放资源 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

/**
 * @author ly_smith
 * @Description #TODO  字节流写数据
 */
public class Demo02 {
    public static void main(String[] args) throws IOException {
        FileOutputStream fos = new FileOutputStream("./myTest.txt");//构造字节输出流对象,覆盖写
//        FileOutputStream fos = new FileOutputStream("./myTest.txt",true);//构造字节输出流对象,追加写

        //一次写一个字节，通过字符编码写入文件
//        fos.write(65);
//        fos.write(66);
        //将26个英文字母写入到文件中
//        for (int i = 0; i < 26; i++) {
//            fos.write(65 + i);
//        }

        //写整个byte数组
//        byte[] bytes = {97,98,99,100,101,102,103};
//        fos.write(bytes);

        //写byte数组中的一部分内容
        byte[] bytes = "123456789腾讯".getBytes();
        //参数二：表示起始位置，参数三：表示写多长的数据
        fos.write(bytes,5,7);
        fos.close();//关闭流

        //在不同的编码格式下，中文占用的字节数是不同的
        //在UTF-8编码格式下，一个中文使用3个字节来表示
        //在GBK编码格式下，一个中文使用2个字节来表示
    }
}

# 2.3 - 字节流异常处理

  • 抛出去 或者 try、catch
  • 通过 finally 来 close
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

/**
 * @author ly_smith
 * @Description #TODO   字节流异常处理
 */
public class Demo03 {
    public static void main(String[] args) {
        FileOutputStream fos = null;//构造字节输出流对象,覆盖写
        try {
            fos = new FileOutputStream("./myTest.txt");
            //写byte数组中的一部分内容
            byte[] bytes = "123456789腾讯".getBytes();
            //参数二：表示起始位置，参数三：表示写多长的数据
            fos.write(bytes,5,7);
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                fos.close();//关闭流
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

# 2.4 - 字节流读数据

  • InputStream - 字节输入流
方法名 说明
FileInputStream(File file) 根据参数指定的 File 对象来构造字节输入流对象
FileInputStream(String name) 根据参数指定的字符串来构造字节输入流对象
int read() 用于从输入流中读取单个的字节数据
int read(byte[] bytes) 用于从输入流中读取数组长度个字节数组
int read(byte[] bytes , int off ,int len) 用于从输入流中读取数组中一部分内容
void close() 关闭流并释放资源 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
import java.io.FileInputStream;
import java.io.IOException;

/**
 * @author ly_smith
 * @Description #TODO  字输入流读数据
 */
public class Demo04 {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("./myTest.txt");//创建字节输入流对象

        //一次读取一个字节，返回的是字符编码
//        int by = fis.read();
//        //如果读到了-1 ，说明文件中有效的内容已经读完了。
//        System.out.println((char) by);

        //循环的方式读取单个字节
//        int by;//用来存储字符编码
//        while ((by = fis.read()) != -1){//如果没有数据可读了，则会返回-1
//            System.out.println((char)by);
//        }

        //一次读取一个数组
        byte[] bytes = new byte[1024];//创建一个数组来存储读取到的数据
        int len;//用来存储读取到的数据的实际长度
//        len = fis.read(bytes);
//        //将byte数组转换成字符串并打印输出
//        System.out.println(new String(bytes,0,len));

        //循环的方式一次读取一个数组
        while ((len = fis.read(bytes)) != -1){
            System.out.println(new String(bytes,0,len));
        }

        fis.close();//关闭流并释放资源
    }
}
  • 字节流一次读写一个字节
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

/**
 * @author ly_smith
 * @Description #TODO  字节流一次读写一个字节
 */
public class Demo05 {
    public static void main(String[] args) throws IOException {
        //创建字节输入/输出流对象
        FileInputStream fis = new FileInputStream("./myTest.txt");
        FileOutputStream fos = new FileOutputStream("./newTest.txt");

        //读写操作
        int by;//存储字符编码
        while ((by = fis.read()) != -1){//第一个字节
            fos.write(by);//通过输出流写到关联的文件中
        }

        //关闭流
        fis.close();
        fos.close();
    }
}
  • 复制图片
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

/**
 * @author ly_smith
 * @Description #TODO  复制图片
 */
public class Demo06 {
    public static void main(String[] args) throws IOException {
        //创建字节输入输出流对象
        FileInputStream fis = new FileInputStream("./pic.png");
        FileOutputStream fos = new FileOutputStream("./newPic.png");

        //使用单个字节来赋值图片
//        int by;
//        while ((by = fis.read()) != -1){//读一个字节
//            fos.write(by);//写一个字节
//        }

        //使用一次读写一个数组
        byte[] bytes = new byte[1024];//计算机中的单位进制位是1024
        int len;//用来存储数组中读取到的实际数据的长度
        while ((len = fis.read(bytes)) != -1){//读一个数组
            fos.write(bytes,0,len);//写一个数组
        }

        //关闭流
        fis.close();
        fos.close();
    }
}

# 3 - I/O 字符流

# 3.1 - 字符输出流写数据

  • OutputStreamWriter`
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;

/**
 * @author ly_smith
 * @Description #TODO  字符流写数据
 */
public class Demo01 {
    public static void main(String[] args) throws IOException {
        //构造字符输出流对象
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("./myTest.txt"));//覆盖写
//        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("./myTest.txt",true));//追加写

        //写一个字符
//        osw.write(65);
//        osw.write('Z');

        //写一个字符串
//        osw.write("你好，JavaSE！");
//        osw.write("1234567890",2,6);//写字符串中一部分内容，参数二：起始位置  参数三：写数据的长度

        //写一个字符数组
        char[] chs = {'a','b','c','d','e','f','g'};
//        osw.write(chs);//写一整个char数组
        osw.write(chs,4,2);

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

# 3.2 - 字符输入流读数据

  • InputStreamReader
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;

/**
 * @author ly_smith
 * @Description #TODO  字符输入流读数据
 */
public class Demo02 {
    public static void main(String[] args) throws IOException {
        //构造字符输入流对象
        InputStreamReader isr = new InputStreamReader(new FileInputStream("./myTest.txt"));

        //使用循环，一次读取一个字符
//        int ch;//用来存储字符编码
//        while ((ch = isr.read()) != -1){
//            System.out.print((char) ch);
//        }

        //一次读取一个数组
        char[] chs = new char[1024];
        int len;
        while ((len = isr.read(chs)) != -1){
            System.out.println(new String(chs,0,len));
        }

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

# 3.3 - 字符流的文本拷贝

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
import java.io.*;

/**
 * @author ly_smith
 * @Description #TODO  字符流的文本拷贝
 */
public class Demo03 {
    public static void main(String[] args) throws IOException {
        //构造字符输入输出流对象
        InputStreamReader isr = new InputStreamReader(new FileInputStream("./myTest.txt"));
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("./newTest.txt"));

        //一次读写单个字符
//        int ch;//存储字符编码
//        while ((ch = isr.read()) != -1) {//读一个字符
//            osw.write(ch);//写一个字符
//        }

        //一次读写单个字符数组
        char[] chs = new char[1024];
        int len;//存储读取到的数据的长度
        while ((len = isr.read(chs)) != -1){//读一个数组
            osw.write(chs,0,len);//写个一个数组
        }

        //关闭流
        isr.close();
        osw.close();
    }
}

# 3.4 - 字符流的简化写法

FileReader FileWriter

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
import java.io.*;

/**
 * @author ly_smith
 * @Description #TODO  字符流的简化写法
 */
public class Demo04 {
    public static void main(String[] args) throws IOException {
        //字符流的正常写法
//        InputStreamReader isr = new InputStreamReader(new FileInputStream("./a.txt"));
//        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("./a.txt"));
        //通过简化方式构造字符输出输入流对象
        FileReader fr = new FileReader("./myTest.txt");
        FileWriter fw = new FileWriter("./newTest.txt");

        //一次读写一个字符
//        int ch;
//        while ((ch = fr.read()) != -1){//读一个字符
//            fw.write(ch);//写一个字符
//        }

        //一次读写一个数组
        char[] chs = new char[1024];
        int len;
        while ((len = fr.read(chs)) != -1){//读一个数组
            fw.write(chs,0,len);//写一个数组
        }

        //关闭流
        fr.close();
        fw.close();
    }
}

# 3.5 - 缓冲区高效读写

方法名 说明
BufferedReader(Reader reader) 根据参数构造缓冲区字符输入流对象
BufferedWriter(Writer writer) 根据参数构造缓冲区字符输出流对象

  • 缓冲区字符流特有方法

    • BufferedWriter - void newLine() 插入换行符

      - void flush() 刷新输出流

    • BufferedReader - String readLine() 读取一行

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
import java.io.*;

/**
 * @author ly_smith
 * @Description #TODO  缓冲区高效读写
 */
public class Demo05 {
    public static void main(String[] args) throws IOException {
        //构造缓冲区字符输入流对象
//        BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("./myTest.txt")));
        //构造缓冲区字符输出流对象
//        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("./newTest.txt")));

        //简单方法
        BufferedReader br = new BufferedReader(new FileReader("./myTest.txt"));
        BufferedWriter bw = new BufferedWriter(new FileWriter("./newTest.txt"));

        String line;//用来存储读取出来的一行数据的
        while ((line = br.readLine()) != null){//如果读不到数据说明读到了文件的末尾，并且返回null
            bw.write(line);//写一行
            bw.newLine();//换一行
            bw.flush();//刷新流
        }

        //关闭流
        br.close();
//        bw.close();//释放资源的同时，也会有刷新流的动作
    }
}

# 4 - 标准输入 / 输出 / 错误流

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
import java.io.*;
import java.util.Scanner;

/**
 * @author ly_smith
 * @Description #TODO  标准输入流  System.in
 */
public class Demo06 {
    public static void main(String[] args) throws IOException {
//        String line = new Scanner(System.in).nextLine();
//        System.out.println(line);

//        InputStream in = System.in;//字节流
//        InputStreamReader isr = new InputStreamReader(in);//字符流
//        BufferedReader br = new BufferedReader(isr);//将普通字符流包装成缓冲区字符输入流

        //自己将标准输入流封装成缓冲区字符输入流
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        //创建缓冲区字符输出流对象与文件向关联
        BufferedWriter bw = new BufferedWriter(new FileWriter("./myTest.txt"));

        String str;
        while (true){
            if((str = br.readLine()).equals("over")){
                break;//退出循环
            }

            bw.write(str);//写一行
            bw.newLine();//插入换行符
            bw.flush();//刷新流
        }

        //关闭流
        br.close();
        bw.close();
    }
}
  • System.out
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.PrintStream;

/**
 * @author ly_smith
 * @Description #TODO  标准输出流  System.out
 */
public class Demo07 {
    public static void main(String[] args) throws IOException {
        System.out.println("正常打印");

        PrintStream out = System.out;//字节流
        //字节通过缓冲区字符流封装的标准输出流
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));

        bw.write("Hello JavaSE!");

        bw.close();//关闭流，刷新流
    }
}
  • System.err
1
2
3
4
5
6
7
8
9
10
11
12
/**
 * @author ly_smith
 * @Description #TODO  标准错误流  System.err
 */
public class Demo08 {
    public static void main(String[] args) {
        System.out.println("标准输出流");
        System.err.println("标准错误流");//输出优先级高于普通输出流，但并不绝对，

        //尝试着自己封装
    }
}

# 5 - 对象的持久化存储

# 5.1 - 通过之前学过的知识去做对象的持久化存储

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
import java.io.*;

/**
 * @author ly_smith
 * @Description #TODO  通过之前学过的知识完成对象的持久化存储的工作
 */
public class Demo01 {
    public static void main(String[] args) throws IOException {
//        mySave();//存对象中的内容

        Student newStu = myLoad();//加载对象
        System.out.println(newStu);
    }

    /**
     * 将文件中的对象信息加载出来
     * @return
     */
    private static Student myLoad() throws IOException {
        //构造缓冲区字符输入流对象
        BufferedReader br = new BufferedReader(new FileReader("./myTest.txt"));
        String str = br.readLine();//  Andy##18
        //拆分字符串
        String[] sp = str.split("##"); // sp[0]:姓名  sp[1]:年龄

        br.close();//关闭流并释放资源

        //将学生信息组成新的学生对象并进行返回
        return new Student(sp[0],Integer.parseInt(sp[1]));
    }

    /**
     * 将一个自定义的对象存储到文件中
     */
    private static void mySave() throws IOException {
        Student stu = new Student("Andy", 18);//构造学生对象
        //自己封装一个缓冲区字符输出流对象
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("./myTest.txt")));

        //将学生姓名和年龄分别取出后写入到文件中
        bw.write(stu.getName() + "##" + stu.getAge());

        bw.close();//关闭流并释放资源
    }
}

# 5.2 - 对象的序列化操作

方法名 说明
ObjectOutputStream(OutputStream out) 通过参数构造序列化对象（写）
ObjectInputStream(InputStream in) 通过参数构造反序列化对象（读） 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
import java.io.*;

/**
 * @author ly_smith
 * @Description #TODO  使用对象的序列化工具进行对象的存取
 */
public class Demo02 {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
//        Student stu = new Student("Bob", 21);//构造学生对象
//        //使用序列化（串行化）将学生对象写入到文件中
//        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("./myTest.txt"));
//
//        //写学生对象
//        oos.writeObject(stu);
//
//        oos.close();//关闭流

        System.out.println("-------------------------------------");

        //使用反序列化（反串行化）将文件中的学生对象加载到内存中来
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("./myTest.txt"));

        Student newStu = (Student) ois.readObject();

        System.out.println(newStu);

        ois.close();//关闭流并释放资源
    }
}
JavaSe
#JavaSe #IO流
JavaSe基础---IO流
https://rofgd.github.io/2020/05/11/JavaSe基础---IO流/
作者
ReadPond
发布于
2020年5月11日
许可协议