【韩老师零基础30天学会Java 18】IO分类重要，节点流和处理流。缓冲流。对象流，序列化，反序列化，标准流，打印流，Properties

已于 2022-12-21 15:14:54 修改
阅读量143 收藏
点赞数
分类专栏： java SE 文章标签： IO分类 节点流 处理流 序列化 缓冲流
于 2022-12-21 15:14:05 首次发布
原文链接：https://www.bilibili.com/video/BV1fh411y7R8?p=685&spm_id_from=pageDriver&vd_source=b63e9afd510deaf9d2a1b680368b9935
版权

详细体系分类

字节流

  • lnputStream
    • FilelnputStream 文件输入流
    • PipedInputStream
    • **ObjectlnputStream ** 对象字节输入流
    • ByteArraylnputStream
    • SequencelnputStream
    • FilterlnputStream 过滤输入
      • BufferedlnputStream 缓冲字节输入流
      • DigestinputStream
      • DatalnputStream
  • OutputStream
    • FileOutputStream
    • PipedOutputStream
    • ObjectOutputStream
    • ByteArrayOutputStream
    • FilterOutputStream
      • BufferedOutputStream
      • DigestOutputStream
      • DataOutputStream
      • PrintStream

字符流

  • Reader 字符输入流
    • lnputStreamReader
      • FileReader
    • BufferedReader
    • CharArrayReader
    • FilterReader
    • PipedReader
    • StringReader
  • Writer 字符输出流
    • OutputStreamWriter
      • FileWriter
    • BufferedWriter
    • CharArrayWriter
    • FilterWriter
    • PipedWriter
    • PrintWriter
    • StringWriter

节点流和处理流（重要）

1.节点流可以从一个特定的数据源读写数据 如FileReader、FileWriter[源码]

  • 特定的数据源：文件 数组 管道 字符串

  • 对文件 使用字符流 操作。所以是 特定的。

  • 文件——节点流 ——程序

2.处理流(也叫包装流)是“连接”在已存在的流（节点流或处理流)之上,为程序提供
更为强大的读写功能,如BufferedReader、 BufferedWriter [源码]

  • 缓冲 转换 对象 打印 特殊（数据字节）
分类字节输入流字节输出流字符输入流字符输出流
节点流
抽象基类InputStreamOupulStreamReaderWriter
访问文件FilelnputStreamFileOutputStreamFileReaderFileWriter
访问数组ByteArrayInputStreamByteArrayOutputStreamCharArrayReaderCharArrayWriter
访问管道PipedInputStreamPipedoutputStreamPipedReaderPipedWriter
访问字符串StringReaderStringWriter
处理流 包装流装饰着模式修饰器
缓冲流BufferedInputStreamBufferedOutputStreamBufferedReadcrBufferedWriter
转换流InputStreamReaderOutputStream Writer
对象流ObjectInputStreamObjectOutputStream
抽象基类（缓冲父）FilterlnputStreamFilterOuputStreamFilterReaderFilterWriter
打印流PrintStreamPrintWriter
推回输入流PushbackInputStreamPushbackReader
特殊流DatalnputStreamDataOutputStream
public class BufferedReader extends Reader {

    private Reader in;//将来可以是：FileReader  FileWriter 或 如数组 CharArrayReader。即可以封装一个节点流。
}

节点流和处理流的区别和联系
1.节点流是底层流/低级流,直接跟数据源相接。
2.处理流包装节点流，既可以消除不同节点流的实现差异，也可以提供更方便的方法
来完成输入输出。[源码理解]
3.处理流(也叫包装流)对节点流进行包装，使用了修饰器设计模式，不会直接与数据
源相连[模拟修饰器设计模式]

处理流的功能主要体现在以下两个方面:
1.性能的提高:主要以增加缓冲的方式来提高输入输出的效率。
2.操作的便捷:处理流可能提供了一系列便捷的方法来一次输入输出大批量的数据,使
用更加灵活方便

1. 装饰（者）器

一里接单开合迪

创建型：建工抽原单

结构型：石桥组装享外贷

  • 装饰器 结构型的

行为型：责令中介叠呗观状测模仿

抽象父类
public abstract class Reader_ { //抽象类
    public void readFile() {
    }
    public void readString() {
    }

    //在Reader_ 抽象类，使用read方法统一管理.
    //后面在调用时，利于对象动态绑定机制， 绑定到对应的实现子类即可.
    //public abstract void read();
}
子类重写父类的方法
public class FileReader_ extends Reader_ {

        public void readFile() {
        System.out.println("对文件进行读取...");
    }
}

public class StringReader_ extends Reader_ {
    public void readString() {
        System.out.println("读取字符串..");
    }
}
包装 装饰类
public class BufferedReader_ extends Reader_{
	//拥有父类
    private Reader_ reader_; //属性是 Reader_类型

    //接收Reader_ 子类对象
    public BufferedReader_(Reader_ reader_) {
        this.reader_ = reader_;
    }

    //再次封装
    public void readFile() { //封装一层
        reader_.readFile();
    }
    
	//封装并 加强。
    //让方法更加灵活， 多次读取文件, 或者加缓冲byte[] ....
    public void readFiles(int num) {
        for(int i = 0; i < num; i++) {
            reader_.readFile();
        }
    }

    //扩展 readString, 批量处理字符串数据
    public void readStrings(int num) {
        for(int i = 0; i <num; i++) {
            reader_.readString();
        }
    }

}

        BufferedReader_ b1 = new BufferedReader_(new FileReader_());
        b1.readFiles(10);
        //b1.readFile();

        //Serializable
        //Externalizable
        //ObjectInputStream
        //ObjectOutputStream
        //这次希望通过 BufferedReader_ 多次读取字符串

        BufferedReader_ b2 = new BufferedReader_(new StringReader_());

        b2.readStrings(5);

2. BufferedReader 和 Writer

BufferedReader和 BufferedWriter属于字符流，是按照字待来读取数据的

关闭时处理流,只需要关闭外层流即可[后面看源码]

  • 因为本质是 内层的，关外层的时候 自动调用 内层的关闭。
  • new BufferedReader_(new FileReader_())
使用

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

		String filePath = "e:\\a.java";

        //创建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 ，因为底层会自动的去关闭 节点流
        //FileReader。
        /*
            public void close() throws IOException {
                synchronized (lock) {
                    if (in == null)
                        return;
                    try {
                        in.close();//in 就是我们传入的 new FileReader(filePath), 关闭了.
                    } finally {
                        in = null;
                        cb = null;
                    }
                }
            }

         */
        bufferedReader.close();

        String filePath = "e:\\ok.txt";
        //创建BufferedWriter
        //说明:
        //1. new FileWriter(filePath, true) 表示以追加的方式写入
        //2. new FileWriter(filePath) , 表示以覆盖的方式写入
        BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(filePath));

        bufferedWriter.write("hello, 韩顺平教育!");
        bufferedWriter.newLine();//插入一个和系统相关的换行

        bufferedWriter.write("hello2, 韩顺平教育!");
        bufferedWriter.newLine();


        //说明：关闭外层流即可 ， 传入的 new FileWriter(filePath) ,会在底层关闭
        bufferedWriter.close();
拷贝
        //1. BufferedReader 和 BufferedWriter 是安装字符操作
        //2. 不要去操作 二进制文件[声音，视频，doc, pdf ], 可能造成文件损坏
        //BufferedInputStream
        //BufferedOutputStream
        String srcFilePath = "e:\\a.java";
        String destFilePath = "e:\\a2.java";

        BufferedReader br = null;
        BufferedWriter bw = null;
        String line;
        try {
            br = new BufferedReader(new FileReader(srcFilePath));
            bw = new BufferedWriter(new FileWriter(destFilePath));

            //说明: readLine 读取一行内容，但是没有换行
            while ((line = br.readLine()) != null) {
                //每读取一行，就写入
                bw.write(line);
                //插入一个换行
                bw.newLine();
            }
            System.out.println("拷贝完毕...");

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //关闭流
            try {
                if(br != null) {
                    br.close();
                }
                if(bw != null) {
                    bw.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

3. BufferedInputStream和Out

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

父类：FilterlnputStream 过滤输入

public class BufferedInputStream extends FilterInputStream {}

class FilterInputStream extends InputStream {
    protected volatile InputStream in;
}

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

void flush () //刷新此缓冲的输出流。
拷贝

        String srcFilePath = "e:\\a.java";
        String destFilePath = "e:\\a3.java";

        //创建BufferedOutputStream对象BufferedInputStream对象
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;

        try {
            //因为 FileInputStream  是 InputStream 子类
            bis = new BufferedInputStream(new FileInputStream(srcFilePath));
            bos = new BufferedOutputStream(new FileOutputStream(destFilePath));

            //循环的读取文件，并写入到 destFilePath
            byte[] buff = new byte[1024];
            int readLen = 0;
            //当返回 -1 时，就表示文件读取完毕
            while ((readLen = bis.read(buff)) != -1) {
                bos.write(buff, 0, readLen);
            }

            System.out.println("文件拷贝完毕~~~");

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

            //关闭流 , 关闭外层的处理流即可，底层会去关闭节点流
            try {
                if(bis != null) {
                    bis.close();
                }
                if(bos != null) {
                    bos.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }

        }

4. ObjectInputStream 和 Out

  • 处理流

将int num = 100这个int数据保存到文件中,注意不是100数字，而是int 100，并且，能够从文件中直接恢复int 100

将Dog dog = new Dog(“小黄”，3)这个dog对象保存到文件中，并且能够从文供灰复.

上面的要求，就是能够将基本数据类型或者对象进行序列化和反序列化操作

序列化和反序列化
1.序列化就是在保存数据时,保存数据的值和数据类型

2.反序列化就是在恢复数据时，恢复数据的值和数据类型

3．需要让某个对象支持序列化机制，则必须让其类是可序列化的，为了让某个类是可序列化的，该
类必须实现如下两个接口之一:
Serializable/这是一个标记接口

Externalizable

public interface Serializable {
}

//该接口有方法需要实现,因此我们一般实现上面的
public interface Externalizable extends java.io.Serializable {}

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

  2. ObjectOutputStream 提供序列化功能

  3. ObjectlnputStream 提供反序列化功能

序列化
        //序列化后，保存的文件格式，不是存文本，而是按照他的格式来保存
        String filePath = "e:\\data.dat";

        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(filePath));

        //序列化数据到 e:\data.dat
        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("数据保存完毕(序列化形式)");
序列化的类
//如果需要序列化某个类的对象，实现 Serializable
public class Dog implements Serializable {
    private String name;
    private int age;
    
    
    //序列化对象时，默认将里面所有属性都进行序列化，但除了static或transient修饰的成员
    private static String nation;
    private transient String color;
    
    //序列化对象时，要求里面属性的类型也需要实现序列化接口
    private Master master = new Master();

    //serialVersionUID 序列化的版本号，可以提高兼容性。如果加了一个属性（认为是升级版），不会认为是新的类
    private static final long serialVersionUID = 1L;

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

    @Override
    public String toString() {}
    
    //get set
}

transient
adj.
转瞬即逝的，短暂的；暂住的，（工作）临时的
反序列化
        //指定反序列化的文件
        String filePath = "e:\\data.dat";

        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(filePath));

        //读取
        //老师解读
        //1. 读取(反序列化)的顺序需要和你保存数据(序列化)的顺序一致
        //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());


        //dog 的编译类型是 Object , dog 的运行类型是 Dog
        Object dog = ois.readObject();
        System.out.println("运行类型=" + dog.getClass());
        System.out.println("dog信息=" + dog);//底层 Object -> Dog

        //这里是特别重要的细节:

        //1. 如果我们希望调用Dog的方法, 需要向下转型
        //2. 需要我们将Dog类的定义，放在到可以引用的位置
        //序列化 和 反序列化的 Dog 类，要是 同一个。
        Dog dog2 = (Dog) dog;
        System.out.println(dog2.getName()); //旺财..

        //关闭流, 关闭外层流即可，底层会关闭 FileInputStream 流
        ois.close();

注意事项和细节说明

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

Integer 的父类 Number 实现了 序列化的 接口。
public abstract class Number implements java.io.Serializable {}

5. 标准输入 输出流

System.in 标准输入

System.out 标准输出

类型：

标准输入是 lnputStream 真正的为包装类：BufferedInputStream

标准输出 PrintStream

默认设备

键盘

显示器

public final class System {
    
    public final static InputStream in = null;
    
    public final static PrintStream out = null;
}

        //System 类 的 public final static InputStream in = null;
        // System.in 编译类型   InputStream
        // System.in 运行类型   BufferedInputStream
        // 表示的是标准输入 键盘
        System.out.println(System.in.getClass());//class java.io.BufferedInputStream

        //老韩解读
        //1. System.out public final static PrintStream out = null;
        //2. 编译类型 PrintStream
        //3. 运行类型 PrintStream
        //4. 表示标准输出 显示器
        System.out.println(System.out.getClass());//class java.io.PrintStream

        System.out.println("hello, 韩顺平教育~");

        Scanner scanner = new Scanner(System.in);
        System.out.println("输入内容");
        String next = scanner.next();
        System.out.println("next=" + next);

6. 转换流

InputStreamReader 和 OutputStreamWriter

字节流 ——转为——字符流

  • 字节流 可以指定编码的格式
  1. InputStreamReader:Reader的子类,
    可以将InputStream(字节流)包
    装成Reader(字符流)
  2. 用的是 字节流 按照 字符方式 处理的。
  3. 从类的继承关系来说叫包装，达到的效果来说，叫转换。
  4. OutputStreamWriter:Writer的子类,
    实现将OutputStream(字节流)
    包装成Writer(字符流)
  5. 当处理纯文本数据时，如果使用字符流效率更高，并且可以有效解决中文
    问题,所以建议将字节流转换成字符流
  6. 可以在使用时指定编码格式(比如utf-8,
    gbk , gb2312, ISO8859-1等)
    1. 繁体中文 big5码
public class InputStreamReader extends Reader {
    
    //构造
	public InputStreamReader(InputStream in, String charsetName)
        throws UnsupportedEncodingException
    {
        super(in);
        if (charsetName == null)
            throw new NullPointerException("charsetName");
        sd = StreamDecoder.forInputStreamReader(in, this, charsetName);
    }
    
 }


public class OutputStreamWriter extends Writer {

    public OutputStreamWriter(OutputStream out, String charsetName)
        throws UnsupportedEncodingException
    {
        super(out);
        if (charsetName == null)
            throw new NullPointerException("charsetName");
        se = StreamEncoder.forOutputStreamWriter(out, this, charsetName);
    }
}
乱码问题
  • 如果把 a.txt改为 ansi （根据系统选择，中文系统变成了gbk）编码，则会乱码
        //读取e:\\a.txt 文件到程序
        //思路
        //1.  创建字符输入流 BufferedReader [处理流]
        //2. 使用 BufferedReader 对象读取a.txt
        //3. 默认情况下，读取文件是按照 utf-8 编码
        String filePath = "e:\\a.txt";
        BufferedReader br = new BufferedReader(new FileReader(filePath));

        String s = br.readLine();
        System.out.println("读取到的内容: " + s);
        br.close();

        //InputStreamReader
        //OutputStreamWriter
自定义编码读取
  • 注意使用 缓冲流 包裹 InputStreamReader
        String filePath = "e:\\a.txt";
        //解读
        //1. 把 FileInputStream 转成 InputStreamReader
        //2. 指定编码 gbk
        //InputStreamReader isr = new InputStreamReader(new FileInputStream(filePath), "gbk");
        //3. 把 InputStreamReader 传入 BufferedReader
        //BufferedReader br = new BufferedReader(isr);

        //将2 和 3 合在一起
        BufferedReader br = new BufferedReader(new InputStreamReader(
                                                    new FileInputStream(filePath), "gbk"));

        //4. 读取
        String s = br.readLine();
        System.out.println("读取内容=" + s);
        //5. 关闭外层流
        br.close();
OutputStreamWriter
* 把FileOutputStream 字节流，转成字符流 OutputStreamWriter
* 指定处理的编码 gbk/utf-8/utf8

        String filePath = "e:\\hsp.txt";
        String charSet = "utf-8";
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(filePath), charSet);
        osw.write("hi, 韩顺平教育");
        osw.close();

7. PrintStream 和 Writer

打印流-PrintStream 字节流 和 PrintWriter 字符流

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

  • 不仅能打印到显示器，还能打印到文件。

    PrintStream(File)

PrintStream(boolean, OutputStream, Charset)
    
PrintWriter(File)
PrintWriter(Charset, File)

PrintWriter(Writer)
PrintWriter(OutputStream)

OutputStream

  • FilterOutputStream
    • BufferedOutputStream
    • PrintStream

Writer 字符输出流

  • PrintWriter
        PrintStream out = System.out;
        //在默认情况下，PrintStream 输出数据的位置是 标准输出，即显示器
        /*
             public void print(String s) {
                if (s == null) {
                    s = "null";
                }
                write(s);
            }

         */
        out.print("john, hello");
        //因为print底层使用的是write , 所以我们可以直接调用write进行打印/输出
        out.write("韩顺平,你好".getBytes());
        out.close();

        //我们可以去修改打印流输出的位置/设备
        //1. 输出修改成到 "e:\\f1.txt"
        //2. "hello, 韩顺平教育~" 就会输出到 e:\f1.txt
        //3. public static void setOut(PrintStream out) {
        //        checkIO();
        //        setOut0(out); // native 方法，修改了out
        //   }
        System.setOut(new PrintStream("e:\\f1.txt"));
        System.out.println("hello, 韩顺平教育~");

        //PrintWriter printWriter = new PrintWriter(System.out); out是PrintStream，是OutputStream 子类
        
        PrintWriter printWriter = new PrintWriter(new FileWriter("e:\\f2.txt"));
        printWriter.print("hi, 北京你好~~~~");
        printWriter.close();//flush + 关闭流, 才会将数据写入到文件..

8. Properties

引出
        //读取mysql.properties 文件，并得到ip, user 和 pwd
        BufferedReader br = new BufferedReader(new FileReader("src\\mysql.properties"));
        String line = "";
        while ((line = br.readLine()) != null) { //循环读取
            String[] split = line.split("=");
            //如果我们要求指定的ip值
            if("ip".equals(split[0])) {
                System.out.println(split[0] + "值是: " + split[1]);
            }
        }

        br.close();
基本介绍

Map

  • Hashtable
    • Properties

键=值

注意:键值对不需要有空格,值不需要用引号
起来。默认类型是String

基本介绍
3)Properties的常见方法

  • Ioad:加载配置文件的键值对到Properties对象·
  • list:将数据显示到指定设备/流对象（显示器/文件）
  • getProperty(key):根据键获取值
  • setProperty(key,value):设置键值对到Properties对象
  • store:将Properties中的键值对存储到配置文件,在idea中,保存信息到配置文件,如果含有中文，会存储为unicode码
读取
        //使用Properties 类来读取mysql.properties 文件

        //1. 创建Properties 对象
        Properties properties = new Properties();
        //2. 加载指定配置文件
		//或 new FileInputStream("a.properties");
        properties.load(new FileReader("src\\mysql.properties"));
        //3. 把k-v显示控制台
        properties.list(System.out);

        //4. 根据key 获取对应的值
        String user = properties.getProperty("user");
        String pwd = properties.getProperty("pwd");

        System.out.println("用户名=" + user);
        System.out.println("密码是=" + pwd);


        //加载属性列表
        Iterator<String> it=p.stringPropertyNames().iterator();
        //遍历，key
        while(it.hasNext()){
            String key=it.next();
            //使用key 得到value
            System.out.println(key+":"+p.getProperty(key));
        }
存储
        //使用Properties 类来创建 配置文件, 修改配置文件内容

        Properties properties = new Properties();
        //创建
        //1.如果该文件没有key 就是创建
        //2.如果该文件有key ,就是修改
        /*
            Properties 父类是 Hashtable ， 底层就是Hashtable 核心方法
            public synchronized V put(K key, V value) {
                // Make sure the value is not null
                if (value == null) {
                    throw new NullPointerException();
                }

                // Makes sure the key is not already in the hashtable.
                Entry<?,?> tab[] = table;
                int hash = key.hashCode();
                int index = (hash & 0x7FFFFFFF) % tab.length;
                @SuppressWarnings("unchecked")
                Entry<K,V> entry = (Entry<K,V>)tab[index];
                for(; entry != null ; entry = entry.next) {
                    if ((entry.hash == hash) && entry.key.equals(key)) {
                        V old = entry.value;
                        entry.value = value;//如果key 存在，就替换
                        return old;
                    }
                }

                addEntry(hash, key, value, index);//如果是新k, 就addEntry
                return null;
            }

         */
        properties.setProperty("charset", "utf8");
        properties.setProperty("user", "汤姆");//注意保存时，是中文的 unicode码值。注意：我的测试，是直接保存为中文
        properties.setProperty("pwd", "888888");

        //将k-v 存储文件中即可
		//./zhang.properties 会保存在 \代码 目录下 和 本次打开的 chapter19 同级。
        properties.store(new FileOutputStream("src\\mysql2.properties"), null);
        System.out.println("保存配置文件成功~");
  • getProperty 无法获得 非String的值。
  • setProperty 和 getProperty 就是专为 String key 和 String Value 而准备的。
  • put 和 get 方法 适用所有的。
        p.put("age", 12);
        System.out.println(p.getProperty("age"));//返回null

作业

文件的操作

        /**
         *(1) 在判断e盘下是否有文件夹mytemp ,如果没有就创建mytemp
         *(2) 在e:\\mytemp 目录下, 创建文件 hello.txt
         *(3) 如果hello.txt 已经存在，提示该文件已经存在，就不要再重复创建了
         *(4) 并且在hello.txt 文件中，写入 hello,world~

         */

        String directoryPath = "e:\\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";// e:\mytemp\hello.txt
        file = new File(filePath);
        if(!file.exists()) {
            //创建文件
            if(file.createNewFile()) {
                System.out.println(filePath + " 创建成功~");

                //如果文件存在，我们就使用BufferedWriter 字符输入流写入内容
                BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(file));
                bufferedWriter.write("hello, world~~ 韩顺平教育");
                bufferedWriter.close();

            } else {
                System.out.println(filePath + " 创建失败~");
            }
        } else {
            //如果文件已经存在，给出提示信息
            System.out.println(filePath + " 已经存在，不在重复创建...");
        }


    }

BufferedReader和InputStreamReader

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

        String filePath = "e:\\a.txt";
        BufferedReader br = null;
        String line = "";
        int lineNum = 0;
        try {
            //直接使用 缓冲流。默认使用utf-8
            br = new BufferedReader(new FileReader(filePath));

            //使用转换流，设置编码。文件设置成了gbk，这里就要改为gbk。news1.txt使用 junti就是src下
            //BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("news1.txt"), "utf8"));

            while ((line = br.readLine()) != null) {//循环读取
                System.out.println(++lineNum + line);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {

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

Properties 和 序列化反序列化

public class Homework03 {
    public static void main(String[] args) throws IOException {
        /**
         * (1) 要编写一个dog.properties   name=tom age=5 color=red
         * (2) 编写Dog 类(name,age,color)  创建一个dog对象，读取dog.properties 用相应的内容完成属性初始化, 并输出
         * (3) 将创建的Dog 对象 ，序列化到 文件 e:\\dog.dat 文件
         */
        String filePath = "src\\dog.properties";
        Properties properties = new Properties();
        properties.load(new FileReader(filePath));
        String name = properties.get("name") + ""; //Object -> String
        int age = Integer.parseInt(properties.get("age") + "");// Object -> int
        String color = properties.get("color") + "";//Object -> String

        Dog dog = new Dog(name, age, color);
        System.out.println("===dog对象信息====");
        System.out.println(dog);

        //将创建的Dog 对象 ，序列化到 文件 dog.dat 文件
        String serFilePath = "e:\\dog.dat";
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(serFilePath));
        oos.writeObject(dog);

        //关闭流
        oos.close();
        System.out.println("dog对象，序列化完成...");
    }

    //在编写一个方法，反序列化dog
    @Test
    public void m1() throws IOException, ClassNotFoundException {
        String serFilePath = "e:\\dog.dat";
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(serFilePath));
        Dog dog = (Dog)ois.readObject();

        System.out.println("===反序列化后 dog====");
        System.out.println(dog);

        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 + '\'' +
                '}';
    }
}
天海华兮
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java核心基础编程精讲-IO流
06-21
Java IO流提供了丰富的类库，如使用FileInputStream和FileOutputStream读写文件，使用BufferedReader和BufferedWriter进行高效的文本读写，使用DataInputStream和DataOutputStream处理基本数据类型，使用...
Java-IO流基础例题 & 例题源码 & PPT教学文档（黑马程序员详细版）.rar
07-24
Java IO流还分为节点流和处理流，节点流直接连接到数据源或目的地，如FileInputStream和FileOutputStream；处理流则建立在其他流之上，用于增强或改变原有流的功能，如BufferedReader和PrintWriter。 二、Java IO流...
JavaSE学习笔记(十五.IO流)
weixin_74783792的博客
02-03 103
2.处理流(也叫包装流)是"连接"在已存在的流(节点流或处理流)之上，为程序提供更为强大的读写功能，也更加灵活。文件对我们并不陌生，是保存数据的地方，比如大家经常使用的word文档，txt文件，excel文件...都是文件。1.I/O 是 input/output 的缩写，I/O 技术是非常实用的技术，用于处理数据传输.如读写/文件，网络通讯等。注：BufferReader 类中，有属性Reader，即可以封装一个节点流，该节点流是任意的，只要是Reader子类。
IO流：节点流和处理流详细归纳。
yzh2776680982的博客
07-03 3308
目录一、节点流和处理流二、处理流1、BufferedReader 字符流2、BufferedWriter 字符流3、利用二者进行文件拷贝4、BufferedInputStream 字节流5、BufferedOutputStream 字节流三、ObjectOutputStream、ObjectInputStream 1、序列化和反序列化 2、 ObjectOutputStream 3、ObjectInputStream 4、注意事项 5、标准输入流和输出流 四、转换流 1、基本介绍 2、把 FileInput
IO流 使用BufferedReader读取文本文件，加上行号，输出到屏幕
weixin_43806049的博客
11-23 1577
IO流 使用BufferedReader读取文本文件，加上行号，输出到屏幕 2.编程题 要求：使用BufferedReader读取一个文本文件，为每行加上行号，再连同内容一并输出到屏幕上。 如果把文件的编码改成了gbk，出现中文乱码 1.默认是按照 utf-8处理，开始没有乱码 2.提示：使用我们的转换流，将FilelnputStream->InputStreamReader[可以指定编码] ->BufferedReader…… public class Homework02{ public
2020老杜最新Java零基础进阶视频教程-IO流课件
12-10
Java IO流是Java编程语言中处理输入输出操作的重要部分，尤其在文件操作、网络通信以及数据传输等场景中起着核心作用。Java IO流体系结构庞大，包括了字节流和字符流两大类，每类又有输入流和输出流之分。 1. Java...
简单总结Java IO中stream流的使用方法
09-02
- 对象流（如ObjectInputStream和ObjectOutputStream，用于序列化和反序列化对象） **处理流**主要包括： - 缓冲流（如BufferedReader和BufferedWriter，提供缓冲功能，减少频繁的I/O操作） - 转换流（如Reader和...
马士兵老师的java io流课程
06-04
Java IO流课程是Java编程领域中的重要组成部分，尤其对于初学者和有经验的开发者来说，理解和熟练运用IO流是至关重要的。马士兵老师的这门课程深入浅出地讲解了Java IO流的相关概念和技术，旨在帮助学员掌握数据输入...
大数据技术分享 Spark技术讲座 荷兰铁路的预测性维护 共32页.pdf
07-18
大数据技术分享 Spark技术讲座 荷兰铁路的预测性维护 共32页.pdf
计算机控制技术复习题.doc
07-18
计算机
Python人工智能课程 AI算法课程 Python机器学习与深度学习 12卷积神经网络 共76页.pdf
07-18
【内容大纲】 1.Python与数学基础 共83页.pdf 1.矩阵和线性代数_Python 共90页.pdf 2.概率论与数理统计 共89页.pdf 3.数据清洗和特征选择 共16页.pdf 4.多元回归与逻辑回归 共69页.pdf 5.决策树随机森林 共91页.pptx 6.支持向量机 共70页.pdf 7.聚类 共88页.pdf 8.EM算法 共66页.pptx 9.HMM 共80页.pptx 10.主题模型 共78页.pdf 11.卷积神经网络 共76页.pdf 12.目标检测算法 共47页.pdf 12卷积神经网络 共76页.pdf 13.RNN 共47页.pptx 14.NLP技术分享 自然语言处理技术课程 共184页.pdf 15.GAN网络 共25页.pdf 15.GAN源代码讲解及GAN项目介绍 共24页.pdf 16.强化学习-课件 共125页.pdf
告门诊统筹电子处方流转平台落地处方外流迎新高度.pdf
07-18
告门诊统筹电子处方流转平台落地处方外流迎新高度
计算机模拟系统在腔内泌尿外科教学中的运用.doc
07-18
计算机
大数据Spark技术分享 使用Databricks构建糖尿病药物推荐系统的实时数据管道 共31页.pdf
最新发布
07-18
大数据Spark技术分享 使用Databricks构建糖尿病药物推荐系统的实时数据管道 共31页.pdf
大数据技术分享 Spark技术讲座 了解Apache Spark中机器学习算法的并行化 共29页.pdf
07-18
大数据技术分享 Spark技术讲座 了解Apache Spark中机器学习算法的并行化 共29页.pdf
JAVA工程师物联网方向面试题及答案02.txt
07-18
JAVA工程师物联网方向面试题及答案
进销存表-淘宝店铺自动计算销存比率-Excel模板
07-18
【作品名称】： 【适用人群】：适用于希望学习不同技术领域的小白或进阶学习者。可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。
《单片机原理与应用》复习题1.doc
07-18
单片机
Java IO流深入解析：从File类到各种流的运用
对象流（ObjectInputStream/ObjectOutputStream）则支持Java对象的序列化和反序列化，实现了对象的持久化存储。 最后，随机存取文件流（RandomAccessFile）允许程序在文件中的任何位置进行读写，而不仅仅是从头到尾...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值