# 流的学习

流

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

1.流的分类

• 按方向
  • 输入流：将存储设备中的内容读入到内存中
  • 输出流：将内存中的内容写入存储设备中
• 按单位
  • 字节流：以字节为单位，可以读写所有数据
  • 字符流：以字符为单位，只能读写文本数据
• 按功能
  • 节点流：具有实际传输数据的读写功能
  • 过滤流：在节点流得到基础上增强功能

2.字节流

字节流的父类(抽象类):

• InputStream:字节输入流
• OutputStream:字节输出流

3.文件字节流

• FileInputStream:
  • public int read(byte[] b)//从流中读取多个字节，将内存存入b数组，返回实际读到的字节数；如果达到文件的尾部，则返回-1。
• FileOutputStream:
  • public void write(byte[] b)//一次写多个字节，将b数组中所有字节，写入输出流。

/**
 * FileInputStream使用
 * 文件字节输入流
 */
public class Demo01 {
    public static void main(String[] args) throws Exception{

        //1.创建FileInputStream
        FileInputStream fileInputStream = new FileInputStream("E:\\aaa.txt");
        //2.读取文件
        //2.1单个字节读取
//        int data = 0;
//        while ( (data=fileInputStream.read() )!=(-1) ){
//            System.out.println((char) data);
//        }

        //2.2一次读取多个字节
//        byte[] bytes = new byte[4];
//        int count = 0;
//        while ( ( count=fileInputStream.read(bytes) )!=(-1) ){
//            System.out.println(new String(bytes,0,count));
//        }


        //3.关闭
        fileInputStream.close();
        System.out.println("close");
    }
}

/**
 * FileOutputStream
 * 文件字节输出流
 */
public class Demo01 {
    public static void main(String[] args) throws Exception{

        //1.创建文件字节流输出对象
        FileOutputStream fileOutputStream = new FileOutputStream("e:\\bbb.txt",true);//append设置为true，为追加

        //2.写入文件
//        fileOutputStream.write(97);
//        fileOutputStream.write('b');
        String str = "hellowrold";
        fileOutputStream.write(str.getBytes());


        //3.关闭
        fileOutputStream.close();
        System.out.println("执行完成");
    }
}

4.字节缓冲流

缓冲流：BufferedInputStream/BufferedOutputStream

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

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

/**
 *BufferedInputStream
 */
public class Demo01 {
    public static void main(String[] args) throws Exception{

        //1.创建BufferedInputStream
        FileInputStream fis = new FileInputStream("E:\\aaa.txt");
        BufferedInputStream bufferedInputStream = new BufferedInputStream(fis);
        //2.读取
        int data = 0;
        while ( (data = bufferedInputStream.read() )!= -1 ){
            System.out.println((char)data);
        }
//        byte[] buf = new byte[1024];
//        int count = 0;
//        while ( (count = bufferedInputStream.read(buf) )!= -1 ){
//            System.out.println( new String(buf,0,count));
//        }


        //3.关闭
        bufferedInputStream.close();


    }
}

public class Demo01 {
    public static void main(String[] args) throws Exception{

        //1.创建字节缓冲输出流
        FileOutputStream fos = new FileOutputStream("e:\\bbb.txt");
        BufferedOutputStream bos = new BufferedOutputStream(fos);

        //2.写入文件
        for (int i = 0; i < 10; i++) {
            bos.write("hellowrold\r\n".getBytes());//写入8K缓冲区
            bos.flush();//刷新到硬盘
        }

        //3.关闭(内部调用flush方法)
        bos.close();


    }
}

5.对象流

对象流：ObjectOutputStream/ObjectInputStream

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

/**
 * 学生类
 */
public class Student implements Serializable{
    private String name;
    private int age;

    public Student(){

    }

    public Student(String name,int age){
        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;
    }

    @Override
    public String toString() {
        return "[Name:"+this.name+" Age:"+this.age+"]";
    }
}


/**
 * 使用ObjectOutputStream实现对象的序列化
 * 要求：
 * (1)序列化类必须要实现Serializable接口
 * (2)序列化类中对象属性要求实现Serializable接口
 * (3)序列化版本号ID，保证序列化的类和反序列化的类是同一个类
 * (4)使用transient(瞬间的)修饰属性，这个属性就不能序列化
 * (5)静态属性不能序列化
 * (6)序列化多个对象，可以借助集合实现
 */
public class Demo01 {
    public static void main(String[] args) throws Exception{

        //1.创建对象流
        FileOutputStream out = new FileOutputStream("e:\\stu.bin");
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(out);

        //2.序列化(写入操作)
        Student s1 = new Student("A",20);
        Student s2 = new Student("B",21);
        ArrayList<Student> list = new ArrayList<Student>();
        list.add(s1);
        list.add(s2);
        objectOutputStream.writeObject(list);

        //3.关闭
        objectOutputStream.close();
        System.out.println("关闭");

    }
}

/**
 * 使用ObjectInputStream实现反序列化，读取重构
 */
public class Demo02 {
    public static void main(String[] args) throws Exception{

        //1.创建对象流
        FileInputStream fileInputStream = new FileInputStream("e:\\stu.bin");
        ObjectInputStream objectInputStream = new ObjectInputStream(fileInputStream);

        //2.读取文件（反序列化）
//        Student s = (Student) objectInputStream.readObject();
//        Student s2 = (Student) objectInputStream.readObject();

        ArrayList<Student> list = ( ArrayList<Student> ) objectInputStream.readObject();

        //3.关闭
        objectInputStream.close();
        System.out.println("关闭成功");
        System.out.println(list);
        //System.out.println(s.toString());
        //System.out.println(s2.toString());

    }
}

5.字符编码

• ISO-8859-1 收录除ASCII外，还包括西欧、希腊语、泰语等等
• UTF-8：针对Unicode码表的可变长度字符编码
• GB2312:简体中文
• GBK:简体中文、扩充
• BIG5台湾：繁体中文

6.字符流

字符流的父类（抽象类）

• Reader：字符输入流
  • public int read
• Writer:字符输出流
  • public void write(int n)d

7.文件字符流

• FileReader
  • public int read(char[] c)//从流中读取多个字符，将读到内容存入数组，返回实际读到的字符数；如果达到文件的尾部，则返回-1.
• FileWriter
  • public void write(String str)//一次写多个字符，将b数组中所有字符，写入输出流。

/**
 * 使用FileReader读取文件
 */
public class Demo02 {
    public static void main(String[] args) throws Exception{

        //1.创建FileReader
        FileReader fileReader = new FileReader("e:\\hello.txt");
        //2.读取
        //2.1单个字符读取
//        int data = 0;
//        while ((data = fileReader.read())!=-1){
//            System.out.println((char)data);
//        }
        //2.2
        char[] buf = new char[1024];
        int count = 0;
        while ((count = fileReader.read(buf))!=-1){
            System.out.println(new String(buf ,0,count));
        }
        //3.关闭
        fileReader.close();
    }
}

/**
 * 使用FileWrite写入文件
 */
public class Demo03 {
    public static void main(String[] args) throws Exception{

        //1.创建FileWriter对象
        FileWriter fileWriter = new FileWriter("e:\\write.txt");
        //2.写入
        for (int i = 0; i < 10; i++) {
            fileWriter.write("语言\r\n");
            fileWriter.flush();//刷新
        }
        //3.关闭
        fileWriter.close();
    }
}

/**
 * 使用FileReader和FileWriter复制文本文件，不能复制图片或二进制文件
 */
public class Demo04 {
    public static void main(String[] args) throws Exception{

        //1.创建对象
        FileReader fileReader = new FileReader("e:\\write.jpeg");
        FileWriter fileWriter = new FileWriter("E:\\copy.jpeg");

        //2.读取
        //2.1读取单个字符
        int data = 0;
        while( ( data=fileReader.read() ) !=-1){
            fileWriter.write(data);
        }
        //2.2读取到缓冲区
//        int count = 0;
//        char[] buf = new char[1024];
//        while ( (count = fileReader.read(buf) ) != -1){
//            fileWriter.write(new String(buf,0,count));
//        }

        //3.关闭
        fileReader.close();
        fileWriter.close();
        System.out.println("复制完毕");
    }
}

8.字符缓冲流

缓冲流：BufferedReader/BufferedWriter

• 高效读写
• 支持输入换行符
• 可一次写一行、读一行

/**
 * 使用BufferedReader读取文件
 */
public class Demo01 {
    public static void main(String[] args) throws  Exception{

        //1.创建BufferedReader
        FileReader fileReader = new FileReader("e:\\hello.txt");
        BufferedReader bufferedReader = new BufferedReader(fileReader);

        //2.读取
        //2.1 第一种
//        char[] buf = new char[1024];
//        int count = 0;
//        while ( (count = bufferedReader.read(buf) ) !=-1){
//            System.out.println(new String(buf,0,count) );
//        }

        //2.2 读取一行
        String line = null;
        while ( (line = bufferedReader.readLine() ) !=null){
            System.out.println(line);
        }


        //3.关闭
        bufferedReader.close();

    }
}

/**
 * 使用BufferedWriter
 */
public class bufferWriter {
    public static void main(String[] args) throws Exception{

        //1.创建对象
        FileWriter fileWriter = new FileWriter("e:\\write.txt");
        BufferedWriter bufferedWriter = new BufferedWriter(fileWriter);

        //2.写入
        for (int i = 0; i < 10; i++) {
            bufferedWriter.write("好好学习");
            bufferedWriter.newLine();//换行
            bufferedWriter.flush();
        }

        //3.关闭
        bufferedWriter.close();
        System.out.println("执行完毕");
    }
}

9.打印流

PrintWriter:

• 封装了print/println方法，支持写入后换行
• 支持数据原样打印

/**
 * 使用PrintWriter
 */
public class Demo01 {
    public static void main(String[] args) throws Exception{

        //1.创建打印流
        PrintWriter pw = new PrintWriter("e:\\print.txt");

        //2.打印
        pw.println(97);
        pw.println(true);
        pw.println(3.14);
        pw.println('a');
        pw.println("AS");

        //3.关闭
        pw.close();
        System.out.println("执行完毕");
    }
}

10.转换流

桥转换流：InputStreamReader/OutputStreamWriter

• 可将字节流转换为字符流
• 可设置字符的编码方式

/**
 * InputStreamReader读取文件，指定使用的编码
 */
public class Demo01 {
    public static void main(String[] args) throws  Exception{

        //1.创建对象
        FileInputStream fileInputStream = new FileInputStream("e:\\write.txt");
        InputStreamReader iSR = new InputStreamReader(fileInputStream,"gbk");

        //2.读取文件
        int data = 0;
        while ( (data = iSR.read())!=-1){
            System.out.print((char)data);
        }
        //3.关闭
        iSR.close();
        System.out.println("执行成功");

    }
}

/**
 * 使用OutputStreamWriter
 */
public class Demo02 {
    public static void main(String[] args) throws Exception{

        //1.创建对象
        FileOutputStream fileOutputStream = new FileOutputStream("e:\\info.txt");
        OutputStreamWriter osw = new OutputStreamWriter(fileOutputStream,"utf-8");

        //2.写入
        for (int i = 0; i < 10; i++) {
            osw.write("好好学习\r\n");
            osw.flush();
        }

        //3.关闭
        osw.close();
        System.out.println("finish");
    }
}

11.File类

概念：代表物理盘中的一个文件或者文件夹

方法:

• createNewFile()//创建一个新的空文件
• mkdir()//创建目录

/**
 * File类的使用
 * (1)分隔符
 * (2)文件操作
 * （3）文件夹操作
 */
public class Demo01 {
    public static void main(String[] args) throws Exception{

//        separator();
//        fileOpe();
        directoryOpe();
    }
    //(1)分隔符
    public static void separator(){
        System.out.println("路径分隔符"+ File.pathSeparator);
        System.out.println("名称分隔符"+File.separator);
    }
    //（2）文件操作
    public static void fileOpe() throws Exception{
        //1.创建文件
        File file = new File("e:\\file.txt");
        if (!file.exists()){
            boolean b = file.createNewFile();
            System.out.println("result:"+b);
        }

        //2.删除文件
        //2.1直接删除
        //System.out.println("delete:" +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()).toLocaleString());

        //4.判断
        System.out.println("是否可写:"+file.canWrite());
        System.out.println("是否是文件："+file.isFile());
        System.out.println("是否隐藏:"+file.isHidden());
    }

    //(3)文件夹操作
    public static void directoryOpe() throws Exception{
        //1.创建文件夹
        File dir = new File("e:\\a\\b\\ccc");
        System.out.println(dir);
        if ( !dir.exists()){
            //dir.mkdir();//只能创建单级目录
            System.out.println(dir.mkdirs());//创建多级目录
        }

        //2.删除
//        //2.1直接删除
//        System.out.println("delete:"+dir.delete());//只删除最底层的目录(且为空目录)
//        //2.2使用JVM删除
//        dir.deleteOnExit();
//        Thread.sleep(5000);

        //3.获取文件夹信息
        System.out.println("获取绝对路径："+dir.getAbsolutePath());
        System.out.println("获取路径:"+dir.getPath());
        System.out.println("获取名称："+dir.getName());//获得的最底层的名称
        System.out.println("获取父目录："+dir.getParent());
        System.out.println("获取创建时间:"+ new Date(dir.lastModified()).toLocaleString());

        //4.判断
        System.out.println("是文件夹吗："+dir.isDirectory());
        System.out.println("是隐藏的:"+dir.isHidden());

        //5.遍历文件夹
        File dir2 = new File("C:\\Users\\LK\\Desktop\\图片");
        String[]  str = dir2.list();
        for (String s:str) {
            System.out.println(s);
        }

        //使用FileFilter
        System.out.println("========fileFilter接口使用");
        File[] file2 =  dir2.listFiles(new FileFilter() {
            @Override
            public boolean accept(File pathname) {
                if (pathname.getName().endsWith(".jpeg"))
                    return true;
                else
                return false;
            }
        });
        for (File f:file2) {
            System.out.println(f.getName());
        }

    }
}

FileFilter接口

public interface FileFilter

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

//使用FileFilter
        System.out.println("========fileFilter接口使用");
        File[] file2 =  dir2.listFiles(new FileFilter() {
            @Override
            public boolean accept(File pathname) {
                if (pathname.getName().endsWith(".jpeg"))
                    return true;
                else
                return false;
            }
        });
        for (File f:file2) {
            System.out.println(f.getName());
        }

/**
 * 递归遍历文件夹
 */
public class Demo02 {
    public static void main(String[] args) {

        File dir = new File("e:\\a");

        listDir(dir);
//        System.out.println("=======");
//        deleteDir(dir);

    }
    //递归遍历文件夹
    public static void listDir(File dir){

        File[] f = dir.listFiles();
        System.out.println(dir.getAbsolutePath());
        if (f!=null && f.length>0){

            for (File f1:f) {
                if (f1.isDirectory()){
                    listDir(f1);
                }
                else{
                    System.out.println(f1.getAbsolutePath());
                }
            }

        }
    }

    //递归删除文件夹
    public static void deleteDir(File dir){

        File[] file = dir.listFiles();
        if (file != null && file.length>0){
            for (File f:file) {
                if (f.isDirectory()){
                    deleteDir(f);
                }
                else{
                    System.out.println(f.getAbsolutePath()+" 删除:"+f.delete());
                }
            }
        }
        System.out.println(dir.getAbsolutePath()+"删除:"+dir.delete() );
    }
}

12.Properties

Properties:属性集合

特点

1. 存储属性名和属性值
2. 属性名和属性值都是字符串类型
3. 没有泛型
4. 和流有关

/**
 * Properties集合的使用
 */
public class Demo01 {
    public static void main(String[] args) throws Exception{

        //1.创建集合
        Properties properties = new Properties();

        //2.添加数据
        properties.setProperty("username","A");
        properties.setProperty("age","20");
        System.out.println(properties.toString());

        //3.遍历
        //3.1 keyset
        //3.2 entryset
        //3.3 stringPropertyNames()
        Set<String> set = properties.stringPropertyNames();
        for (String str:set) {
            System.out.println(str+"==="+properties.getProperty(str));
        }

        //4.和流有关的方法
        //  1.list方法
//        PrintWriter pw = new PrintWriter("e:\\print.txt");
//        properties.list(pw);
//        pw.close();

//        // 2.store方法
//        FileOutputStream fileOutputSteam = new FileOutputStream("e:\\store.properties");
//        properties.store(fileOutputSteam,"注释");
//        fileOutputSteam.close();

        // 3.load方法
        Properties properties1 = new Properties();
        FileInputStream fis = new FileInputStream("e:\\store.properties");
        properties1.load(fis);
        fis.close();
        System.out.println(properties1.toString());

    }
}