1 流式思想
-
流式思想类似于工厂车间的“生产流水线”。当需要对元素进行操作（特别是多步操作）的时候，考虑到性能及便利性，我们应该首先拼好一个“模型”步骤 方案，然后再按照方案去执行它。
2 Stream 概念
Stream 是JDK1.8 中处理集合的关键抽象概念，Lambda 和 Stream 是JDK1.8新增的函数式编程最有亮点的特性了，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。
使用Stream API 对集合数据进行操作，就类似于使用SQL执行的数据库查询。Stream 使用一种类似用 SQL 语句从数据库查询数据的直观方式来提供一种对 Java 集合运算和表达的高阶抽象。Stream API可以极大提高Java程序员的生产力，让程序员写出高效率、干净、简洁的代码。
Stream处理元素可以看成是一种流式处理。元素流在管道中经过中间操作（intermediate operation）的处理，最后由最终操作(terminal operation)得到前面处理的结果。
3 Stream创建
# Stream创建
- 可以通过Collection系列集合提供的stream()或者paralleStream()来创建
- 通过Arrays中的静态方法stream()获取数组流
- 通过Stream中的静态方法of()
- 创建无限流 iterate(),generate()
- 可以通过Coolection系列集合提供的stream()或者paralleStream()来创建
List<String> list = new ArrayList<>();
Collections.addAll(list, "a", "b", "c");
Stream<String> stream1 = list.stream();
Stream<String> stream2 = list.parallelStream();- 通过Arrays中的静态方法stream()获取数组流
Integer[] array = {1, 2, 3, 4, 5,};
Stream stream = Arrays.stream(array);- 通过Stream中的静态方法of()
Stream<Integer> stream = Stream.of(1, 2, 3, 4);
- 创建无限流，流中的元素无限多个，所以要配合limit使用。 generate(), iterate()
- 当创建流的时候，数组类型是基本数据类型的时候，需要用到boxed()，把流中的数据变成引用数据类型（装箱）
double[] array = {1, 2, 3, 4, 5};
DoubleStream stream = Arrays.stream(array);
Stream<Double> boxed = stream.boxed();4 Stream流的中间操作
# Stream流的中间操作，所谓中间操作的意思是，stream经过中间操作以后，变成的还是stream。
- filter---从stream流中过滤某些元素
- limit--- 截断流，使其元素不超过指定数量
- skip--- 跳过元素
- distinct---筛选，去除重复元素
- sort--- 流中的数据排序
- map--- 映射
filter
filter需要的参数是Predicate，也就是判断。predicate方法test的参数就是Stream流中的数据类型。
ArrayList<Person> list = new ArrayList<>();
Collections.addAll(list,
new Person(1, "镜", 20),
new Person(2, "雾摇", 18),
new Person(3, "狗多", 22),
new Person(3, "包子", 12));
Stream<Person> stream = list.stream();
Stream<Person> stream1 = stream.filter(new Predicate<Person>() {
@Override
public boolean test(Person person) {
return person.getAge()>=20;
}
});
Stream<Person> stream2 = stream.filter(person -> person.getAge() >= 20);
stream2.forEach(System.out::println);注意：以上代码想要执行，需要注释掉stream1的代码，因为stream1已经修改过了stream
limit
limit是从流中的数据获取前几个，0表示没有，1表示获取第一个，不能是负数，否则抛出异常，经常和无限流配合使用。
ArrayList<Person> list = new ArrayList<>();
Collections.addAll(list,
new Person(1, "镜", 20),
new Person(2, "雾摇", 18),
new Person(3, "狗多", 22),
new Person(3, "包子", 12));
Stream<Person> stream = list.stream();
stream.limit(2).forEach(System.out::println);
Stream.generate(()->new Random().nextInt(100)).limit(10).forEach(System.out::println);skip
跳过元素，参数long类型，表示跳过的个数
ArrayList<Person> list = new ArrayList<>();
Collections.addAll(list,
new Person(1, "镜", 20),
new Person(2, "雾摇", 18),
new Person(3, "狗多", 22),
new Person(3, "包子", 12));
Stream<Person> stream = list.stream();
stream.skip(2).forEach(System.out::println);distinct
去除流中重复数据，如果数据是引用数据类型，需要重写equals和hashCode
ArrayList<Person> list = new ArrayList<>();
Collections.addAll(list,
new Person(1, "镜", 20),
new Person(2, "雾摇", 18),
new Person(2, "雾摇", 18),
new Person(3, "狗多", 22),
new Person(3, "包子", 22),
new Person(3, "突狗", 12));
Stream<Person> stream = list.stream();
stream.distinct().forEach(System.out::println);sort
指定流中数据的排序规则，参数是Comparator
ArrayList<Person> list = new ArrayList<>();
Collections.addAll(list,
new Person(1, "雾摇", 18),
new Person(2, "狗多", 15),
new Person(3, "镜", 22),
new Person(4, "包子", 24),
new Person(5, "突狗", 7),
new Person(6, "雪糕", 83));
Stream<Person> stream = list.stream();
Stream<Person> stream1 = stream.sorted((o1, o2) -> o1.getAge() - o2.getAge());
stream1.forEach(System.out::println);map
映射，将流中集合的数据类型转化成另一种数据类型，map的参数是Function
ArrayList<Person> list = new ArrayList<>();
Collections.addAll(list,
new Person(1, "雾摇", 18),
new Person(2, "狗多", 15),
new Person(3, "镜", 22),
new Person(4, "包子", 24),
new Person(5, "突狗", 7),
new Person(6, "雪糕", 83));
Stream<Person> stream = list.stream();
Stream<String> stream1 = stream.map(p -> p.getName());
stream1.forEach(System.out::println);5 Stream流的终端操作
查找与匹配
-
allMatch--检查是否匹配所有元素
-
anyMatch--检查是否至少匹配一个元素
-
noneMatch--检查是否没有匹配所有元素
-
findFirst--返回第一个元素
-
findAny--返回当前流中的任意元素
-
count--返回流中元素的总个数
-
max--返回流中最大值
-
min--返回流中最小值
int[] array = {1, 3, 5, 7, 8, 10, 12, 15};
Stream<Integer> stream = Arrays.stream(array).boxed();
System.out.println(stream.allMatch(num -> num % 2 == 0));
System.out.println(stream.anyMatch(num -> num % 2 == 0));
System.out.println(stream.noneMatch(num -> num % 2 == 0));
Optional<Integer> optional1 = stream.filter(num -> num > 5).findFirst();
System.out.println(optional1.get());
Optional<Integer> optional2 = stream.filter(num -> num > 5).findAny();
System.out.println(optional2.get());
long count = stream.count();
System.out.println(count);
Optional<Integer> max = stream.max((o1, o2) -> o1 - o2);
System.out.println(max.get());
Optional<Integer> min = stream.min((o1, o2) -> o1 - o2);
System.out.println(min.get());归约(reduce)
元素累加，一般用作加法计算
int[] array = {1, 3, 5, 7, 8, 10, 12, 15};
Stream<Integer> stream = Arrays.stream(array).boxed();
Optional<Integer> reduce = stream.reduce((x1, x2) -> x1 + x2);
Integer sum = reduce.get();
System.out.println(sum);ArrayList<Person> list = new ArrayList<>();
Collections.addAll(list,
new Person(1, "雾摇", 18),
new Person(2, "狗多", 15),
new Person(3, "镜", 22),
new Person(4, "包子", 24),
new Person(5, "突狗", 7),
new Person(6, "雪糕", 83));
Stream<Person> stream = list.stream();
Optional<Person> reduce1 = stream.reduce(new BinaryOperator<Person>() {
@Override
public Person apply(Person person1, Person person2) {
person1.setAge(person1.getAge() + person2.getAge());
return person1;
}
});
Optional<Person> reduce2 = stream.reduce((p1, p2) -> {
p1.setAge(p1.getAge() + p2.getAge());
return p1;
});
收集(collect)
就是把一个流收集起来，最终可以是收集成一个值也可以收集成一个新的集合。
-
返回list集合
ArrayList<Person> list = new ArrayList<>();
Collections.addAll(list,
new Person(1, "雾摇", 18),
new Person(2, "狗多", 15),
new Person(3, "镜", 22),
new Person(4, "包子", 24),
new Person(5, "突狗", 7),
new Person(6, "雪糕", 83));
Stream<Person> stream = list.stream();
List<String> personList1 = stream.map(Person::getName).collect(Collectors.toList());
ArrayList<String> personList2 = stream.map(Person::getName).collect(Collectors.toCollection(ArrayList::new));- 返回set集合
Set<String> personSet1 = stream.map(Person::getName).collect(Collectors.toSet());
HashSet<String> personSet2 = stream.map(Person::getName).collect(Collectors.toCollection(HashSet::new));- 返回map集合
Map<String, Integer> collect = stream.collect(Collectors.toMap(Person::getName, Person::getAge));
System.out.println(collect);分组 groupingBy
ArrayList<Person> list = new ArrayList<>();
Collections.addAll(list,
new Person(1, "雾摇", 18),
new Person(2, "狗多", 15),
new Person(3, "镜", 22),
new Person(4, "包子", 24),
new Person(5, "突狗", 7),
new Person(6, "雪糕", 83));
Stream<Person> stream = list.stream();
Map<Integer, List<Person>> collect = stream.collect(Collectors.groupingBy(Person::getAge));
System.out.println(collect);6 Optional
是jdk8中的一个新特性
Optional 是个容器：它可以保存类型T的值，或者仅仅保存null。如果值存在则isPresent()方法会返回true，调用get()方法会返回该对象。
常用方法：
-
isPresent() ，返回容器中是否有值，有值 true
-
optional.get() 从容器中获取值，如果没有值，会抛出异常
-
ifPresent(消费一个数据) 如果容器中有数据，我们该怎么处理这个数据
-
orElse(值) 是前两个方法的组合，如果容器中有数据，就返回容器中的数据，没有的话，使用括号中的值
int[] array = {1, 3, 5, 7, 8, 10, 12, 15}; Stream<Integer> stream = Arrays.stream(array).boxed(); Optional<Integer> optional = stream.filter(num -> num > 100).findAny(); if(optional.isPresent()){ System.out.println(optional.get()); } optional.ifPresent(System.out::print); Integer integer = optional.orElse(-1);
836
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
