java8新特性之------- Stream流学习笔记记录

java8新特性之------- Stream流学习笔记记录

Java 8 API添加了一个新的抽象称为流Stream，可以让你以一种声明的方式处理数据。Stream 使用一种类似用 SQL 语句从数据库查询数据的直观方式来提供一种对 Java 集合运算和表达的高阶抽象。

就是将要处理的元素集合看作一种流， 流在管道中传输， 并且可以在管道的节点上进行处理， 比如筛选， 排序，聚合等。元素流在管道中经过中间操作（intermediate operation）的处理，最后由最终操作(terminal operation)得到前面处理的结果

概述

Stream是一个来自特定类型的对象（集合，数组，I/O channel， 产生器generator ……）形成队列并支持聚合操作（类似SQL语句一样的操作， 比如filter, map, reduce, find, match, sorted……），但是Stream不会存储元素

基础特征

• Pipelining: 中间操作都会返回流对象本身。 这样多个操作可以串联成一个管道， 如同流式风格（fluent style）。 这样做可以对操作进行优化， 比如延迟执行(laziness)和短路( short-circuiting)。
• 内部迭代： 以前对集合遍历都是通过Iterator或者For-Each的方式, 显式的在集合外部进行迭代， 这叫做外部迭代。 Stream提供了内部迭代的方式， 通过访问者模式(Visitor)实现。

使用一个流的时候，通常包括三个基本步骤：获取一个数据源（source）→ 数据转换→执行操作获取想要的结果，每次转换原有 Stream 对象不改变，返回一个新的 Stream 对象（可以有多次转换），这就允许对其操作可以像链条一样排列，变成一个管道。

生成流or获取流

方法名	作用说明
stream（）	为集合创建串行流
parallelStream（）	为集合创建并行流

获取流的方式可以如下几种：

1.java.util.Collection中的stream()方法，因此其实现类也均可获取流

2.java.util.Map,因采用的是键-值对的储存方式，所以要区分key-value的情况.

3.使用数组时，只能使用Stream中提供的静态方法of - Stream<String> stream = Stream.of(array);

API中常用的方法

• 延迟方法：返回Stream接口的自身类型的方法，支持链式调用
• 终结方法：不支持StrinBuilder链式调用

forEach

Stream提供了forEach来迭代每个数据,该方法接收一个 Consumer 接口函数，会将每一个流元素交给该函数进行处理

public class StreamForEach {
    public static void main(String[] args) {
        ArrayList<String> strings = new ArrayList<>();
        for(int i=0;i<10;i++){
            strings.add(i+"");
        }
        strings.forEach(System.out::println);
    }
}

map

将一种T类型转换成为R类型，而这种转换的动作，就称为“映射”;

public static void streamMap(String[] arr){
        Stream<String> stringStream = Stream.of(arr);
        Stream<Integer> integerStream = stringStream.map(s -> Integer.parseInt(s));
        integerStream.forEach(System.out::println);
    }

    public static void main(String[] args) {

        String[] str = {"12","123","1234"};
        streamMap(str);
    }

filter

过滤出设置条件的元素

public static void filterMethod(){
    List<String> strList = Arrays.asList("123", "a", "1234");

    Stream<String> stringStream = strList.stream().filter(s -> s.length() > 3);
    stringStream.forEach(System.out::print);
}
public static void main(String[] args) {
    filterMethod();
}

截取前几个limit，与之类似的就是skip，意为跳过前几个。

count计算个数，返回值long

Stream<T> limit(long maxSize);如果maxSize>当前的集合长度，不操作；Demo如下：

public static void countAndLimit(){
    Stream<String> name = Stream.of("Tim","Tom", "Bob", "Alice");
    Stream<String> limit = name.limit(3);
    long t = limit.filter(s -> s.startsWith("T")).count();
    System.out.println(t);
}
public static void main(String[] args) {
    countAndLimit();
}

sorted对流进行排序

 @Test
    public void sortedStream(){
        List<String> strings = Arrays.asList("12", "1231", "1");
        strings.stream().sorted().forEach(System.out::println);
    }

parallel

流并行处理

@Test
public void parallelTest(){
    List<String> strings = Arrays.asList("12", "21", "3432");
    long count = strings.parallelStream().count();
    System.out.println(count);
}

Collectors用于返回列表或字符串

@Test
public void collectors(){
    List<String> strings = Arrays.asList("12", "21", "3432","");
    String collect = strings.stream().filter(s -> !s.isEmpty()).collect(Collectors.joining("<"));
    System.out.println(collect);

}