stream 流的并发

jdk 8 以后增加stream 接口；

stream 流的各个方法使用如下：

package Test01;import java.util.ArrayList;
import java.util.function.Predicate;
import java.util.logging.Filter;/*** @auther SyntacticSugar* @data 2018/9/3 0003下午 12:43**static interface  Stream.Builder<T> 一个可变的构建器，用于 Stream 。****① 筛选出张    长度  大于2* ②  stream 流** * Collection中 的  default Stream<E> stream()*/
public class Test09 {public static void main(String[] args) {ArrayList<String> list = new ArrayList<>();list.add("网大嘴");list.add("张无忌");list.add("周芷若");list.add("赵敏");list.add("张强");list.add("张三丰");//使用函数式接口for (String s : list) {if (printStr(s,(string)->string.startsWith("张"),(string)->string.length()>2)) {System.out.println(s);}}System.out.println("-------------------------------");
//使用stream  流来完成list.stream().filter(name->name.startsWith("张")).filter(name->name.length()==3).forEach(System.out::println);  //filter  链式调用}public static boolean printStr(String str, Predicate<String> one,Predicate<String> two){boolean test = one.and(two).test(str);
//        System.out.println("满足条件？"+test);return test;}}

通过collection获取对象，

通过map 获取流：

package Test01;import java.util.*;
import java.util.stream.Stream;/*** @auther SyntacticSugar* @data 2018/9/3 0003下午 1:20* <p>* <p>* static <T> Stream<T> of(T... values) 返回其元素是指定值的顺序排序流。* <p>* ①根据collection   来获取流* ②根据map来获取流*/
public class Test10 {public static void main(String[] args) {
//collection     list    setCollection<String> string1 = new ArrayList<>();Stream<String> s1 = string1.stream();sop(s1);List<String> string2 = new ArrayList<>();Stream<String> s2 = string2.stream();sop(s2);Set<String> string3 = new HashSet<>();Stream<String> s3 = string3.stream();sop(s3);//        java.util.stream.ReferencePipeline$Head@4b6995df
//        java.util.stream.ReferencePipeline$Head@2fc14f68
//        java.util.stream.ReferencePipeline$Head@61443d8f}public static void sop(Object obj) {System.out.println(obj);}
}

package Test01;import java.util.HashMap;
import java.util.Map;
import java.util.stream.Stream;import static Test01.Test10.sop;/*** @auther SyntacticSugar* @data 2018/9/3 0003下午 7:22** 通过map集合  获取stream流* 流需要分key、value或entry等情况：*/
public class Test11 {public static void main(String[] args) {//HashMap<String, Integer> map = new HashMap<>();Stream<Map.Entry<String, Integer>> stream1 = map.entrySet().stream();Stream<Integer> stream2 = map.values().stream();Stream<String> stream3 = map.keySet().stream();//sop(stream1);sop(stream2);sop(stream3);}
}

通过数组来获取流：

package Test01;import java.util.stream.Stream;/*** @auther SyntacticSugar* @data 2018/9/3 0003下午 7:34** String[] array = { "张无忌", "张翠山", "张三丰", "张一元" };*静态的   获取stream流对象* static <T> Stream<T> of(T t) 返回包含单个元素的序列 Stream 。* static <T> Stream<T> of(T... values) 返回其元素是指定值的顺序排序流。**/
public class Test12 {public static void main(String[] args) {//String[] array = { "张无忌", "张翠山", "张三丰", "张一元" };Stream<String> array1 = Stream.of(array);array1.forEach(System.out::println);//张无忌//张翠山//张三丰//张一元}
}

filter 选择器，筛选

package Test01;import java.util.stream.Stream;/*** @auther SyntacticSugar* @data 2018/9/3 0003下午 7:41**  把filter转化为子集流      Stream<T> filter(Predicate<? super T> predicate);*"张无忌", "张学友", "刘德华", "张三丰"** 选出来不是      姓张的*/
public class Test13 {public static void main(String[] args) {//Stream<String> stream = Stream.of("张无忌", "张学友", "刘德华", "张三丰");stream.filter((s)->!s.startsWith("张")).forEach(System.out::println);//
//        G:\tools\java_jdk\jdk-9.0.1\bin\java.exe "-javaagent:
//       刘德华}
}

limit 和skip这两个参数，long count 的终结

package Test01;import java.util.stream.Stream;/*** @auther SyntacticSugar* @data 2018/9/3 0003下午 7:49* <p>* <p>* long count() 返回此流中的元素数。* limit   和  skip      这两个参数*/
public class Test14 {public static void main(String[] args) {//Stream<String> stream = Stream.of("张无忌", "张学友", "刘德华", "张三丰");
//        long count = stream.count();
//        System.out.println(count);//4System.out.println("-----------------------");//前三个     姓张的stream.limit(3).filter((s) -> s.startsWith("张")).forEach(System.out::println);System.out.println("-----------------------");//跳过2 个    筛选姓张的stream.skip(2).filter((s) -> s.startsWith("张")).forEach(System.out::println);//stream 只开启一次   就关闭了}
}

concat的拼接，拼接流对象

package Test01;import java.util.stream.Stream;/*** @auther SyntacticSugar* @data 2018/9/3 0003下午 7:56** function   接口的 apply 方法      字符串强转   数字*  R apply(T t);** concat    拼接使用**/
public class Test15 {public static void main(String[] args) {//Stream<String> stringStream = Stream.of("3", "4", "5", "6", "7");//of 长度固定
//        Stream<Integer> integerStream = stringStream.map((s) -> Integer.parseInt(s));
//        integerStream.forEach(System.out::println);// 优化如下：stringStream.map(Integer::parseInt).forEach(System.out::println);System.out.println("-----------------");//Stream<String> s1 = Stream.of("熊大", "熊二");Stream<String> s2 = Stream.of("熊大", "熊二");Stream<String> concat = Stream.concat(s1, s2);//拼接concat.forEach(System.out::println);//遍历//}
}

package Test01;import java.util.ArrayList;
import java.util.stream.Stream;/*** @auther SyntacticSugar* @data 2018/9/3 0003下午 8:11** 1. 第一个队伍只要名字为3个字的成员姓名；   //filter* 2. 第一个队伍筛选之后只要前3个人；    //limit* 3. 第二个队伍只要姓张的成员姓名；    //filter* 4. 第二个队伍筛选之后不要前2个人；   //sip* 5. 将两个队伍合并为一个队伍；           //concat* 6. 根据姓名创建Person对象；* 7. 打印整个队伍的Person对象信息。*/
public class Test16 {public static void main(String[] args) {//ArrayList<String> list1 = new ArrayList<>();list1.add("迪丽热巴");list1.add("宋远桥");list1.add("苏星河");list1.add("老子");list1.add("庄子");list1.add("孙子");list1.add("洪七公");Stream<String> stringStream = list1.stream().filter(name -> name.length() == 3);
//        stringStream.forEach(System.out::println);stringStream.limit(3).forEach(System.out::println);System.out.println("-------------");ArrayList<String> list2 = new ArrayList<>();list2.add("古力娜扎");list2.add("张无忌");list2.add("张三丰");list2.add("赵丽颖");list2.add("张二狗");list2.add("张天爱");list2.add("张三");Stream<String> stringStream1 = list2.stream().filter(name -> name.startsWith("张"));stringStream1.skip(2).forEach(System.out::println);//筛选之后再次筛选System.out.println("-------------");Stream<String> concat = Stream.concat(stringStream, stringStream1);//调用person 的构造concat.map(Person::new).forEach(System.out::println);}
}
class Person{private String name;private int age;public Person(String name, int age) {this.name = name;this.age = age;}public Person() {}public Person(String name) {this.name = name;}@Overridepublic String toString() {return "Person{" +"name='" + name + '\'' +", age=" + age +'}';}
}

parallel 的方法

package Test01;import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.stream.Stream;/*** @auther SyntacticSugar* @data 2018/9/3 0003下午 8:39* stream 流的并发* <p>* <p>* Interface BaseStream<T,S extends BaseStream<T,S>>* <p>* 参数类型* T - 流元素的类型* S - 实现 BaseStream的流的类型     有一个parallel  方法** xxxxxxxxxxx* default Stream<E> parallelStream() 返回可能并行的 Stream与此集合作为其来源。*/
public class Test17 {public static void main(String[] args) {//数组的并发String[] str = {"张无忌", "张学友", "刘德华", "张三丰"};Stream<String> stream = Stream.of(str);Stream<String> parallel = stream.parallel();//返回一个  回平行的等效流。parallel.forEach(System.out::println);//  输出时无序 ，说明并发执行
//        parallel.forEach((s)-> System.out.println(s));System.out.println("-------------------------");//Collection<? super String> list=new ArrayList<String>();Collections.addAll(list,"张无忌", "张学友", "刘德华", "张三丰");
//        System.out.println(list);list.parallelStream().forEach(System.out::println);//通过集合直接获取 并发流}
}

数组获取stream 流

package Test01;import java.util.Arrays;
import java.util.stream.Stream;/*** @auther SyntacticSugar* @data 2018/9/3 0003下午 9:19**<A> A[] toArray(IntFunction<A[]> generator)   在stream 接口中* 指定泛型    不局限于 object  类型**/
public class Test20 {public static void main(String[] args) {//Stream<String> stringStream = Stream.of("1", "2", "3", "4");//收集到 integer 数组
//        Object[] objects = stringStream.toArray();String[] array = stringStream.toArray(String[]::new);//装到数组中for (String s : array) {System.out.println(Integer.parseInt(s)+1); //增加1}}
}

collectors 的方法，toList toMap toSet

package Test01;import java.util.Collections;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.Stream;/*** @auther SyntacticSugar* @data 2018/9/3 0003下午 8:55* 收集流的使用    会关闭stream* <p>* Interface Collector<T,A,R>* <p>* 参数类型* T - 还原操作的输入元素的类型* A - 缩减操作的可变累积类型（通常作为实现细节隐藏）* R - 缩小操作的结果类型* <p>* ------------ collectors   中的方法    toList()  toMap()  toSet()* Object[] toArray() 返回一个包含此流的元素的数组。*/
public class Test18 {public static void main(String[] args) {//Stream<String> stringStream = Stream.of("熊大", "熊二", "光头强");List<String> list = stringStream.collect(Collectors.toList());//收集到list集合
//        Set<String> set = stringStream.collect(Collectors.toSet());//收集到 set集合
//        String[] strings = stringStream.toArray(String[]::new);//收集到数组中
//        Object[] array = stringStream.toArray();//收集到无参数组中//
//        list.forEach(System.out::println);//收集流方法调用以后  stream就被关闭了
//        set.forEach(System.out::println);//收集流方法调用以后  stream就被关闭了//收集流方法调用以后  stream就被关闭了for (String s : list) {System.out.println(s);}System.out.println("-----------------------");
//        for (String s : set) {
//            System.out.println(s);
//        }}
}

stream 流的并发相关推荐

CUDA 7 Stream流简化并发性
CUDA 7 Stream流简化并发性异构计算是指高效地使用系统中的所有处理器,包括 CPU 和 GPU .为此,应用程序必须在多个处理器上并发执行函数. CUDA 应用程序通过在 streams ...
CUDA Stream流并发性
目录 1.CUDA 中的异步命令 2.默认流 3.Multistream多流示例异构计算是指高效地使用系统中的所有处理器,包括 CPU 和 GPU .为此,应用程序必须在多个处理器上并发执行函数. ...
CUDA 7流简化并发
CUDA 7流简化并发异构计算是指有效使用系统中的所有处理器,包括CPU和GPU.为此,应用程序必须在多个处理器上同时执行功能.CUDA应用程序通过在流(按顺序执行的命令序列)中,执行异步命令来管理 ...
Cuda Stream流分析
Cuda Stream流分析 Stream 一般来说,cuda c并行性表现在下面两个层面上: • Kernel level • Grid level Stream和event简介 Cuda stre ...
Java8 Stream流递归，几行代码搞定遍历树形结构
欢迎关注方志朋的博客,回复"666"获面试宝典可能平常会遇到一些需求,比如构建菜单,构建树形结构,数据库一般就使用父id来表示,为了降低数据库的查询压力,我们可以使用Java8中 ...
【Java10】lambda表达式（函数式编程），Stream流，File类，字节/字符流，乱码，缓冲/转换/序列化/打印流，Properties
文章目录 1.lambda表达式标准语法:()->{} 2.lambda表达式简略语法:可推导即可省略 3.lambda表达式原理:lambda效率比匿名内部类高 4.两个函数式接口:Consu ...
List增删元素后size大小发生变化带来的影响、Stream流操作、Lambda表达式
目录 List增删元素后size大小发生变化带来的影响 List的几种遍历方式报异常原因增强for循环原理异常原理建议删除操作性能对比 Stream流操作 Lambda表达式语法 Lamb ...
【Stream】java8新特性Stream流总结
一.什么是stream 在 java8 中增加了一个新的抽象接口 Stream API,使用 Stream 操作集合类似于使用 SQL 语句数据库查找数据类似,提供直观的方法进行操作. Stream ...
Stream流和Optional
Lambda表达式和函数式接口 https://blog.csdn.net/qq_45888932/article/details/122451124 目录一.什么是Stream流注意事项二.快 ...

stream 流的并发

stream 流的并发相关推荐

最新文章

热门文章