何为流?

JDK8给我们提供了一新概念---Stream流 流遵守了“做什么而非做什么的原则”,在流的示例中,我们描述了需要做什么:获取长单词,并对他们计数**。
流表面上看起来和集合很相似,都可以让我们转换获取数据。但是,他们之间存在显著的差异:

1、流并不存储其元素。
2、流的操作不会修改数据源,例如,filter方法不会改变原来的元素,而是会生成一个新的Stream流
3、流的操作是尽可能惰性执行,这意味着直至需要结果时,操作才会执行

操作流时的典型流程:
1、创建一个流
2、指定将初始流转化成其他流的中间操作,可能包含多个步骤
3、终止操作,从而产生结果。从此以后,这个流就不能再使用了

下面对Stream流常用API总结

1、filter(过滤,接收predicate函数接口,产生包含满足predicate的所有元素,内置consumer<T t>消费型接口)
基本格式Stream<T> filter​(Predicate<? super T> predicate)

/**
 *测试Stream<T> filter​(Predicate<? super T> predicate)过滤 
 *在集合中找出姓张的人
 * @author 16003
 *
 */
public class Stream_filter {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        List<String> list2 = new ArrayList<>();    
        Collections.addAll(list, "张三丰","张无忌","姜子牙","张飞","奥特曼");
        //方法一,用Lamda表达式的函数式接口
        list2 = fun(list, str->{
            return str.startsWith("张");
            });
        System.out.println(list2);
        
        //方法二,用Stream流的filter方法过滤    
        Stream<String> stream3 = list.stream().filter(str->{return str.startsWith("张");});
        stream3.forEach(str->System.out.println(str));
        
    }
    
    //方法一,用lamda表达式的函数式接口
    public static List<String> fun(List<String> list,Predicate<String>cate){
        List<String> list1 = new ArrayList<>();
        for(String str:list) {
            if(cate.test(str)==true) {
                list1.add(str);
            }
        }
        return list1;
    }
}

2、limit(截断,截断前N个元素并返回一个新Stream流)
基本格式Stream<T> limit​(long maxSize)

/**
 * 测试Stream中limit方法 取前几个元素
 * @author 16003
 *
 */
public class Stream_limit {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        Collections.addAll(list, "红鲤鱼","绿鲤鱼","黄鲤鱼","驴");
        Stream<String> stream = list.stream().limit(3);
        stream.forEach(str->System.out.println(str));
    }
}

3、map(映射,对元素进行映射,返回映射后的新Stream流,内置Function<T ,R>接口)
基本格式<R> Stream<R> map​(Function<? super T,​? extends R> mapper)

/**
 * 测试Stream中的map<Function<T t> mapper>方法
 * @author 16003
 *
 */
public class Stream_map {
    public static void main(String[] args) {
        //将字符串转换成Integer
        Stream<String> stream = Stream.of("1","2","3","4");
        Stream<Integer> stream1 = stream.map((String str)->{
            return Integer.parseInt(str);
        });
        
        stream1.forEach(str->System.out.println(str.getClass().getSimpleName()));
        
        
    }
}

4、skip(跳过,跳过前N个元素,并返回一个新的Stream流)
基本格式Stream<T> skip​(long n)

/**
 * 测试Stream中skip方法 跳过前几个元素
 * @author 16003
 *
 */
public class Stream_skip {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        Collections.addAll(list, 1,2,3,4,5,6,7,8,9);
        //跳过前三个元素
        Stream<Integer> stream = list.stream().skip(3);
        stream.forEach(str->System.out.println(str));
    }
}

5、count(返回此流中元素的数量)
基本格式long count()

/**
 * 测试Stream中count方法 返回流中元素个数
 * @author 16003
 *
 */
public class Stream_count {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        Collections.addAll(list, 1,2,3,4,5,6,7,8,9,0);
        Stream<Integer> stream = list.stream();
        long cnt = stream.count();
        System.out.println(cnt);
    }
}

6、forEach(对此流的每个元素执行操作 )
基本格式void forEach​(Consumer<? super T> action)

/**
 * Stream中Foreach方法 遍历
 * @author 16003
 *
 */
public class Stream_foreach {
    public static void main(String[] args) {
        Stream<String> stream = Stream.of("张三","李四","王五");
        stream.forEach(name -> System.out.println(name));
    }
}

其他API查看帮助文档:JDK8中文在线帮助文档

最后修改:2020 年 11 月 17 日 05 : 26 PM
如果觉得我的文章对你有用,请随意赞赏