Java-IO流


前言

哈喽!大家好,我是小简。今天开始学习《Java-IO流》,此系列是我做的一个 “Java 从 0 到 1 ” 实验,给自己一年左右时间,按照我自己总结的 Java-学习路线,从 0 开始学 Java 知识,并不定期更新所学笔记,期待一年后的蜕变吧!<有同样想法的小伙伴,可以联系我一起交流学习哦!>

小简目前研一,每天都有很多课程,另外还有科研的压力,只能利用空余时间更新文章,目前的安排是每天学习一点 Java 基础知识,正所谓基础不牢,地动山摇,一起加油吧✊。

  • 🚩时间安排:预计一周更新完
  • 🎯开始时间:02-27
  • 🎉结束时间:03-03
  • 🍀总结:用时 5 天,提前两天完成任务,继续下一个 🚩

IO流简介

  • 流:数据在数据源(文件)和程序(内存)之间经历的路径

  • 输入流:数据从数据源(文件)到程序(内存)的路径

  • 输出流:数据从程序(内存)到数据源(文件)的路径

    流分类

  • 按操作数据单位不同分为

    • 字节流(8 bit) –适合操作二进制文件
    • 字符流(按字符) –适合操作文本文件
  • 按数据流的流向不同分为

    • 输入流
    • 输出流
  • 按流的角色的不同分为

    • 节点流
    • 处理流/包装流

体系图

文件操作

创建文件

  • new File(String pathname) //根据路径构建一个File对象
  • new File(File parent. String child) //根据父目录文件+子路径构建
  • new File(String parent,String child) //根据父目录+子路径构建
  • createNewFile() //文件创建
import org.junit.Test;
import java.io.File;
import java.io.IOException;

public class FileCreate {
  
    //new File(String pathname) //根据路径构建一个File对象
    @Test
    public void create01(){
        String pathname = "/Users/jianjian/Downloads/test1.txt";
        File file = new File(pathname);
        try {
            file.createNewFile();
            System.out.println("文件创建成功");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
  
    //new File(File parent. String child) //根据父目录文件+子路径构建
    @Test
    public void create02(){
        File parentFile = new File("/Users/jianjian/Downloads/");
        String fileName = "test2.txt";
        File file = new File(parentFile, fileName);
        try {
            file.createNewFile();
            System.out.println("文件创建成功");
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
  
    //new File(String parent,String child) //根据父目录+子路径构建
    @Test
    public void create03(){
        String parentFile = "/Users/jianjian/Downloads/";
        String fileName = "test3.txt";
        File file = new File(parentFile, fileName);
        try {
            file.createNewFile();
            System.out.println("文件创建成功");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

获取文件信息

  • getName() 文件名字
  • getAbsolutePath() 文件绝对路径
  • file.getParent() 文件父级目录
  • file.length() 文件大小(字节)
  • file.exists() 文件是否存在
  • file.isFile() 是不是一个文件
  • file.isDirectory() 是不是一个目录
import org.junit.Test;
import java.io.File;

public class FileInfomation {
    //获取文件的信息
    @Test
    public void info() {
        //先创建文件对象
        File file = new File("/Users/jianjian/Downloads/test.txt");
        //调用相应的方法,得到对应信息
        System.out.println("文件名字=" + file.getName());
        System.out.println("文件绝对路径=" + file.getAbsolutePath());
        System.out.println("文件父级目录=" + file.getParent());
        System.out.println("文件大小(字节)=" + file.length());//中文字符3个字节,英文字符1个字节
        System.out.println("文件是否存在=" + file.exists());//T
        System.out.println("是不是一个文件=" + file.isFile());//T
        System.out.println("是不是一个目录=" + file.isDirectory());//F
    }
}

目录操作

  • mkdir() 创建一级目录

  • mkdirs() 创建多级目录

  • delete() 删除空目录或文件

实例:

  1. 判断 /Users/jianjian/Downloads/test.txt 文件是否存在,如果存在就删除。
  2. 判断 /Users/jianjian/Downloads/test 目录是否存在,如果存在就提示已经存在,否则就创建。
  3. 判断 /Users/jianjian/Downloads/test/a/b 目录是否存在,如果存在就提示已经存在,否则就创建。
import org.junit.Test;
import java.io.File;

public class Directory_ {

    //1) 判断 /Users/jianjian/Downloads/test.txt 文件是否存在如果存在就删除。
    @Test
    public void Q1(){
        String fileName = "/Users/jianjian/Downloads/test.txt";
        File file = new File(fileName);
        if (file.exists()) {
            System.out.println(file.getName()+"文件存在");
            if (file.delete()) {
                System.out.println(file.getName()+"删除成功");
            }
        } else {
            System.out.println(file.getName()+"文件不存在");
        }
    }

    //2) 判断 /Users/jianjian/Downloads/test 目录是否存在,如果存在就提示已经存在,否则就创建。
    @Test
    public void Q2(){
        String fileName = "/Users/jianjian/Downloads/test";
        File file = new File(fileName);
        if (file.exists()) {
            System.out.println(file.getName()+"文件存在");
        } else{
            System.out.println(file.getName()+"文件不存在");
            if (file.mkdir()) {
                System.out.println(file.getName()+"文件创建成功");
            } else{
                System.out.println(file.getName()+"文件创建失败");
            }
        }
    }

    //3) 判断 /Users/jianjian/Downloads/test/a/b  目录是否存在,如果存在就提示已经存在,否则就创建。
    @Test
    public void Q3(){
        String fileName = "/Users/jianjian/Downloads/test/a/b";
        File file = new File(fileName);
        if (file.exists()) {
            System.out.println(file.getName()+"文件存在");
        } else{
            System.out.println(file.getName()+"文件不存在");
            if (file.mkdirs()) {
                System.out.println(file.getName()+"文件创建成功");
            } else{
                System.out.println(file.getName()+"文件创建失败");
            }
        }
    }
}

字节流

FileInputStream

  • read() //单字节读取
  • read(byte[] b) //多字节读取

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

单字节读取

import org.junit.Test;
import java.io.FileInputStream;
import java.io.IOException;

public class FileInputStream_ {
    @Test
    public void readFile01() {
        String filePath = "/Users/jianjian/Downloads/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();
            }
        }
    }
}

多字节读取

import org.junit.Test;
import java.io.FileInputStream;
import java.io.IOException;

public class FileInputStream_ {
    @Test
    public void readFile02() {
        String filePath = "/Users/jianjian/Downloads/hello.txt";
        int readLen = 0;
        byte[] buf = new byte[8];//一次读取8个字节.
        FileInputStream fileInputStream = null;
        try {
            //创建FileInputStream 对象,用于读取文件
            fileInputStream = new FileInputStream(filePath);
            //从该输入流读取最多b.length 字节的数据到字节数组。
            //如果返回-1 , 表示读取完毕
            //如果读取正常, 返回实际读取的字节数
            while ((readLen = fileInputStream.read(buf)) != -1) {
                System.out.print(new String(buf,0,readLen));
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //关闭文件流,释放资源.
            try {
                fileInputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

FileOutputStream

  • 创建方式
  • new FileOutputStream(filePath) //当写入内容时,会覆盖原来的内容
  • new FileOutputStream(filePath, true) //当写入内容时,是追加到原来的内容后面
  • 写入方式
    • write(byte[] b); //单字节写入
    • write(byte[] b, int off, int len) //将 len字节从位于偏移量off 的指定字节数组写入此文件输出流

例子1🌰:请使用 FileOutputStream 在 a.txt 文件中写入 “hello,world”, 如果文件不存在,会创建文件(注意:前提是目录已经存在)

package com.jwt.outputstream_;

import org.junit.Test;

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

public class FileOutputStream_ {

    @Test
    public void writeFile01(){
        String filePath = "/Users/jianjian/Downloads/a.txt";
        FileOutputStream fileOutputStream = null;
        try {
            fileOutputStream = new FileOutputStream(filePath);//覆盖
            fileOutputStream.write('J');
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    @Test
    public void writeFile02(){
        String filePath = "/Users/jianjian/Downloads/a.txt";
        FileOutputStream fileOutputStream = null;
        String str = "Hello,jwt";
        try {
            fileOutputStream = new FileOutputStream(filePath,true);//追加
            //str.getBytes() 可以把字符串-> 字节数组
            fileOutputStream.write(str.getBytes());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    @Test
    public void writeFile03(){
        String filePath = "/Users/jianjian/Downloads/a.txt";
        FileOutputStream fileOutputStream = null;
        String str = "Hello,jwt";
        try {
            fileOutputStream = new FileOutputStream(filePath);
            fileOutputStream.write(str.getBytes(), 0, str.length());
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}

例子1🌰:编程完成图片的拷贝,将 /Users/jianjian/Downloads/a.jpg 拷贝到 /Users/jianjian/Downloads/test/a.jpg,即输入流和输出流同时使用

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

public class FileCopy {
    public static void main(String[] args) {
        String srcFilePath = "/Users/jianjian/Downloads/a.jpeg";
        String destFilePath = "/Users/jianjian/Downloads/test/a.jpeg";
        FileInputStream fileInputStream = null;
        FileOutputStream fileOutputStream = 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("拷贝ok~");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                //关闭输入流和输出流,释放资源
                if (fileInputStream != null) {
                    fileInputStream.close();
                }
                if (fileOutputStream != null) {
                    fileOutputStream.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

字符流

FileReader

  • new FileReader(File/String)
  • read():每次读取单个字符,返回该字符,如果到文件末尾返回-1
  • read(char[]):批量读取多个字符到数组,返回读取到的字符数,如果到文件末尾返回-1
  • 相关API:
    • new String(char[]):将char[]转换成String
    • new String(char[],off,len):将char[]的指定部分转换成String

例子🌰:使用 FileReader 从 hello.txt 读取内容,并显示

import org.junit.Test;
import java.io.FileReader;
import java.io.IOException;

public class FileReader_ {
    /**
     * 单个字符读取文件
     */
    @Test
    public void readFile01() {
        String filePath = "/Users/jianjian/Downloads/hello.txt";
        FileReader fileReader = null;
        int data = 0;
        try {
            //创建FileReader 对象
            fileReader = new FileReader(filePath);
            //循环读取使用read, 单个字符读取
            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() {
        String filePath = "/Users/jianjian/Downloads/hello.txt";
        FileReader fileReader = null;
        int readLen = 0;
        char[] buf = new char[8];
        try {
            //创建FileReader 对象
            fileReader = new FileReader(filePath);
            //循环读取使用read(buf), 返回的是实际读取到的字符数
            //如果返回-1, 说明到文件结束
            while ((readLen = fileReader.read(buf)) != -1) {
                System.out.print(new String(buf, 0, readLen));
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (fileReader != null) {
                    fileReader.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

FileWriter

  • 创建

    • newFileWriter(File/String):覆盖模式,相当于流的指针在首端

    • new FileWriter(File/String,true):追加模式,相当于流的指针在尾端

  • 写入

    • write(int);写入单个宇符

    • write(char[]):写入指定数组

    • write(char[],off,len):写入指定数组的指定部分

    • write (string):写入整个字符串

    • write(string,off,len):写入字符串的指定部分

  • 相关APl:

    • String类:toCharArray:将String转换成char[]
  • 注意:FileWriter使用后,必须要关闭(close)或刷新(flush),否则写入不到指定的文件!

例子🌰:使用 FileWriter 将 “Hello,World” 写入到 hello.txt 文件中

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

public class FileWriter_ {
    public static void main(String[] args) {
        String filePath = "/Users/jianjian/Downloads/hello.txt";
        //创建FileWriter 对象
        FileWriter fileWriter = null;
        char[] chars = {'a', 'b', 'c'};
        try {
            fileWriter = new FileWriter(filePath);//默认是覆盖写入
            // 1) write(int):写入单个字符
            fileWriter.write('H');
            // 2) write(char[]):写入指定数组
            fileWriter.write(chars);
            // 3) write(char[],off,len):写入指定数组的指定部分
            fileWriter.write("加油啊小简".toCharArray(), 0, 3);
            // 4) write(string):写入整个字符串
            fileWriter.write(" 你好啊~");
            // 5)write(string, off, len):写入字符串的指定部分
            fileWriter.write("一起学Java", 0, 2);
        //在数据量大的情况下,可以使用循环操作.
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //对于FileWriter , 一定要关闭流,或者flush 才能真正的把数据写入到文件
            try {
                //fileWriter.flush();
                //关闭文件流,等价flush() + 关闭
                fileWriter.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        System.out.println("程序结束...");
    }
}

节点流&处理流

  • 节点流可以从一个特定的数据源读写数据,如FileReader、 FileWriter

  • 处理流(也叫包装流)是”连接”在已存在的流(节点流或处理流)之上,为程序提供更为强大的读写功能,也更加灵活,如BufferedReader、BufferedWriter

节点流和处理流一览图

节点流和处理流区别

  • 节点流是底层流/低级流,直接跟数据源相接。
  • 处理流对节点流进行包装,使用了修饰器设计模式,不会直接与数据源相连,既可以消除不同节点流的实现差异,也可以提供更方便的方法来完成输入输出。

处理流之缓冲流

BufferedReader

使用 BufferedReader 读取文本文件,并显示在控制台

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

public class BufferedReader_ {
    public static void main(String[] args) throws IOException {
        String filePath = "/Users/jianjian/Downloads/hello.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();
    }
}

关闭流时,只需要关闭外层流(处理流)即可,因为底层会自动的去关闭节点流

BufferedWriter

使用 BufferedWriter 将 ”hello, World”,写入到文件中

package com.jwt.writer_;

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

public class BufferedWriter_ {
    public static void main(String[] args) throws IOException {
        String filePath = "/Users/jianjian/Downloads/hello.txt";
        BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(filePath,true));//以追加的方式写入
        bufferedWriter.write("Hello,World");
        bufferedWriter.newLine();//插入一个和系统相关的换行
        bufferedWriter.write("Hi,World");
        bufferedWriter.newLine();
        //关闭外层流即可, 传入的new FileWriter(filePath) ,会在底层关闭
        bufferedWriter.close();
    }
}

例子🌰:综合使用 BufferedReader 和 BufferedWriter 完成文本文件拷贝,注意文件编码

  • BufferedReader 和 BufferedWriter 是按照字符操作
  • 不要去操作二进制文件[声音,视频,doc, pdf ], 可能造成文件损坏
package com.jwt.writer_;

import java.io.*;

public class BufferedCopy_ {
    public static void main(String[] args) {
        String srcFilePath = "/Users/jianjian/Downloads/hello.txt";
        String destFilePath = "/Users/jianjian/Downloads/test/hello.txt";
        BufferedReader bufferedReader = null;
        BufferedWriter bufferedWriter = null;
        String data;
        try {
            bufferedReader = new BufferedReader(new FileReader(srcFilePath));
            bufferedWriter = new BufferedWriter(new FileWriter(destFilePath));
            //说明: readLine 读取一行内容,但是没有换行
            while ((data=bufferedReader.readLine()) != null) {
                //每读取一行,就写入
                bufferedWriter.write(data);
                //插入一个换行
                bufferedWriter.newLine();
            }
            System.out.println("拷贝完毕...");
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                //关闭流
                if (bufferedReader != null){
                    bufferedReader.close();
                }
               if (bufferedWriter != null){
                   bufferedWriter.close();
               }

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

BufferedInputStream & BufferedOutputStream

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

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

例子🌰:编程完成图片/音乐的拷贝(要求使用Buffered..流)

package com.jwt.writer_;

import java.io.*;

public class BufferedCopy02 {
    public static void main(String[] args) {
        String srcFilePath = "/Users/jianjian/Downloads/a.jpeg";
        String destFilePath = "/Users/jianjian/Downloads/test/a.jpeg";
        BufferedInputStream bufferedInputStream = null;
        BufferedOutputStream bufferedOutputStream = null;
        int data;
        try {
            bufferedInputStream = new BufferedInputStream(new FileInputStream(srcFilePath));
            bufferedOutputStream = new BufferedOutputStream(new FileOutputStream(destFilePath));
            //循环的读取文件,并写入到destFilePath
            byte[] buff = new byte[1024];
            int readLen = 0;
            //当返回-1 时,就表示文件读取完毕
            while ((readLen=bufferedInputStream.read(buff)) != -1) {
                //每读取一行,就写入
                bufferedOutputStream.write(buff,0,readLen);
            }
            System.out.println("拷贝完毕...");
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                //关闭流
                if (bufferedInputStream != null){
                    bufferedInputStream.close();
                }
                if (bufferedOutputStream != null){
                    bufferedOutputStream.close();
                }

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

处理流之对象流

对象功能:提供了对基本类型或对象类型的序列化和反序列化的方法

看一个需求

  • 1.将 int num = 100 这个 int 数据保存到文件中,注意不是 100 数字,而是 int 100,并且能够从文件中直接恢复 int 100
  • 2.将 Dog dog = new Dog(“小黄”,3) 这个 dog 对象保存到文件中,并且能够从文件恢复
  • 3.上面的要求,就是能够将基本数据类型或者对象进行序列化反序列化操作

序列化和反序列化

  • 序列化就是在保存数据时,保存数据的值和数据类型
  • 反序列化就是在恢复数据时,恢复数据的值和数据类型
  • 需要让某个对象支持序列化机制,则必须让其类是可序列化的,为了让某个类是可序列化的,该类必须实现如下两个接口之一
    • Serializable //这是一个标记接口,没有方法
    • Externalizable //该接口有方法需要实现,因此我们一般实现上面的Serializable接口

注意事项和细节说明

  • 1)读写顺序要一致
  • 2)要求序列化或反序列化对象,需要实现 Serializable 接口
  • 3)序列化的类中建议添加SerialVersionUID,为了提高版本的兼容性
  • 4)序列化对象时,默认将里面所有属性都进行序列化,但除了static或transient修饰的成员
  • 5)序列化对象时,要求里面属性的类型也需要实现序列化接口
  • 6)序列化具备可继承性,也就是如果某类已经实现了序列化,则它的所有子类也已经默认实现了序列化

ObjectOutputStream

  • ObjectOutputStream 提供序列化功能

  • 序列化对象,需要实现Serializable

例子🌰:使用 ОbjесtОutрutЅtrеаm 序列化基本数据类型和一个 Dоg 对象(nаmе, аgе), 并保存到 data.dat 文件中

package com.jwt.outputstream_;

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

public class ObjectOutStream_ {
    public static void main(String[] args) throws Exception {
        //序列化后,保存的文件格式,不是存文本,而是按照他的格式来保存
        String filePath = "/Users/jianjian/Downloads/b.dat";
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(filePath));
        //序列化数据到filePath
        oos.writeInt(100);// int -> Integer (实现了Serializable)
        oos.writeBoolean(true);// boolean -> Boolean (实现了Serializable)
        oos.writeChar('a');// char -> Character (实现了Serializable)
        oos.writeDouble(9.5);// double -> Double (实现了Serializable)
        oos.writeUTF("一定要开心啊");//String
        //保存一个dog 对象
        oos.writeObject(new Dog("旺财", 10));
        oos.close();
        System.out.println("数据保存完毕(序列化形式)");
    }
static class Dog implements Serializable {
    String name;
    int age;
    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }
}
}

ObjectInputStream

  • ObjectInputStream 提供反序列化功能
  • 反序列化对象,需要实现Serializable

例子🌰:使用 ObjectInputStream 读取 data.dat 并反序列化恢复数据

package com.jwt.inputstream_;

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

public class ObjectInputStream_ {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        // 1.创建流对象
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("/Users/jianjian/Downloads/b.dat"));
        // 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~");
    }
}

标准输入输出流

名称 类型 默认设备
System.in 标准输入流 InputStream 键盘
System.out 标准输出流 OutputStream 显示器
package com.jwt.standard;

import java.util.Scanner;

public class InputOutput {
    public static void main(String[] args) {
        //1.源码:public final static Inputstream in = null;
        //2.System.in 编译类型 Inputstream
        //3.System.in 运行类型 BufferedInputstream
        //4.表示的是标准输入 键盘
        System.out.println(System.in.getClass());
        Scanner scanner = new Scanner(System.in);
        System.out.println("输入:");
        System.out.println("输出:" + scanner.next());

        //1.源码:public final static PrintStream out = null;
        //2.编译类型 Printstream
        //3.运行类型 Printstream
        //4.表示标准输出 显示器
        System.out.println(System.out.getClass());
        System.out.println("hello,你好~");
    }
}

转换流

  • InputStreamReader:Reader的子类,可以将InputStream(字节流)包装成(转换)Reader(字符流), 它读取字节,并使用指定的字符集将其解码为字符。
  • OutputStreamWriter:Writer的子类,实现将OutputStream(字节流)包装成Writer(字符流)
  • 当处理纯文本数据时,如果使用字符流效率更高,并且可以有效解决中文问题,所以建议将字节流转换成字符流
  • 可以在使用时指定编码格式(比如utf- 8, gbk,gb2312, IS08859-1等)

InputStreamReader

例子🌰:编程将字节流 FileInputStream 包装成(转换成)字符流 InputStreamReader,对文件进行读取(按照utf-8/gbk格式),进而在包装成BufferedReader

package com.jwt.transformation;

import java.io.*;

public class InputStreamReader_ {
    public static void main(String[] args) throws IOException {
        String filePath = "/Users/jianjian/Downloads/a.txt";
        //1. 把FileInputStream 转成InputStreamReader,指定编码gbk
        InputStreamReader isr = new InputStreamReader(new FileInputStream(filePath),"gbk");
        //2. 把InputStreamReader 传入BufferedReader
        BufferedReader br = new BufferedReader(isr);
        //将1和2合在一起
        //BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream(filePath), "gbk"));
        //3. 读取
        String s = br.readLine();
        System.out.println("读取内容=" + s);
        //4. 关闭外层流
        br.close();
    }
}

OutputStreamWriter

例子🌰:编程将字节流 FileOutputStream 包装成(转换成)字符流 OutputStreamWriter,对文件进行写入(按照gbk格式,可以指定其他,比如utf-8)

package com.jwt.transformation;

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

public class OutputStreamWriter_ {
    public static void main(String[] args) throws IOException {
        // 1.创建流对象
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("/Users/jianjian/Downloads/a.txt"), "gbk");
        // 2.写入
        osw.write("hello,你好呀~");
        // 3.关闭
        osw.close();
        System.out.println("保存成功~");
    }
}

打印流

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

PrintStream

package com.jwt.transformation;

import org.junit.Test;

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

public class PrintStream_ {
    @Test
    //标准输出到屏幕
    public void write01() throws IOException {
        PrintStream printStream = new PrintStream(System.out);
        printStream.print("hello,你好");
        //printStream.write("hello,你好".getBytes());
        printStream.close();
    }
    @Test
    //修该打印流输出位置
    public void write02() throws FileNotFoundException {
        System.setOut(new PrintStream("/Users/jianjian/Downloads/a.txt"));
        System.out.println("你好呀");
    }
}

PrintWriter

package com.jwt.transformation;

import org.junit.Test;

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

public class PrintWriter_ {
    @Test
    //标准输出到屏幕
    public void write01(){
        PrintWriter printWriter = new PrintWriter(System.out);
        printWriter.print("hello,你好");
        printWriter.close();
    }

    @Test
    //输出到文件
    public void write02() throws IOException {
        PrintWriter printWriter = new PrintWriter(new FileWriter("/Users/jianjian/Downloads/a.txt"));
        printWriter.print("hello,你好");
        printWriter.close();
    }
}

Properties类

问题引出

如下一个配置文件 mysql.properties

user=root
password=12345

请问编程读取 user 和 password 的值是多少?

传统方法

package com.jwt.io.properties_;
import org.junit.Test;
import java.io.*;
import java.util.Properties;

public class Properties01 {
    //传统的方法
    @Test
    public void traditionRead() throws IOException {
        BufferedReader bufferedReader = new BufferedReader(new FileReader("src//mysql.properties"));
        String line = "";
        while ((line = bufferedReader.readLine()) != null){
            String[] split = line.split("=");
            //如果我们要求指定的值
            if("user".equals(split[0])) {
                System.out.println("用户名=" + split[1]);
            }
            if("password".equals(split[0])) {
                System.out.println("密码=" + split[1]);
            }
        }
        bufferedReader.close();
    }
}

使用Properties类

package com.jwt.io.properties_;
import org.junit.Test;
import java.io.*;
import java.util.Properties;

public class Properties01 {
    @Test
    public void propertiesRead() throws IOException {
        //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("password");
        System.out.println("用户名=" + user);
        System.out.println("密码是=" + pwd);
    }
}

Properties 介绍

Properties 是专门用于读写配置文件的集合类

  • 配置文件的格式:
键=值
键=值
  • 注意:键值对不需要有空格,值不需要用引号引起来,默认类型是String

Properties的常见方法

  • load():加载配置文件的键值对到Properties对象
  • list():将数据显示到指定设备
  • getProperty(key):根据键获取值
  • setProperty(key,value):设置键值对到Properties对象
  • store(arg0,arg1):将Properties中的键值对存储到配置文件,在idea中,保存信息到配置文件,如果含有中文,会存储为unicode码
    • 第一个参数为 OutputStream/Writer 用来指向加载的配置文件
    • 第二个参数为 String 用来给配置文件添加注释。
  • http://tool.chinaz.com/tools/unicode.aspx unicode码查询工具

例子🌰:使用 Properties 类添加 key-val 到新文件 mysql2.properties 中,再使用 Properties 类完成对 mysql2.properties 的读取,并修改某个 key-val

要点:使用Properties 类来创建配置文件, 修改配置文件内容

  • 1.如果该文件没有key就是创建

  • 2.如果该文件有key就是修改

package com.jwt.io.properties_;

import org.junit.Test;

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

public class Properties01 {
    @Test
    public void insertProperties() throws IOException {
        Properties properties = new Properties();
        //添加
        properties.setProperty("test","123");
        properties.setProperty("user", "汤姆");//保存时,是中文的unicode 码值
        properties.store(new FileWriter("src//mysql.properties2"), null);
//        properties.store(new FileOutputStream("src//mysql.properties2"),null);
        System.out.println("保存配置文件成功~");
        //读取
        Properties properties2 = new Properties();
        properties2.load(new FileReader("src//mysql.properties2"));
        properties2.list(System.out);
        //修改
        properties2.setProperty("test","456");
        properties2.store(new FileWriter("src//mysql.properties2"),"测试一下下");
        System.out.println("修改成功~");
    }
}

IO练习

1.编程题Homework01.java

  • (1)在判断是否有文件夹mytemp ,如果没有就创建mytemp
  • (2)在mytemp目录下,创建文件hello.txt
  • (3)如果hello.txt已经存在,提示该文件已经存在,就不要再重复创建了
  • (4)并且在hello.txt文件中,写入hello,world~
package com.jwt.io.homework;
import java.io.*;

public class Homework01
{
    public static void main(String[] args) throws IOException {
        String directory = "/Users/jianjian/Downloads/mytemp";
        File file = new File(directory);
        if (!file.exists()) {
            file.mkdirs();
            System.out.println("目录创建成功");
        } else {
            System.out.println("目录已存在");
        }
        String filePath = directory + "/hello.txt";
        File file2 = new File(filePath);
        if (!file2.exists()){
            file2.createNewFile();
            System.out.println("文件创建成功");
            FileWriter fileWriter = new FileWriter(filePath);
            fileWriter.write("hello,world~");
            System.out.println("文本写入成功");
            fileWriter.close();
        } else{
            System.out.println("文件已存在");
        }
    }
}

2.编程题Homework02.java

要求:使用 BufferedReader 读取一个文本文件,为每行加上行号,再连同内容一并输出到屏幕上。

  • 如果把文件的编码改成了gbk ,出现中文乱码,如何解决?
  • 1.默认是按照utf-8处理,开始没有乱码
  • 2.提示:使用转换流,将FilelnputStream -> InputStreamReader[指定编码] -> BufferedReader
package com.jwt.io.homework;

import java.io.*;

public class Homework02 {
    public static void main(String[] args){
        String filePath = "/Users/jianjian/Downloads/hello.txt";
        BufferedReader bufferedReader = null;
        String line = "";
        int linenum = 0;
        try {

            bufferedReader = new BufferedReader(new FileReader(filePath));
            while ((line = bufferedReader.readLine()) != null) {
                System.out.println(++linenum + line);
            }

            //1. 把FileInputStream转成InputStreamReader,指定编码gbk
            InputStreamReader isr = new InputStreamReader(new FileInputStream(filePath),"gbk");
            //2. 把InputStreamReader 传入BufferedReader
            BufferedReader br = new BufferedReader(isr);
            while ((line = br.readLine()) != null) {
                System.out.println(++linenum + line);
            }
            
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (bufferedReader != null) {
                try {
                    bufferedReader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

}

3.编程题Homework03.java

  • (1)编写一个 dog.properties
name=tom
age=5
color=red
  • (2)编写 Dog 类 (name,age,color) 创建一个 dog 对象,读取 dog.properties 用相应的内容完成属性初始化,并输出
  • (3)将创建的Dog对象,序列化到文件dog.dat文件
  • (4)再读取 dog.dat 并反序列化恢复数据
package com.jwt.io.homework;

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

public class Homework03 {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        Properties properties = new Properties();
        properties.load(new FileReader("src//dog.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);
        
        //将创建的Dog对象,序列化到文件dog.dat文件
        String filePath = "/Users/jianjian/Downloads/dog.dat";
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(filePath));
        oos.writeObject(dog);
        oos.close();
        System.out.println("数据保存完毕(序列化形式)");

        // 反序列化dog
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(filePath));
        System.out.println(ois.readObject());
        ois.close();

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

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

❤️Sponsor

您的支持是我不断前进的动力,如果您恰巧财力雄厚,又感觉本文对您有所帮助的话,可以考虑打赏一下本文,用以维持本博客的运营费用,拒绝白嫖,从你我做起!🥰🥰🥰

支付宝支付 微信支付

文章作者: 简简
版权声明: 本博客所有文章除特別声明外,均采用 CC BY 4.0 许可协议。转载请注明来源 简简 !
评论
填上邮箱会收到评论回复提醒哦!!!
 上一篇
牛客-SQL练习 牛客-SQL练习
小简计划 入门篇:【题数:39道题】【难度:🌟🌟| 用时:3☀️】 必会篇:【题数:50道题】【难度:🌟|用时:3☀️】 进阶篇:【题数:46道题】【难度:🌟🌟🌟|用时:7☀️】 真题篇:【题数:3
2022-02-28
下一篇 
Java-线程 Java-线程
前言哈喽!大家好,我是小简。今天开始学习《Java-线程》,此系列是我做的一个 “Java 从 0 到 1 ” 实验,给自己一年左右时间,按照我自己总结的 Java-学习路线,从 0 开始学 Java 知识,并不定期更新所学笔记,期待一年后
2022-02-22
  目录