JAVA-基础（Stream流）

说起stream流大家的第一反应是io，但是实际上谁规定流一定是存在io包里呢？在java8中得益于Lambda表达式的函数式编程，引入了一个全新的概念，stream。

1.优势？

在java8之前我们遍历集合大概就是增强for循环，如果我们想在这个集合里增加一些添加来搜索集合的一些东西，我们会发现代码会变得非常杂乱无章，但是我们现在用stream就会很优雅的解决这个问题。

代码：

1. 首先筛选所有姓茂的人；

2. 然后筛选名字有三个字的人；

3. 最后进行对结果进行打印输出。

package cn.fan;
​
import java.util.ArrayList;
import java.util.List;
​
public class Stream1 {
    public static void main(String[] args) {
        //第一条件：筛选姓茂的
        //第二条件：筛选名字三个字的
        //再进行打印
        List<String> list = new ArrayList<>();
        list.add("茂小喵");
        list.add("罗三炮");
        list.add("阿龟哥");
        list.add("范小饭");
        List<String> maoList = new ArrayList<>();
        for (String name : list) {
            if (name.startsWith("茂")) {
                maoList.add(name);
            }
        }
​
        List<String> shortList = new ArrayList<>();
        for (String name : maoList) {
            if (name.length() == 3) {
                shortList.add(name);
            }
        }
​
        for (String name : shortList) {
            System.out.println(name);
        }
​
    }
}

那么现在有一种更加优雅的做法：

package cn.fan;
​
import java.util.ArrayList;
import java.util.List;
​
public class Stream2 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("茂小喵");
        list.add("罗三炮");
        list.add("阿龟哥");
        list.add("范小饭");
​
        list.stream()
                .filter(s->s.startsWith("茂"))
                .filter(s->s.length()==3)
                .forEach(System.out::println);
    }
}

2.获取stream的两种方法？

default Stream<E> stream()

static <T> Stream<T> of(T... values)

package com.itheima.demo02.Stream;
​
import java.util.*;
import java.util.stream.Stream;
​
/*
    java.util.stream.Stream<T>是Java 8新加入的最常用的流接口。（这并不是一个函数式接口。）
    获取一个流非常简单，有以下几种常用的方式：
        - 所有的Collection集合都可以通过stream默认方法获取流；
            default Stream<E> stream()
        - Stream接口的静态方法of可以获取数组对应的流。
            static <T> Stream<T> of(T... values)
            参数是一个可变参数,那么我们就可以传递一个数组
 */
public class Demo01GetStream {
    public static void main(String[] args) {
        //把集合转换为Stream流
        List<String> list = new ArrayList<>();
        Stream<String> stream1 = list.stream();  Set<String> set = new HashSet<>();
    Stream<String> stream2 = set.stream();
​
    Map<String,String> map = new HashMap<>();
    //获取键,存储到一个Set集合中
    Set<String> keySet = map.keySet();
    Stream<String> stream3 = keySet.stream();
​
    //获取值,存储到一个Collection集合中
    Collection<String> values = map.values();
    Stream<String> stream4 = values.stream();
​
    //获取键值对(键与值的映射关系 entrySet)
    Set<Map.Entry<String, String>> entries = map.entrySet();
    Stream<Map.Entry<String, String>> stream5 = entries.stream();
​
    //把数组转换为Stream流
    Stream<Integer> stream6 = Stream.of(1, 2, 3, 4, 5);
    //可变参数可以传递数组
    Integer[] arr = {1,2,3,4,5};
    Stream<Integer> stream7 = Stream.of(arr);
    String[] arr2 = {"a","bb","ccc"};
    Stream<String> stream8 = Stream.of(arr2);
}
}

3.stream流只能使用一次？为什么？

首先我们要知道，stream流属于管道流，只能被消费一次，当第一个stream流调用完毕方法，数据就会流向下一个stream流，所以第一个stream流就没数据了，关闭了。

4.映射，将一个stream流的数据转换为另一种stream流？

如果我们需要将流中的元素映射到一个流中，我们可以使用map方法

代码：

package cn.fan;
​
import java.util.stream.Stream;
​
/*
    Stream流中的常用方法_map:用于类型转换
    如果需要将流中的元素映射到另一个流中，可以使用map方法.
    <R> Stream<R> map(Function<? super T, ? extends R> mapper);
    该接口需要一个Function函数式接口参数，可以将当前流中的T类型数据转换为另一种R类型的流。
    Function中的抽象方法:
        R apply(T t);
 */
public class Stream_map {
    public static void main(String[] args) {
        //获取一个String类型的Stream流
        Stream<String> stream = Stream.of("1", "2", "3", "4");
        //使用map方法,把字符串类型的整数,转换(映射)为Integer类型的整数
        Stream<Integer> stream2 = stream.map((String s)->{
            return Integer.parseInt(s);
        });
        //遍历Stream2流
        stream2.forEach(i-> System.out.println(i));
    }
}

5.终结方法，将一个stream流的数据count？

package cn.fan;
​
import java.util.stream.Stream;
​
​
public class StreamCount {
    public static void main(String[] args) {
        Stream<String> original = Stream.of("张无忌", "张三丰", "周芷若");
        Stream<String> result = original.filter(s -> s.startsWith("张"));
        System.out.println(result.count()); // 2
    }
​
}

6.取用前几个：limit？

参数是一个long型，如果集合当前长度大于参数则进行截取；否则不进行操作。基本使用：

package cn.fan;
import java.util.stream.Stream;
​
public class StreamLimit {
    public static void main(String[] args) {
        Stream<String> original = Stream.of("张无忌", "张三丰", "周芷若");
        Stream<String> result = original.limit(2);
        System.out.println(result.count()); // 2
    }
}

7.跳过前几个：skip？

如果希望跳过前几个元素，可以使用 skip 方法获取一个截取之后的新流：

Stream skip(long n);

如果流的当前长度大于n，则跳过前n个；否则将会得到一个长度为0的空流。

package cn.fan;
​
import java.util.stream.Stream;
​
public class StreamSkip {
    public static void main(String[] args) {
        Stream<String> original = Stream.of("张无忌", "张三丰", "周芷若");
        Stream<String> result = original.skip(2);
        System.out.println(result.count()); // 1
    }
​
}

8.组合：concat？

如果有两个流，希望合并成为一个流，那么可以使用 Stream 接口的静态方法 concat ：

static Stream concat(Stream a, Stream b)

备注：这是一个静态方法，与 java.lang.String 当中的 concat 方法是不同的。

package cn.fan;
​
import java.util.stream.Stream;
​
public class StreamConcat {
    public static void main(String[] args) {
        Stream<String> streamA = Stream.of("张无忌");
        Stream<String> streamB = Stream.of("张翠山");
        Stream<String> result = Stream.concat(streamA, streamB);
    }
}