java中使用stream给对象设置值 java stream中间操作方法

流表示包含着一系列元素的集合，我们可以对其做不同类型的操作，用来对这些元素执行计算

二.中间流的部分应用
中间操作会再次返回一个流，所以，我们可以链接多个中间操作，注意这里是不用加分号的。

/*
Stream流中间操作方法

- 概念
  中间操作的意思是，执行完此方法之后，Stream流依然可以继续执行其他操作。
- 常见方法
    方法名                                     	说明
    Stream<T> filter(Predicate predicate)   	用于对流中的数据进行过滤
    Stream<T> limit(long maxSize)           	返回此流中的元素组成的流，截取前指定参数个数的数据
    Stream<T> skip(long n)                  	跳过指定参数个数的数据，返回由该流的剩余元素组成的流
    static <T> Stream<T> concat(Stream a, Stream b)	合并a和b两个流为一个流
    Stream<T> distinct()                    	返回由该流的不同元素（根据Object.equals(Object) ）组成的流
    Stream<T> sorted()                      	返回由此流的元素组成的流，根据自然顺序排序
    Stream<T> sorted(Comparator comparator) 	返回由该流的元素组成的流，根据提供的Comparator进行排序
    <R> Stream<R> map(Function mapper)      	返回由给定函数应用于此流的元素的结果组成的流
    IntStream mapToInt(ToIntFunction mapper)	返回一个IntStream其中包含将给定函数应用于此流的元素的结果

 */
public class StreamDemo {
    public static void main( String[] args ) {
        List<String> list = new ArrayList<>();
        list.add("孙悟空");
        list.add("齐天大圣");
        list.add("孙悟能");
        list.add("孙源");
        list.add("王孙");
        System.out.println("-----------Stream<T> filter(Predicate predicate)----------------");
       /*
       Stream<T> filter(Predicate predicate)   	用于对流中的数据进行过滤
       Predicate接口:表示一个参数的谓词（布尔值函数）。
       startsWith : String类中的方法;包含的意思
        */
         list.stream().filter(s -> s.startsWith("孙")).forEach(System.out::println);//结果: 孙悟空 孙悟 孙源

        System.out.println("-------------- Stream<T> limit(long maxSize) ------------------");
        /*
        Stream<T> limit(long maxSize)           	返回此流中的元素组成的流，截取前指定参数个数的数据
         */
          list.stream().limit(3).forEach(s -> System.out.println(s));//截取制定 的参数: 孙悟空 齐天大圣 孙悟能

        System.out.println("---------------static <T> Stream<T> concat(Stream a, Stream b)-----------------");
        // Stream<T> skip(long n)                  	跳过指定参数个数的数据，返回由该流的剩余元素组成的流
        // list.stream().skip(2).forEach(System.out::println);//取2以后的所有参数 结果:孙悟能 孙源 王孙
        //static <T> Stream<T> concat(Stream a, Stream b)	合并a和b两个流为一个流
        Stream<String> limit = list.stream().limit(3);
        Stream<String> skip = list.stream().skip(3);
        Stream.concat(limit, skip).forEach(System.out::print); //孙悟空 齐天大圣 孙悟能 孙源 王孙

        //Stream<T> distinct()                    	返回由该流的不同元素（根据Object.equals(Object) ）组成的流
        Stream.concat(list.stream().limit(3), list.stream().skip(2)).distinct().forEach(System.out::println);//去掉了孙悟能这个名字:  孙悟空 齐天大圣  孙悟能 孙源  王孙

        System.out.println("-------Stream<T> sorted()   -----------");
       //Stream<T> sorted()                      	返回由此流的元素组成的流，根据自然顺序排序
        list.stream().sorted().forEach(System.out::println);

        System.out.println("-------------Stream<T> sorted(Comparator comparator)--------------------");
        //Stream<T> sorted(Comparator comparator) 	返回由该流的元素组成的流，根据提供的Comparator进行排序
        list.stream().sorted((s1,s2)->s1.length()-s2.length()).forEach(System.out::println);//根据长度自定义排序

        System.out.println("---------Stream<R> map(Function mapper) -------------");
        //<R> Stream<R> map(Function mapper)      	返回由给定函数应用于此流的元素的结果组成的流
        list.stream().map(s -> s).forEach(System.out::println);//将String转换为String
        System.out.println("-----------IntStream mapToInt(ToIntFunction mapper)------------------");
        //IntStream mapToInt(ToIntFunction mapper)	返回一个IntStream其中包含将给定函数应用于此流的元素的结果
        //跟map性质是一样的, 另有一个Integer求和功能sum
        List<Integer> list1 = new ArrayList<>();
        list1.add(100);
        list1.add(111);
        list1.add(211);
        list1.add(311);
        int sum = list1.stream().mapToInt(s -> s).sum();//求数组的和
        System.out.println("数组和: "+sum);
        
        System.out.println("-------------------求平均值----------------------");
        list1.stream().mapToInt(s -> s)//将s转换为s
                .average()//求平均值
                .ifPresent(System.out::println);//值不为空输出

System.out.println("-----------------------Optional<T> findFirst\u200B() 返回Optional描述此流的第一个元素，或空Optional如果流是空的。----------------------------");
        //Optional<T> findFirst() 返回Optional描述此流的第一个元素，或空Optional如果流是空的。
       list1.stream().findFirst().ifPresent(System.out::println);
    }

}

结果:

孙悟空
孙悟能
孙源
-------------- Stream<T> limit(long maxSize) ------------------
孙悟空
齐天大圣
孙悟能
---------------static <T> Stream<T> concat(Stream a, Stream b)-----------------
孙悟空齐天大圣孙悟能孙源王孙孙悟空
齐天大圣
孙悟能
孙源
王孙
-------Stream<T> sorted()   -----------
孙悟空
孙悟能
孙源
王孙
齐天大圣
-------------Stream<T> sorted(Comparator comparator)--------------------
孙源
王孙
孙悟空
孙悟能
齐天大圣
---------Stream<R> map(Function mapper) -------------
孙悟空
齐天大圣
孙悟能
孙源
王孙

-----------IntStream mapToInt(ToIntFunction mapper)------------------
数组和: 733

-------------------求平均值----------------------
183.25

-----------------------Optional<T> findFirst() 返回Optional描述此流的第一个元素，或空Optional如果流是空的。----------------------------
100

Stream流终结操作方法
终端操作是对流操作的一个结束动作，一般返回 void 或者一个非流的结果。

import java.util.ArrayList;
import java.util.List;

/*
Stream流终结操作方法【应用】

- 概念
  终结操作的意思是，执行完此方法之后，Stream流将不能再执行其他操作。
- 常见方法
    方法名                          	说明
    void forEach(Consumer action)	对此流的每个元素执行操作
    long count()                 	返回此流中的元素数

 */
public class StreamDemo1 {
    public static void main( String[] args ) {
        List<String> arr = new ArrayList<>();
        arr.add("大圣");
        arr.add("齐天大圣");
        arr.add("大圣2");
        arr.add("大圣3");
        System.out.println("---------------void forEach(Consumer action)\t对此流的每个元素执行操作---------------");
        arr.stream().forEach(System.out::println);

        System.out.println("--------------------long count()  \t返回此流中的元素数-----------------------");
        long count = arr.stream().filter(s -> s.startsWith("大")).count();
        System.out.println(count);//返回第一个字包含大的有几个名字
    }

}