java学习总结之Java的“流”及“流式处理”

一，java的流式处理

1.1 什么是流式处理？

在JDK8以后，提供对集合的流式操作，对集合的元素可以向“流水”一样，依次方便，遍历，排序等，它是“不可逆的”（访问后面元素之后不能再次返回前面元素 ） ， 根据流的处理方式不同，可以分为 串行流和并行流， 串行流表示同一时间只能有一个流式操作，而并行流可以有多个流式操作。

​ 流返回的结果包括中间操作和 最终操作

中间操作：它的返回值依然是 流对象 ，例如 排序、过滤、去重

最终操作： 返回值是特定的结果类型 ，例如 遍历，取最大值，最小值或返回新的集合

1.2 常用方法

常用方法：

​ stream() :将一个集合流式化

​ filter()： 按条件过滤，里面使用lambda表达式

​ sort(): 排序集合元素

​ distinct： 过滤重复元素

​ reduce() : 将集合的所有元素累加或拼接

​ map()； 映射一个新的集合 对集合元素变更输出

​ collect():返回一个新集合

​ max（） min()：返回集合最大值或最小值

​ get (): 获取集合计算的结果
代码实现：

 public static void main(String[] args) {
   
        List<Integer> list = new ArrayList();
        for(int i = 0 ;i<7;i++){
   
              list.add(i+1);
        }
         // 1、过滤 filter()   过滤掉偶数
        list.stream().filter( param ->param%2==1 )
                    .forEach(System.out::println); //遍历元素

        // 2、排序 sort()   降序
        list.stream().sorted((o1,o2)->o2-o1).forEach(System.out::println);

        //  3 map() 映射一个新的集合 ， 如果是奇数 输出奇数 ，否则偶数
        list.stream().map(
                param -> param%2==1?"这个元素是奇数":"这是偶数"
                ).forEach(System.out::println);

        list.add(1);
        list.add(1);
        System.out.println("去重元素");
        // 4 distinct（）  去除重复元素
        list.stream().distinct().forEach(System.out::println);

        // 5 reduce() 将集合的所有元素 累加（或拼接）

        int sum =  list.stream().reduce((o1,o2)->o1+o2).get();
        System.out.println("总和："+sum);

        // 6 collect 返回一个新的集合
        List<Integer> list2= list.stream().filter(param->param%2==1).collect(Collectors.toList());
        System.out.println("遍历新集合");
        list2.stream().forEach(System.out::println);

        // 7、最大和最小
        int max = list2.stream().max((o1,o2)->o1-o2 ).get();
        System.out.println("最大值："+max);
        int min = list2.stream().min((o1,o2)->o1-o2 ).get();
        System.out.println("最小值："+min);
    }

二，java的I/O流

2.1 什么是I.O

在生活中，你需要将U盘的文件 ，拷贝到电脑（或者将电脑的文件拷贝到其他设备）， 文件是通过数据流的方式依次到达另一个设备中， 文件的拷贝就是一个输入（Input）和输出（Output）的过程

Java中提供对应的API支持对文件的输入和输出 ， java.io.*

2.2 什么是流

生活中 也存在流的概念，例如 管道中的流水，从管道的入口到达管道出口，一滴水可以从入口流到出口，可以将“水”比作 “字节数据或字符数据”，数据也可以从一端流到另一端。

输入（Input）： Java中，以“应用程序（内存）”为中心，将磁盘文件（设备端）到达内存中的过程 称为 输入

输出（Output）： 以“应用程序（内存）”为中心，将数据从内存到达磁盘文件（设备端）的过程称为 输出

根据文件操作方式不同可以将IO分为三类

1、按照读写方向不同: 输入流（InputStream）和输出流（OutputStream）

2、按照数据类型不同： 字节流（Byte）和字符流（Char）

3、按照读写效率不同： 单一流和包装流（buffered等缓冲流）

关于流的分类Java提供 4个顶级抽象类 ，分布构建它们的子类

常见的流

1、文件字节输入流和文件字节输出流 ： FileInputStream 和 FileOutputStream

2、文件字符输入流和文件字符输出流： FileReader 和 FileWriter

3、缓存字节输入流和 缓存字节输出流 BufferedInputStream 和 BufferedOutputStream

4、缓存字符输入流和缓冲字符输出流 BufferedReader 和BuffereWriter

5、数据输入流和数据输出流： DataInputStream 和 DataOutputStream

6、字节数组输入流 和 字节数组输出流 ： ByteArrayInputStream 和 ByteArrayOutputStream

7、字符数组输入流 和 字符数组输出流： CharArrayReader 和 CharArrayWriter

8、转换流： （字节流转成字符流） InputStreamReader 和 OutputStreamWriter

9、对象流（序列化流）： ObjectInputStream 和 ObjectOutputStream

10、随机访问流（这个流既可以读，也可以写）：RandomAccessFIle

2.2.1 字节流

​ 定义： 文件的输入输出以一个“字节”为单位，进行流处理

FileInputStream 和 FileOutputStream

读入： 将文件中的数据读到内存中

常用方法：

​ int read() : 一个字节的读取 ，返回字节 的asci码 ，对于汉字会分3次读取

​ int read(byte) ： 按一个数组长度读取， 返回实际读取的字节长度， 数据存放在数组中

​ int read(byte , offset , len) : 读取流中指定长度的数据，并存放在指定位置，

​ available() :返回流中剩余的字节长度，如果已读完，则返回0

​ skip(long n ): 丢弃指定的字节长度，从下一个开始读取

      File file = new File("d:/aaa.txt");
        FileInputStream fis = new FileInputStream(file);
       //
		byte [] b= new byte[10];
        StringBuffer sb = new StringBuffer();
            //每次读取的长度，  b： 存放数据的数组
          int len = 0;
          while((len = fis.read(b)) !=-1){
   
              sb.append( new String(b,0,len));
          }

        System.out.println(sb);
        fis.close();


 public static void read2() throws IOException {
   
        // InputStream是抽象类
        InputStream is = new FileInputStream("d:/aaa.txt");
        //丢弃前两个字节
        is.skip(2);
        System.out.println((char)is.read());
        System.out.println("还剩下多少个字节："+ is.available());
        // 将后面的字节继续使用字节数组读
        byte [] b = new byte[10];
        int len = is.read(b,1,4);
        // 显示数组中读取的所有数据
        System.out.println(Arrays.toString(b));
        //将数组的内容转成字符串  对于空内容不会转换
        System.out.println(new String(b));

        is.close();


    }

文件写出： 将内存的数据写出到磁盘中

构造方法：

new FileOutputStream（File/String ） ： 构造文件对象的写出流， 默认覆盖写出

new FileOutputStream(File/String , append): 构造文件对象的写出流，

append：表示在原有文件上追加数据， false ： 覆盖

常用方法：

​ void write(int) : 写出一个字节

​ void writer(byte []) ：写出一个字节数组，这里需要指定数组的编码格式 “UTF-8”

​ void writer(byte[] , offerset,len) : 写出一个字节数组，指定数组的长度和下标。 从数组的下标开始写出，len表示写出长度

​ flush（） ：清空缓存，对于使用缓冲流时，将缓冲强制清空。

   //将内存的数据写出到文件   如果文件不存在，会自动创建， 默认覆盖写入  true:追加
        FileOutputStream fos = new FileOutputStream("d://aaa.txt" ,true);
        String str="今天天气还不错";
        fos.write(99);
        //写出一个字符串    字符串可以转成字节数组 或字符数组
        fos.write(str.getBytes("UTF-8"));
        // 写出指定长度
        fos.write(str.getBytes("UTF-8"),0,3); // 写出这个数组的前2个字节
        // 清空缓存
        fos.flush();
        // 关闭流
        fos.close();
        System.out.println("写出成功");

文件复制：

将文件（图片，文本，视频）从一个目录复制到另一个目录， 其中数据长度不变，通过文件读写的方式