java: IO流

四点明确

1. 操作的数据:数据源/数据目的(读入/写出)
    - 源：InputStream　　Reader
    - 目的：OutputStream　　Writer
2. 操作的设备上的数据:字节/文本
    - 源：字节： InputStream  文本： Reader
    - 目的：字节： OutputStream  文本： Writer
3. 数据所在的具体设备:
    - 源设备：
        硬盘：文件File开头
        内存：数组，字符串
        键盘：System.in  ##控制台输入
        网络：Socket
    - 对应目的设备：
        硬盘：文件File开头
        内存：数组，字符串
        屏幕：System.out
        网络：Socket
4. 是否需要额外功能:
    - 需要转换[转换流]: InputStreamReader OutputStreamWriter
    - 需要高效[缓冲流]: Bufferedxxx
    - 多个源[序列流]: SequenceInputStream
    - 对象序列化: ObjectInputStream ObjectOutputStream
    - 保证数据的输出形式[打印流]: PrintStream Printwriter
    - 操作基本数据,保证字节原样性: DataOutputStream DataInputStream

IO流的分类:

Scanner 类

java.util.Scanner：
 [文本扫描程序]
 [构造方法]
    - Scanner(System.in)
 [方法]：
    - hasNext()  ##是否有下一个
    - next()  ##查找并返回下一个
    - hasNextLine()  ##是否有下一行
    - nextLine()  ##查找并返回下一行

File类

• java.io.File类

  - 文件操作类: 操作[文件本身],不操作[文件内容]
  - 抽象表示(文件/目录): [文件/目录]的[创建/查找/删除]等操作
  

• 构造方法

  #创建File实例:
      - File(String[路径])
      - File(String[父路径],String[子名称])
      - File(File[父路径],String[子名称])   
      - File(URL[url地址路径])
  #[绝对/相对]路径:
      - 绝对路径：完整的路径,以盘符开头
      - 相对路径：简化的路径,以项目开头
  #注意点：
      - 一个[File对象]代表一个实际存在的[文件/目录]
      - 该路径下是否存在[文件/目录]，不影响[File对象]的创建
  

• 常用方法

  #获取功能:
      - [String]getAbsolutePath()  ##获取绝对路径
      - [String]getPath()  ##获取构造(抽象)路径
      - [String]getName()  ##获取名称
      - [String]length()   ##获取长度 
      - [String]getParent()  ##获取父路径名
      - [File]getParentFile()  ##获取父路径
      - [String]lastModified()  ##获取最后修改日期
      - [boolean]setLastModified(String[时间戳])  ##设置最后修改日期
  #判断功能：
      - [boolean]exists()  ##[文件/目录]是否实际存在
      - [boolean]isDirectory()  ##是否为目录
      - [boolean]isFile()  ##是否为文件
      - [boolean]isHidden()  ##是否为隐藏文件
      - [boolean]isAbsolute()  ##抽象是否为绝对路径名
      - [boolean]canRead()  ##应用程序是否可以读取
      - [boolean]canWrite()  ##应用程序是否可以修改
      - [boolean]compareTo(File[文件])  ##比较文件路径
  #创建删除功能
      - [File]File.createTempFile(Striing[名称],String[文件类型], new File(String[地址]))  ##创建临时文件
      - [boolean]createNewFile()  ##文件不存在,创建一个空文件
      - [boolean]delete()  ##删除[文件/目录]
      - deleteOnExit()  ##虚拟机终止，删除
      - [boolean]mkdir()  ##创建目录
      - [boolean]mkdirs()  ##创建多级目录
      - [boolean]renameTo(File[路径名])  ## 重新命名
      - [boolean]setReadOnly()  ##设置只读
  #目录的遍历
      - [String[]]list()  ##获取该目录中所有[子文件/目录]名称
      - [String[]]list(FilenameFilter[过滤])  ##获取该目录中所有[子文件/目录]名称
      - [File[]]listFiles()  ##获取该目录中所有[子文件/目录] (目录必须存在&必须是目录)
      - [File[]]listFiles(FileFilter[过滤])  ##获取该目录中所有[子文件/目录] (目录必须存在&必须是目录)
      - [File[]]File.listRoots()  ##系统所有根目录
  #java.io.FileUtils
      - [long]sizeOfDirectory(File[目录文件])  ##目录大小
  

  递归遍历文件夹下所有的文件:

    //递归遍历文件夹下所有的文件
    public static void Recursion(File file){
        //1、判断传入的是否是目录
        if(!file.isDirectory()){
            //不是目录直接退出
            return;
        }
        //已经确保了传入的file是目录
        File[] files = file.listFiles();
        //遍历files
        for (File f: files) {
            //如果该目录下文件还是个文件夹就再进行递归遍历其子目录
            if(f.isDirectory()){
                //递归
                Recursion(f);
            }else {
                //如果该目录下文件是个文件，则打印对应的名字
                System.out.println(f.getName());
            }

        }
    }

IO流

• 介绍

  输入流[input]: 流向内存,读取数据
  输出流[output]: 流出内存,写出数据
  

• 分类

  #流向分:
      - 输入流：把[数据]从[其他设备]上读取到[内存]中的流
      - 输出流：把[数据]从[内存] 中写出到[其他设备]上的流
  #类型分:
      - 字节流：以[字节]为单位，读写[数据]的流
      - 字符流：以[字符]为单位，读写[数据]的流
  

	输入流	输出流
字节流	字节输入流 InputStream	字节输出流 OutputStream
字符流	字符输入流 Reader	字符输出流 Writer
注：这四个类的子类名的后缀基本都是父类名

• 分流向
  
  

字节流[InputStream/OutputStream]

• 继承关系
  

• 文件的世界里一切皆为字节

  - 字节流可以传输任意文件数据
  - 底层传输的始终为二进制数据
  

• 字节输入流[InputStream]

  #java.io.InputStream
   [字节输入流的所有类的超类(父类)] 
      - 读取字节信息到内存中
  #共性方法:
      - close()  ##关闭并释放
      //末尾返-1
      - [int]read()  ##读取字节(char)
      //返回有效字节数,末尾返-1
      - [int]read(byte[][字节数组])  ##读取到字节数组
  #FileInputStream类: [文件输入流]
   [java.io.FileInputStream]  
   [构造方法]:
      - FileInputStream(File[对象])
      //必须存在该文件
      - FileInputStream(String[路径名])
   [方法]：
      - [int]available()  ##下一次不受阻塞的可读取字节数
  #ByteArrayInputStream类: [字节数组输入流]
   [java.io.ByteArrayInputStream]  
   [构造方法]:
      - ByteArrayInputStream(byte[][字节数组])
      - ByteArrayInputStream(byte[][字节数组],int[开始],int[长度])  ##定长
  #DataInputStream类: [数据输入流]
   [java.io.DataInputStream]  
       - DataInputStream(InputStream[输入流])
  

• 字节输出流[OutputStream]

  #java.io.OutputStream:
   [字节输出流的所有类的超类(父类)]
      - 将指定的字节信息写出
  #共性方法:
      - close()  ##关闭并释放
      - flush()  ##刷新并强制写出缓冲
      - write(int[字节])  ##写出字节 
      - write(byte[][字节数组])  ##写出字节数组
      - write(byte[][字节数组],int[开始],int[长度])  ##写出定长字节数组
  #FileOutputStream类: [文件输出流]
   [java.io.FileOutputStream]  ##文件输出流
   [构造方法]:
      //创建文件-创建流对象-流对象指向文件
      //没有文件:创建/有文件:清空
      - FileOutputStream(File[对象])
      - FileOutputStream(String[路径名])
      //有文件:追加/续写
      - FileOutputStream(File[对象],boolean[追加])
      - FileOutputStream(String[路径名],boolean[追加])
  #ByteArrayOutputStream类: [字节数组输出流]
   [java.io.ByteArrayOutputStream]  
   [构造方法]:
      - ByteArrayOutputStream()
      - ByteArrayOutputStream(int[字节大小])  ##创建定字节大小的缓冲区
   [方法]：
      - [byte[]]toByteArray()  ##创建一个新分配的字节数组
  #DataOutputStream类: [数据输出流]
   [java.io.DataOutputStream]  
       - DataOutputStream(OutputStream[输出流]) 
  

  复制文件:

    // 1.创建流对象
    // 1.1 指定数据源
    FileInputStream fis = new FileInputStream("数据源路劲名");
    // 1.2 指定目的地
    FileOutputStream fos = new FileOutputStream("目的地路劲名");
    // 2.读写数据
    // 2.1 定义数组
    byte[] b = new byte[1024];
    // 2.2 定义长度
    int len;
    // 2.3 循环读取
    while ((len = fis.read(b))!=-1) {
        // 2.4 写出数据
        fos.write(b, 0 , len);
    }
    // 3.关闭资源
    fos.close();
    fis.close();

字符流[Reader/Writer]

• 继承关系
  

• 字符流=字节流+编码表

  #[字符]为单位读写数据:
    [用于处理文本文件]
  #字节流字符乱码问题：
    [读中文会乱码(中文字符占用多个字节存储)]
      - new String(byte[][字节数组],int[开始],int[长度])   ##有解码功能(默认utf-8)
  

• 字符输入流[Reader]

  #java.io.Reader:
   [字符输入流的所有类的超类(父类)]
      - 读取字符信息到内存中
  #共性方法:
      - close()  ##关闭并释放
      //末尾返-1
      - [int]read()  ##读取字符
       //返回有效字符数,末尾返-1
      - [int]read(char[][字符数组])])  ##读取到字符数组
  #FileReader类: 
   [java.io.FileReader]  ##读取字符文件的便利类
   [构造方法]:
      - FileReader(File[对象])
      //必须存在该文件
      - FileReader(String[路径名])
  

• 字符输出流[Writer]

  #java.io.Writer
   [字符输出流的所有类的超类(父类)]
      - 将指定的字符信息写出
  #共性方法:
      - write(int[字符])  ##写出字符
      - write(char[][字符数组])  ##写出字符数组
      - write(char[][字符数组],int[开始],int[长度])  ##写出定长字符数组
      - write(String[字符串])  ##写出字符串
      - write(String[字符串],int[开始],int[长度])  ##写出定长字符串      
      //数据只是保存到缓冲区
      - flush()  ##刷新并强制写出缓冲
      - close()  ##关闭并释放,但要先刷新
  #FileWriter类：
   [java.io.FileWriter]  ##写出字符到文件的便利类
   [构造方法]:
      - FileWriter(File[对象])
      - FileWriter(String[路径名])
      //有文件:追加/续写
      - FileWriter(File[对象],boolean[追加])
      - FileWriter(String[路径名],boolean[追加]) 
  

IO异常

• try…catch…finally

  #IOException  ##IO流异常
  #FileNotFoundException  ##文件不存在异常
  

缓冲流[掌握]

• 概述

  #[高效流]: 对4个[FileXxx]流的“增强流”
      - 创建一个内置的默认大小的缓冲区数组，通过缓冲区读写，减少系统IO次数，从而提高读写的效率。
  #数据类型分类:
   [字节缓冲流]: BufferedInputStream　　BufferedOutputStream
   [字符缓冲流]: BufferedReader　　BufferedWriter
  

• 字节缓冲流

  [构造方法]:
      - BufferedInputStream(InputStream[字节流])
      - BufferedOutputStream(OutputStream[字节流])
  

• 字符缓冲流

  [构造方法]:
      - BufferedReader(Reader[字符流])
      - BufferedWriter(Writer[字符流])
  [特有方法]:
      BufferedReader:
      - [String]readLine()  ##读一行 (最后返回null)
      BufferedWriter:
      - newLine()  ##换行 (系统属性定义符号)
  

转换流[掌握]

• 字符编码与解码

  [编码]: 按照某种规则,将字符存储到计算机中
      - [byte[] - String]new String(byte[][字节数组],String[字符集])
  [解码]: 按照某种规则,将存储在计算机中的二进制数解析显示出来
      - [String - byte[]]getBytes(String[字符集])
  

• 字符集[Charset]

  #[编码表]: 系统支持的所有字符的集合
   [ASCII字符集]:(美国信息交换标准代码: 显示现代英语)
      - 控制字符(回车键、退格、换行键等)
      - 可显示字符(英文大小写字符、阿拉伯数字和西文符号)
   [ISO-8859-1字符集]:(拉丁码表: 显示欧洲使用的语言)
      - 荷兰、丹麦、德语、意大利语、西班牙语等
      - 兼容ASCII编码
   [GBxxx字符集]:(中文码表: 显示中文)
      - GB2312[简体]
      - GBK[常用]
      - GB18030[最新]
   [Unicode字符集]:(统一码\标准万国码: 任意语言的任意字符)
      - UTF-8[常用]
      - UTF-16
      - UTF-32
  

• 字符为转换流[InputStreamReader]

  #java.io.InputStreamReader
   [从字节流到字符流的桥梁]
   [构造方法]:
      - InputStreamReader(InputStream[字节流])  ##默认UTF8
      - InputStreamReader(InputStream[字节流],String[字符集])  ##指定
   [方法]:
      - [boolean]ready()  ##是否可读
  

• 转换为字节流[OutputStreamWriter]

  #java.io.OutputStreamWriter
   [从字符流到字节流的桥梁]
   [构造方法]:
      - OutputStreamWriter(OutputStream[字节流])  ##默认UTF8
      - OutputStreamWriter(OutputStream[字节流],String[字符集])  ##指定
   [方法]:
      - append(String[字符串])  ##附加
  

序列化流[理解]

• 对象[序列化]

  #用[字节序列]表示对象
      - 包含: 对象的数据\对象的类型\对象中存储的属性等
      - 序列化：写出到文件，持久保存对象的信息
      - 反序列化：读取文件，重构为对象
  #java.io.Serializable  ##序列化接口(必须实现)
      - [static final long]serialVersionUID  ##序列版本号
      - NotSerializableException  ##不实现此接口异常
      - transient  ##瞬态(属性不需要可序列化的注明)
  

• 序列化流[ObjectOutputStream]

  #java.io.ObjectOutputStream
   [将对象的原始数据类型写出到文件,实现对象的持久存储]
   [构造方法]: 
      - ObjectOutputStream(OutputStream[字节流])
   [写出对象方法]: 
      - writeObject(Object[对象])  ##写出指定的对象
  

• 反序列化流[ObjectInputStream]

  #java.io.ObjectInputStream
   [将序列化的原始数据恢复为对象]
   [构造方法]:
      - ObjectInputStream(InputStream[字节流])
   [读取对象方法]:
      - [Object]readObject()  ##读取对象
   [异常]:
      - ClassNotFoundException  ##找不到class文件异常
      - InvalidClassException ##无效class文件异常
  

打印流[掌握]

[在控制台打印输出]
#分类：
    - 字节输出打印流[PrintStream]: PrintStream(String[路径名])  
    - 字符输出打印流[PrintWriter]: PrintWriter(String[路径名])
#特点：
    - 操作目的地,不操作数据源
    - 操作任意类型的数据
    - 启用自动刷新,在调用println()时,能够换行并刷新
    - 可以直接操作文件
#方法：
    - println(String[字符串])  ##写入

Properties属性类

• Properties

  #System.getProperties  ##如获取系统属性
  #java.util.Properties
   [集合类,Hashtable的子类,持久的属性集]
   [构造方法]:
      - Properties()
   [存储方法]:
      - [Object]setProperty(String key, String value)  ##保存属性
      - [String]getProperty(String key)  ##获取属性值
      - [Set<String>]stringPropertyNames()  ##所有键的名称的集合
   [IO流结合的方法]:
       ##把键值对形式的文本文件加载到集合
       - load(Reader[字符流])
       - load(InputStream[字节流])
       ##把集合中的数据存储到文本文件
       - store(Writer[字符流],String[comments])
       - store(OutputStream[字节流],String[comments])