Day16 IO流

流的概念和作用

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

Java流类图结构：

Stream流的聚合操作

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

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

 public class TestStream1 {

     public static void main(String[] args) {
         //存整数  生产者模式 思想
         //返回 一个 流对象
         IntStream stream = IntStream.builder().add().add().add().add().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>).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, , );// 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, , );
        //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())!=-) {
                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 = {,,};
        String [] name = {"aa","bb","cc"};
        for(int i = ; 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 = ; 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();
         guojing.setName("郭靖");
         //序列化  把对象 以二进制流 的形式存储起来。-------------------------------------------------------
         //
 /*//        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();*/
         //反序列化  把对象 以二进制流的形式 从文件中还原-----------------------------------------------------
         //
         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
         //
         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())!= -) {
             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------------读-------------------------
         //
         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();
         }
     }

 }