Java8新特性3 Stream

https://blog.csdn.net/y_k_y/article/details/84633001

（1）概念

Stream 是 Java8 中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。使用Stream API 对集合数据进行操作，就类似于使用 SQL 执行的数据库查询。也可以使用 Stream API 来并行执行操作。简而言之，Stream API 提供了一种高效且易于使用的处理数据的方式。

特点：

1 . 不是数据结构，不会保存数据。

2. 不会修改原来的数据源，会产生一个新流。

3. 惰性求值，流在中间处理过程中，只是对操作进行了记录，并不会立即执行，需要等到执行终止操作的时候才会进行实际的计算。

集合关注的是数据，流关注的是计算。

（2）操作

创建Stream：一个数据源（集合、数组），获取一个流。
中间操作：对数据源的数据进行处理。
终止操作：产生结果。

package Stream;

import org.junit.Test;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.stream.Stream;

/**
 * @autour zdc
 * @create 2020-03-20-22:45
 */
public class _1Test {
    private List<Person> people = Arrays.asList(
            new Person("zd2",11,22.3), new Person("zd2",11,22.3),
            new Person("zdi",12,11d),new Person("zdi",12,11d),
            new Person("zdt",113,222.3),
            new Person("zdf",114,22.33),
            new Person("zdf",117,22.3),
            new Person("zddsd",8,22.3),
            new Person("zdcfff",1100,22.3)
    );

    @Test
    public void test1(){
        //1.通过Collection提供的stream()或parrallelStream()方法
        List<String> list = new ArrayList<>();
        Stream<String> stream = list.stream();

        //2.通过Arrays的stream()
        Person[] people = new Person[10];
        Stream<Person> stream1 = Arrays.stream(people);

        //3.通过Stream类中的静态方法of()
        Stream<String> stream2 = Stream.of("aa", "bb", "cc");

        //4.创建无限量
        //迭代
        Stream.iterate(0, x -> x + 2).limit(10).forEach(System.out::println);

        //
        Stream.generate(()->Math.random()).limit(10).forEach(System.out::println);

    }

    /*
    * 中间操作 ：多个中间操作可以连接成一个流水线，而在终止操作一次性执行全部，叫做惰性求值。
    *   filter 过滤流（接收Predicate）
    *   limit 截断流
    *   skip(n) 跳过前几个元素，若流中元素不足n个，返回一个空流
    *   distinct 删除重复元素（比较hashcode equals）
    *
    *   映射:
    *    map- 接收一个函数作为参数(接收function)，该函数会被应用到每个元素，并将其映射成一个新的元素
    *       flapMap- 接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流。
    *       flapMap接收Function，function必须返回一个Stream对象！！！！！
    *
    *   排序:
    *        sorted()    Comparable 某个类实现了Comparable接口，会自然排序
    *       sorted(Comparator comparator)   Comparator 定制排序
    *
    * 终止操作:
    *   
    * */

    @Test
    public void test2(){
        List<Person> list = new ArrayList<Person>();
        //filter是中间操作 forEach是终止操作
        people.stream().filter((x)->x.getAge()<100).skip(1).distinct().forEach(p->list.add(p));
        System.out.println(list);

        //映射
        people.stream().map((person -> {
            person.setName(person.getName()+"希特勒");
            return person;
        })).forEach(System.out::println);


        Stream<Stream<Character>> stream = people.stream().map(person -> {
            //将每一个人的名字中每个字符取出来作为一个List -->  Map<Stream<Character>)>
            List<Character> list1 = new ArrayList<>();
            for (Character character : person.getName().toCharArray()) {
                list1.add(character);
            }
            return list1.stream();
        });

//        stream.forEach(sm->{
//            sm.forEach(System.out::println);
//        });


        //flapMap- 接收一个函数作为参数，该函数必须返回Stream对象，将流中的每个值都换成另一个流，然后把所有流连接成一个流
        Stream<Character> characterStream = people.stream().flatMap(person -> {
            List<Character> list1 = new ArrayList<>();
            for (Character character : person.getName().toCharArray()) {
                list1.add(character);
            }
            return list1.stream();
        });
        characterStream.forEach(System.out::println);

        people.stream().sorted(Comparator.comparing(Person::getAge)).forEach(System.out::println);


    }
}

猜你喜欢