stream 流的并发

版权声明：本站所提供的文章资讯、软件资源、素材源码等内容均为本作者提供、网友推荐、互联网整理而来（部分报媒/平媒内容转载自网络合作媒体），仅供学习参考，如有侵犯您的版权，请联系我，本作者将在三个工作日内改正。 https://blog.csdn.net/weixin_42323802/article/details/82347331

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 获取流：

扫描二维码关注公众号，回复： 3183993 查看本文章

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    set
        Collection<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);//4
        System.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;
    }

    @Override
    public 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);
//        }

    }
}