Java8——Stream流的使用(获取流)

Stream有以下常见方式获取流:1.从集合;2.从数组;3.从文件;4.从函数;5.指定元素。

有以下常见方式获取流:

  1. 从集合
    1. Java8开始Collection超级接口中,提供了一个stream()默认方法,这个方法可以从调用集合中获取全部集合元素的流,因此全部的Collection体系下面的集合都可以调用stream()方法获取流,流元素就是单个集合元素。
    2. 注意,Map集合中没有直接获取流的方法!
  2. 从数组
    1. 数组的Arrays.stream静态方法接收一个数组,返回一个具有数组全部元素的流,流元素就是单个数组元素。
  3. 从文件
    1. Files类中具有读取文件并且生成流的方法,最重要的就是lines方法,用于获取文件的所有行的流。
  4. 从函数
    1. Stream API提供了两个静态方法来从函数生成流:Stream.iterate和Stream.generate。从函数生成的流被称为无限流,通常我们只需要截取一部分即可!
    2. static < T > Stream< T > iterate(T seed, UnaryOperator< T > f),iterate第一个参数是一个初始值,第二个参数是一个依次应用在每个产生的新值上的UnaryOperator,即一元操作器,这个 将上一次生成的值当作参数,生成下一个值。
    3. static < T > Stream< T > generate(Supplier< T > s),generate方法没有指定初始值,后面的值也不是依据前一个值计算出来的,generate接受一个Supplier,它的值就是通过这个生产者返回的!因此,如果我们需要获取随机数,使用generate就很方便!
  5. 指定元素
    1. static < T > Stream< T > of(T… values),返回其元素是指定值的顺序排序流。
    2. static < T > Stream< T > of(T t),返回包含单个元素的顺序 Stream 。

获取流的案例:

/**
 * @author lx
 */
public class CreateTest {

    /**
     * @author lx
     */
    class Filter {
        private int x;

        public int getX() {
            return x;
        }

        public void setX(int x) {
            this.x = x;
        }

        public Filter(int x) {
            this.x = x;
        }

        public Filter() {
        }

        @Override
        public String toString() {
            return "Filter{" +
                    "x=" + x +
                    '}';
        }
    }


    /**
     * 从集合获取流
     */
    @Test
    public void test() {
        List<Filter> filters = new ArrayList<>();
        filters.add(new Filter(0));
        filters.add(new Filter(3));
        filters.add(new Filter(9));
        filters.add(new Filter(8));
        //从集合
        Stream<Filter> stream = filters.stream();
        stream.forEach(System.out::println);
    }

    /**
     * 从数组获取流
     */
    @Test
    public void test1() {
        Filter[] filArr = new Filter[]{new Filter(1),
                new Filter(3),
                new Filter(9),
                new Filter(8)};

        //从数组
        Stream<Filter> stream = Arrays.stream(filArr);
        stream.forEach(System.out::println);
    }


    /**
     * 从文件获取流
     */
    @Test
    public void test2() {
        //读取文件的所有行的流
        try (Stream<String> lines = Files.lines(Paths.get("target/classes/lines.txt"))) {
            lines.forEach(System.out::println);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }


    /**
     * iterate获取10个偶数
     */
    @Test
    public void iterate() {
        Stream.iterate(0, n -> n + 2)
                //取前十个数据(后面会讲,这叫做“筛选”)
                .limit(10)
                .forEach(System.out::println);


    }

    /**
     * iterate获取下标
     * 采用Stream通过下标遍历集合
     */
    @Test
    public void iterate2() {
        ArrayList<Object> objects = new ArrayList<>();
        objects.add(1);
        objects.add(3);
        objects.add(2);
        objects.add(4);
        Stream.iterate(0, i -> i + 1)
                //截取前集合长度的数据
                .limit(objects.size())
                .forEach(i -> System.out.println(i + "-->" + objects.get(i)));

    }

    /**
     * generate获取10个随机数
     */
    @Test
    public void generate() {
        Stream.generate(Math::random)
                .limit(10)
                .forEach(System.out::println);
    }


    //复杂数据生成

    /**
     * iterate获取10个斐波那契数
     */
    @Test
    public void iterateFibonacci() {
        //斐波那契数列的规律:F(0)=0,F(1)=1,F(2)=1, F(n)=F(n - 1)+F(n - 2)(n ≥ 2,n ∈ N*)
        //我们初始化数组new int[]{0, 1}
        //后续的数组的第1个元素是前一个数组的第2个元素,后续的数组的第2个元素是前一个数组的第1、2个元素的和
        //这样实际上生成的数组如下:
        //new int[]{0, 1}
        //new int[]{1, 1}
        //new int[]{1, 2}
        //new int[]{2, 3}
        //new int[]{3, 5}
        //new int[]{5, 8}
        //new int[]{8, 13}
        //new int[]{13, 21}
        //new int[]{21, 34}
        //取每个数组的第一个元素就是斐波那契数

        Stream.iterate(new int[]{0, 1},
                t -> new int[]{t[1], t[0] + t[1]})
                //生成10个数组
                .limit(10)
                //获取每个数组的第一个元素(后面会讲,这叫做“映射”)
                .map(t -> t[0])
                .forEach(System.out::println);
    }


    /**
     * Stream.of
     */
    @Test
    public void of() {
        Stream.of(1, 2, 3, "11").forEach(System.out::println);
    }
}

  • 发表于 2020-09-16 15:46
  • 阅读 ( 27 )

0 条评论

请先 登录 后评论
NX小编
NX小编

1209 篇文章

作家榜 »

  1. NX小编 1209 文章
  2. 58沈剑 309 文章
  3. 奈学教育 137 文章
  4. 李希沅 | 奈学教育 36 文章
  5. 江帅帅 | 奈学教育 29 文章
  6. 林淮川 | 奈学教育 12 文章
  7. 科技热点 10 文章
  8. 邱鹏超 2 文章