javaStream流的学习笔记

体验Stream流

创建集合，再通过对集合的筛选，得到我们想要的内容，下面是stream流的实现代码

import java.util.ArrayList;
public class ConsumerDemo {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("aa");
        list.add("ba");
        list.add("ab");
        list.add("abc");
        //stream流 filter提限制条件 startsWith过滤开头字符 length过滤长度 //foreach输出过滤后的集合
        list.stream().filter(s -> s.startsWith("a")).filter(s -> s.length()==2).forEach(System.out::println);
    }
}

运行结果：

在体验中我们能感受到stream流的方便，原本复杂的代码通过stream可以非常简便的实现该功能。

Stream流常见生成方式

代码实现：

import java.util.*;
import java.util.stream.Stream;
public class StreamDemo {
    public static void main(String[] args) {
        //stream流的常见生成方式
        //1.Collection体系的集合可以使用默认方法
        List<String> arrayList = new ArrayList<>();//List
        Stream<String> stream1 = arrayList.stream();
        Set<String> hashSet = new HashSet<String>();//Set
        Stream<String> stream2 = hashSet.stream();
        //2.Map体系的集合间接的生成
        Map<String, Integer> hashMap = new HashMap<>();
        Stream<String> stream3 = hashMap.keySet().stream();//String
        Stream<Integer> stream4 = hashMap.values().stream();//Intger
        Stream<Map.Entry<String, Integer>> stream5 = hashMap.entrySet().stream();
        //3.数组可以通过Stream接口的静态方法of生成流
        String[] ss = {"hello","world","java"};
        Stream<String> ss1 = Stream.of(ss);
        Stream<String> ss2 = Stream.of("hello", "world", "java");
        Stream<Integer> ss3 = Stream.of(10, 10, 10);
    }
}

Stream流的常见中间操作方法

下面是中间操作方法常见方法

1.filter​(Predicate<? super T> predicate) 返回由与此给定谓词匹配的此流的   元素组成的流。（filter中你可以规定条件，将其进行过滤） 

2.limit​(long maxSize) 返回由此流的元素组成的流，截断长度不超过 maxSize 。

（截取前指定参数个数的数据）

3.skip​(long n) 在丢弃流的第一个 n元素后，返回由此流的其余元素组成的流。

4.concat​(Stream<? extends T> a, Stream<? extends T> b) 创建一个延迟连接的流，其元素是第一个流的所有元素，后跟第二个流的所有元素。（合并a和b两个流为一个流）

5.distinct()返回由此流的不同元素（根据 Object.equals(Object) ）组成的流。（去掉重复的元素）

6.sorted() 返回由此流的元素组成的流，按照自然顺序排序。

sorted​(Comparator<? super T> comparator) 返回由此流的元素组成的流，根据提供的 Comparator进行排序。

7.map​(Function<? super T,​? extends R> mapper) 返回一个流，该流包含将给定函数应用于此流的元素的结果。

mapToInt​(ToIntFunction<? super T> mapper) 返回 IntStream其中包含将给定函数应用于此流的元素的结果。

 8.forEach​(Consumer<? super T> action) 对此流的每个元素执行操作。

count()返回此流中元素的数量。

下面是各方法的代码实现

1.filter​(Predicate<? super T>predicate)

public static void main(String[] args) {
    ArrayList<String> list = new ArrayList<>();
    list.add("张三");
    list.add("张五");
    list.add("王小三");
    list.add("李小二");
    list.add("赵小四");
    list.add("赵三");
    //filter
    //取“张”的姓，输出
    list.stream().filter(s -> s.startsWith("张")).forEach(System.out::println);
    System.out.println("............");
    //名字长度为3的输出
    list.stream().filter(s -> s.length()==3).forEach(System.out::println);
    System.out.println("............");
}

运行结果：

2.limit​(long maxSize)与skip​(long n)

public static void main(String[] args) {
    ArrayList<String> list = new ArrayList<>();
    list.add("张三");
    list.add("张五");
    list.add("王小三");
    list.add("李小二");
    list.add("赵小四");
    list.add("赵三");
    //limit 取前三个元素输出
    list.stream().limit(3).forEach(System.out::println);
    System.out.println("............");
    //skip 跳过前两个元素输出后面的
    list.stream().skip(2).forEach(System.out::println);
    System.out.println("............");
}

运行结果：

3.concat​(Stream<? extends T>a,Stream<?extends T>b)

和distinct()

public static void main(String[] args) {
    ArrayList<String> list = new ArrayList<>();
    list.add("张三");
    list.add("张五");
    list.add("王小三");
    list.add("李小二");
    list.add("赵小四");
    list.add("赵三");
    //concat 将limit和skip合并为一个流，输出
    Stream<String> limit = list.stream().limit(3);
    Stream<String> skip = list.stream().skip(2);
    Stream.concat(limit,skip).forEach(System.out::println);
    System.out.println("............ ");
    //distinct 将limit和skip合并为一个流，最后输出
    Stream.concat(limit,skip).distinct().distinct().forEach(System.out::println);
    System.out.println("............");
}

运行结果：

我们可以发现，运行第二个是会报错，我们需要注意使用forEach语句使得该流结束了，不能被distinct调用。因此，我们可以把第一次注释掉。

将其注释

//        Stream.concat(limit,skip).forEach(System.out::println);

运行结果得到第二个结果：

4.sorted()

和sorted​(Comparator<? super T>comparator)

public static void main(String[] args) {
    ArrayList<String> list = new ArrayList<String>();
    list.add("fasfafasf");
    list.add("dgsgsdg");
    list.add("fasdfsaf");
    list.add("vcxxgdfg");
    list.add("ewttgfrefg");
    list.add("afasj");
    //sorted
    //按照字母顺序把数据在控制台输出
    list.stream().sorted().forEach(System.out::println);
    System.out.println("...........");
    //按照字符串长度把数据在控制台输出
    list.stream().sorted((s1,s2)->s1.length()-s2.length()).forEach(System.out::println);

}

运行结果：

5.map​(Function<? super T,​? extends R>mapper)

和mapToInt​(ToIntFunction<? super T>mapper)

public static void main(String[] args) {
    ArrayList<String> list = new ArrayList<>();
    list.add("10");
    list.add("20");
    list.add("30");
    list.add("40");
    list.add("50");
    //需求，将集合中的字符串数据转换为整数后在控制台输出
    list.stream().map(s->Integer.parseInt(s)).forEach(System.out::println);
    System.out.println(".........");
    list.stream().map(Integer::parseInt).forEach(System.out::println);
    System.out.println(".........");
    list.stream().mapToInt(Integer::parseInt).forEach(System.out::println);
    //返回一个总和
    System.out.println(".........");
    System.out.println(list.stream().mapToInt(Integer::parseInt).sum());
}

运行结果：

6.forEach​(Consumer<? super T>action)

和count()

public static void main(String[] args) {
    ArrayList<String> list = new ArrayList<>();
    list.add("张三");
    list.add("张五");
    list.add("王小三");
    list.add("李小二");
    list.add("赵小四");
    list.add("赵三");
    //统计集合中有几个姓张的元素，并输出在控制台
    long cot = list.stream().filter(s->s.startsWith("张")).count();
    System.out.println(cot);
}

运行结果：