Stream流

Stream

         流式思想
         Stream流是1.8才出现的 
          
       Stream流是一个来自数据源的元素队列  
          元素是特定类型的对象，也就是有泛型，java中的Stream并不会存储元素，
               而是按需计算 
          数据源   流的来源，可以是集合，数组等 
             和collection操作不同，Stream操作还有两个继承的特征、
           Pipelining:中间操作都会返回流对象本身，这样多个操作可以串联成一个管
                      道，这样做可以对操作进行优化，比如延迟执行和短路 
           内部迭代:以前对集合遍历都是通过iterator或者增强for的方式，显示的集合
                   外部进行迭代，叫外部迭代，而Stream流提高了内部迭代的方式，流
                   可以直接调用遍历方法
  
  Stream流是一个管道流，被消费使用一次后，就会关闭流，如果调用的·方法会返
    回一个流的话，那么前一个流的元素会转到下一个流，前一个流不能调用方法了

获取流

     java.util.stream.Stream<T>是1.8加入最常用的流接口 
     获取流的方式 
          所有的Collection集合都可以通过stream默认方法获取流 
                    default Stream<E> stream()
                    所有的Collection单例集合都有的方法，
                    当然对于map集合
                          它的键可以封装成set,也就是keySet，
                          对于value值来说 map提供了values方法返回Collection<E>
                          对于键与值Map.Entry方式返回Set集合    map的三种获取流方式
          Stream接口的静态方法of可以获取数组对应的流
                     static <T> Stream<T> of(T... values) 
                     static <T> Stream<T> of(T t)
                         方法的参数里可以放置数组，返回流对象

常用方法

   延迟方法 ：返回值类型仍然是Stream接口自身类型的方法，因此支持链式样式
            调用（除了终结方法外，其余方法均为延迟方法） 
   终结方法：返回值类型不再是Stream接口自身类型的方法，因此不再支持类似
            Stringbuilder那样的链式调用，终结方法包括count和forEach方法，调用了
            终结方法后不能再调用Stream流中的其他方法                 

   forEach
        此方法和for-each是不一样的，该方法遍历的是流数据
        参数是void forEach(Consumer<? super T> action)一个函数式
        接口，comsumer消费者的意思，消费者接口，
          抽象方法  void accept(T t);
          
          String []sz={"好吧","什么","不可能"};
          Stream<String> s = Stream.of(sz);
          s.forEach(name-> System.out.println(name));
           使用这种方式遍历流中的元素，
           
   filter    
        过滤器  
          Stream<T> filter(Predicate<? super T> predicate);
          该参数也是一个函数式接口，
          抽象方法boolean test(T t); 
          如 
            String sz[]={"晓晓","小小","小何","小刘"};
            Stream<String> s=Stream.of(sz);
            Stream<String> stream = s.filter(name -> name.startsWith("小")); 
            功能为过滤字符串中开头字母不是“小"的元素 
             
    map 
       将流类型转换为另一个流类型，返回一个新的流类型
       <R> Stream<R> map(Function<? super T, ? extends R> mapper); 
       抽象方法 R apply(T t);
       如 
           String sz[]={"3","5","2","8"};
           Stream<String> sz1 = Stream.of(sz);
           Stream<Integer>in=sz1.map(name->Integer.parseInt(name)); 
            
     count 
        Stream的方法
        long count();返回流中元素的个数，返回值long 
         
     limit  
        Stream流中的方法，用于截取流元素，只能取前n个，如果截取长度大于
        流元素的个数，则不操作 ,Stream<T> limit(long maxSize);
        如 
          String name[]={"哈哈","拉拉","嘻嘻","呵呵","嘿嘿"};
          Stream<String> name1 = Stream.of(name);
          Stream<String> limit = name1.limit(4); 
          后面的流里面存了截取的流对象，有四个元素， 
           
      skip    
        丢弃前n个元素   ，和limit刚好相反  
        Stream<T> skip(long n);
        如 
          String name[]={"哈哈","拉拉","嘻嘻","呵呵","嘿嘿"};
          Stream<String> name1 = Stream.of(name);
          Stream<String> skip = name1.skip(4);
          此时前面的流关闭，后面的流存了数组里的最后一个元素，过滤了四个 
           
      concat 
          将两个流合为一个流 
          static <T> Stream<T> concat(Stream<? extends T> a,Stream<? extends T> b) 
          但要注意流的元素类型，也就是泛型 
          如  
           String name[]={"哈哈","拉拉","嘻嘻","呵呵","嘿嘿"};
           String sz[]={"晓晓","小小","小何","小刘"};
           Stream<String> name1 = Stream.of(name);
           Stream<String> sz1 = Stream.of(sz);
           Stream<String>ss=Stream.concat(name1,sz1); 
            关于组合后哪个流的元素排在前面，在于参数中流的前后位置顺序