第10章 文件与流

/*****************
***第10章 文件与流
*******知识点:
**************1.文件类
******************1.1 文件的基本操作
******************1.2 文件遍历
******************1.3 文件过滤器
**************2.IO流
******************2.1 输入流
**************************2.1.1 字节流
**************************2.1.2 字符流
******************2.2 输出流
**************************2.2.1 字节流
**************************2.2.2 字符流
******************2.3 缓冲流
**************************2.3.1 输入缓冲流
**************************2.3.2 输出缓冲流
******************2.4 序列化
******************2.5 随机访问
**************3.编码集


*/
import java.io.*;
/*
*自定义文件过滤器 
*    1.实现FilenameFilter接口  
*    2.重写accept方法
*/
class DirFilter implements FilenameFilter {
    private String type;
    
    public DirFilter(String type){
        this.type = type;
    }
    
    public boolean accept(File dir,String name){
        return name.endsWith(type) || new File(name).isDirectory();
    }
}

class Person implements Serializable{
    private String id,name;
    Person(){
        this.id = "0000";
        this.name = "无名氏";
    }
    Person(String id, String name){
        this.id = id;
        this.name = name;
    }
    
    public String toString(){
        return "{编码：" + id +",姓名：" + name +"}\r\n"; 
    }
}

public class test10{
    public static final String filePath = "F:\\ciade\\学习\\学习笔记\\Java\\第10章(文件和流)";
    
    public static void main(String[] args){
        showDemo("1.文件类");//演示1.文件类
        demoFile();
        
        showDemo("2.IO流");//演示2.IO流
        demoIO();
        
        showDemo("3.编码集");//演示3.编码集
        demoCodeSet();
    }
    
    /*
    *1.文件类
    */
    public static void demoFile(){
        
        /**1.1 文件的基本操作**/
        System.out.println("返回系统默认分隔符：" + File.pathSeparator);//返回系统默认分隔符
        System.out.println("返回系统默认路径分隔符：" + File.separator);//返回系统默认路径分隔符
        File f_File = new File(filePath + "\\test10_1.class");
        System.out.println("是否存在文件：" + f_File.exists());//判断文件是否存在
        System.out.println("是否为文件：" + f_File.isFile());//判断是否是文件
        System.out.println("是否为目录：" + f_File.isDirectory());//判断是否是文件夹
        System.out.println("返回文件绝对路径：" + f_File.getPath());//返回文件绝对路径
        System.out.println("返回父级目录绝对路径：" + f_File.getParent());//返回父级目录绝对路径
        System.out.println("返回文件长度大小：" + f_File.length());//单位:字节
        
        //文件增加和删除
        File f_New = new File(filePath + "\\test.txt");
        if(!f_New.exists()){//判断是否存在
            try{
                System.out.println("创建文件：" + f_New.createNewFile());//创建新的文件
                
            }catch(Exception e){
                System.out.println("创建文件失败，失败原因" + e);
                
            }
        }else{
            try{
                System.out.println("删除文件成功：" + f_New.delete());//删除文件
            }catch(Exception e){
                System.out.println("删除文件失败，失败原因" + e);
            }
        }
        
        /**1.2 文件遍历**/
        try{
            //初始化创建文件和文件夹
            File f_file,f_fold;
            for(int i = 0; i<10;i++){
                f_file =  new File(filePath + "\\" + i + ".txt");
                f_fold =  new File(filePath + "\\" + i + "_");
                f_file.createNewFile();//创建文件
                f_fold.mkdir();//创建目录
            }    
            System.out.println("初始化文件成功!");
            
            File file = new File(filePath);
            File[] file_list = file.listFiles();//得到所有文件对象和文件夹对象
            
            //遍历文件列表
            for(File f:file_list){
                if(f.isFile() && f.getName().endsWith(".txt")){
                    System.out.println("找到文件：" + f.getName());
                    f.delete();
                    System.out.println("文件"+ f.getName() + "删除成功");
                    
                }else if(f.isDirectory()){
                    System.out.println("找到文件夹：" + f.getName());
                    f.delete();
                    System.out.println("文件夹"+ f.getName() + "删除成功");
                }else{
                    System.out.println("找到文件：" + f.getName());
                }
            }
            
            /**1.3 文件过滤器**/
            String[] str_file = file.list(new DirFilter(".java"));//得到所有.java文件名
            for(String str:str_file){
                System.out.println("找到.java文件：" + str);
            }
        }catch(IOException e){
            System.out.println("操作失败，失败原因" + e);
        }
    }
    
    /*
    *2.IO流
    */
    public static void demoIO(){
        //流————一组有顺序的，有起点和终点的字节集合，是对数据传输的总称或抽象。本质就是数据传输
        //IO流————输入输出流
        //分类————————1.根据数据类型不同分为：字符流和字节流   2.根据数据流方向不同分为：输入流和输出流
        //字节流：以字节（8bit）为传输单位的流
        //字符流：以字符为传输单位的流
        //两者区别：
        //    1.读写单位不同
        //    2.处理对象不同(字节流能处理所有类型的数据 如图片等  而字符流只能处理字符类的数据)
        //    3.字节流本身不会使用到缓冲区,字符流会通过缓冲区操作文件
        //结论：推荐使用字节流，原因是硬盘上的所有文件都是以字节的形式进行传输和存储的。而字符只是在内存才会形成
        
        /**2.1 输入流**/
        //2.1.1 字节流
        //InputStream 是所有输入字节流的父类，它是一个抽象类
        //其中有ByteArrayInputStream/StringBufferInputStream/FileInputStream/ObjectInputStream/FilterInputStream/DataInputStream等子类
        //ByteArrayInputStream：从Byte数组中读取数据 //意义不大。读取数组直接数组遍历即可  无需使用IO流
        
        /*byte[] byte_b = new byte[1024];
        byte[] byte_b1 = new byte[1024];
        int count = 0;
        for(int i = 0;i<1024;i++){
            byte_b[i] = (byte)(i % 10);
        }
        System.out.println(new String(byte_b));
        
        ByteArrayInputStream byteInputStream = new ByteArrayInputStream(byte_b);
        while (byteInputStream.read() != -1){
            byte_b1[count++] = (byte)byteInputStream.read();
            
        }
        byteInputStream.close();//关闭
        byteInputStream = null //释放资源
        System.out.println(new String(byte_b1));
        */
        
        //StringBufferInputStream：从StringBuffer中读取数据  已过时
        //FileInputStream：从文件读取数据
        /*
        File file = new File(filePath + "\\test.ini");
        InputStream in = new FileInputStream(file);    
        byte[] byte_b = new byte[1024];    
        int count = 0;
        int temp = 0;
        while((temp=in.read()) != -1){//注意：当读到文件末尾的时候会返回-1.正常情况下是不会返回-1的。
            byte_b[count++] = (byte)temp;
        }
        in.close();//关闭连接
        in = null ;
        String str = new String(byte_b);
        System.out.println("读取数据有：" + str);
        */
        
        //ObjectInputStream/FilterInputStream/DataInputStream和其子类都是装饰流
        //装饰流：不直接链接数据流，而是以其他流对象为基础建立的流类，该类流实现了将实体流中的数据进行转换，增强流对象的读写能力
        /*
        DataInputStream dataInput = new DataInputStream(in);
        byte[] byte_b = new byte[(int)file.length()];
        dataInput.read(byte_b);
        dataInput.close();
        dataInput = null;
        System.out.println(new String(byte_b));
        */        
        //使用同FileInputStream一致。相关方法查看API
        
        //PipedInputStream：是从与其它线程共用的管道中读取数据
        
        //所以字节流推荐使用FileInputStream  可配合 FilterInputStream 装饰流一同使用
        
        
        //2.1.2 字符流
        //Reader 是所有的输入字符流的父类，它是一个抽象类。
        //其中有CharReader/StringReader/FileReader/FilterReader 等子类
        //CharReader：读取Char数组  
        //StringReader：读取String
        //FileReader：读取文件
        //BufferedReader /FilterReader为装饰流
        //InputStreamReader 是链接字节流和字符流的桥梁它将字节流转变成字符流
        /*
        FilterReader reader = new FilterReader(new FileReader(file));
        String str_temp = null;
        while((str_temp = reader.readLine())  != null){
            System.out.println("行内容：" + str_temp);
        }
        reader.close();
        reader = null;
        */
        //所以推荐使用FileReader(继承了InputStreamReader) 配合FilterReader一同使用
        
        /**2.2 输出流**/
        //2.2.1 字节流
        //OutputStream 是所有输出字节流的父类，它是一个抽象类
        //其中有ByteArrayOutputStream/FileOutputStream/ObjectOutputStream/FilterOutputStream等子类
        
        //ByteArrayOutputStream：写入Byte数组数据 //意义不大。直接循环初始化数组值即可  无需使用IO流
        
        //FileOutputStream：写入文件数据
        /*
        File file = new File(filePath + "\\testOutFile.ini");
        Person p1 = new Person();
        Person p2 = new Person("0001","李四");
        Person p3 = new Person("0002","王五");
        Person p4 = new Person("0003","ciade");
        Person[] p_Array = new Person[4];
        p_Array[0] = p1;
        p_Array[1] = p2;
        p_Array[2] = p3;
        p_Array[3] = p4;
        
        OutputStream out =  new FileOutputStream(file,true);//参数1为文件名，参数2为true是追加模式 为false是重写模式
        byte[] byte_b ;
        for(Person p:p_Array){
            byte_b = p.toString().getBytes();
            for(int i=0; i < byte_b.length;i++){
                if(byte_b[i] >= 97 && byte_b[i] <= 122)
                    byte_b[i] = (byte)(byte_b[i] - 32); //如果是小写字母转换成大写字母
            }
            out.write(byte_b);
        }
        out.close();
        out = null;
        
        BufferedReader reader = new BufferedReader(new FileReader(file));
        String str = null;
        while((str = reader.readLine())!=null){
            System.out.println("行内容：" + str);
        }
        reader.close();
        reader =  null;
        */
        //ObjectOutputStream/FilterOutputStream 装饰流
        /*
        FilterOutputStream ft = new FilterOutputStream(new FileOutputStream(file,true));
        byte[] byte_b ;
        for(Person p:p_Array){
            byte_b = p.toString().getBytes();
            for(int i=0; i < byte_b.length;i++){
                if(byte_b[i] >= 97 && byte_b[i] <= 122)
                    byte_b[i] = (byte)(byte_b[i] - 32); //如果是小写字母转换成大写字母
            }
            ft.write(byte_b);
        }
        ft.flush();//刷新此输出流，并强制将所有缓冲数据写入该流中
        ft.close();
        ft = null;
        */    
        
        //读写文件  字节流方式
        /*FileInputStream in = new FileInputStream(file);
        FilterOutputStream out = new FilterOutputStream(new FileOutputStream(new File(filePath + "\\test1.jpg")));
        int temp;
        int count = 0;
        byte[] out_file = new byte[(int)file.length()];
        while((temp=in.read())!=-1){
            out_file[count++] = (byte)temp;
        }
        in.close();
        in = null;
        
        out.write(out_file);
        out.flush();
        out.close();
        out = null;*/
        
        //PipedOutputStream：是向与其它线程共用的管道中写入数据
        //推荐使用FileOutputStream 可配合FilterOutputStream 装饰流一同使用
        
        //2.2.2 字符流
        //Writer 是所有的输出字符流的父类，它是一个抽象类。
        //其中有CharArrayWriter/StringWriter/FileWriter/BufferedWriter/FilterWriter 等子类
        //CharArrayWriter：写入Char数组  
        //StringWriter：写入String
        //FileWriter：写入文件
        //BufferedWriter /FilterWriter为装饰流
        //OutputStreamWriter 是链接字节流和字符流的桥梁它将字节流转变成字符流
        //推荐FileWriter 配合FilterWriter 一同使用
        
        /**2.3 缓冲流**/
        //缓冲处理流包括：BufferedInputStream,BufferedOutputStream,BufferedReader,BufferedWriter
        //BufferedInputStream,BufferedOutputStream 针对的是字节
        //BufferedReader,BufferedWriter 针对的是字符
        //更多使用方法可查看API
        
        
        /**2.4 序列化**/
        //序列化是一种将对象以一连串的字节描述的过程
        //反序列化是将这些字节重建成一个对象的过程
        //实现方式：需要序列化的类实现Serializable接口就可以了，用于标记这个类可以序列化
        //对象的默认序列化机制写入的内容是：对象的类，类签名，以及非瞬态和非静态字段的值。
        //注意：
        //    1.当一个父类实现序列化，子类自动实现序列化，不需要显式实现Serializable接口
        //    2.当一个对象的实例变量引用其他对象，序列化该对象时也把引用对象进行序列化
        //    3.static,transient后的变量不能被序列化
        
        //演示序列化
        //步骤：需要序列化的类实现Serializable接口 使用ObjectOutputStream对象写入文件
        /*ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(file));
        Person p1 = new Person();
        Person p2 = new Person("0001","李四");
        Person p3 = new Person("0002","王五");
        Person p4 = new Person("0003","ciade");
        
        List<Person> list = new ArrayList<Person>();
        list.add(p1);
        list.add(p2);
        list.add(p3);
        list.add(p4);
        oos.writeObject(list);
        
        oos.flush();
        oos.close();
        */
        
        //演示反序列化
        /*
        ObjectInputStream oin = new ObjectInputStream(new FileInputStream(file));
        List<Person> list = (ArrayList<Person>)oin.readObject();
        oin.close();
        for(Object o : list){
            System.out.println(o);
            
        }
        System.out.println("序列化类的类名是:" + list.get(0).getClass());//获取序列化类的类名
        
        */
        
        /**2.5 随机访问**/
        //RandomAccessFile类：用于随机访问文件的类
        //特点：1.支持随机访问任意位置进行读写 2.支持指定位置进行读写
        //应用场景：断点续传，多线程下载
        //写入文件
        /*
        File file = new File(filePath + "\\testOutRandomFile.ini");
        RandomAccessFile rm = new RandomAccessFile(file,"rwd");
        
        Person p1 = new Person();
        Person p2 = new Person("0001","lisi");
        Person p3 = new Person("0002","wang");
        Person p4 = new Person("0003","ciade");
        Person[] p_Array = new Person[4];
        p_Array[0] = p1;
        p_Array[1] = p2;
        p_Array[2] = p3;
        p_Array[3] = p4;
        long pos = 1024;
        rm.seek(pos);//设置写入位置  参数为long型
        for(Person p: p_Array){
            rm.writeUTF(p.toString());//使用 modified UTF-8 编码以与机器无关的方式将一个字符串写入该文件。
        }
        rm.close();
        */
        
        //读取文件
        /*
        File file = new File(filePath + "\\testOutRandomFile.ini");
        RandomAccessFile rm = new RandomAccessFile(file,"r");//只读模式
        String str = null;
        long pos = 1024;//设置读取位置  参数为long型
        rm.seek(pos);
        while((str = rm.readLine())!= null){
            System.out.println("行内容：" + str);
        }
        */
        
        /**总结常有IO类图**/
        //1.字节流
        //    1.1输入————InputStream->FileInputStream->FilterInputStream
        //    1.2输出————OutputStream->FileOutputStream->FilterOutputStream
        //2.字符流
        //    2.1输入————Reader->FileReader->FilterReader
        //    2.2输出————Writer->FileWriter->FilterWriter
        //3.缓存流
        //    3.1 字节型—————BufferedInputStream、BufferedOutputStream
        //    3.2 字符型—————BufferedReader、BufferedWriter
        //4.桥接流
        //    4.1输入————InputStreamReader(实现子类有 FileReader)
        //    4.2输出————OutputStreamWriter(实现子类有 FileWriter)
        //5.序列化类
        //    5.1输入————ObjectInputStream
        //    5.2输出————ObjectOutputStream
        //6.RandomAccessFile————随机文件类
    }
    
    /*
    *3.编码集
    */
    public static void demoCodeSet() {
        //FileWriter和FileReader使用系统当前默认的编码方式
        //如果需要创建或者读取一个编码格式为utf-8的文件通过FileWriter和FileReader这两个类是不能实现的
        //但可以通过桥接类OutputStreamWriter和InputStreamReader来指定格式
        //获取系统文件编码集
        System.out.println("系统文件编码集为:" + System.getProperty("file.encoding"));
        //获取虚拟机编码集
        System.out.println("虚拟机编码集为:" + java.nio.charset.Charset.defaultCharset().toString());//注意此包为第三方包
        
        try{
            FileWriter fw = new FileWriter(new File(filePath + "\\testOutCodeSetFile.ini"));//与系统当前默认的编码方式相同
            FileReader fr = new FileReader(new File(filePath + "\\testOutCodeSetFile.ini"));//与系统当前默认的编码方式相同
            //获取FileWriter编码集
            System.out.println("FileWriter编码集为:" + fw.getEncoding());//
            
            //获取FileReader编码集
            System.out.println("FileReader编码集为:" + fr.getEncoding());
        }catch(Exception e){
            System.out.println("操作失败！");
        }
            
        try{
            File file = new File(filePath + "\\testOutCodeSetFile.ini");
            OutputStreamWriter out = new OutputStreamWriter(new FileOutputStream(file),"utf-8");//以utf-8格式写入数据到文件中
            
            Person p1 = new Person();
            Person p2 = new Person("0001","lisi");
            Person p3 = new Person("0002","wang");
            Person p4 = new Person("0003","ciade");
            
            out.write(p1.toString());
            System.out.println("成功写入Person1数据：" + p1);
            out.write(p2.toString());
            System.out.println("成功写入Person2数据：" + p2);
            out.write(p3.toString());
            System.out.println("成功写入Person3数据：" + p3);
            out.write(p4.toString());
            System.out.println("成功写入Person4数据：" + p4);
            out.flush();
            out.close();
            
            InputStreamReader in = new InputStreamReader(
                                        new FileInputStream(file),"utf-8"
                                    );//以utf-8格式读取文件数据   注意如果格式不对会产生乱码现象
            StringBuffer sb = new StringBuffer();
            while(in.ready()){
                sb.append((char) in.read());
            }
            in.close();
            System.out.println("读取内容是：" + sb.toString());
        }catch(Exception e){
            System.out.println("操作异常！");
        }
        
    }
    /*
    *    抽取打印演示函数  用于打印演示功能提示
    */    
    public static void showDemo(String demoStr){
        System.out.println("演示:" + demoStr);
    }
}