复习4,---Java中的stream

什么是stream
stream（流）是一个来自数据源的元素队列并支持聚合操作

• 元素是特定类型的对象，形成一个队列，Java中的stream并不会储存元素，而是根据需要去计算

• 数据源是流的来源

• 聚合操作是类似sql语句一样的操作
  stream操作基础特征：

• Pipelinling：中间操作都会返回流对象本身，这样多个操作连成一个管道，如同流式风格，这样可以对操作进行优化，比如延迟执行

• 内部迭代：以前集合遍历集合都是通过Iterator或者foreach的方式，显式的在集合外不进行迭代，这叫做外部迭代，Stream提供了内部迭代方式

读取本地文件中的一行：
实现方式：

package com.example.demo.studyone.stream;

import java.io.*;

/**
 * Stream
 * InputStream:   输入流
 *                从文件中往当前程序中入   是抽象类，不能直接new，供子类继承
 * outputStream： 输出流
 *                接口是一种特殊的抽象类，不能直接new  供实现类实现 implements
 *                接口             抽象类
 *                接口的实现类      抽象类的子类
 */
public class streamone {
    public static void main(String[] args) {
        File file = new File("C:\\Users\\de'l'l\\Desktop\\实训\\工程测试文件路径\\aaa.txt");
        try {
            FileInputStream fileInputStream = new FileInputStream(file);
            fileInputStream.read();
            FileReader fileReader = new FileReader(file);
            BufferedReader bufferedReader = new BufferedReader(fileReader);
            String line = bufferedReader.readLine();
            System.out.println(line);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

如果希望对集合中的元素进行筛选过滤：

1、将集合A根据条件一过滤为子集B
2、然后再根据条件二过滤为子集C

package com.example.demo.studyone.stream;

import java.util.ArrayList;

public class streamtwo {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("黄豆芽");
        list.add("敬业福");
        list.add("利应届");
        list.add("利口酒");
        list.add("蛋炒饭");
        list.add("也不多");
        //对list集合中的元素进行过滤,只要以利开头的元素,存储到一个新的集合中
        ArrayList<String> list1 = new ArrayList<>();
        for(String two : list){
            if (two.startsWith("利")){
                list1.add(two);
            }
        }
        //对listA集合进行过滤,只要姓名长度为3的人,存储到一个新集合中
        ArrayList<String> list2 = new ArrayList<>();
        for (String two : list1){
            if (two.length() == 3){
                list2.add(two);
            }
        }
        //遍历list2集合
        for (String two : list2){
            System.out.println(two);
        }
    }
}
/**
 * 利应届
 * 利口酒
 */

这段代码中含有三个循环，每一个作用不同：

首先筛选所有姓张的人；
然后筛选名字有三个字的人；
后进行对结果进行打印输出。
每当我们需要对集合中的元素进行操作的时候，总是需要进行循环、循环、再循环。这是理所当然的么？不是。循 环是做事情的方式，而不是目的。另一方面，使用线性循环就意味着只能遍历一次。如果希望再次遍历，只能再使 用另一个循环从头开始。
那，Lambda的衍生物Stream能给我们带来怎样更加优雅的写法呢？
Stream的更优写法

package com.example.demo.studyone.stream;

import java.util.ArrayList;

public class streamthree {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("黄豆芽");
        list.add("敬业福");
        list.add("利应届");
        list.add("利口酒");
        list.add("蛋炒饭");
        list.add("也不多");
        //对list集合中的元素进行过滤,只要以张开头的元素,存储到一个新的集合中
        //对listA集合进行过滤,只要姓名长度为3的人,存储到一个新集合中
        //遍历listB集合
        list.stream()
                .filter(name -> name.startsWith("利"))
                .filter(name -> name.length() == 3)
                .forEach(name -> System.out.println(name));
    }
}
/**
 * 利应届
 * 利口酒
 */

全部实例
https://www.runoob.com/java/java8-streams.html
其中一部分

package com.example.demo.studyone.stream;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class streamfour {
    public static void main(String[] args) {
        List<String> strings = Arrays.asList("aaad", "dhc","", "kusbxfs", "qa", "poiujhgf", "dbft","");
        System.out.println("列表"+strings);
        long count = getCount(strings);

        System.out.println("空字符数量为："+count);//空字符数量为：2

        count = getCountLength3UsingJava7(strings);
        System.out.println("字符长度为3的数量为："+count);//字符长度为3的数量为：1

        //删除空字符串
        List<String> filtered = deleteEmpty(strings);
        System.out.println("删除后列表："+filtered);

        //删除空字符串，并使用逗号把它们合并起lai
        String merdedString = getMerged(strings,",");
        System.out.println("合并后的字符串：" + merdedString);

        // 获取列表元素平方数
        List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 5);
        List<Integer> squaresList = getSquares(numbers);
        System.out.println("平方数列表："+squaresList);
    }

    private static List<Integer> getSquares(List<Integer> numbers) {
        ArrayList<Integer> squaresList = new ArrayList<>();
        for (Integer number:numbers){
            Integer squares = new Integer(number.intValue() * number.intValue());
            if (!squaresList.contains(squares)){
                squaresList.add(squares);

            }
        }
     return squaresList;
    }

    private static String getMerged(List<String> strings, String separator) {
        StringBuilder stringBuilder = new StringBuilder();
        for(String string:strings){
            if(!string.isEmpty()){
                stringBuilder.append(string);
                stringBuilder.append(separator);
            }
        }
        String mregedString = stringBuilder.toString();
        return mregedString.substring(0,mregedString.length()-2);
    }

    private static List<String> deleteEmpty(List<String> strings) {
        ArrayList<String> arrayList = new ArrayList<>();
        for (String string : strings){
            if (! string.isEmpty()){
                arrayList.add(string);
            }
        }

        return arrayList;
    }

    private static int getCountLength3UsingJava7(List<String> strings) {
        int count = 0;
        for (String string:strings){
            if(string.length() ==3){
                count++;
            }
        }
        return count;
    }

    private static int getCount(List<String> strings) {
       int count = 0;
        for (String string : strings){
           if (string.isEmpty()){
               count++;
           }
        }
        return count;
    }


}
/**
 * 列表[aaad, dhc, , kusbxfs, qa, poiujhgf, dbft, ]
 * 空字符数量为：2
 * 字符长度为3的数量为：1
 * 删除后列表：[aaad, dhc, kusbxfs, qa, poiujhgf, dbft]
 * 合并后的字符串：aaad,dhc,kusbxfs,qa,poiujhgf,dbf
 * 平方数列表：[9, 4, 49, 25]
 */