8.Java基础（File&Stream&NIO浅说）

1.File

1.文件的概念
File  代表文件和目录，可以进行文件的创建删除重命名，File不能访问内容本身，内容本身的访问可以通过输入/ 输出流来进行处理
创建可以是相对路径 也可以是绝对路径
文件过滤器
list（）方法中含有文件过滤器：
    FilenameFilter 接口 包含一个accept（File，name）
2.文件的简单使用
    a.java.io.File类 表示文件 和目录路径名的抽象表示形式
        分隔符 pathSeparatotChar => /  \
        File f=new File("d:/src/jkjk.java");//操作这个文件
        new File("d:/src");//代表目录
        File f3 =new file(f2,"kjkl.java");也可以这样代表这个文件
        f3.isFile() //是否是个文件  
        f3.isDirectory()//是否是一个目录
        canRead（） 可读的
        exits（） 是否存在
        lastmodified（） 最后修改时间
        getName（）
        getPath（）
        length（）
    b.创建文件或目录
        File f4 =new File("d:/xxxx.text");
        f4.createNewFile（）//
        在f4路径创建一个指定文件，需要处理异常
        f4.delete（）；删除f4的文件
        mkdir（）   f5.mkdir();//创建f5路径下的一个文件
        mkdirs（）   。。。。。。的多个文件夹
    c.以递归展示树形文件结构
        File[] fi=file.listFiles();//将目录每层分别存储在一个file文件中，形成数组
        package cn.bjsxt.test.file;
        import java.io.File;
        public class FileTree {
        public static void main(String[] args) {
               //找一个自己硬盘上有用的文件夹
               File f = new File("d:/aaa");
               printFile(f, 0);
        }
       
        static void printFile(File file,int level){
               for (int i = 0; i < level; i++) {
                       System.out.print("-");
               }
               System.out.println(file.getName());
               
               if(file.isDirectory()){
                       File[]  files = file.listFiles();
                       for (File temp : files) {
                               printFile(temp, level+1);
                       }
               }
        }
        }
3.separator常量
    两个常用常量
    1.路径分隔符 file.pathSeparator ==:
    2文件分隔符 (/window  \非windows) file.separator
        string path = "e:\\xp\\"转义
        path="e:"+file.....
        path ="e：/xd/d/d/d/"推荐使用
    通过绝对路径、相对路径创建
    getpath 获得路径，如果创建时使用相对路径返回相对路径，绝对路径返回绝对路径
    getabsolutepath 绝对路径
    getparent 返回上一级目录 ，如果为相对路径，返回null
    上边只是一种建立联系的过程，并不一定在实盘中创建
4.判断信息：
    读取文件信息（属性）是否存在：src.exists()
    是否可读写：src.canWrinte();
    isFile()
    isDirectory()
    isAbsolute 是否是绝对路径(判断盘符是否存在),主要用于消除平台的差异以盘符开都，其他以/开头
    length（） 字节数//注：文件夹并不能读取长度，
    createNewFile()//只有文件存在才创建和删除文件
注：如果问路径不存在，不能让系统具体判断是否是确定文件的话一律当成文件夹来区别
并不是以是否有.来进行区分的,如：文件夹 命名为2.jpj也是可以的

5.操作文件：
    1.首先建立联系
    2，判断文件是否存在
    3.createNewFile ：boolean 判断文件是否存在
        并不是所有的创建活动都会成功，需要抛出异常
        如创建con 就会失败，con是系统关键字
        如果系统有该文件则不会创建该文件
        delete ：boolean 如果文件正在使用这不会被删除
        temp =FIle.createTempFile（）；当程序退出，则文件就自动删除
        temp.deleteOnExit（）
    4. mkdir（）创建目录，必须保证父目录存在，否则穿件失败
       mkdirs（）创建目录：如果父目录不存在，会创建目录联
    5.过滤
        list （）返回子目录|文件的名称（string）
        listFiles()子目录文件的文件表示形式
        new file（new FileFilter（）｛
           void accept（file ,name ）{
               }
        ｝）//过滤器操作
    6.打出所有名称
        File.listRoot()//打印盘符 c： d:
        过滤器存在listfile（filter）中

2.Stream

输入输出流是从程序运行所在内存的角度来考虑
java使用处理流可以用来包装字节流一种 装饰器设计模式 ，可以消除不同字节流的是差异
字符串内容的最后是\r\n这是windwos平台的换行符
处理流都是直接以物理IO节点作为构造器参数的
在使用处理流包装底层节点流之后，挂载输入输出流资源时，只要关闭最上层的处理流即可， 关闭最上层的处理流时，系统会自动关闭被该处理包装的节点流
由于BufferedReader具有一个readLine（）方法，可以非常方便的一次读入一行，所以经常将读取文本的输入流包装成BufferedReader
-------------------------------------------------------------
一.流：流向 从一段移动到另一端 源头和目的地
程序与文件|数组网络连接 数据库 依程序为中心
二.IO流分类
    1.流向：输入流与输入流
    2.数据：字节流 可以处理一切数据 包括纯文本doc音频视频
                   字符流 文本文件，只能处理文本
    3.功能：节点流 ：包裹源头，离流近
处理：增强功能，提供性能
三、字节流，和字符流
    1.字节流：
           输入流Inputstream        read（byte[]）+close()
           实现：FilePutStream
           输出流ouputstream        write(byte[]) flush() close()
           FileoutStream
    2.reader  read(char[])
           writer wirte(char[]) flush + close()
                   writer(string)
    3.字符流：只能处理存文本，可以全部可见的字符，txt html
        a. 纯文本读取：仅限纯文本，二进制打不开
            1.建立联系
            2.选择流
            3.读取char[] flush = new char[1024]
            4. 关闭
        b..写入
    4.工具类 ：一般使用的是字节流
    5.处理流：增强流，处理流一定要在节点流的基础上
    6.节点流：字节字符，输入输入出流
    7.字节缓冲流
        BUfferedInputstream
        BufferedOutputStream   这两个没有新增方法
    8.字符缓冲流（建议加上缓冲流提高性能）
        BufferedReader  新增方法 readline()
        BufferedWriter        新增方法newline()
        new BufferedInputstream（new FileInputsream（））
        注：使用新增方法不能用多态
            while（null=（String lin =read.readline() ））{
            wo.writer(line);
            wo.append("\r\n")//换行
            === wo.newline();}
    9.转化流：字节流转化为字符流 处理乱码（编码集，解码集）（只能字节转字符）
        1.编码与解码概念
            编码： 字符 编码 --》二进制
            解码 ：二进制 解码字符集-->字符集
            错误：1)编码和解码不同一  2)字节缺失
            解码byte-->char
                String str ="中国";
                编码 char ->byte
                byte[] data = str.getDytes();
            //编码和解码的同一
                syso(new String(data));
                data=str.getbyte("utf-8");//设定字符集
                str = new string（data，"utf-8"）
            1)解码和编码的字符集必须相同，否则乱码2)字节数不完整
        2.文件乱码：
            一定要知道编码的时候的字符集，否则解不回来
            转化流：字节转为字符
            1.输出流ouputstreamWriter 编码
            2.输入流inputstramreader  解码
            new BufferedReader(new inputstreamReader(new FileInputStream(file),"utf-8"))
    10.字节数组输入流\输出流
        ByteArrayInputStream 可以不用close（）
        ByteArrayOutputStream 中特有的复杂行+toByteArray（）
        综合：
            文件 ->程序-> 数组
            数组-->程序-> 文件
            文件输入流 ->程序->数组输入流（不能用多态）
            数组输入流 ->程序 ->文件输出流
    
    11.处理流：
        数据类型（基本类型+String）处理流：给机器阅读的
        1.基本类型+string  保留数据+类型
        输入流 DataInputStream  +readXXX（）
        输出流            +writerxxxx（）
        数据+类型输出到文件
        注：读取的顺序与写出一直 必须存在才能读取
        数据+类型输出到字节数组中
        bos = new ByteArrayInputStream()
        dateouputStream oos = new DataOutputstram( new BufferedInputstream（bos));
        bos.toByteArray（）
    12.系统 System.out
        打印流：printstream 输出流
        处理流：printstream ps = system.out;
                 ps.println();
        输出到文件
                system.out
                system.err 本质上一样的
                system.in 输入流
        重定向 ： 从默认到 文件，默认输出到控制台，或者键盘
            setIn()
            setOUt(new printstream(new buffedoutput(new fieloutputstra(new file("xxx"),true))))
            setErr()
            通过system.out 进行重新定向
            以后程序中会出现大量的system.out
        1.用来调试代码
        2.打印日志
        回控制台：
        什么是控制台： 进入system类可查看
        FileDescrioptor.in 不能直接使用 需要和filestream 联合使用
        bufferedReader br = new Bufferreader(new inputstreamReader(is));
        string str = br.readline();
    13.RandomAccessFile 局限： 只能用于读写文件，不能读写其他IO节点
       RandomAccessFile可以自由移动记录指针，即可以向前移动，也可以向后移动
       long getFilePointer（）//返回当前记录指针的位置
       seek（long） 将文件的记录指针定位到pos位置
        注意：多线程断点传输工具
        RandomAccessFile  随机读取文件
        RandomAccessFile rnf = newRandomAccessFile（new file（""））;
        rnd.seek(10)';从10开始读
        文件的分块思路：
            1.分块的块数
            2.每块的大小
            3.每块的名称
        第二步：
            1.分隔
            2.第几块、每块的起点，最后
            while(-1 ! =(len = rnf.read(fluse))){
            if(len>=20){
            new stirng(flush,0,20)
            }else{
            flush,0,len
            }
            }
        将一个文件分隔为几个文件
        文件的合并：文件的追加



    
四、读取文件信息(属性)
    1.建立联系  File对象
    2.选择流
    3.操作目录：
        byte[] bt = new byte[1024];                
        File  src = new FIle("")                
        new FileInputStream(src);
        while(-1 !=(lemn= stream.read(buff))){
            new string(bugg,o,len)
        }        
        FileOutputStream("FIle",true);追加 默认false 覆盖
        os.flush();强制刷新出去
        try cath 中含有flush 默认还有flush操作    
五、文件拷贝：        
    源文件文件存在且为文件
    目的地可以不存在，自动创建
    流的过程中会出现乱码现象
六、文件夹拷贝
    1.递归查找子孙级文件 文件夹并不能读取长度，只有文件才能
    2 文件 赋值（IO复制）
    文件夹 创建
    文件是可以覆盖的，但是文件夹是不可以覆盖的，会报文件拒绝访问
    字节流可以处理一切数据，包括二进制

3.序列化

1.Serialable
序列化： RMI Romote Method Invoke 远程方法调用 过程中的参数 和返回值都需要序列化参数，web 应用中需要保存到HttpSession 或servletContext属性的java对象
    程序创建的每个javabean类都实现了serilizable ,只是一种标记
    通常创建将一个javaBean类的实现serializble
ObjectOutput是一个处理流
    readObject
    writeObject
java反序列化的是数据，而不是java类
在进行java反序列化的时候必须提供class文件，否则将会引发ClassNotFoundException--找不到对应的java类时将会引发该异常

注意： 
    1.序列化工程过程中如果包含了其他对象的引用则会序列化其包含的引用对象，我们称为递归序列化
    2.transient 关键字用于修饰实例变量，不可修饰java程序中的其他成分，用于表明 不必序列化，序列化时则将其看为默认值 0 u/0000 false
    3.writeObject（）方法存储实例变量的顺序应该和readObject（）方法中恢复实例的变量的顺序一致，否则将不能正常恢复该java对象
序列化过程中提供了一种更为彻底的序列化机制：将当前序列化对象转变为方法writeRplace（）方法返回值object
任何序列化对象都可以重写这个方法
    ANY_ACCESS_MODIFIER object writeReplace()
序列化对象时首先执行replaceWriter方法 ，可不断调用replaceWriter（）方法，知道返回值不再是obj为止
例外一个 replaceResolve（）用来取代readObject的返回值 ，在readObject（）运行后执行，在序列化单例 、枚举的时候尤为重要 ，小心使用

注：反序列话机制在恢复java对象时无须调用构造器来初始化java对象，从这种意义上来看，反序列化机制可以用来克隆对象

2.Externalizable
序列化机制 实Externalizable现接口，并实现 writeExteranl 和readExternal ，从而手动完成需要序列化的数据
static 关键字也可以是实现实例变量的的非序列化，但是不可以这样使用
序列化只是针对对象而言，而不是类
注：反序列化对象必须要有序列化对象的class文件，
但通过文件网络来读取序列化的对象时，必须按实际写入的顺序读取
版本兼容：
    手动指定 static final long serialVersionUID = 7878L;
    反射里面的IoC 是反射的框架

4.NIO浅说

1.NIO出现背景和名词
java.io 包的缺点：
    1.如果数据源中没有数据将会阻塞线程
    2.底层实现依赖字节处理 效率不高
       
NIO：新io将文件或者文件的一段映射到内存中（模拟操作系统上的虚拟内存的概念）
Channel 通道 和Buffer （缓冲）是新IO中的两个核心对象
Channel（通道） 是对传统输入输出的模拟，最大的区别是增加了一个map（）方法，通过map()方法可以直接将一块数据映射到内存中，如果输入输出是面向流的处理，则新IO是面向块处理;buffer 是一个容器，本质是一个数组，发送到Channel的所有对象都要首先放入到Buffer 当中;提供将Unicode 字符串映射字节序列以及逆映射操作的charset类，也提供支持非阻塞输入输出selector
Buffer 是一个接口，常用的子类 ByteBuffer、CharBuffer、shotrBuffer...
有get（）和set（）方法
allocate（int） 创建一个 buffer 空间为int 大小
容量、界限、位置
MappedByteBuffer用于表示Channel将磁盘文件的部分或者全部内容映射到内存中得到的结果
mark 用于标记位置
0<=mark<=position<=limit<capacity
positioin只能跳转到已经读取的数据位置，可以往前但不能向后
Buffer中包含两个重要的方法，即flip() ,flip()为从buffer 去处数据做准备，clear（）为再次向buffer中装入数据做准备
flip（） 将limit变为position位置，position变为0
clear（）将limit编程capacity position变为0
ByteBuffer还提供allocateDirect（）来创建Buffer的方法，创建成本很高但是读取速度很快，所以只适合那些生存周期很长的情况
Channel 类似传统流对象
    1.可以将指定文件部分或全部映射成buffer
    2.只能和buffer交流
根据功能可以分为DatagramChannel（udp）、FileChannel、。。。
不通过构造器得到，而是通过InputStream、outPutStream 的getChannel（）方法
map（） write（） read（）
字符集和Charset：
通常而言 把明文转为计算机理解的二进制序列称谓编码，把二进制序列转换为不同人都能看得懂的明文字符串称为 解码
当需要保存文本时，必须将每个字符转换为二进制序列，当需要读取文件时，需要将二进制序列转化为一个个字符
Charset.forName("ISO-8859-1");用来创建一个Charset对象
newDecoder （）方法和 newEncoder（）方法分别得到CharsetDecoder和CharsetEncoder对象

2.NIO中对文件的重定义：
a.文件锁的功能： 有效阻止多个进程并发修改同一个文件
    FileChannel中提供 lock或者tryLock可以获取FileLock对象
    共享锁和排他锁 默认生成排他锁
    使用release（）开始放锁
    文件锁虽然可以用于控制并发访问，当时对于并发访问的情形，还是推荐使用数据库来保存程序信息，而不是文件
    FIleLock 在不同平台上的表现是不同的
b.NIO2 提供全面的文件IO 和文件系统访问支持, 基于异步channel的IO
    File类弊端太多将升级 FIles Paths有两个返回path的静态工厂方法。
    path接口代表一个与平台无关的平台路径
    FIles 操作文件的工具类，文件路径是通过path传入，来完成文件复制、读取文件、写入文件内容等方式，大大简化了IO操作，本来应该是流的操作
    FileVisitor便利文件和目录
    Files文件提供walkFileTree(Path,FileVisitor) 从path开始遍历，每次遍历都会触发FileVisitor 的里面相应方法，FIleVIsitor是一个抽象类，可通过继承SimpleFileVisitor 方法来继承
    WatchService监控文件变化
    Path的register（WatchService ，WatchEvent.kind）
    访问文件属性：
    file.attribute()文件可以用来获取特定文件属性