标签：使用   imp   filter   lang   数组   main   src   循环   extends   

Stream流

Stream API可以极大提高Java程序员的生产力，让程序员写出高效率、干净、简洁的代码。这种风格将要处理的元素集合看作一种流， 流在管道中传输， 并且可以在管道的节点上进行处理， 比如筛选， 排序，聚合等。元素流在管道中经过中间操作（intermediate operation）的处理，最后由最终操作(terminal operation)得到前面处理的结果。

对比：

package com.py.Stream;

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

public class DemoStreamFilter {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("张三丰");
        list.add("霍元甲");
        list.add("张无忌");
        list.add("杨过");
        list.add("张文");
//      过滤获得一张开头的名字
        ArrayList<String> nlist = new ArrayList<>();
        for (String i :
                list) {
            if (i.startsWith("张")){
                nlist.add(i);
            }
        }

//      循环得到字符长度为3的名字
        for (String i :
                nlist) {

            if (i.length()==3){
                System.out.println(i);
            }
        }
    }
}

package com.py.Stream;

import java.util.ArrayList;

public class DemoStreamFilter01 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("张三丰");
        list.add("霍元甲");
        list.add("张无忌");
        list.add("杨过");
        list.add("张文");
        //      过滤获得一张开头的名字
        //      循环得到字符长度为3的名字
        //      遍历
        list.stream()
                .filter(name->name.startsWith("张"))
                .filter(name->name.length()==3)
                .forEach(naem-> System.out.println(naem));
    }
}

获取Stream流的方法

• 所有的Collection集合（单列集合）都可以通过Strem方式获得流

  • java.util.Interface Collection

  ? default Stream stream() 返回以此集合作为源的顺序 Stream 。

• Stream接口的静态方法of可以获得数组对应的流

  • java.util.stream.Interface Stream

集合间的关系

实例

package com.py.Stream;

import java.util.*;
import java.util.stream.Stream;

public class DemoGetStream {
    public static void main(String[] args) {
        //把ArraryList转换为流
        ArrayList<String> list = new ArrayList<>();
        Stream<String> stream01 = list.stream();

        //将set转化为流
        Set<String> set = new HashSet<>();
        Stream<String> stream02 = set.stream();

        //Map转化为stream流
        Map<String,String> map = new HashMap<>();
            //将键转化为流
        Stream<String> stream03 = map.keySet().stream();
            //将值转化为流
        Stream<String> stream04 = map.values().stream();
            //获取键值对
        Stream<Map.Entry<String, String>> stream05 = map.entrySet().stream();


        //将数组转化为流
        Stream<Integer> stream06 = Stream.of(1, 2, 3, 4, 5, 6);
			//int类型
        Integer[] integer = {1,2,3,4,5,6};
        Stream<Integer> stream07 = Stream.of(integer);
			//String类型
        String [] str = {"ni","aef","zsdf","dsfg"};
        Stream<String> stream08 = Stream.of(str);


    }
}

常用方法

常用的方法分为两类:

• 延迟方法：返回值仍然是Stream流接口的方法，支持链式调用
• 终结方法： 返回值类型不再是stream流接口的方法，因此不再支持类似的链式调用

forEach

Consumer 接口中包含抽象方法void accept（T t），消费一个指定泛型的数据。

? T：流中的元素类型

Filter

Predicate：函数式接口，可以使用lambda表达式对数据进行过滤。

? 抽象方法 test(T t)

Map

Function：函数式接口，可以使用lambda表达式进行映射

? 抽象方法：R apply (T);

Count

此方法是一个终结方法，统计流中元素个数，调用后不能继续使用。

Limit

截取前maxSize位的元素，组成一个新的流。

Skip

丢弃前n个元素后，追成一个新的流。

Concat

练习

package com.py.Stream;

import java.util.stream.Stream;

public class DemoStreamMethor {
    public static void main(String[] args) {
        Stream<String> stream = Stream.of("张三", "李四", "王五", "刘六", "田七");
//        filter(stream);
//        count(stream);
//        limit(stream);
//        skip(stream.skip(3));
    }

    private static void skip(Stream<String> skip) {
        skip
                .forEach(name -> {
                    System.out.println(name);
                });
    }

    private static void limit(Stream<String> stream) {
        skip(stream.limit(3));
    }

    private static void count(Stream<String> stream) {
        System.out.println(stream.count());
    }

    private static void filter(Stream<String> stream) {
        stream.filter((String name)->{ return name.startsWith("张");})
                .forEach((name->{System.out.println(name);}));
    }
}

实例

package com.py.Stream;

import java.util.ArrayList;
import java.util.stream.Stream;

public class DemoTest {
    public static void main(String[] args) {
        ArrayList<String> one = new ArrayList<>();
        one.add("迪丽热巴");
        one.add("宋远桥");
        one.add("迪丽热巴");
        one.add("苏星河");
        one.add("石破天");
        one.add("老子");

        Stream<String> oneStream = one.stream().filter(name -> {
            return name.length() == 3;
        }).limit(3);



        ArrayList<String > two = new ArrayList<>();
        two.add("古力娜扎");
        two.add("张无忌");
        two.add("赵丽颖女");
        two.add("张三丰");
        two.add("赵四");
        two.add("汪远");
        two.add("铃木爱理");

        Stream<String> twoStream = two.stream().filter(name -> {
            return name.length() == 4;
        }).skip(1);

        Stream.concat(oneStream,twoStream).map(name->{return new Person(name);}).forEach(p->{
            System.out.println(p);
        });

    }
}

Stream流

标签：使用   imp   filter   lang   数组   main   src   循环   extends   

原文地址：https://www.cnblogs.com/yuknight/p/13780274.html