Day16 IO流

流的概念和作用

流是一组有顺序的，有起点和终点的字节集合，是对数据传输的总称或抽象。即数据在两设备间的传输称为流，流的本质是数据传输，根据数据传输特性将流抽象为各种类，方便更直观的进行数据操作。 

Java流类图结构：

Stream流的聚合操作

1.末端方法；都是一次性的使用，流就会关闭，不能再用此流了。

2.中间方法；会返回一个新的流对象，继续调用其他的聚合方法操作。

public class TestStream1 {

    public static void main(String[] args) {
        //存整数  生产者模式 思想 
        //返回 一个 流对象
        IntStream stream = IntStream.builder().add(11).add(22).add(33).add(44).build();
//        System.out.println(stream.max().getAsInt());//末端
//        IntStream stream1 = IntStream.builder().add(11).add(22).add(33).add(44).build();
//        System.out.println(stream1.min().getAsInt());
//        System.out.println(stream.min().getAsInt());
//        System.out.println(stream.sum());
//        System.out.println(stream.average().getAsDouble());
//        System.out.println(stream.count());
        //是否 所有的 数据 都 满足条件，都满足 true，否则不成立
    /*    System.out.println(stream.allMatch(new IntPredicate() {
            
            @Override
            public boolean test(int value) {
                // TODO Auto-generated method stub
                return value > 10;
            }
        }));*/
//        System.out.println(stream.allMatch(v-> v > 10));
        //只要有一个元素满足条件 就 成立 true
//        System.out.println(stream.anyMatch(v-> v > 22));
        //中间方法
//        System.out.println(stream.filter(v-> v > 22).count());
        stream.filter(v->v>22).forEach(System.out::println);
        
        
    }
    
    

}

IO流

File类

File类主要用来获取文件（或目录）本身的一些信息，如文件的名字，不涉及文件的读写操作。

常用方法

对文件的操作

public class TestFile {

    public static void main(String[] args) throws IOException {
        // File
        //文件 ：
        File f1 = new File("d:/data");
        File f = new File(f1,"x.txt");
//        File f = new File("d:/data","x.txt");
//        File f = new File("d:\data\x.txt");
//        File f = new File("./x.txt");
        System.out.println(f.exists());
        //新建文件
        f.createNewFile();//
        //判断文件是否存在
        System.out.println(f.exists());
        //文件名字
        System.out.println(f.getName());
        //文件的路径:根据指定的 文件路径不同显示不同，可以显示 绝对的也可以显示相对的
        System.out.println(f.getPath());
        //绝对路径
        System.out.println(f.getAbsolutePath());
        //父路径
        System.out.println(f.getParent());
        //文件 是否 可读，可写
        System.out.println(f.canRead());
        System.out.println(f.canWrite());
        //判断 是否是文件
        System.out.println(f.isFile());
        //最后修改的时间
        long time = f.lastModified();
        System.out.println(time);
        //格式化
        //DateFormat -> SimpleDateFormat
        System.out.println(DateFormat.getDateInstance().format(time));
        //文件的长度：文件内容的字节数
        long len = f.length();//
        System.out.println(len);
        //删除文件
        f.delete();
        System.out.println(f.exists());    
        
    }

}

对目录的操作

public class TestFile1 {

    public static void main(String[] args) {
        // File目录
        File f = new File("d:/data");
//        File f = new File("d:/data2/data3");
        System.out.println(f.exists());
        //是否 是目录
        System.out.println(f.isDirectory());
        //建立目录
//        f.mkdir();
        //建立目录 包括 父目录
//        f.mkdirs();
        //获得 目录下 的 子目录 和文件的 名称 的数组
        String [] str1 = f.list();
        Arrays.stream(str1).forEach(System.out::println);
        //FilenameFilter文件名过滤器
        String [] str2 = f.list(new FilenameFilter() {
            
            @Override
            public boolean accept(File dir, String name) {
                // 把扩展名 是 java的过滤出来
                return name.endsWith("java");
            }
        });
        String [] str3 = f.list((d,name)->name.endsWith("java"));
        
        System.out.println("------------------------");
        Arrays.stream(str2).forEach(System.out::println);
        System.out.println("------------------------");
        //-----------------------------------------------------
        File[] fl1 = f.listFiles();
        for(File ff:fl1) {
            if(ff.isFile()) {
                System.out.println(ff.getName());
            }else {
                System.out.println(ff.getPath());
            }
        }
        //FileFilter过滤器
        File[] fl2 = f.listFiles(new FileFilter() {
            
            @Override
            public boolean accept(File pathname) {
                //把扩展名 是 java的过滤出来
                return pathname.getName().endsWith("java");
            }
        });
        System.out.println("------------------------");
        for(File ff:fl2) {
            if(ff.isFile()) {
                System.out.println(ff.getName());
            }else {
                System.out.println(ff.getPath());
            }
        }    
    }

}

流的分类

序列化是写，反序列化是读

按照流的数据类型：分为字节流和字符流

按照方向：输入和输出

按照功能：节点流和处理流

节点流：直接对数据源（文件）操作。

处理流（过滤流，包装流）：套接（包装）在节点流之上的，提供更丰富的功能或提高效率。

字节流

字节流由2个抽象类定义：

InputStream：所有字节输入流的父类

int read()：从输入流中读取一个字节，到达文件尾返回-1

void close()：关闭此输入流并释放与该留关联的所有系统资源

OutputStream：所有字节输出流的父类

abstract void write(int)：将指定的字节写入此输出流

void close()：关闭此输出流并释放与该留关联的所有系统资源

文件流

FileInputStream

read()：读一字节，到文件末尾返回-1

read(byte[])： 返回读到的字节数

read(,,) ：(存入的字节数组，存入的起始位置，存入几个字节）

public static void main(String[] args) throws IOException {
        // FileInputStream 文件 输入流
        //1 创建流对象
        File f = new File("d:/data/a.txt");
        FileInputStream fin = new FileInputStream(f);
        //把字节流转换成字符流
        //转换字符流
//        InputStreamReader ir = new InputStreamReader(fin);
        //2读
/*        int temp ;
        while((temp = fin.read())!= -1) {
            System.out.print((char)temp);
        }*/
//        byte [] b = new byte[(int)f.length()];
        byte [] b = new byte[fin.available()];//获得流中的字节数
        //把文件的内容 读入 到 b中
//        fin.read(b);
        //  (存入的字节数组，存入的起始位置，存入几个字节）
        fin.read(b, 1, 2);// ab
        String s = new String(b,"gbk");
        System.out.println(s);
        //3.关
        fin.close();
        /*ir.close();*/
//        ir.close();
    }

FileOutputStream

write(int )：写一字节

write(byte[])：写一个字节数组

write(b, 2, 2)：(数组，起始位置，字节数)

public static void main(String[] args) throws IOException {
        // FileOutputStream 写 输出
        //String s = "hello"存到  d:/data/b.txt
        //1  true追加 ，false覆盖 吗，默认 false
        FileOutputStream fout = new FileOutputStream("d:/data/b.txt",false);
        //2写
        String s = "hello";
        byte [] b = s.getBytes();
//        fout.write(b[0]);//写一字节
//        fout.write(b);//写一个字节数组 ，
        //  (数组，起始位置，字节数)
        fout.write(b, 2, 2);
        //3.关
        fout.close();
    }

缓冲流

BufferedInputStream和BufferedOutputStream，默认8192字节，提供了缓冲区，提高效率

public class TestFileInputOutputStream {

    public static void main(String[] args)  {
        // 复制图片
/*        //1 。创建对象
        FileInputStream fin = new FileInputStream("d:/data/aoteman.jpg");
        FileOutputStream fout = new FileOutputStream("d:/data/aotemannew.jpg");
        
        BufferedInputStream bfin = new BufferedInputStream(fin);//缓冲流 提供了 板车  8192字节
        BufferedOutputStream bfout = new BufferedOutputStream(fout);// 提供了汽车 8192字节
        //2读和写
        int temp;
        while((temp = bfin.read())!=-1) {
            bfout.write(temp);
        }
        bfout.flush();//强制写入
        //3
        bfin.close();
        bfout.close();*/
        
        //----------------------------------------------------
        FileInputStream fin = null;
        FileOutputStream fout = null;
        BufferedInputStream bfin = null;
        BufferedOutputStream bfout = null;
        try {
            fin = new FileInputStream("d:/data/aoteman.jpg");
            fout = new FileOutputStream("d:/data/aotemannew.jpg");
            bfin = new BufferedInputStream(fin);//缓冲流 提供了 板车  8192字节
            bfout = new BufferedOutputStream(fout);// 提供了汽车 8192字节
            int temp;
            while((temp = bfin.read())!=-1) {
                bfout.write(temp);
            }
            bfout.flush();//强制写入
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
                try {
                    if(bfin != null) {
                        bfin.close();
                    }
                    if(bfout != null) {
                        bfout.close();
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
            
        }
        
        
    }

}

数据流

DataInputStream和DataOutputStream

提供了 使用 Java的不同数据类型 的方式 读和写。

public class TestDateOutputStream {

    public static void main(String[] args) throws Exception {
        // DataOutputStream数据流
        //-------------写--------------------------
        //1
//        DataOutputStream dout = new DataOutputStream(new FileOutputStream("d:/data/stu.txt"));
        FileOutputStream fout = new FileOutputStream("d:/data/stu.txt");
        DataOutputStream dout = new DataOutputStream(fout);
        //2.写
        int [] no = {11,22,33};
        String [] name = {"aa","bb","cc"};
        for(int i = 0; i < no.length; i++) {
            dout.writeInt(no[i]);
            dout.writeUTF(name[i]);
        }
        //3.
        dout.close();
        //---------------读-------------------------
        FileInputStream fin = new FileInputStream("d:/data/stu.txt");
        DataInputStream din = new DataInputStream(fin);
        for(int i = 0; i < no.length; i++) {
            System.out.println(din.readInt());
            System.out.println(din.readUTF());
        }
        din.close();
    }

}

对象流

ObjectInputStream和ObjectOutputStream

永久性的存储对象，需要实现Serializable接口

序列化：把对象以二进制的形式存储起来。

反序列化：把对象以二进制流的形式从文件中还原

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.Serializable;

class Student implements Serializable{
    
    /**
     * 字节码文件中存储的那个版本号, 不显示指定，系统会自动随机一个
     */
    private static final long serialVersionUID = 1L;
    private int no;
    private String name;
    private int age;
    public int getNo() {
        return no;
    }
    public void setNo(int no) {
        this.no = no;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    
}
public class TestObjectStream {
    public static void main(String[] args) throws FileNotFoundException, IOException, ClassNotFoundException {
        // 创建对象
        Student guojing = new Student();
        guojing.setNo(11);
        guojing.setName("郭靖");
        //序列化  把对象 以二进制流 的形式存储起来。-------------------------------------------------------
        //1
/*//        ObjectOutputStream obj = new ObjectOutputStream(new FileOutputStream("d:/data/obj.txt"));
        FileOutputStream fout = new FileOutputStream("d:/data/obj.txt");
        ObjectOutputStream obj = new ObjectOutputStream(fout);
        //2写 
        obj.writeObject(guojing);
        //3.
        obj.close();*/
        //反序列化  把对象 以二进制流的形式 从文件中还原-----------------------------------------------------
        //1
        FileInputStream fin = new FileInputStream("d:/data/obj.txt");
        ObjectInputStream objin = new ObjectInputStream(fin);
        //2读 
        Student stu = (Student)objin.readObject();
        System.out.println(stu.getNo()+","+stu.getName());
        //3.
        objin.close();

    }

}

打印输出字节流

PrintStream

public class TestPrintStream {

    public static void main(String[] args) throws IOException {
        /*// TODO Auto-generated method stub
        System.out.println("hello");
        System.err.println("abc");*/
        //PrintStream
        //把读到的文件 的内容 在控制台上打印输出
        //System.out
        //1
        FileInputStream fin = new FileInputStream("d:/data/a.txt");
        //2读
        byte [] b = new byte[fin.available()];
        fin.read(b);
        //3.
        fin.close();
        //-----------------打印到控制台------------------------------
        //System.out控制台输出 System.in控制台输入
        PrintStream print = new PrintStream(System.out);
        print.println(new String(b,"gbk"));
        print.close();
    }

}

字符流

抽象父类
Reader
Writer

子类：

1.文件字符流（节点流）

FileReader
FileWriter

public class TestReader1 {

    public static void main(String[] args) throws IOException {
        // 逆序写入
        //读-----------------------------
        File f = new File("d:/data/a.txt");
        FileReader fr = new FileReader(f);
        int temp;
        StringBuffer sf = new StringBuffer();
        while((temp = fr.read())!= -1) {
            sf.append((char)temp);//连接
        }
        fr.close();
        //写------------------------------
        FileWriter fw = new FileWriter("d:/data/b.txt");
        //反转
        String s = sf.reverse().toString();
        fw.write(s);//写入
        fw.close();
    }

}

2.字符缓冲流

BufferedReader
BufferedWriter

public class TestReader {

    public static void main(String[] args) throws IOException {
        // FileReader------------读-------------------------
        //1
        FileReader fr = new FileReader("d:/data/a.txt");
        BufferedReader bfr = new BufferedReader(fr);
        //2读
        String s = null;
        while((s = bfr.readLine())!= null) {
            System.out.println(s);
        }
    
        /*int temp ;
        while((temp = fr.read())!= -1) {
            System.out.print((char)temp);
        }*/
        //3.
        fr.close();
        //FileWriter---------------写----------------------------
    /*    FileWriter fw = new FileWriter("d:/data/b.txt");
        String s = "hello";
        fw.write(s);
        fw.close();*/
        
    }

}

3.打印输出流

PrintWriter

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;

public class TestPrintWriter {

    public static void main(String[] args) {
        // PrintWriter
/*        PrintWriter pw = new PrintWriter("d:/data/num.txt");
        for(int i = 1; i <= 10; i++) {
//            System.out.println(i);
            pw.println("数字："+i);
        }
        pw.close();*/
        //----------------循环写入内容------------------------
        //1
        // System.in
/*        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter pw = new PrintWriter("d:/data/namenew.txt");
        String s;
        while(true) {
            s = br.readLine();//读一行
            if(s.equals("q")) {
                break;
            }
            pw.println(s);
        }
        br.close();
        pw.close();
        */
        //自动资源释放
        try(BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter pw = new PrintWriter("d:/data/namenew.txt");){
        
            String s;
            while(true) {
                s = br.readLine();//读一行
                if(s.equals("q")) {
                    break;
                }
                pw.println(s);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}