Day13：IO流

IO流主要涉及到Java中的数据是怎样传送的，是一什么方式传送的，又是以什么方式阅读的

IO流：
    IO:用于处理设备上的数据的技术。设备：内存，硬盘，光盘。
    流：系统资源，windows系统本身就可以操作设备。各种语言只是使用系统平台上的这个资源。
        并对外提供了各种语言自己的操作功能，这些功能最终调用的是系统资源。
        使用完资源一定要记住：释放。
        
IO：java中所涉及的功能对象都存储到java.io包中。    
设备上数据最常见的存储表现形式文件file.

小知识点
* 递归：函数自身调用自身。函数内部又使用到了该函数功能。
* 什么时候使用？
* 功能被重复使用，但是每次该功能使用参与运算的数据不同时，可以考虑递归方式解决。
* 使用时，一定要定义条件。
* 注意递归次数过多，会出现栈内存溢出。
* String LINE_SEPARATOR = System.getProperty("line.separator");（任何系统都可以的换行符）

/*
 * 将数据写入到文件中。
 * 使用字节输出流。
 * FileOutputStream。
 */
File dir = new File("tempfile");
if(!dir.exists()){
    dir.mkdir();
}
//1，创建字节输出流对象。用于操作文件，在对象初始化时，必须明确数据存储的目的地。
//输出流所关联的目的地，如果不存在，会自动创建。如果存在，则覆盖。
FileOutputStream fos = new FileOutputStream("tempfile\fos.txt");
        
//2,调用输出流的写功能。
fos.write("abcde".getBytes());
                
//3,释放资源。
fos.close();

    public static void main(String[] args) {

　　　//         需求获取一个想要的指定文件的集合。获取javase_code下(包含子目录)的所有的.java的文件对象。并存储到集合中。
        /*
         * 思路：
         * 1，既然包含子目录，就需要递归。
         * 2，在递归过程中需要过滤器。
         * 3，满足条件，都添加到集合中。
         */ 
        File dir = new File("e:\javase_code");
        
        List<File> list = fileList(dir,".java");
        
        for(File file : list){
            System.out.println(file);
        }   
    }
    /**
     * 对指定目录进行递归。
     * 
     * 多级目录下都要用到相同的集合和过滤器。那么不要在递归方法中定义，而是不断的进行传递。
     * 
     * @param dir 需要遍历的目录。
     * @param list 用于存储符合条件的File对象。
     * @param filter 接收指定的过滤器。
     */
    public static void getFileList(File  dir,List<File> list,FileFilter filter){
 
        //1，通过listFiles方法，获取dir当前下的所有的文件和文件夹对象。
        File[] files = dir.listFiles();
        
        //2，遍历该数组。
        for(File file : files){
            
            //3,判断是否是文件夹。如果是，递归。如果不是，那就是文件，就需要对文件进行过滤。
            if(file.isDirectory()){
                getFileList(file, list, filter);
            }else{
                //4，通过过滤器对文件进行过滤
                if(filter.accept(file)){
                    list.add(file);
                }
            }
            
        }
    }

　　

   /**
     * 定义一个获取指定过滤器条件的文件的集合。
     */
    public static List<File> fileList(File dir,String suffix){
        
        //1,定义集合。
        List<File> list = new ArrayList<File>();
        
        //2,定义过滤器。
        FileFilter filter = new FileFilterBySuffix(suffix);//自定义的文件拦截器
        
        getFileList(dir, list, filter);
        
        return list;  
    }

File:IO技术用于操作设备上数据的，而数据最常见的体现方式是文件。
先了解了文件的操作。
    创建，删除，存在，隐藏，获取......;


需求：怎么操作文件的数据呢？
    使用IO流对象。而且文件数据都是字节存在。
学习了可以操作文件的字节流。    
    InputStream
        |--FileInputStream
    OutputStream
        |--FileOutputStream
        
为了提高了操作效率。引入缓冲区。
    InputStream
        |--FileInputStream
        |--FilterInputStream
            |--BufferedInputStream
    OutputStream
        |--FileOutputStream
        |--FilterOutputStream    
            |--BufferedOutputStream

发现，文件数据，媒体文件字节流没问题。
但是对于文本文件，想要操作文件中的中文数据时，字节流只能操作字节，需要我们字节解码成字符。麻烦。
所以就到API找对象,就发现字符流中有字节和字符的桥梁，传说中的转换流。
    Reader
        |--InputStreamReader:字节-->字符。
    Writer
        |--OutputStreamWriter：字符--->字节。
        
它们出现了解决了中文的编码转换问题。

为了便捷操作字符文件。找到了转换流的子类，但是它有局限性，只能操作文件，而且是默认编码。
如果不操作文件，而且编码不是默认的，需要使用转换流。
    Reader
        |--InputStreamReader:字节-->字符。
            |--FileReader
    Writer
        |--OutputStreamWriter：字符--->字节。
            |--FileWriter

    
为了提高了字符流的操作效率。引入字符串的缓冲区。
字符流=字节流+编码

    Reader
        |--InputStreamReader:字节-->字符。
            |--FileReader=FileInputStream+InputStreamReader
        |--BufferedReader：String readLine()
    Writer
        |--OutputStreamWriter：字符--->字节。
            |--FileWriter=FileOutputStream+OutputStreamWritter
        |--BufferedWriter：String newLine();

        /*
         * 需求：把目录中的1.jpg复制一次并把文件名改为2.jpg
         */
        //1、获取文件
        File file = new File("1.jpg");
        //2、创建具体流对象，明确数据源
        FileInputStream fis = new FileInputStream(file);
        BufferedInputStream bis = new BufferedInputStream(fis);
        //3、创建对冲流，明确目的文件
        FileOutputStream fos = new FileOutputStream("2.jpg");
        BufferedOutputStream bos = new BufferedOutputStream(fos);
        //4、进行频繁读写
        int len = 0;
        byte[] buf = new byte[1024];
        while((len=bis.read(buf))!=-1){
            //写入流
            bos.write(buf,0,len);
            //刷新流
            bos.flush();
        }
        //5、释放资源
        fis.close();
        fos.close();

接着，来一个综合性的流的练习题

        /*
         * 作业：键盘录入多名学生的信息：格式：姓名,数学成绩,语文成绩,英文成绩.
         * 按总分由高到低，将学生的信息进行排列到文件中。
         * 
         * 思路：
         * 1，使用键盘录入技术。
         * 2，操作的学生信息，信息很多，需要将信息封装成学生对象。
         * 3，总分由高到低，需要排序，需要对学生对象中的总分排序。需要将多个学生对象进行容器存储。
         * 哪个容器呢？TreeSet集合。
         * 4，将容器中学生对象的信息写入到文件中。
         * 
         * 
         */
        
        
        //创建一个逆序的比较器。
        Comparator<Student> comp = Collections.reverseOrder();
        
        //使用操作学生信息的工具类。
        Set<Student> set = GetInfoTool.getStudents(comp);
        
        File destFile = new File("tempfile\info.txt");
        GetInfoTool.write2File(set, destFile);

//学生类
public class Student implements Comparable<Student> {

    private String name;
    private int ma,cn,en;
    private int sum;
    public Student() {
        super();
        
    }
    public Student(String name, int ma, int cn, int en) {
        super();
        this.name = name;
        this.ma = ma;
        this.cn = cn;
        this.en = en;
        this.sum = ma+cn+en;
    }
    
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        result = prime * result + sum;
        return result;
    }
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Student other = (Student) obj;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        if (sum != other.sum)
            return false;
        return true;
    }
    
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getMa() {
        return ma;
    }
    public void setMa(int ma) {
        this.ma = ma;
    }
    public int getCn() {
        return cn;
    }
    public void setCn(int cn) {
        this.cn = cn;
    }
    public int getEn() {
        return en;
    }
    public void setEn(int en) {
        this.en = en;
    }
    public int getSum() {
        return sum;
    }
    public void setSum(int sum) {
        this.sum = sum;
    }
    
    @Override
    public int compareTo(Student o) {
        
        int temp = this.sum - o.sum;
        
        return temp==0?this.name.compareTo(o.name):temp;
    }
}

//对学生信息进行操作
public class GetInfoTool {

    /**
     * 获取所有学生对象集合，按照学生对象的自然排序。
     * @throws IOException 
     */
    public static Set<Student> getStudents() throws IOException{
        
        return getStudents(null);
    }
    /**
     * 获取学生对象集合，按照指定的比较器排序。
     * @param comp
     * @return
     * @throws IOException
     */
    public static Set<Student> getStudents(Comparator<Student> comp) throws IOException{
        //1,键盘输入。
        BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
        
        //创建一个容器存储学生对象。
        
        Set<Student> set = null;
        //如果比较器存在，就创建带有比较器的对象。
        if(comp!=null){
            set = new TreeSet<Student>(comp);
        }else{
            set = new TreeSet<Student>();
        }
        
        
        //2,获取键盘录入的信息。
        String line = null;
        while((line=bufr.readLine())!=null){
            
            //键盘录入结束标记。
            if("over".equals(line)){
                break;
            }
            
            //因为录入的数据是有规律的。可以通过指定的规则进行分割。
            String[] strs = line.split(",");
            //将数组中的元素封装成对象。
            Student stu = new Student(strs[0],Integer.parseInt(strs[1])
                    ,Integer.parseInt(strs[2])
                    ,Integer.parseInt(strs[3]));
            
            //将学生对象存储到集合中。
            set.add(stu);
        }
        
        //关闭键盘录入须知：如果后面不在使用键盘录入是可以关闭的，如果后面还要使用，就不要关闭，继续通过System.in就可以获取。
//        bufr.close();
        
        return set;
    }
    
    /**
     * 将集合中的学生信息写入到文件中。
     * @throws IOException 
     */
    public static void write2File(Set<Student> set,File destFile) throws IOException{
        
        BufferedWriter bufw  = null;
        try{
            bufw = new BufferedWriter(new FileWriter(destFile));
            
            //遍历集合。
            for(Student stu : set){
                bufw.write(stu.getName()+"	"+stu.getSum());
                bufw.newLine();
                bufw.flush();
            }
        }finally{
            if(bufw!=null){
                try {
                    bufw.close();
                } catch (IOException e) {
                    
                    e.printStackTrace();
                }
            }
        }    
    }
}

缓冲区原理：
    临时存储数据的方法。减少对设备操作的频率，提高了效率。其实就是将数据临时缓存到了内存(数组)中。
    
模拟一个BufferedReader。
    
    
Writer
    |--TextWriter
    |--MediaWriter

在对数据写入操作过程中，希望提升效率。
要对操作文本的对象提升效率，使用缓冲区技术。

Writer
    |--TextWriter
        |--BufferedTextWriter
    |--MediaWriter    
        |--BufferedMediaWirter
    |--AudioWriter
        |--BufferedAudioWriter
        
这样的体系，为了增加一些功能，而通过产生子类来完成，会导致继承体系变得很臃肿。
重新思考体系的设计问题。都是在写的方法进行效率的提升。
为什么不将该功能进行单独的封装呢？要提升哪个具体对象，将哪个具体对象交给该功能不就可以了吗？

class BufferedWriter extends Writer
{
    BufferedWriter(Writer w)
    {
    }
    /*
    BufferedWriter(TextWriter w)
    {}
    
    BufferedWriter(MediaWriter w)
    {
    }
    */
}        
Writer
    |--TextWriter
    |--MediaWriter
    |--AudioWriter
    |--BufferedWriter
        
TextWriter tw = new TextWriter();
BufferedWriter bufw = new BufferedWriter(tw);
//tw.write();
bufw.write();
    
解决：可以给对象提供额外的功能(职责)。比继承这种方式更为灵活。
起个名字，装饰设计模式(Wrapper,Decorator)。
装饰类与被装饰类都所属于同一个体系。
同时装饰类中持有被装饰类的引用。