A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

© 娱乐逗 初级黑马   /  2018-11-26 16:51  /  658 人查看  /  0 人回复  /   0 人收藏 转载请遵从CC协议 禁止商业使用本文

[石家庄]就业班笔记[IO流]

File类
在java.io包里,是文件 和 目录 的路径的抽象表现形式,主要用于文件和目录的创建,查找和删除
file类是一个与系统无关的类,任何操作系统都可以使用这个类中的方法
重要英文单词
file :文件
directory: 目录
path: 路径
File类的静态成员变量
static String pathSeparator路径分隔符字符串形式  Windows ;分号 Linux :冒号
static char pathSeparatorChar: 路径分隔符的char形式
static String separator文件名分隔符字符串形式  Windows\反斜杠  Linux /正斜杠
static char separatorChar: 文件名称分隔符的char形式


写路径时不要写死,要写String separator 以便让不同的操作系统识别
绝对路径和相对路径
绝对路径:是一个完整的路径(真实的)
以盘符(c:,d:)开始的路径  c:\\a
相对路径:是一个简化的路径
相对指的是相对于当前项目的路径
如果使用当前项目的根目录,路径可以简化书写(可以省略项目的根路径)
注意:       
1,路径不区分大小写
2,路径一般写成字符串,Windows中反斜杠是转义符.所以要写两个反斜杠
File类的构造方法
// 构造方法(创建了File对象, 并将其指向该路径. 不会真正在磁盘上创建这个文件)
File File(String pathname): 根据 路径字符串 封装一个File对象
C:/Users/Administrator/AppData/Local/YNote/data/x409428917@163.com/388b820738bf46f4b48798106880b984/clipboard.png
File File(String parent, String child): 根据 父路径字符串 和 子路径字符串 封装File对象
父路径       子路径
好处: 父路径和子路径,可以单独书写,使用起来非常灵活,父路径和子路径都可以变化
File File(File parent, String child): 根据 父路径的File对象 和 子路径 封装File对象
好处: 父路径和子路径,可以单独书写,使用起来非常灵活,父路径和子路径都可以变化
  父路径是File类型,可以使用File的方法对路径进行一些操作,再使用路径创建对象
File类的获取方法
// 常用获取方法
    String?getAbsolutePath(): 返回此File的绝对路径名字符串
    String?getPath(): 获取File对象的封装路径 (创建对象时传入的路径)
    String?getName(): 获取File对象的文件名或目录名
获取的构造方法传递路径的结尾部分(文件/文件夹)
    long?length(): 获取File表示的文件大小的字节byte数 (不能获取目录的大小)
File类的判断方法
// 常用判断方法
        boolean?exists(): 判断File对象代表的文件或目录是否实际存在
存在:true  不存在:false
        boolean?isDirectory(): 判断File表示的是否为目录
判断构造方法中给定的路径是否以文件夹结尾
是:true 不是:false
        boolean?isFile(): 判断File表示的是否为文件
判断构造方法中给定的路径是否以文件结尾
是:true 不是:false
boolean?endsWith: 判断结尾是否跟给定的一致
注意:电脑的硬盘只有文件/文件夹,两个方法是互斥
这两个方法使用前提,路径必须是存在的,否则否返回false
File类的创建删除方法
// 常用创建删除方法
        boolean?createNewFile(): 当文件不存在时, 创建一个新的空文件
C:/Users/Administrator/AppData/Local/YNote/data/x409428917@163.com/2865eb9b1bb947e3be9ad59f2fd7374e/clipboard.png
        boolean?delete(): 删除由此File表示的文件或目录. (删除目录时必须是空目录)
注意:delete方法是直接在硬盘删除文件,不走回收站,删除要慎重
        boolean?mkdir(): 创建File表示的目录(文件夹)
创建单级文件夹
        boolean?mkdirs(): 创建File表示的多级目录
即可创建单级文件夹,也可创建多级文件夹
File类的遍历目录方法
// 常用获取目录中内容的方法
        String[]?list(): 获取当前File目录下的所有子文件或目录的名字数组
获取构造方法中给出的目录名称,把目录中的文件/文件夹名称存储到一个string类型数组中
隐藏在路径下的文件/文件夹也可以获取到
获取的是文件/文件夹的名称
        File[]?listFiles(): 获取当前File目录中的所有子文件或目录的File对象数组
获取的是文件/文件夹的绝对路径名
" ." 当前项目 ".."当前项目上一级
注意       
list方法和listFiles方法遍历的是构造方法中给出的目录
如果构造方法中给出的目录的路径不存在,会抛出空指针异常
如果构造方法中给出的路径不是一个目录,页会抛出空指针异常


递归
递归:方法内部调用方法自己 (所以必须定义方法)
分为:直接递归:方法自己调用方法
间接递归:A方法调用B方法, B方法调用C方法, C方法调用A方法
递归时的注意事项:
     1. 递归要有限定条件(出口), 保证递归能够停止(就是在某种情况下方法不再调用自己), 否则会栈内存溢出
    2. 递归次数不能太多, 否则会栈内存溢出
    3. 构造方法不能递归
递归的使用前提:
        调用方法时, 方法的主体不变, 但每次传递的参数值不同, 可以使用递归
递归求n的和原理
C:/Users/Administrator/AppData/Local/YNote/data/x409428917@163.com/d290b3f68dad47a9b9273243df50885e/clipboard.png
递归求n的阶乘
原理同求和
递归打印多级目录
补充String类中的方法:
        boolean endsWith(String suffix): 判断字符串是否以指定的字符串结尾
String toLowerCase(): 将字符串转为小写字母
C:/Users/Administrator/AppData/Local/YNote/data/x409428917@163.com/5014ad1938be45039de606cca6308843/clipboard.png
C:/Users/Administrator/AppData/Local/YNote/data/x409428917@163.com/d7b13d27ca6841178f8fbd5c7c3924b6/clipboard.png
FileFilter文件过滤器的原理和使用
java.io.File类:  Filter过滤器
        File[] listFiles(FileFilter filter): 返回文件过滤器过滤后的File对象数组


File[] listFiles(FilenameFilter filter): 返回文件过滤器过滤后的File对象数组
java.io.FileFilter接口: 用于File对象的过滤器
        boolean accept(File pathName): true则会将参数的File对象加入返回的File[], false则不加入


boolean accept(File dir, String name): true则会将参数的File对象加入返回的File[], false则不加入
                dir: 被找到的文件所在的目录 (父路径)
                name: 文件的名称          (子路径)
注意 两个过滤器接口是没有实现类的,需要我们自己写实现类,重写过滤的方法,在方法中自己定义过滤的规则

IO流
输入(in put)
输出(output)
流: 数据流


输入: 从硬盘(文件)读取到内存(Java程序)
输出: 从内存(Java程序)写入到硬盘(文件)
IO流的分类:
字节流 (读写字节: byte, 可以读写所有类型的文件, 包括视频, 图片, 音频, 文本等)
        字节输入流: java.io.InputStream 抽象类
        字节输出流: java.io.OutputStream 抽象类
字符流 (读写字符: char, String, 只能读写文本文件)
        字符输入流: java.io.Reader 抽象类
        字符输出流: java.io.Writer 抽象类
C:/Users/Administrator/AppData/Local/YNote/data/x409428917@163.com/7e8fd857155d448ca889cd012c9c1d6f/clipboard.png
字节流
计算机中一切皆为字节
字节输出流OutputStream(抽象类)和FileOutputStream
java.io.OutputStream抽象类: 字节输出流 (顶层类)
        // 成员方法
        void close() :释放资源
        void flush() :刷新缓冲区(对于字节流来说没有作用)
        // 写字节的成员方法
        abstract void write(int b): 一次写一个字节 (参数int便于传递byte的整数不用强转)
        void write(byte[] b): 一次写一个字节数组
        void write(byte[] b, int offset, int len): 一次写一个字节数组的一部分
java.io.FileOutputStream类: 文件字节输出流 (向文件写数据)
        // 构造方法
        FileOutputStream(String name): 通过文件路径创建文件字节输出流
        FileOutputStream(File file): 通过File对象创建文件字节输出流
        构造方法的作用:
                1. 创建一个FileOutputStream对象
                2. 根据构造方法传递的路径, 在磁盘上创建一个空文件 ("如果文件存在则会清空数据")
                3. 将创建的FileOutputStream对象指向这个磁盘上的文件
C:/Users/Administrator/AppData/Local/YNote/data/x409428917@163.com/45fe9b6b1816460dab77b0176f88a900/clipboard.png


C:/Users/Administrator/AppData/Local/YNote/data/x409428917@163.com/b5abe09a3d154f279431a831177a051d/clipboard.png
字节输出流: 一次写一个字节到文件
写数据的原理:
        Java程序 -> JVM虚拟机 -> OS操作系统 -> OS调用写数据的方法 -> 将数据写入文件
使用字节输出流写数据到文件的步骤:
        1. 创建对象: 创建FileOutputStream对象, 构造方法中传递文件路径
        2. 写入数据: 使用FileOutputStream对象调用 write(int b) 方法, 将字节写入文件
        3. 释放资源: 使用FileOutputStream对象调用 close() 方法, 关闭流对象释放资源
FileOutputStream fos = new FileOutputStream("模块名\\文件名.txt");
        fos.write(97);
        fos.close();


字节输出流的使用方法[重点]
1,创建一个FileOutputStream对象,构造方法中传递写入数据的目的地
2,调用对象中方法write,把数据写入到文件中
3,释放资源
C:/Users/Administrator/AppData/Local/YNote/data/x409428917@163.com/c76709393176437ba643bff33299c3de/clipboard.png
文件存储数据的原理
其他: 查询系统默认码表
                        Windows简体中文系统的程序打开是按 GBK 码表
                        IDEA中使用的是 UTF-8 码表
字节输出流:一次写多个字节
java.io.FileOutputStream类: 文件字节输出流 (向文件写数据)
        void write(byte[] b): 一次写一个字节数组
        void write(byte[] b, int off, int len): 一次写一个字节数组的一部分
           byte[] b = String.getBytes()
写多个字节时:
        如果第一个字节是正数中的 0~127, 则记事本会查询 ASCII码表 显示字符
        如果第一个字节是负数中的:-128~-1, 则记事本会查询 GBK码表 显示字符.(将两个连续的byte组合为一个中文)
数据的续写和换行
java.io.FileOutputStream类: 文件字节输出流
        // 带有 续写 功能的构造方法, 不会清空文件
        FileOutputStream(String name, boolean append): 通过文件路径创建流, true可以续写
        FileOutputStream(File file, boolean append): 通过File对象创建流, true可以续写
换行符:
        Windows系统: "\r\n"
        Linux系统: "\n"
        MacOS系统: "\r
C:/Users/Administrator/AppData/Local/YNote/data/x409428917@163.com/313cdc131a514f25926c031cffc73cd3/clipboard.png
字节输入流:InputStream和FilelnputSream
java.io.InputStream抽象类: 字节输入流 (顶层类)
        // 常用成员方法
        void close(): 释放资源
        // 读数据的方法
        int read(): 一次读一个字节
                读到文件末尾返回-1 (返回int也是为了代码编写方便)
        int read(byte[] b): 一次读一个字节数组
                读到的字节存放在参数中的字节数组中, 返回int值是本次读到的字节的个数. 读到文件末尾返回-1   
java.io.FileInputStream类: 文件字节输入流
        // 构造方法
        FileInputStream(String name): 使用文件路径创建文件字节输入流
        FileInputStream(File file): 使用File对象创建文件字节输入流
        构造方法的作用:
                1. 创建FileInputStream对象
                2. 将FileInputStream对象指向磁盘上的文件
字节输入流一次读取一个
FileInputStream读数据步骤:
        1. 创建FileInputStream对象
        2. 使用FileInputStream对象, 调用 int read() 方法, 一次读取一个byte
        3. 释放资源
java.io.InputStream抽象类: 字节输入流 (顶层类)
        int read(): 一次读一个字节
                读到文件末尾返回-1 (返回int也是为了代码编写方便)
C:/Users/Administrator/AppData/Local/YNote/data/x409428917@163.com/ad195204fb234c698a1e8e33ceaff9ef/clipboard.png
字节流读取中文问题
GBK编码中, 一个汉字占用2个byte
UTF-8编码中, 一个汉字占用3个byte
字符流
注意: 字符流只能读写"文本文件"
java.io.Reader抽象类: 字符输入流 (顶层)
        // 常用成员方法
        void close() :关闭此流并释放与此流相关联的任何系统资源
        // 读
        int read(): 一次读一个字符char, 返回读到的字符.
            读到文件末尾返回-1  (返回int为了代码编写方便)
        int read(char[] cbuf): 一次读取一个字符数组char[]
                返回读取的字符个数. 读到文件末尾返回-1
java.io.FileReader类: 文件字符输入流
        // 构造方法
        FileReader(File file): 根据File对象创建文件字符输入流
        FileReader(String fileName): 根据File对象创建文件字符输入流
        构造方法的作用:
                1. 创建FileReader对象
                2. 将FileReader对象指向磁盘上的文件
字符输入流Reader和FileReader
java.io.Reader抽象类: 字符输入流 (顶层)
        int read(): 一次读一个字符char, 返回读到的字符.
            读到文件末尾返回-1  (返回int为了代码编写方便)
        int read(char[] cbuf): 一次读取一个字符数组char[]
                返回读取的字符个数. 读到文件末尾返回-1
java.lang.String类:
        String(char[] value): 将char数组转换为String
        String(char[] value, int offset, int count): 将char数组的一部分转换为String
C:/Users/Administrator/AppData/Local/YNote/data/x409428917@163.com/dbc10ac852c04f09a46a7cfe8baf500f/clipboard.png
字符输出流Writer和FileWriter
java.io.Writer抽象类: 字符输出流 (顶层类)   'a''b'  缓冲区    97 98
        // 常用成员方法
        abstract void close(): 刷新缓冲区并释放资源
        abstract void flush() :刷新缓冲区
        // 写
        void write(int c): 写一个字符 (int类型为了代码编写方便)
        void write(char[] cbuf): 写一个字符数组
        abstract void write(char[] b, int off, int len): 写一个字符数组的一部分
        void write(String str): 写一个字符串
        void write(String str, int off, int len): 写一个字符串的一部分
        注意: write()方法只是将数据写到内存缓冲区, 最后必须调用flush()或close()才能将数据真正写入磁盘
java.io.FileWriter类: 文件字符输出流
        // 构造方法
        FileWriter(File file): 通过File对象创建文件字符输出流
        FileWriter(String fileName): 通过文件路径创建文件字符输出流
        作用:
                1. 创建FileWriter对象
                2. 根据构造方法中的路径, 在磁盘上创建文件 ("如果文件已存在, 则清空文件内容")
                3. 将FileWriter对象指向磁盘上的文件
字符输出流: 一次写一个字符
FileWriter使用步骤:
        1.创建FileWriter对象, 构造方法中绑定要写入数据的目的地
        2.使用FileWriter中的方法 write(), 把数据写入到"内存缓冲区"中(字符转换为字节的过程)
        3.使用FileWriter中的方法 flush(), 把内存缓冲区中的数据,"刷新到文件中"
        4.释放资源 close() (会先把内存缓冲区中的数据刷新到文件中
FileWriter fw = new FileWriter("09_IOAndProperties\\d.txt");
        fw.write(97);  // int ch 用int值代表char
        //fw.flush();
        fw.close();
字符输出流: flush与close区别
区别:
        flush(): 刷新缓冲区 (将数据从内存中写入到磁盘)
        close(): 刷新缓冲区, 并释放资源. 关闭流后不能再用同一个流对象操作
flush() 可以省略, 只用 close()来 刷新并释放资源
字符输出流: 其他方法
写的其他方法:
        void write(char[] cbuf): 写一个字符数组
        abstract void write(char[] b, int off, int len): 写一个字符数组的一部分
        void write(String str): 写一个字符串
        void write(String str, int off, int len): 写一个字符串的一部分
字符输出流: 续写, 换行
FileWriter中带有续写功能的构造:
        FileWriter(File file, boolean append): 通过File对象创建流. 第二个参数为true可以续写
        FileWriter(String fileName, boolean append): 通过文件路径创建流. 第二个参数为true可以续写       
换行:
        windows: "\r\n"  fw.write("\r\n");
字节流 和 字符流 如何选择:
        1. 如果不确定读写的是什么类型的数据, 用字节流最通用
        2. 如果确定读写的就是文本, 用字符流最方便
IO异常处理
IO流操作中的异常处理
IO流的标准格式:
        FileWriter fw = null;
    try {
        //IO流对象的创建, 操作等代码
        fw = new FileWriter("d:\\09_IOAndProperties\\g.txt", true);
        for (int i = 0; i <10 ; i++) {
            fw.write("HelloWorld"+i+"\r\n");
        }
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        // 释放资源
        if(fw != null){
            try {
                fw.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
C:/Users/Administrator/AppData/Local/YNote/data/x409428917@163.com/02edecc4b2494c4482f3f94e1a4b16e4/clipboard.png


C:/Users/Administrator/AppData/Local/YNote/data/x409428917@163.com/f7ed74f62ef4418bb1f083c0113c84f6/clipboard.png
Properties集合
Properties存储数据和遍历
Properties双列集合:
        键和值都是 String 类型
java.util.Properties类: 属性集, 属于Map的双列集合, 继承自Hashtable
        // 构造方法
        Properties(): 创建一个Properties集合
        // 可以使用Map接口中的方法
        // 特有成员方法
        Object setProperty(String key, String value): 保存/替换键值对
        String getProperty(String key): 通过键获取值. 键不存在返回null
        Set<String> stringPropertyNames(): 返回键的集合
        void store(OutputStream out, String comments): 将集合用字节流写入文件(不能中文),并写入注释
        void store(Writer writer, String comments): 将集合用字符流写入文件(可以中文),并写入注释
        void load(InputStream inStream): 从配置文件中通过字节流加载数据到Properties集合(不能中文)
        void load(Reader reader): 从配置文件中通过字符流加载数据到Properties集合(可以中文)
Properties: store()存储数据到文件
Properties将数据写入到文件的方法:
        void store(OutputStream out, String comments): 将集合用字节流写入文件(不能中文),并写入注释
        void store(Writer writer, String comments): 将集合用字符流写入文件(可以中文), 并写入注释       
使用步骤:
        1.创建Properties集合对象,添加数据
        2.创建字节输出流/字符输出流对象,构造方法中绑定要输出的目的地
        3.使用Properties集合中的方法store,把集合中的临时数据,持久化写入到硬盘中存储
        4.释放资源
属性集(配置文件), 标准的后缀是 .properties
配置文件格式要求:
        一行一个键值对
        键和值中间用=分隔 (标准格式, 但空格分开也行)
        #表示单行注释
Properties: load()从文件加载数据到集合
Properties将数据从文件加载到集合中的方法:
        void load(InputStream inStream): 从配置文件中通过字节流加载数据到Properties集合(不能读中文)
        void load(Reader reader): 从配置文件中通过字符流加载数据到Properties集合(可以读中文)  
使用步骤:
        1.创建Properties集合对象
        2.使用Properties集合对象中的方法load读取保存键值对的文件
        3.遍历Properties集合

缓冲流              
缓冲流的原理:
        底层也是使用基本流(FileXxx)来读写
        但缓冲流内部定义了一个缓冲数组, 在读的时候类似于我们一次读一个数组的方式, 减少了磁        盘操作次数, 提高了程序效率                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         
缓冲字节输出流:        bufferedoutputstream
java.io.BufferedOutputStream类: 缓冲字节输出流
        // 构造方法
        BufferedOutputStream(OutputStream out): 使用基本流创建一个缓冲字节输出流
        BufferedOutputStream(OutputStream out, int size): 使用基本流创建一个缓冲字节输出流, 设置缓冲区大小
BufferedOutputStream使用步骤:
        1.创建FileOutputStream对象, 构造方法中绑定要输出的目的地
        2.创建BufferedOutputStream对象, 构造方法中传递FileOutputStream对象
        3.使用BufferedOutputStream对象中的方法 write(), 把数据写入到内部缓冲区中
        4.使用BufferedOutputStream对象中的方法 flush(), 把内部缓冲区中的数据,刷新到文件中
        5.释放资源(会先调用flush方法刷新数据, 第4步可以省略)
FileOutputStream fos = new FileOutputStream("文件路径");
        BufferedOutputStream bos = new BufferedOutputStream(fos);
        bos.write("你好".getBytes());
        // bos.flush();  // 可以省略
        bos.close();
缓冲字节输入流:bufferedinputstream
java.io.BufferedInputStream类: 缓冲字节输入流
        // 构造方法
        BufferedInputStream(InputStream in): 使用基本流创建一个缓冲字节输入流
        BufferedInputStream(InputStream in, int size): 使用基本流创建一个缓冲字节输入流, 设置缓冲区大小
使用步骤:
        1.创建FileInputStream对象, 构造方法中绑定要读取的数据源
        2.创建BufferedInputStream对象, 构造方法中传递FileInputStream对象
        3.使用BufferedInputStream对象中的方法 read(), 读取文件
        4.释放资源 close()
缓冲字符输出流:bufferedwriter
java.io.BufferedWriter类:
        // 构造方法
        BufferedWriter(Writer out): 使用基本流创建一个缓冲字符输出流
        BufferedWriter(Writer out, int size): 使用基本流创建一个缓冲字符输出流, 设置缓冲区大小
        // 特有方法
        void newLine(): 写入一个换行符, 换行符自动根据当前系统确定
缓冲字符输入流:bufferedreader
java.io.BufferedReader类: 缓冲字符输入流
        // 构造方法
        BufferedReader(Reader in): 使用基本流创建一个缓冲字符输入流
        BufferedReader(Reader in, int size): 使用基本流创建一个缓冲字符输入流, 设置缓冲区大小
        // 特有方法
        String readLine(): 一次读一行字符串, "不包含换行符". 读到文件末尾返回null
转换流
字符编码和字符集
编码: 字符 -> 字节  'a' -> 97
解码: 字节 -> 字符  97 -> 'a'
编码表: 字符和二进制数字的对应规则
字符集和编码表: 字符集包含编码表
        ASCII字符集
                ASCII编码表
                ASCII扩展编码表
        ISO-8859-1字符集: Tomcat Web服务器程序
                Latin-1: 拉丁字符. 没有中文. 每个字符由1个byte组成
        GB字符集
                GB2312编码表: 每个字符由2个byte组成
                GBK编码表: 每个字符由2个byte组成
                GB18030编码表: 每个字符由1, 2, 4个byte组成
        Unicode字符集
                UTF-8: ASCII字符占1个byte, 拉丁字符占2个byte, 中文占3个byte, Unicode辅助字符占4个byte
                UTF-16
                UTF-32
        ANSI: 表示使用系统默认编码表
乱码问题: FileReader读取GBK编码
乱码原因: 读写编码不一致
   GBK文件中存储的是"你好"在GBK中对应的byte
   而IDEA中使用FileReader读取文件时, 是将byte按照UTF-8编码表查找字符, 结果找不到, 就显示了问号
OutputStreamWriter类介绍及使用
java.io.OutputStreamWriter类: 输出转换流. 字符流通往字节流的桥梁
        // 构造方法
        OutputStreamWriter(OutputStream out): 使用默认编码表创建转换流
        OutputStreamWriter(OutputStream out, String charsetName(编码表名)): 使用指定编码表创建转换流
// 使用默认UTF-8
OutputStreamWriter o = new OutputStreamWriter(new FileOutputStream("a.txt"));
o.write("dsfdsfdsaf")
// 使用指定的GBK
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("a.txt"), "GBK");
                osw.write("你") -> 查"GBK"码表 -> -1,-2 -> FileOutputStream -> a.txt文件
         写数据: 字符流 --------------------------> 字节流
InputStreamReader类介绍及使用
java.io.InputStreamReader类: 输入转换流. 字节流通往字符流的桥梁
        // 构造方法
        InputStreamReader(InputStream in): 使用默认编码表创建转换流
        InputStreamReader(InputStream in, String charsetName): 使用指定编码表创建转换流
// 使用默认UTF-8
InputStreamReader r = new InputStreamReader(new FileInputStream("a.txt"));
// 使用指定的GBK
InputStreamReader isr = new InputStreamReader(new FileInputStream("a.txt"), "GBK");
     '你' <- 查"GBK"码表 <- isr.read() <- -1,-2 <- FileInputStream <- a.txt文件
                         读数据: 字符流 <---------- 字节流
转换流主要用于解决Web开发中的乱码问题
序列化流(对象流)
序列化和反序列化概述
序列化: 内存中的对象转换为字节序列, 以流的方式写入到磁盘的文件中
        对象 -> 字节
反序列化: 磁盘文件中的字节序列, 以流的方式读取到内存中变成对象
        字节 -> 对象
通过序列化流, 我们可以将内存中的数据方便的存储到磁盘上, 下次程序启动后也能从磁盘读取恢复之前的对象状态
OutputStream
        |_ ObjectOutputStream类: 对象字节输出流
InputStream
        |_ ObjectInputStream类: 对象字节输入流
序列化流的应用场景:
    以后我们会用到"缓存", 缓存就是一些数据, 是存储在内存中的, 比如存储某个用户登录的状态
   而内存中的数据, 服务器一重启, 数据就没了, 所以我们需要在服务器重启前, 将内存中的数据写入到磁盘保存
    这时就可以用 序列化流
    服务器重启后, 先通过 反序列化流 读取到内存, 这样可以保持之前的状态
对象序列化流: ObjectOutputStream
java.io.ObjectOutputStream类: 对象字节输出流
        // 构造方法
        ObjectOutputStream(OutputStream out)
        // 特有成员方法
        void writeObject(Object obj): 将对象写出
注意:
        被读写的对象的类必须实现"java.io.Serializable"接口, 否则会抛                出"NotSerializableException"
对象反序列化流: ObjectInputStream
java.io.ObjectInputStream类: 对象字节输入流
        // 构造方法
        ObjectInputStream(InputStream in)
        // 特有成员方法
        Object readObject(): 读取对象
打印流
打印流PrintStream: 概述和使用
PrintStream特点:
        1. 只有输出流, 没有输入流
        2. PrintStream不会抛出IOException
        3. 有特殊方法 print(), println(), 可以输出任意类型的值, 原样输出
java.io.PrintStream类: 字节打印流
        // 构造方法
        PrintStream(File file): 创建字节打印流, 输出到一个文件
        PrintStream(OutputStream out): 创建字节打印流, 输出到一个字节输出流
        PrintStream(String fileName): 创建字节打印流, 输出到一个文件路径
ava.lang.System类:
        // 静态方法
        static void setOut(PrintStream out): 设置System.out的输出目的地为参数的打印流





0 个回复

您需要登录后才可以回帖 登录 | 加入黑马