流（Stream）中保存对集合或数组数据的操作。和集合类似，但集合中保存的是数据。
Stream特点
1.Stream 自己不会存储元素。
2.Stream不会改变源对象。相反，他们会返回一个持有结果的新Stream。
3.Stream操作是延迟执行的。这意味着他们会等到需要结果的时候才执行。
Stream使用步骤
1.创建 ：新建一个Stream
2.中间操作：在一个或多个步骤中，将初始Stream转化到另一个Stream的中间操作。
3.终止操作：使用一个终止操作来产生一个结果。该操作会强制它之前的延迟操作立即执行。在这之后，该Stream就不能使用了。
创建Stream
1.通过Collection对象的stream()或parallelStream（）方法。
2.通过Arrays类的stream（）方法
3.通过Stream接口的of（）、iterate（）、generate（）方法。
4.用过IntStream、Long Stream、DoubleStream接口中的of、range、rangeClosed方法。
package text;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Random;
import java.util.stream.IntStream;
import java.util.stream.Stream;
/**
* Stream的使用
* @author zdf
*/
public class Demo5Stream {
public static void main(String[] args) {
//1.通过Collection对象的stream()或parallelStream（）方法。
ArrayList<String> arrayList = new ArrayList<>();
arrayList.add("huawei");
arrayList.add("xiaomi");
arrayList.add("pingguo");
Stream<String> stream = arrayList.stream();
//遍历
// stream.forEach(s-> System.out.println(s));
stream.forEach(System.out::println);
// 2.Arrays工具类的Stream方法
String[] arr={"aaa","bbb","ccc"};
Stream<String> stream1 = Arrays.stream(arr);
stream1.forEach(System.out::println);
// 3.Stream接口中的of,iterate,generate方法
Stream<Integer> of = Stream.of(10,20,30,40);
of.forEach(System.out::println);
//迭代流
Stream<Integer> iterate = Stream.iterate(0, x -> x + 2);
iterate.limit(10).forEach(System.out::println);
// 生成流
Stream<Integer> generate = Stream.generate(() -> new Random().nextInt(100));
generate.limit(10).forEach(System.out::println);
// 4IntStream,LongStream,DoubleStream 的of,range,rangeClosed
IntStream intStream = IntStream.of(100, 200, 300);
intStream.forEach(System.out::println);
}
}
中间操作、终止操作
中间操作
1.filter、limit、skip、distinct、sorted
2.map
3.parallel q
package text;
import java.util.ArrayList;
import java.util.Comparator;
public class Demo6 {
public static void main(String[] args) {
ArrayList<Employee> list = new ArrayList<>();
list.add(new Employee("小王", (double) 15000));
list.add(new Employee("小李", (double) 20000));
list.add(new Employee("小张", (double) 18000));
list.add(new Employee("小孙", (double) 12000));
list.add(new Employee("小孙", (double) 12000));
// 中间操作1.filter 过滤 2.limit 限制 3. skip 跳过 4.distinct 去重 5. sorted 排序
//filter 过滤
list.stream().filter(e->e.getMoney()>(double)15000).forEach(System.out::println);
//limit 限制
list.stream().limit(2).forEach(System.out::println);
//skip跳过
list.stream().skip(2).forEach(System.out::println);
// distinct 去重复
list.stream().distinct().forEach(System.out::println);
// sorted 排序
list.stream().sorted(Comparator.comparingDouble(Employee::getMoney)).forEach(System.out::println);
// 中间操作2map
list.stream().map(e->e.getName()).forEach(System.out::println);
// 中间操作3 parallel 采用多线程效率
list.parallelStream().forEach(System.out::println);
}
}
终止操作
1.foreach、 min、max、count
2.reduce、collect
package text;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;
public class Demo8 {
public static void main(String[] args) {
ArrayList<Employee> list = new ArrayList<>();
list.add(new Employee("小王", (double) 15000));
list.add(new Employee("小李", (double) 20000));
list.add(new Employee("小张", (double) 18000));
list.add(new Employee("小孙", (double) 12000));
list.add(new Employee("小孙", (double) 12000));
//终止操作 foreach
list.stream().filter(e->e.getMoney()>15000).forEach(System.out::println);
//终止操作 min max count
Optional<Employee> min = list.stream().min(Comparator.comparingDouble(Employee::getMoney));
System.out.println(min.get());
//终止操作reduce 规约
//计算所有员工的工资和
Optional<Double> reduce = list.stream().map(Employee::getMoney).reduce((x, y) -> x + y);
System.out.println(reduce.get());
//终止方法collect收集
//获取所有员工姓名，封装一个list集合
List<String> collect = list.stream().map(Employee::getName).collect(Collectors.toList());
for (String string : collect){
System.out.println(string);
}
}
}
