JavaIO

JavaIO

1、什么是流

• 概念：内存与存储设备之间传输数据的通道。

2、流的分类

2.1、按照方向分【重点】

• 输入流：将存储设备中的内容读入到内存中

• 输出流：将内存中的内容写入到存储设备中

2.2、按照单位分

• 字节流：以字节为单位，可以读写所有数据

• 字符流：以字符为单位，只能读写文本数据

2.3、按照功能分

• 节点流：具有实际传输数据的读写功能

• 过滤流：在节点流的基础之上增强功能

 

3、文件字节流

FileInputStream

• int read（byte[] b）//从流中读取多个字节，读取到内容存入b数组，返回实际读到的字节数；如果到达文件的尾部，则返回-1。

FileInputStream fip = new FileInputStream("D:\\JavaLearning\\JavaIO\\text\\1.txt");
        byte[] bytes = new byte[1024];
        int count = 0;
        while ((count=fip.read(bytes))!=-1){
            System.out.println(new String(bytes,1,count));
        }
        fip.close();
        System.out.println("执行完毕！");

 

FileOutputStream

• void write（byte[] b）//一次写多个字节，将b数组中的所有字节，写入输出流。

 FileOutputStream  fou = new FileOutputStream("D:\\JavaLearning\\JavaIO\\text\\1.txt",true);
//        fou.write('h');
        String str = "hello world!";
        fou.write(str.getBytes());
        fou.close();
        System.out.println("执行完毕");

复制文件操作

 FileInputStream fi = new FileInputStream("D:\\JavaLearning\\JavaIO\\file\\1.jpg");
        FileOutputStream fo = new FileOutputStream("D:\\JavaLearning\\JavaIO\\file\\5.jpg");
        int count = 0;
        while ((count=fi.read())!=-1){
            fo.write(count);
        }
        fi.close();
        fo.close();
        System.out.println("复制完毕");

4、字节缓冲流

作用

• 缓冲流：BufferedInputStream/BufferedOutputStream

  • 提高IO效率，减少访问磁盘的次数

  • 数据存储在缓冲区中，flush是将缓存区的内容写入文件中，也可以直接close。

BufferedInputStream

FileInputStream fip = new FileInputStream("D:\\JavaLearning\\JavaIO\\file\\1.txt");
        BufferedInputStream buf = new BufferedInputStream(fip);
        int count = 0;
        while ((count=buf.read())!=-1){
            System.out.print((char)count);
        }
        buf.close();

BufferedOutputStream

FileOutputStream fou = new FileOutputStream("D:\\JavaLearning\\JavaIO\\file\\buffer2.txt",true);
        BufferedOutputStream buffer = new BufferedOutputStream(fou);
        for (int i = 0; i < 10; i++) {
            buffer.write("hello IO!\n".getBytes());
            buffer.flush();
        }
        buffer.close();

5、对象流

作用

• 增强了缓冲区功能

• 增强了读写8种基本数据类型和字符串功能

• 增强了读写对象的功能

  • readObject（）从流种读取一个对象

  • writeObject（Object obj）向流中写入一个对象

序列化对象

使用流传输对象的过程称为序列化、反序列化。

ObjectOutputStream

public static void main(String[] args)throws Exception {
        FileOutputStream fo = new FileOutputStream("D:\\JavaLearning\\JavaIO\\file\\1.txt");
        ObjectOutputStream bis = new ObjectOutputStream(fo);
        Student zhangSan = new Student(1, "zhangSan");
        bis.writeObject(zhangSan);
        bis.close();
        System.out.println("执行完毕");
​
    }

 

ObjectInputStream

 FileInputStream fi = new FileInputStream("D:\\JavaLearning\\JavaIO\\file\\1.txt");
        ObjectInputStream obi = new ObjectInputStream(fi);
        Object obj = obi.readObject();
        System.out.println(obj.toString());
        obi.close();

序列化和反序列化的注意事项：

1. 序列化类必须要实现Serializable接口

2. 序列化类中对象属性也要求实现Serializable

3. serialVersionUID：序列化版本号ID，保证序列化的类和反序列化的类是同一个类

4. 使用transient（瞬间的）修饰属性，那么这个属性就不能被序列化

5. 静态属性不可以被序列化

6. 序列化多个对象，可以借助集合实现

 

6、字符流

字符编码

1. ISO-8859-1：收录除ASCII外，还包括西欧、希腊语、泰语、阿拉伯语、希伯来语对应的文字符号。

2. UTF-8 ：针对Unicode码表的可变长度字符编码

3. GB2312： 简体中文

4. GBK：简体中文、扩充

5. BIG5：台湾，繁体中文

FileReader

FileReader fr = new FileReader("D:\\JavaLearning\\JavaIO\\file\\buffer.txt");
        char[] chars = new char[8000];
        int data = 0;
        while ((data=fr.read(chars))!=-1){
            System.out.println(new String(chars,0,data));
        }
        fr.close();
        System.out.println("执行完毕");

 

FileWriter

 FileWriter fw = new FileWriter("D:\\JavaLearning\\JavaIO\\file\\2.txt");
        for (int i = 0; i < 10; i++) {
            fw.write("我爱java");
        }
        fw.close();

 

7、字符缓冲流

BufferedReader

 FileReader fr = new FileReader("D:\\JavaLearning\\JavaIO\\file\\2.txt");
        BufferedReader buffer = new BufferedReader(fr);
        int data = 0;
        while ((data=buffer.read())!=-1){
            System.out.print((char)(data));
        }
        buffer.close();
        System.out.println("操作完毕");

 

BufferedWriter

 FileWriter fw = new FileWriter("D:\\JavaLearning\\JavaIO\\file\\1.txt");
        BufferedWriter buffer = new BufferedWriter(fw);
        buffer.write("我很爱中国！");
//        buffer.flush();
        buffer.close();

 

8、打印流

作用

• 封装了print（）/println（）方法，支持写入后换行

• 支持数据原样打印

PrintWriter

PrintWriter pw = new PrintWriter("D:\\JavaLearning\\JavaIO\\file\\1.txt");
        pw.write(97);
        pw.println(97);
        pw.println("我爱中国");
        pw.println("我爱浙江");
        pw.println('a');
        pw.close();
        System.out.println("执行成功");

 

9、转换流

作用

• 可将字节流转换为字符流

• 可设置字符的编码方式

InputStreamReader

FileInputStream fi = new FileInputStream("D:\\JavaLearning\\JavaIO\\file\\1.txt");
        InputStreamReader isr = new InputStreamReader(fi,"utf-8");
        int data = 0;
        while ((data=isr.read())!=-1){
            System.out.print((char)data);
        }
        isr.close();

 

OutoutStreamWriter

 FileOutputStream fi = new FileOutputStream("D:\\JavaLearning\\JavaIO\\file\\1.txt");
        OutputStreamWriter otw = new OutputStreamWriter(fi,"utf-8");
        for (int i = 0; i < 5; i++) {
            otw.write("我爱中国");
        }
        otw.close();

10、File类

概念

代表物理盘符中的一个文件或者文件夹。

File类的使用

1. 分隔符

2. 文件操作

3. 获取文件信息

4. 判断

测试代码

//1.创建文件
        File file = new File("D:\\JavaLearning\\JavaIO\\file\\file.txt");
        if (!file.exists()){
            boolean b = file.createNewFile();
            System.out.println("创建结果" + true);
        }
        //2.删除文件
        //2.1直接删除
//        System.out.println("直接删除"+file.delete());
        //2.2使用jvm退出时删除
//        file.deleteOnExit();
//        Thread.sleep(5000);
        //3.获取文件信息
        System.out.println("绝对路径" +file.getAbsolutePath());
        System.out.println("获取路径" +file.getPath());
        System.out.println("获取文件名称" +file.getName());
        System.out.println("获取父目录" +file.getParent());
        System.out.println("获取文件长度" +file.length());
        System.out.println("文件创建时间:" + new Date(file.lastModified()).toInstant());
        //4.判断
        System.out.println("是否可写" + file.canWrite());
        System.out.println("是否是文件" + file.isFile());

文件夹操作

许多方法与文件操作类似

 File file = new File("D:\\JavaLearning\\JavaIO\\files\\aa\\bb\\cc");
        if (!file.exists()){
            boolean newFile = file.mkdirs();
            System.out.println("创建文件夹:" + newFile);
        }
//        System.out.println("删除文件" + file.delete());
//        System.out.println("jvm退出时删除"  );
//        file.deleteOnExit();
//        Thread.sleep(5000);
        //遍历文件夹
        System.out.println("-----------------------------------");
        File file2 = new File("D:\\JavaLearning\\JavaIO\\file");
        String[] list = file2.list();
        for (String s : list) {
            System.out.println(s);
        }

文件过滤器

FileFilter接口

• 当调用File类中的listFiles（）方法时，支持传入FileFilter接口接口实现类，对获取文件进行过滤，只有满足条件的文件才可以出现在listFiles（）的返回值中

  System.out.println("---------------过滤器的使用--------------------");
        File file3 = new File("D:\\JavaLearning\\JavaIO\\file");
        File[] files = file3.listFiles(new FileFilter() {
            @Override
            public boolean accept(File pathname) {
                if (pathname.getName().endsWith(".txt")){
                    return true;
                }
                return false;
            }
        });
        for (File file1 : files) {
            System.out.println(file1.getName());
        }

案例一 递归遍历文件夹

public static void dirList(File dir){
        File[] files = dir.listFiles();
        System.out.println(dir.getAbsoluteFile());
        if(files!=null&&files.length>0){
            for (File file : files) {
                if (file.isDirectory()){
                    dirList(file);
                }else {
                    System.out.println(file.getAbsoluteFile());
                }
            }
        }
    }

 

案例二递归删除文件夹

public static void dirDelete(File dir){
        File[] files = dir.listFiles();
        if (files!=null&&files.length>0){
            for (File file : files) {
                if (file.isDirectory()){
                    dirDelete(file);
                }else {
                    System.out.println(file.getAbsoluteFile() + "删除成功" + file.delete());
                }
            }
        }
        System.out.println(dir.getAbsoluteFile() + "删除成功" + dir.delete());
    }

11、Properties

特点：

• 是一个属性集合

• 存储属性名和属性值

• 属性名和属性值都是字符串类型

• 没有泛型

• 和流有关

Properties pro = new Properties();
pro.put("name","张三");
pro.put("age","20");
pro.put("name2","李四");
//通过stringPropertyNames方法遍历
Set<String> strings = pro.stringPropertyNames();
for (String string : strings) {
    System.out.println(string+ "=" + pro.getProperty(string) );
}
PrintWriter pw = new PrintWriter("D:\\JavaLearning\\JavaIO\\files\\file\\file.txt");
pro.list(pw);
pw.close();
 System.out.println("==============store方法 保存=============");
        FileOutputStream fos = new FileOutputStream("D:\\JavaLearning\\JavaIO\\files\\file\\pro.properties");
        pro.store(fos,"注释");
        fos.close();
        System.out.println("===============load方法  加载============");
        FileInputStream fis = new FileInputStream("D:\\JavaLearning\\JavaIO\\files\\file\\pro.properties");
        pro.load(fis);
        fis.close();
        System.out.println(pro.toString());