IO流的学习（二）

已于 2022-08-09 19:07:04 修改
阅读量101 收藏
点赞数
分类专栏： java学习笔记 文章标签： java
于 2022-08-04 21:13:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_48578877/article/details/126166773
版权

节点流和处理流

  • 节点流可以从一个特点的数据源读写数据，如FileReader、FileWriter
  • 处理流（也叫包装流）是连接在已存在的流（节点流或处理流）之上，为程序提供更为强大的读写功能，也更加灵活，如BufferedReader、BufferedWriter

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

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

处理流的功能

  • 性能的提高：主要以增加缓冲的方式来提高输入输出的效率。
  • 操作的便捷：处理流可能提供了一系列便捷的方法来一次输入输出大批量的数据，使用更加灵活方便。

处理流

  • BufferedReader和BufferedWriter属于字符流，是按照字符来读取数据的
  • 关闭时处理流，只需要关闭外层流即可。

BufferedReader

应用案例：使用BufferedReader读取文本文件。

public class BufferedReader_ {
    public static void main(String[] args) throws Exception {
        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();
    }
}

BufferedWriter

应用案例:使用BufferedWriter将字符串写入文件中

public class BufferedWriter_ {
    public static void main(String[] args) throws IOException {
        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();
        bufferedWriter.write("hello3, 今晚打老虎");
        bufferedWriter.newLine();
//说明：关闭外层流即可 ， 传入的 new FileWriter(filePath) ,会在底层关闭
        bufferedWriter.close();
    }
}

应用案例：综合 BufferedWriter和BufferedReader完成文件的拷贝

public class BufferedCopy_ {
    public static void main(String[] args) {
//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();
            }
        }
    }
}

BufferedInputStream和 BufferedOutputStream

  • BufferedInputStream是字节流，在创建BufferedInputStream时，会创建一个内部缓冲区数组。
  • BufferedOutputStream是字节流，实现缓冲的输出流，可以将多个字节写入底层输出流中，而不必对每次写入调用底层系统。

应用案例：完成图片的拷贝

public class BufferedCopy02 {
    public static void main(String[] args) {
// 
        String srcFilePath = "e:\\Koala.jpg";
// 
        String destFilePath = "e:\\hsp.jpg";

//创建 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();
            }
        }
    }
}

对象流

需求：

  • 将int num = 100，这个int数据保存到文件中，并可以从文件中直接恢复int 100；
  • 将Dog dog = new Dog(“小黄”，3)这个dog对象保存到文件中并且能从文件中恢复。

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

序列化和反序列化

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

对象流介绍

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

ObjectOutputStream提供 序列化功能

ObjectInputStream提供 反序列化功能

ObjectInputStream

应用案例：使用ObjectOutputStream序列化基本数据类型和一个Dog对象（name,age)并保存到date.dat文件中

/*
        * 演示 ObjectOutputStream 的使用, 完成数据的序列化
        */
public class ObjectOutStream_ {
    public static void main(String[] args) throws Exception {
//序列化后，保存的文件格式，不是存文本，而是按照他的格式来保存 
        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("数据保存完毕(序列化形式)");
    }
}

ObjectOutputStream

应用案例：使用ObjectlnputStream 读取 data.dat 并反序列化恢复数据

 // 1.创建流对象 
    ObjectInputStream ois = new ObjectInputStream(new FileInputStream("src\\data.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());
        System.out.println(ois.readObject());
        System.out.println(ois.readObject());
// 3.关闭 
        ois.close();
        System.out.println("以反序列化的方式读取(恢复)ok~");

序列化注意事项

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

转换流

使用字符流读含有中文的文件会出现中文乱码的问题

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

InputStreamReader

应用案例：编程将字节流FilelnputStream 包装成(转换成)字符流InputStreamReader,对文件进行读取(按照utf-8/gbk格式)，进而再包装成 BufferedReader。

/**
 * 演示使用 InputStreamReader 转换流解决中文乱码问题 
 * 将字节流 FileInputStream 转成字符流 InputStreamReader, 指定编码 gbk/utf-8 
 */
public class InputStreamReader_ {
    public static void main(String[] args) throws IOException {
        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)

 // 1.创建流对象 
    OutputStreamWriter osw =
            new OutputStreamWriter(new FileOutputStream("d:\\a.txt"), "gbk");
// 2.写入 
osw.write("hello");
// 3.关闭 
        osw.close();
        System.out.println("保存成功~");

Properties 类

需求：如下有一个配置文件mysql.properties

ip = 192.168.0.1

user = root

pwd = 12345

请问编程读取IP user pwd的值是多少

  • 传统方法 字节字符流
  • 使用Properties类
public class Properties01 {
    public static void main(String[] args) throws IOException {
//读取 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();
    }
}

基本介绍

  • 专门用于读写配置文件的集合类 以键=值的方式保存文件信息

  • 键值对不需要有空格，值不需要用引号引起来。默认类型是String

  • 常见方法

    • load：加载配置文件的键值对到Properties对象
    • list：将数据显示到指定设备
    • getProperty(key):根据键值对到Properties对象
    • setProperty(key,value):设置键值对到Properties对象
    • store:将Properties中的键值对存储到配置文件，在idea中保存信息到配置文件，如果含有中文，会存储为Unicode码

    应用案例：使用Properties类完成对mysql.properties文件的读取

    public class Properties02 {
    public static void main(String[] args) throws IOException {
//使用 Properties 类来读取 mysql.properties 文件 
//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("pwd");
        System.out.println("用户名=" + user);
        System.out.println("密码是=" + pwd);
    }
}

应用案例：使用Properties类添加key-val到新文件mysql2.properties中；使用Properties类完成对 mysql2.properties 的读取，并修改某个key-val

public class Properties03 {
    public static void main(String[] args) throws IOException {
//使用 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 存储文件中即可 
        properties.store(new FileOutputStream("src\\mysql2.properties"), null);
        System.out.println("保存配置文件成功~");
    }
}

Unicode码查询工具：http://tool.chinaz.com/tools/unicode.aspx

补充：四个空接口

  • java.rmi.Remote:返回与指定name关联的远程对象的一个引用
  • java.lang.Cloneable:以指示Object.clone方法可以合法的对类实例按字段复制
  • java.util.RandomAccess:支持快速访问的List表示实现这个接口的集合，支持快速随机访问
  • java.io.Serializable:启用序列胡化功能。
囨誌
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
IO流学习总结
01-26
本文档为本人学习 java IO流期间的学习总结笔记，希望对新学习的朋友有所帮助和参考价值。本人java 开发时间不是太长，可能存在不完善或不对之处，欢迎指正！
java-io流学习总结.doc
11-24
Java IO 流学习总结 Java IO 流是 Java 语言中最重要的 Input/Output 机制之一，通过流我们可以自由地控制文件、内存、IO 设备等数据的流向。流机制是 Java 及 C++中的一个重要机制。 一、什么是流？ 流是字节...
Java io流学习
hua226的博客
04-12 2万+
Java io 一、File 1.1 File类概述和构造方法 概述： 它是文件和目录路径名的抽象表示 对于File而言，其封装的并不是一个真正存在的文件，仅仅是一个路径名而已。它可以是存在的，也可以是不存在的。 将来是要通过具体的操作把这个路径的内容转换为具体存在的。 方法名 说明 File(String pathname) 通过将给定的路径名字符串转换为抽象路径名来创建新的File实例 File(String parent,String child) 从父路径名字符串
IO流详解及常用方法
千锋教育
02-20 1285
此时， 在try结构执行结束的时候， 会自动的调用AutoClosable接口实现类中的close方法， 进行流的关闭。从流中流动的数据单位来分， 是一个字节流， 流中流动的数据是以字节为单位的。从流中流动的数据单位来分， 是一个字符流， 流中流动的数据是以字符为单位的。从方向来说， 是一个输入流， 数据是从文件中流动到程序中， 是为了读取文件中的数据的。从方向来说， 是一个输入流， 数据是从文件中流动到程序中， 是为了读取文件中的数据的。流: 指的是一串流动的数据， 在数据在流中按照指定的方向进行流动。
Java 8 IO流学习
weixin_40103877的博客
05-10 975
Java IO流学习 什么是Java IO流 在Java中，一个可以按顺序读取字节的对象即为流，Java IO流是实现输入/输出的基础，InputStream, OutputStream是系列Java IO流程的基类。 Inputstream: 斜体样式 ...
java IO流学习总结
coder150806的博客
09-09 5万+
学习了几天的java IO流，下面我来谈谈对java 输入输出流IO的个人见解吧！ 转载自：https://blog.csdn.net/zhaoyanjun6/article/details/54292148/ java流类结构图 一.流的概念： 流是一组有顺序的，有起点和终点的字节集合，是对数据传输的总称或抽象。它的特性是进行数据传输； 例如从水源地长江把水导入自来水厂，然后又从自...
Java IO流学习总结一：输入输出流
热门推荐
赵彦军
01-09 6万+
Java IO流学习总结一：输入输出流 转载请标明出处：http://blog.csdn.net/zhaoyanjun6/article/details/53761199 本文出自【赵彦军的博客】 Java流类图结构：流的概念和作用流是一组有顺序的，有起点和终点的字节集合，是对数据传输的总称或抽象。即数据在两设备间的传输称为流，流的本质是数据传输，根据数据传输特性将流抽象为各种类，方便更直
javaIO流详解
weixin_46676497的博客
01-27 1794
java常用io流介绍
C# IO流读写文件操作
qq_45728730的博客
05-18 3193
C# IO流读写文件操作 1、创建文件流 2、创建文件读写器 3、执行读写操作 4、关闭文件读写器和文件流 1、创建文件流 string filePath = AppDomain.CurrentDomain.BaseDirectory + @"..\..\..\TextFile1.txt";//文件相对路径 string filePath2 = @"D:\file\TextFile2.txt";//文件绝对路径 FileStream fs =new FileStream( filePath,FileMode
Java学习之IO流
qq_53723728的博客
06-19 1657
IO流介绍IO：输入/输出(Input/Output)流：是一种抽象概念，是对数据传输的总称。也就是说数据在设备间的传输称为流，流的本质是数据传输IO流就是用来处理设备间数据传输问题的。常见的应用：文件复制；文件上传；文件下载IO流的分类按照数据的流向输入流：读数据输出流：写数据按照数据类型来分字节流字节输入流字节输出流字符流字符输入流字符输出流IO流的使用场景如果操作的是纯文本文件，优先使用字符流如果操作的是图片、视频、音频等二进制文件。优先使用字节流。
IO流：节点流和处理流详细归纳。
yzh2776680982的博客
07-03 3315
目录一、节点流和处理流二、处理流1、BufferedReader 字符流2、BufferedWriter 字符流3、利用二者进行文件拷贝4、BufferedInputStream 字节流5、BufferedOutputStream 字节流三、ObjectOutputStream、ObjectInputStream 1、序列化和反序列化 2、 ObjectOutputStream 3、ObjectInputStream 4、注意事项 5、标准输入流和输出流 四、转换流 1、基本介绍 2、把 FileInput
JavaIO流详解
itqcyyl的博客
08-09 2万+
转载：https://www.cnblogs.com/LittleHann/p/3678685.html Java输入、输入、IO流 类层次关系梳理 本文主要关注在Java编程中涉及到的IO相关的类库、方法。以及对各个层次(抽线、接口继承)的流之间的关系进行梳理   相关学习资料 http://baike.baidu.com/view/1007958.htm?noadapt=1 h...
java IO流学习笔记
12-12
java IO流学习笔记
java-网络编程-io流-学习案例
02-25
在本学习案例中，我们关注的是Java的IO流和Socket技术，这些是实现客户端-服务器通信的基础。IO流用于数据的输入输出操作，而Socket则是网络通信的桥梁。 首先，让我们深入了解Java的IO流。IO流在Java中被广泛用于...
IO流、Xml解析
08-26
IO流分为两大类：字符流和字节流，分别处理字符数据和原始二进制数据。字符流适用于文本文件，而字节流则适用于任何类型的数据。IO流还包括输入流（Input Stream）、输出流（Output Stream）、缓冲流（Buffered ...
12. Hibernate 模板设计模式
最新发布
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 1136
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
redis+spring面试题
github_36510643的博客
07-21 407
redis+spring面试题
Java-Lambda
lizhiwei21的博客
07-21 444
lambda表达式可以理解为对匿名内部类的一种简化 , 但是本质是有区别的面向对象思想 :强调的是用对象去完成某些功能函数式编程思想 :强调的是结果 , 而不是怎么去做。
Java内存模型
weixin_44267758的博客
07-19 788
此处的变量不是指java编程中的变量，它包括了实例字段，静态字段和构成数值对象的元素，但不包括局部变量和方法参数。JMM规定所有变量都存储在主内存中。每条线程有自己的工作内存，工作内存中保留了该线程使用到变量的主内存的副本。线程对变量的所有操作都必须在工作内存中进行，不能直接读写主内存的变量，不同的线程间也无法直接访问对方工作内存的变量，线程之间的变量值传递需要通过主内存来完成。
.net的io流学习
05-24
在 .NET 中，IO 流是用于读取和写入文件的重要组件。以下是一些常用的 .NET IO 流类： 1. StreamReader 和 StreamWriter 类：这两个类用于读取和写入文本文件。...希望这可以帮助你开始学习 .NET IO 流。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值