文件流和TomCat/Spring知识框架

 文件流

        文件低级流
            FileInputStream
                文件输入流，连接程序和文件的管道，负责从文件读取字节
            FileOutputStream
                文件输出流，连接程序和文件的管道，负责将字节写入文件
        文件高级流
            字节缓存流
                BufferedInputStream
                    缓存字节输入，块读字节数据加速
                BufferedOutputStream
                    缓存字节写入，块写字节数据加速
            转换流
                InputStreamReader
                    将字节转换成字符，衔接字节和字符流
                OutputStreamWriter
                    将字符转换成字节，衔接字符和字节流
            字符缓存流
                BufferedReaderr
                    按行读取字符，块读文本数据加速
                PrintWriter
                    按行写入字符，块写文本数据加速
            对象流
                ObjectInputStream
                    进行对象反序列化
                ObjuectOutputStream
                    进行对象序列化
    子主题 2
        SE阶段知识梳理
            API知识点罗列
                JAVA IO
                    java.io.File
                        背景知识
                            硬盘
                                机械硬盘
                                固态硬盘
                                硬盘的特性
                                    长久保存数据
                                    读写性能
                                    长久保存数据，读写性能低
                            硬盘与内存
                                什么是内存
                                内存的特性
                                内存与硬盘的关系
                                内存读写性能快，满足CPU运行效率。
                            结论
                        常用构造器
                            File(String pathname)
                            File(File parent,String child)
                        常用API
                            查看属性相关方法
                                获取名字
                                    String getName()
                                获取长度
                                    long length
                                是否可读
                                    boolean  canRead()
                                是否可写
                                    boolean canWrite()
                                是否隐藏
                                    boolean isHidden()
                                是否存在
                                    boolean exists()
                                是否存在且是一个文件
                                    boolean isFile()
                                是否存在且是一个目录
                                    boolean isDirectory()
                            创建与删除
                                创建新文件
                                    boolean createNewFile()
                                创建目录
                                    boolean mkdir()
                                    boolean mkdirs()
                                删除文件或目录
                                    boolean delete()
                                        删除文件
                                        删除目录
                            获取目录子项
                                listFiles()方法
                                    FIle[] listFiles()
                                    File[] listFiles(FileFilter filter)
                                        回调模式
                                        匿名内部类创建过滤器
                                            FileFilter接口
                                                重写accept()方法
                                        lambda表达式
                                            基本语法要求
                                                (参数列表)->{方法体}
                                            几种特殊写法
                                                何时可以不写"()"
                                                何时可以忽略"{}"
                                                    忽略return
                                            JDK8支持
                        常见问题
                            File的length()方法返回的文件长度为0？
                            创建文件出现异常:java.io.IOException: 系统找不到指定的路径。
                                文件所在的目录不存在
                            删除目录失败
                                不是空目录
                    stream流
                        流的分类
                            输入与输出
                                input输入
                                    负责读取操作
                                output输出
                                    负责写出操作
                            字节与字符流
                                字节流
                                    java.io.InputStream
                                        int read()
                                        块读操作
                                            int read(byte[] data)
                                            int read(byte[] data,int offset,int len)
                                    java.io.OutputStream
                                        void write(int d)
                                        块写操作
                                            void write(byte[] data)
                                            void write(byte[] data,int offset,int len)
                                字符流
                                    java.io.Reader
                                        int read()
                                        int read(char[] data)
                                        int read(char[] data,int offset,int len)
                                        int read(CharBuffer target)
                                    java.io.Writer
                                        void write(int d)
                                        void write(char[] data)
                                        void write(char[]data,int offset,int len)
                                        void write(String str)
                            节点与处理流
                                节点流(低级流)
                                    文件流
                                        FileInputStream
                                        FileOutputStream
                                    字节数组流
                                        ByteArrayInputStream
                                        ByteArrayOutputStream
                                处理流(高级流)
                                    缓冲字节流
                                        BufferedInputStream
                                        BufferedOutputStream
                                    对象流
                                        ObjectInputStream
                                        ObjectOutputStream
                                    转换流
                                        InputStreamReader
                                        OutputStreamWriter
                                    缓冲字符流
                                        BufferedReader
                                        PrintWriter
                        常用API
                            文件流
                                FileInputStream
                                    从文件中读取字节数据的流
                                        常用构造器
                                            FileInputStream(String filename)
                                            FileInputStream(File file)
                                        
                                        实例化时常见异常
                                            FileNotFoundException
                                                如果该文件不存在，或者它是一个目录，而不是一个常规文件，抑或因为其他某些原因而无法打开进行读取。
                                FileOutputStream
                                    向文件中写入字节的流
                                        常用构造器
                                            覆盖模式
                                                FileOutputStream(String filename)
                                                FileOutputStream(File file)
                                                如果指定的文件存在，会先将文件原数据清除
                                            追加模式
                                                FileOutputStream(String filename,boolean append)
                                                FileOutputStream(File file,boolean append)
                                                如果参数append为true，则写入的数据会追加到文件中
                                        
                                        实例化时常见异常
                                            FileNotFoundException
                                                如果该文件存在，但它是一个目录，而不是一个常规文件；或者该文件不存在，但无法创建它；抑或因为其他某些原因而无法打开
                            缓冲字节流
                                以块读写形式加快字节数据的读写效率
                                    BufferedInputStream
                                        常用构造器
                                            BufferedInputStream(InputStream in)
                                                创建一个用于连接参数指定的输入流上的缓冲字节输入流，默认缓冲区(内部字节数组)大小8kb(8192个字节)
                                            BufferedInputStream(InputStream in, int size)
                                                创建一个用于连接参数指定的输入流上的缓冲字节输入流，缓冲区(内部字节数组)大小由参数size指定
                                        
                                    BufferedOutputStream
                                        常用构造器
                                            BufferedOutputStream(OutputStream out)
                                                创建一个用于连接参数指定的输出流上的缓冲字节输出流，默认缓冲区(内部字节数组)大小8kb(8192个字节)
                                            BufferedOutputStream(OutputStream out, int size)
                                                创建一个用于连接参数指定的输出流上的缓冲字节输出流，缓冲区(内部字节数组)大小由参数size指定
                                        
                            对象流
                                ObjectInputStream
                                    对象反序列化
                                        常用方法
                                            Object readObject()
                                                读取一组字节并将其反序列化为对象
                                        
                                        常见异常
                                            ClassNotFoundException
                                                找不到序列化对象的类。
                                            InvalidClassException
                                                序列化使用的类出了问题。
                                ObjectOutputStream
                                    对象序列化
                                        常用方法
                                            void writeObject(Object obj)
                                                将参数对象obj序列化并写出
                                        
                                        常见异常
                                            InvalidClassException
                                                序列化操作使用的类出了问题
                                            NotSerializableException
                                                某个要序列化的对象没有实现 java.io.Serializable 接口
                                Serializable
                                    serialVersionUID
                                    transient关键字
                                应用场景
                                    持久化对象
                                        通过在流中使用文件可以实现对象的持久存储
                                    网络传输对象
                                        如果流是网络套接字流，则可以在另一台主机上或另一个进程中重构对象。
                            转换流
                                转换流是字节流与字符流之间的桥梁，起到了"转换器"的作用。
                                    InputStreamReader
                                        常用构造器
                                            InputStreamReader(InputStream in)
                                                使用系统默认字符集创建并连接到参数in指定的直接输入流上
                                            InputStreamReader(InputStream in,Charset cs)
                                                使用参数cs指定的字符集创建并连接到参数in指定的直接输入流上。字符集通常使用：StandardCharset.UTF-8
                                    OutputStreamWriter
                                        常用构造器
                                            OutputStreamReader(OutputStream out)
                                                使用系统默认字符集创建并连接到参数out指定的直接输出流上
                                            OutputStreamReader(OutputStream out,Charset cs)
                                                使用参数cs指定的字符集创建并连接到参数out指定的直接输出流上。字符集通常使用：StandardCharset.UTF-8
                            缓冲字符流
                                以块读写形式加快字符数据的读写效率
                                    BufferedReader
                                        常用构造器
                                            BufferedReader(Reader in)
                                                创建一个用于连接在指定的字符输入流in上的缓冲字符输入流，默认内部缓冲区(char数组)大小为8k(8192个字符)
                                            BufferedReader(Reader in, int size)
                                                创建一个用于连接在指定的字符输入流in上的缓冲字符输入流，内部缓冲区大小由参数size指定
                                        常用方法
                                            String readLine()
                                                读取一个文本行。通过下列字符之一即可认为某行已终止：换行 ('\n')、回车 ('\r') 或回车后直接跟着换行。
                                        
                                    PrintWriter
                                        常用构造器
                                            直接对文件进行操作
                                                PrintWriter(String fileName)
                                                    创建具有指定文件名称且不带自动行刷新的新 PrintWriter
                                                PrintWriter(String fileName, String csn)
                                                    创建具有指定文件名称和字符集且不带自动行刷新的新 PrintWriter
                                                PrintWriter(File file)
                                                    使用指定文件创建不具有自动行刷新的新 PrintWriter
                                                PrintWriter(File file, String csn)
                                                    创建具有指定文件和字符集且不带自动刷行新的新 PrintWriter
                                                常见异常
                                                    FileNotFoundException
                                                        如果给定的文件不表示现有的可写常规文件，并且无法创建该名称的新常规文件，或者在打开或创建文件时发生其他一些错误
                                                    UnsupportedEncodingException
                                                        如果不支持指定字符集，通常原因是字符集名字拼写错误
                                            直接连接字节输出流
                                                创建时会自动在内部连接this->BufferedWriter->OutputStreamWriter->out
                                                    PrintWriter(OutputStream out)
                                                        根据现有的 OutputStream 创建不带自动行刷新的新 PrintWriter。此便捷构造方法创建必要的中间 OutputStreamWriter，后者使用默认字符编码将字符转换为字节。
                                                    PrintWriter(OutputStream out, boolean autoFlush)
                                                        根据现有的 OutputStream 创建不带自动行刷新的新 PrintWriter。此便捷构造方法创建必要的中间 OutputStreamWriter，后者使用默认字符编码将字符转换为字节。
                                            连接在其他字符输出流
                                                PrintWriter(Writer out)
                                                    创建不带自动行刷新的新 PrintWriter。
                                                PrintWriter(Writer out, boolean autoFlush)
                                                    创建新 PrintWriter，通过参数autoFlush设定是否需要自动行刷新
                                                要特别注意，此种创建方式不会自动在内部连接缓冲字符输出流。所以如果需要则需要自行连接BufferedWriter。
                                        
                            字节数组流
                                ByteArrayInputStream
                                    从字节数组中读取数据的流(其内部维护的字节数组，该数组可以在创建流时传入)
                                ByteArrayOutputStream
                                    向字节数组中写入数据的流(写入流内部维护的字节数组中，该数组会自动扩容)
                                        在WebServer项目中实现动态数据响应时，HttpServletResponse中有所应用
                                            常用构造器
                                                ByteArrayOutputStream()
                                                    创建一个新的 byte 数组输出流。缓冲区的容量最初是 32 字节，如有必要可增加其大小。
                                                ByteArrayOutputStream(int size)
                                                    创建一个新的 byte 数组输出流，它具有指定大小的缓冲区容量（以字节为单位）。
                                            常用方法
                                                byte[] toByteArray()
                                                    创建一个新分配的 byte 数组。其大小是此输出流的当前大小，并且缓冲区的有效内容已复制到该数组中。
                                                int size()
                                                    返回缓冲区的当前大小。
                        流连接意义
                            实际开发中我们经常会串联一组高级流最终连接到低级流上，在读写操作时以流水线式的加工
 完成复杂IO操作。这个过程也称为"流的连接"。
                                示意图
                        继承树
                            java.io.AutoCloseable接口
                                java.io.Closeable接口
                                    java.io.InputStream
                                        java.io.FileInputStream
                                        java.io.BufferedInputStream
                                        java.io.ObjectInputStream
                                    java.io.OutputStream
                                        java.io.FileOutputStream
                                        java.io.ByteOutputStream
                                        java.io.BufferedOutputStream
                                        java.io.ObjectOutputStream
                                    java.io.Reader
                                        java.io.InputStreamReader
                                        java.io.BufferedReader
                                    java.io.Writer
                                        java.io.OutputStreamWriter
                                        java.io.BufferedWriter
                                        java.io.PrintWriter
                            java.io.Flushable
                异常
                    异常类型
                        Throwable
                            Error
                                表示JVM级别的系统错误，导致JVM无法继续执行，这类错误是不可恢复的。
                            Exception
                                表示可以恢复的异常，这通常都是程序中出现的异常
                    try-catch
                        基本结构
                            try-catch
                            try-catch-finally
                            try-finally
                        多catch
                            针对不同异常有不同处理方式时，可以分别catch并处理
                        合并catch
                            当多个异常具有相同处理方式时可以合并在一个catch中处理
                        catch捕获优先级
                            由上至下，上面的catch处理后就不会在执行下面同样可以处理该异常的catch
                        异常处理执行流程
                            try语句块中出现异常
                                跳出try语句块并执行对应的catch语句块
                                    有finally
                                        继续执行finally块代码，之后退出异常处理机制继续向后执行
                                    无finally
                                        退出异常处理机制继续向后执行
                            try语句块中不出现异常
                                有finally
                                    try语句块中代码执行到return
                                        先执行finally中代码，之后方法返回。
                                    try语句块中没有return
                                        先执行finally中的代码，之后退出异常处理机制，程序继续向后执行。
                                无finally
                                    try语句块执行完正常退出异常处理机制，程序继续向后执行代码
                    finally
                        finally特点
                            无论try语句块中的代码是否出现异常，finally最终都必定执行
                        finally在IO中的应用
                        自动关闭特性AutoCloseable
                            只有实现了AutoCloseable接口的类在可以在try()中定义并初始化
                            编译器认可，编译后会将在try()中声明并初始化的对象在finally中调用close方法关闭。
                    throw与throws
                        异常抛出的原则
                            异常不应当在当前代码片段被处理时可以将其抛出
                            当遇到满足语法但是不满足业务场景时可以抛出自定义异常
                        throws重写规则
                            允许
                                不再抛出任何异常
                                抛出部分异常
                                抛出超类方法抛出异常的子类型异常
                            不允许
                                额外异常(超类方法没有声明抛出并且也没有继承关系的异常)
                                抛出超类方法抛出异常的超类型异常
                    异常API
                        printStackTrace
                        getMessage
                    自定义异常
                        自定义异常意义
                            通常用来描述业务上的错误问题
                        自定义异常定义步骤
                            类名见名知义
                            直接或间接继承Exception
                            提供超类异常提供的所有构造器
                    Exception中的分类
                        检查与非检查异常
                            非检查异常RuntimeException
                                NullPointerException
                                    空指针异常，当使用一个引用类型变量调用其属性或方法时，若该引用变量值为null时则会引发空指针异常。
                                ArrayIndexOutOfBoundException
                                    数组下标越界，当指定的数组下标超过了数组允许的下标范围时(给定的下标<0或>=数组长度)引发该异常。
                                ClassCastException
                                    将一个超类向下造型成某个子类型时，如果该超类引用指向的对象并非造型的类型时引发该异常。
                                NumberFormatException
                                    在使用数字类型包装类将字符串解析为对应数字时，如果该字符串描述的内容并非数字或是基本类型无法保存的数字时引发该异常
                                掌握出现场景
                            检查异常
                                IOException
                                SQLException
                                SocketException
                                ...
                多线程
                    进程与线程
                    线程生命周期
                        
                    线程的创建与启动
                        继承Thread
                        实现Runnable接口
                    线程API
                        static Thread currentThread()
                        线程信息相关
                            int getId()
                            String getName()
                            int getPriority()
                            boolean isAlive()
                            boolean isInterrupted()
                            boolean isDaemon()
                        static void sleep(long ms)
                        void setDaemon(boolean on)
                        void setPriority(int priority)
                    用户线程与守护线程
                    线程并发安全问题
                        并发安全的出现场景
                        synchronized
                            同步方法
                                成员方法
                                静态方法
                            同步块
                                同步监视器对象的选取原则
                                    成员方法中
                                    静态方法中
                                同步范围
                        互斥
                        死锁
                网络
                    TCP协议三次握手与四次挥手
                    客户端与服务端的划分
                    Socket与ServerSocket相关API
                        java.net.Socket
                            构造方法
                                主机地址信息的含义
                                端口号的含义
                            流的获取
                                getInputStream
                                getOutputStream
                                与远端计算机的数据交互
                            close方法
                        java.net.ServerSocket
                            构造方法
                                端口的含义
                                java.net.BindException
                            accept方法
                    聊天室案例
                        客户端与服务端建立连接过程
                        交互过程
                        多线程并发安全问题的分析与解决
                        常见问题
                            java.net.ConnectException: Connection refused: connect
                                连接拒绝，通常是客户端连接服务端时，由于服务端没有启动导致的
                            java.net.ConnectException: Time out
                                连接超时，通常时由于服务端计算机的防火墙导致客户端无法连接
                            java.net.BindException: address already in use
                                地址已被使用，原因时服务端申请的服务端口已经被系统其他进程所使用导致
                            java.net.SocketException: Connection reset
                                远端计算机异常断开导致(没有调用socket.close()进行正常的挥手操作)
                            含义及解决办法
                集合框架
                    java.util.Collection
                        常见子类
                            List
                            Set
                            区别
                        常用API
                        元素equals对集合的影响
                        泛型应用
                        内存图分析
                    迭代器与新循环
                        Iterator
                            常用API
                            遍历规则
                        增强型for循环
                            遍历数组
                            遍历集合
                            编译器认可，还原后的区别
                        forEach()
                    List集合
                        常用List
                            ArrayList
                            LinkedList
                            数据结构区别与特点，性能差异分析
                        常用API
                    集合与数组的转换
                        Collection的toArray()
                        Arrays.asList()
                    集合排序
                        Collections.sort
                            无参sort
                            有参sort
                                Comparator
                                    匿名内部类创建
                                    lambda创建
                                    compare方法重写规则
                            侵入性问题
                        List.sort()
                    Map
                        散列表应用
                反射机制
                    Class类
                    类加载方式
                    反射API
                        实例化对象
                        方法调用
                        暴力反射
                    注解操作
                JDK新特性汇总
                    lambda
                    变长参数
                    自动关闭特性
            常见面试题
                IO
                线程
                    并发安全
                        多线程同步有哪些方法？
                        一个对象的两个方法加 synchronized，一个线程进去 sleep，另一个线程可以进入到另一个方法吗？
                        什么是可重入锁（ReentrantLock）
                    线程的创建
                        创建线程的三个方法是什么？
                        多线程越多效率越高吗？
                    线程池
                        线程池有哪几种创建方式？
                        线程池参数有哪些？
                        线程池拒绝策略有哪些？
                        你认为对线程池的核心参数实现自定义可配置，三个核心参数是什么?
                        ThreadPoolExecutor 线程池，corePoolSize=5，maximumPoolSize=10，queueCapacity=10，有 20 个耗时任务 交给这个线程池执行，线程池会如何执行这 20 个任务？
                        给用户发消息任务超出队列，你用哪个拒绝策略？有其他方法吗 ？
                异常
                集合
                    Map
                        HashMap 的底层数据结构是怎样的 ？
                        HashMap 的扩容机制是怎样的？
                        ConcurrentHashMap 的存储结构是怎样的？
                    Collection
                        栈与队列
                            什么是栈和队列，举个使用场景例子？
                网络
                    TCP
                        TCP 和 UDP 区别？
                        TCP/IP 协议涉及哪几层架构？
                        描述下 TCP 连接 4 次挥手的过程？为什么要 4 次挥手？
                    HTTP
                JDK特性
                    Java8 新特性有哪些了解?
            涉及到的基础操作
                git
                    git安装
                    idea中git的配置
                    gitee，华为云，github
                        账号注册过程
                        仓库的创建
                        权限管理(开源权限)
                        token使用
                    idea中VCS操作
                        导入git版本控制操作
                        提交commit
                        push操作
                            push远程仓库
                            常见错误
                                提交拒绝
                                无网络
                                用户名密码错误
                                版本不一致
                                无法识别远端仓库
                        pull操作
                        rollback操作
                    操作系统
                        windows
                        mac
                maven基础配置
                    maven项目的创建
                    IDEA中maven配置
                        User Setting File
                            windows默认位置
                            mac默认位置定位
                                Finder的使用
                            settings.xml文件配置
                                doc.canglaoshi.org网站下载
                        Local repository
                            idea中mave依赖下载失败解决方案
                            可修改仓库位置
                idea基本操作
                    新建项目
                        项目位置更改
                        java项目
                        Maven项目
                        SpringBoot项目
                            https://start.springboot.io
                            group与artifact
                            JDK8
                            项目结构
                                包结构
                                Application主启动类
                                Controller
                                    包定义规则
                                    注解
                                        @Controller
                                        @RequestMapping
                            helloworld
                    终极版项目的安装
                        试用操作
                    界面布局的修改
                    本地jar文件依赖导入
                    常用快捷键
                        windows
                        mac
            标签提示
                推荐操作
                注意笔记
                扩展知识
                重点概念