IO流

对文件读写应该哪种流合适?

文件是一个普通的文本文件，字符缓冲流(BufferedReader和BufferedWriter)

文件是一个图片，视频，压缩文件等，非文本文件，用字节流(FileInputStream 和 FileOutputStream)

存或取对象，用对象流 (ObjectInputStream和 ObjectOutputStream)

File类

概念：表示操作系统磁盘上的文件或者是文件夹
常用方法：
createNewFile() 创建一个新文件。
mkdir() 创建一个新目录。如果父目录不存在，则无法创建
mkdirs() 创建一个新目录。如果父目录不存在，则一起创建
delete() 删除文件或空目录。
exists() 判断File对象所对象所代表的对象是否存在。
length() 获取文件(夹)的大小(字节)
getAbsolutePath() 获取文件的绝对路径。 返回String
getAbsoluteFile() 获取文件(夹)的绝对路径：（返回File）
*getName() *获取当前file对象的文件名或者是文件夹名
getParent() 获取当前file对象的父目录（返回String）
isDirectory() 是否是目录。
isFile() 是否是文件。
getPath() 获取文件(夹)的相对路径：（返回String）
listFiles() 列出目录中的所有内容。
list() 列出目录中的所有内容。
lastModified() 获取文件的最后修改时间(毫秒数)
endWith() 以什么结尾

public class Demo2 {
    public static void main(String[] args) throws IOException {
        //创建文件
        File file = new File("a.txt");
        System.out.println(file.createNewFile());
        //创建文件目录
        File file1 = new File("a");
        System.out.println(file1.mkdir());
        //创建一个新目录，如果父目录不存在一起创建
        File file2 = new File("c/d");
        System.out.println(file2.mkdirs());

        //删除文件或空文件夹
        File file3 = new File("c/c.txt");
        System.out.println(file3.delete());

        //判断file所代表的对象是否存在
        System.out.println(file2.exists());

        //获取文件大小(返回字节数)
        File file4 = new File("b/b.txt");
        System.out.println(file4.length());
        //获取绝对路径
        System.out.println(file4.getAbsolutePath());

        //获取绝对路径，返回file对象
        System.out.println(file4.getAbsoluteFile());

        //返回文件名
        System.out.println(file4.getName());

        //获取父目录
        System.out.println(file4.getParent());
        //判断是否为目录
        System.out.println(file4.isDirectory());

        //判断是否为文件
        System.out.println(file4.isFile());

        //获取相对路径
        System.out.println(file4.getPath());

        //列出目录中的所有内容
        File file5 = new File("b");
        File[] files = file5.listFiles();
        for (File f:files){
            System.out.println(f);
        }

        //获取最后一次文件修改时间
        long l = file4.lastModified();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:dd:ss");
        System.out.println(sdf.format(l));


    }
}

查找以***结尾的文件

public class Demo3 {
    public static void main(String[] args) {
        File file = new File("D:\\qf\\code\\java");
//        getFileName(file);
//        getFileName1(file);
        getFileName2(file);
    }
    //listFiles()
    //递归查找文件
    public static void getFileName(File file){
//        File file = new File("D:\\qf\\code\\java");
        File[] files = file.listFiles();
        for (File f:files){
            if (f.isFile()){
                if (f.getName().endsWith("java")){
                    System.out.println(f.getName());
                }
            }else {
                getFileName(f);
            }
        }
    }
    //list()
    public static void getFileName1(File file){
//        File file = new File("D:\\qf\\code\\java");
        String[] list = file.list();
        for (String s:list){
            if (s.endsWith("java")){
                System.out.println(s);
            }
        }
    }
    //匿名内部类重写accept()方法
    //返回以***结尾的文件
    public static void getFileName2(File file){
        File[] files = file.listFiles(new FilenameFilter() {
            @Override
            public boolean accept(File dir, String name) {
                return name.endsWith("java");
            }
        });
        for (File f:files){
            System.out.println(f.getName());
        }
    }
}

删除文件夹

public class Test1 {
    public static void main(String[] args) {
        File file = new File("D:\\qf\\a");
        deleteFile(file);

    }
    //删除文件夹
    public static void deleteFile(File file){
        //判断文件夹是否为空
        if (file!=null){
            //获取文件数组
            File[] files = file.listFiles();
            //如果文件数组长度为0，则说明file是个空文件夹，直接删除
            if (files.length==0){
                file.delete();
            }else {
                //文件数组长度不为0，则遍历
                for (File f:files){
                    //判断遍历的文件是否为文件，是文件直接删除，不是文件则递归文件夹，进行删除
                    if (f.isFile()){
                        f.delete();
                    }else {
                        deleteFile(f);
                    }
                }
                //全部遍历删除，然后再删除最外层的文件夹
                file.delete();
            }


        }
    }
}

IO流

流的分类：
按方向：
输入流：将<存储设备>中的内容读入到<内存>中
输出流：将<内存>中的内容写入到<存储设备>中。
按单位:
字节流：以字节为单位，可以读写所有数据 。 读写任意格式的文件
字符流：以字符为单位，只能读写文本数据 。 读写文本类型的文件
按功能
节点流：具有实际传输数据的读写功能。
过滤流：在节点流的基础之上增强功能

文件字节流

public class Demo5 {
    public static void main(String[] args) {
//        File file = new File("a.txt");
        FileOutputStream fileOutputStream =null;
        FileInputStream fileInputStream=null;
        try {
            fileInputStream = new FileInputStream(new File("a.txt"));
            fileOutputStream = new FileOutputStream(new File("b.txt"));
            //写一个字符
//            fileOutputStream.write(97);

            //写入一个字节数组
//            byte[] bytes="hahhahahahahha".getBytes();
//            fileOutputStream.write(bytes);
            //截取写入
//            byte[] bytes="hahhahahahahha".getBytes();
//            fileOutputStream.write(bytes,0,bytes.length);
            byte[] bytes=new byte[1024];
            int len=0;
            //读取
            while ((len=fileInputStream.read(bytes,0,len))!=-1){
            //写入
                fileOutputStream.write(bytes);
//                bytes=new byte[1024];

            }

        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (fileOutputStream!=null){
                try {
                    fileOutputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (fileInputStream!=null){
                try {
                    fileInputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

文件输入输出流注意事项:

• 1、在使用文件输出流的时候如果文件不存在会自动创建，但是要保证其父目录存在
• 2、在使用文件输出流的时候，如果想要向文件中追加内容，那么需要将构造参数append设置为true
• 3、在使用IO读写的时候，读写的操作应当写在try代码块中，关闭资源的代码写在finally代码块中 --推荐
• 4、将IO流的创建写在try()中，这样IO流在使用完成之后无需关闭 —不推荐

字节缓冲流【重点】
缓冲流：BufferedOutputStream/BufferedInputStream
提高IO效率，减少访问磁盘的次数
数据存储在缓冲区中，flush是将缓存区的内容写入文件中，也可以直接close。

//文件复制
public class Demo1{
    public static void main(String[] args) throws IOException {
        long l = System.currentTimeMillis();
        FileInputStream fis = new FileInputStream("D:\\qfe\\qfe.zip");
        BufferedInputStream bis = new BufferedInputStream(fis);

        FileOutputStream fos = new FileOutputStream("D:\\qfe\\1.zip");
        BufferedOutputStream bos = new BufferedOutputStream(fos);

        byte[] bytes = new byte[1024];
        int len=0;
        //读取
        while ((len=bis.read(bytes))!=-1){
        //写入
            bos.write(bytes,0,len);
        }

        bos.close();
        fos.close();
        bis.close();
        fis.close();
        System.out.println(System.currentTimeMillis()-l);


    }
}

对象流【重点】
对象流：ObjectOutputStream/ObjectInputStream

• 增加了缓冲区功能。
• 增加了读写8种基本数据类型和字符串功能。
• 增加了读写对象的功能：
  • readObject() 从流中读取一个对象。
  • writeObject(Object obj) 向流中写入一个对象

对象流读写基本类型+String类型

//============对象流读写基本类型+String类型============
		
//一、创建流对象
FileOutputStream fos = new FileOutputStream("e.txt");
ObjectOutputStream oos = new ObjectOutputStream(fos);
//二、通过对象流进行读写
oos.writeInt(97);         //Integer
oos.writeDouble(100.25);  //Double
oos.writeUTF("对象流");    //String
//三、关闭流资源
oos.close();
fos.close();

//一、创建流对象
FileInputStream fis = new FileInputStream("e.txt");
ObjectInputStream ois = new ObjectInputStream(fis);
//二、通过对象流进行读写  (读取的顺序和写入的顺序要一致)
System.out.println(ois.readInt());
System.out.println(ois.readDouble());
System.out.println(ois.readUTF());
//三、关闭流资源
ois.close();
fis.close();

对象流写操作(序列化)

//============对象流写对象============

//写入对象
FileOutputStream fos = new FileOutputStream("f.txt");
ObjectOutputStream oos = new ObjectOutputStream(fos);  //对象输出流

User user = new User("cxk", 30);
oos.writeObject(user);

oos.close();
fos.close();

对象流写操作(反序列化)

//读取对象
FileInputStream fis = new FileInputStream("f.txt");
ObjectInputStream ois = new ObjectInputStream(fis);  //对象输入流

User user1 = (User) ois.readObject();
System.out.println(user1);

ois.close();
fis.close();

实体类(必须要实现序列化接口) 实现Serializable接口
class User implements Serializable{
String name;
int age;
//…
}
对象流细节
readObject() id
writeObject() id
序列化的细节:

• 1、对象流读到流的末尾，会抛出异常EOFException
• 2、如果属性不想被序列化，那么可以使用transient关键字修饰
• 3、类实现了Serializable接口，会自动生成一序列化id(序列化和反序列的id要保证一致)

字符流【重点】
Reader：字符输入流
Writer：字符输出流

文件字符流【重点】

public class Demo4 {
    public static void main(String[] args) throws IOException {
        //字符流
        FileReader fr = new FileReader("a.txt");
        System.out.println(fr.read());
        char[] chars=new char[1024];
		
		//字符输出流
        fr.read(chars);
        System.out.println(Arrays.toString(chars));
        fr.close();

        //
        FileWriter fw = new FileWriter("a.txt");
        //字符输出流
        fw.write(99);
        fw.write("abcdef");
        fw.close();

    }
}

字符缓冲流【重点】
1文件是文本文件(.txt) 用字符缓冲流读写
2文件是多媒体(图片，视频，压缩包),用字节流(FileInputStream和FileOutputStream)

缓冲流：BufferedWriter/BufferedReader

public class Demo5 {
    public static void main(String[] args) throws IOException {
        //字符缓冲流
        BufferedReader br = new BufferedReader(new FileReader("a.txt"));
        BufferedWriter bw = new BufferedWriter(new FileWriter("b.txt"));
//        char[] chars=new char[1024];
        String s=null;
        //读一行，读取不到返回null
        while ((s=br.readLine())!=null){
            //写入一行
            bw.write(s);
            //新的一行
            bw.newLine();
        }

        bw.close();
        br.close();

    }
}

转换流

public class Demo6 {
    public static void main(String[] args) throws IOException {
        //字节流
        FileInputStream fis = new FileInputStream("c.txt");
        //字节转换字符流
        InputStreamReader isr = new InputStreamReader(fis,"GBK");
        //字符流
        BufferedReader bufferedReader = new BufferedReader(isr);

        String s = bufferedReader.readLine();
        System.out.println(s);
        bufferedReader.close();
        isr.close();
        fis.close();

        //
        FileOutputStream fos = new FileOutputStream("d.txt");
        OutputStreamWriter osw = new OutputStreamWriter(fos);
        BufferedWriter bufferedWriter = new BufferedWriter(osw);
        bufferedWriter.write("哈哈哈哈哈哈哈");

        bufferedReader.close();
        osw.close();
        fos.close();

    }
}