JDK8-stream

Stream流式思想：

#获取流(Stream)对象的方法：

(1) Collection集合(List,Set)
	 

 //Collection集合list,set
    	   List<String> list = new ArrayList<>();
    	    Stream<String> stream1 = list.stream();
      
		  		      //set
		        Set<String> set = new HashSet<>();
		        Stream<String> stream2 = set.stream();

(2) Stream中的静态方法 of(T t)参数T 可以是数组
 
//static <T> Stream<T> of(T t) Stream中的of()方法返回Stream对象
        //T可以是数组
        Integer[] arr = new Integer[]{1, 2, 3, 12, 32};
        Stream<Integer> stream5 = Stream.of(arr);

#Stream中的方法
void forEach(Consumer<? super T> action) 返回类型不再是 Stream类型 不能再继续调用Stream中的方法

  String[] arr = new String[]{"echo", "Alice", "Jile"};
        Stream<String> stream = Stream.of(arr);
        //foreach(Consume)方法 Consume是函数式接口 参数可以传 lambada表达式
        // void forEach(Consumer<? super T> action) 返回类型不再是Stream类型 不能再继续调用Stream中的方法
        stream.forEach(name -> System.out.println(name));

Stream map(Function<? super T,? extends R> mapper) 实现类型的转换 将T类型转化为R类型

String[] arr = new String[]{"1", "2", "4", "8", "0"};
        Stream<String> stream1 = Stream.of(arr);
        //<R> Stream<R> map(Function<? super T,? extends R> mapper) 实现类型的转换 将T类型转化为R类型
        Stream<Integer> stream2 = stream1.map((String str) -> {
            return Integer.parseInt(str);
        });
        stream2.forEach(i -> System.out.println(i));

Stream filter(Predicate<? super T> predicate) 返回Stream类型

String[] arr = new String[]{"张三", "张三丰", "周芷若", "赵敏"};
        Stream<String> stream = Stream.of(arr);
        //Stream<T> filter(Predicate<? super T> predicate) 返回Stream类型
        Stream<String> stream1 = stream.filter(name -> name.startsWith("张"));
        stream1.forEach(name -> System.out.println(name));

        //Stream流的特点 只能使用一次，使用后就关闭了
        ////java.lang.IllegalStateException: stream has already been operated upon or closed
        stream.forEach(name -> System.out.println(name));

Stream limit(long maxSize) 返回由此流的元素组成的流，截短长度不能超过 maxSize 。

  Stream<String> stream1 = Stream.of("echo", "ALICE", "Juile");
        //Stream<T> limit(long maxSize) 返回由此流的元素组成的流，截短长度不能超过 maxSize 。
        Stream<String> stream2 = stream1.limit(2);
//        long sum = stream2.count();
//        System.out.println(sum);
        stream2.forEach(name -> System.out.println(name));

Stream skip(long n) 在丢弃流的第一个 n元素后，返回由该流的 n元素组成的流。

 Stream<String> stream1 = Stream.of("echo", "ALICE", "Juile", "jike");
        //Stream<T> skip(long n) 在丢弃流的第一个 n元素后，返回由该流的 n元素组成的流。
        Stream<String> stream2 = stream1.skip(2);
        stream2.forEach(name -> System.out.println(name));

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

  List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(0);
        Stream<Integer> stream1 = list.stream();
        // long count() 返回此流中的元素数。
        long sum = stream1.count();
        System.out.println(sum);

static Stream concat(Stream<? extends T> a, Stream<? extends T> b)(将两个流合成一个流)

在这里插入代码片String[] arr = new String[]{"echo", "Alice", "Jile"};
        Stream<String> stream = Stream.of(arr);
        String[] arr1 = new String[]{"张三", "张三丰", "周芷若", "赵敏"};
        Stream<String> stream1 = Stream.of(arr1);
        //static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b)
        //静态方法 返回Stream对象
        Stream stream2 = Stream.concat(stream, stream1);
        stream2.forEach(name -> System.out.println(name));