java学习--IO

目录

　　  1.File类

　　2.主要方法

　　3.流

一、File类

　　File类表示的是一个文件对象，可以表示一个文件或者文件夹

二、主要方法

1、创建文件

ceateNewFile

2、创建文件夹

mkDir()
mkDirs()

3、遍历文件夹

File[] files = listFile();
String[] files = file.list();

4、删除文件

文件夹和文件的删除都统一用delete() 

注意：文件夹不为空时，删除不成功！

5、创建临时文件

File.createTmpFile()

6.deleleOnExit()与delete()的区别

deleteOnExit()是在jvm退出前删除文件，delete()则是在被调用是就删除文件

7、文件过滤器

FilenameFilter 文件名过滤器
FileFilter 文件过滤器

文件过滤器是在遍历文件夹时使用，需要重写accept方法，返回的Boolean值为true则保留下来

三、流

对文件内容的操作
File 只能对文件本身属性进行操作

分类：
输入流： 外介 - 》 程序
Scanner sc = new Scanner(System.in);
输出流：程序 -》 外介
字节流：传输单位1个字节（8位）
字符流：传输单位2个字节（16位）

InputStream ： 所有字节输入流超类
OutputStream ： 所有字节输出流超类

Writer:所有字符输出流超类

Reader:所有字符输入流超类

1.字节流

InputStream--字节输入流

OutputStream--字节输出流

ps：写文件时，如果文件不存在，会创建该文件
读文件时，如果文件不存在，则会抛异常。

package com.demo.io;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class CopyDemo {
    /**
     * 文件拷贝方法
     * @param oldpath
     * @param newpath
     * @return
     * 2018年8月28日
     */
    public static boolean copy(String oldpath,String newpath) {
        FileInputStream  fis=null;
        FileOutputStream fos =null;
        try {
            fis = new FileInputStream(new File(oldpath));
            fos = new FileOutputStream(new File(newpath));
            byte [] b = new byte[1024];
            int len = 0;
            while((len = fis.read(b))!= -1) {
                fos.write(b, 0, len);
                fos.flush();
            }
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally {
            try {
                fos.close();
                fis.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            
        }
        
        return false;
    }
    
}

2.字符流

Writer:所有字符输出流超类

Reader:所有字符输入流超类

FileWriter--文件输出字符流

FileReader--文件输入字符流

package com.demo.io;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class CopyDemo {
    /**
     * 文件拷贝方法
     * @param oldpath
     * @param newpath
     * @return
     * 2018年8月28日
     */
    public static boolean copy(String oldpath,String newpath) {
        FileWriter fw = null;
        FileReader fr = null;
        try {
            fw= new FileWriter(new File(newpath));
            fr=new FileReader(new File(oldpath));
            char[] c = new char[1024];
            int len =0;
            while((len=fr.read(c))!=-1) {
                fw.write(c,0,len);
                fw.flush();
            }
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally {
            try {
                fr.close();
                fw.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            
        }
        
        return false;
    }
    
}

字节流转换成字符流的桥梁
InputStreamReader：
OutputStreamWriter：

 字节流与字符流的使用场景

字节流：
一次读写一个字节，一般应用于底层通信或者以
二进制流存储的文件，比如图片、视频、音频等多媒体文件。

字符流：
一次读写一个字符，缓冲流可对其进行包装，效率较高
因为字符流的字符编码采取unicode编码，国际化支持
较好，一般有中文的文本采用字符流较好。

4.缓冲流

BufferedReader 缓冲输入字符流
BufferedWriter 缓冲输出字符流

利用缓冲字符流进行文件拷贝

package com.demo.io;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class CopyDemo {
    /**
     * 文件拷贝方法
     * @param oldpath
     * @param newpath
     * @return
     * 2018年8月28日
     */
    public static boolean copy(String oldpath,String newpath) {
        BufferedReader br = null;
        BufferedWriter bw = null;
        try {
            br = new BufferedReader(new FileReader(oldpath));
            bw = new BufferedWriter(new FileWriter(newpath));
            String data = null;
            while((data=br.readLine())!=null) {
                bw.write(data);
                bw.newLine();
                bw.flush();
            }
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally {
            try {
                bw.close();
                br.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        return false;
    }
    
}

BufferedInputStream 缓冲输入字节流
BufferedOutputStream 缓冲输出字节流

利用缓冲字节流进行文件拷贝package com.demo.io;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class CopyDemo {
    /**
     * 文件拷贝方法
     * @param oldpath
     * @param newpath
     * @return
     * 2018年8月28日
     */
    public static boolean copy(String oldpath,String newpath) {
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;
        try {
            bis = new BufferedInputStream(new FileInputStream(oldpath));
            bos = new BufferedOutputStream(new FileOutputStream(newpath));
            byte[] b = new byte[1024];
            int len = 0;
            while((len = bis.read(b))!=-1) {
                bos.write(b,0,len);
                bos.flush();
            }
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally {
            try {
                bos .close();
                bis.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            
        }
        return false;
    }
    
}

5.打印流

只有输出流，没有输入流
增强流，提供各种数据类型的格式输出
PrintStream 包装字节流
PrintWriter 包装字节、字符流

含有丰富的print和println方法

println方法相当于字符输出流的newLine方法。

打印流不会抛出异常，并不是没有异常，而是在其内部已经处理了

6.对象流

ObjectOutputStream--序列化
ObjectInputStream--反序列化

序列化--将程序中的对象保存到磁盘，或者允许在网络中传播

反序列化--从IO流恢复对象

序列化的对象需要实现Serializable接口，并且生成一个serialVersionUID

package com.work.io;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;

public class SerializableDemo implements Serializable{
    /**
     * 2018年9月6日
     */
    private static final long serialVersionUID = 2105404167541676591L;
    private String name;
    private int age;
    public SerializableDemo(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    
}
class Main{
    
    public static void serialization(String path,Object obj) {
        ObjectOutputStream oos  = null;
        try {
            oos = new ObjectOutputStream(new FileOutputStream(path));
            oos.writeObject(obj);
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    
    public static List<SerializableDemo> unserialization(String path) {
        ObjectInputStream ois = null;
        List<SerializableDemo> list = new ArrayList<>();
        try {
            ois=new ObjectInputStream(new FileInputStream("path"));
            SerializableDemo sd = null;
            
            while((sd=(SerializableDemo)ois.readObject())!=null) {
                list.add(sd);
            }
            return list;
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally {
            try {
                ois.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return null;
    }
    
}

7. flush()方法

　　这个方法很是将存在内存中的数据清空。就像在水管的一端施加外力一样。

以下面的代码为例：

while((tempData = bis.read())!=-1){
    os.write(tempData);
    os.flush();
}

while((tempData = bis.read())!=-1){
    os.write(tempData);
}
os.flush();

上面这两种情况若是写到网页端的话，效果会很明显，

第一种是缓加载出来的。而后一种则是一下直接加载一大半或全部加载完成。