二、流处理
1、流的概念
流：从支持数据操作的源，生产而来的元素序列。
这里源可以是集合，输入/数据流等，有序序列生成的元素序列仍保持之前的顺序。
流操作分为中间操作和终端操作，可以顺序执行也可以并行执行。
流操作特点：流水线、内部迭代（相比之前为外部迭代或显式迭代）。
图片.png
注意：终端操作只能进行一次，如不能forEach后再次forEach
public static List<String> getLowCaloricDishesNamesInJava8(List<Dish> dishes){
return dishes.stream()
.filter(d -> d.getCalories() < 400)
.sorted(comparing(Dish::getCalories))
.map(Dish::getName)
.collect(toList());
}
流的性能问题：http://www.importnew.com/17262.html
2、 常用流操作
(1)筛选切片
Streams接口支持filter方法，该接收接收一个谓词(返回boolean的函数)作为参数，返回一个符合谓词的元素的流。如：
// Filtering unique elements
List<Integer> numbers = Arrays.asList(1, 2, 1, 3, 3, 2, 4);
numbers.stream()
.filter(i -> i % 2 == 0)
.distinct()//对元素做去重
.forEach(System.out::println);
// Truncating a stream
List<Dish> dishesLimit3 =
menu.stream()
.filter(d -> d.getCalories() > 300)
.limit(3)//返回流的前3个
.collect(toList());
dishesLimit3.forEach(System.out::println);
// Skipping elements
List<Dish> dishesSkip2 =
menu.stream()
.filter(d -> d.getCalories() > 300)
.skip(2)//返回流的后2个
.collect(toList());
dishesSkip2.forEach(System.out::println);
(2)映射:map与flatmap
StreamAPI的map方法、flatMap对流中每个元素应用函数，不同之处在于flatMap将流中每个元素转化一个流，然后把所有流连成一个流(扁平化)。
// map
List<String> dishNames = menu.stream()
.map(Dish::getName)
.collect(toList());
System.out.println(dishNames);
// map
List<String> words = Arrays.asList("Hello", "World");
List<Integer> wordLengths = words.stream()
.map(String::length)
.collect(toList());//通过collect将流Stream转成集合
System.out.println(wordLengths);
// flatMap
words.stream()
.flatMap((String line) -> Arrays.stream(line.split("")))
.distinct()
.forEach(System.out::println);
// flatMap
List<Integer> numbers1 = Arrays.asList(1,2,3,4,5);
List<Integer> numbers2 = Arrays.asList(6,7,8);
List<int[]> pairs =
numbers1.stream()
.flatMap((Integer i) -> numbers2.stream()
.map((Integer j) -> new int[]{i, j})
)
.filter(pair -> (pair[0] + pair[1]) % 3 == 0)
.collect(toList());
pairs.forEach(pair -> System.out.println("(" + pair[0] + ", " + pair[1] + ")"));
//输出(1,8)、(2,7)、(3,6)
Paste_Image.png
Paste_Image.png
(3)查找和匹配
StreamAPI提供方法：
allMatch:检查谓词是否匹配所有元素
anyMatch:检查谓词是否至少匹配一个元素
noneMatch:相对于allMatch，检查流中没有任何元素和谓词匹配
findAny：返回流中任意元素
findFirst：查找流中第一个元素
public static void main(String...args){
if(isVegetarianFriendlyMenu()){
System.out.println("Vegetarian friendly");
}
System.out.println(isHealthyMenu());
System.out.println(isHealthyMenu2());
Optional<Dish> dish = findVegetarianDish();
dish.ifPresent(d -> System.out.println(d.getName()));
}
private static boolean isVegetarianFriendlyMenu(){
return menu.stream().anyMatch(Dish::isVegetarian);
}
private static boolean isHealthyMenu(){
return menu.stream().allMatch(d -> d.getCalories() < 1000);
}
private static boolean isHealthyMenu2(){
return menu.stream().noneMatch(d -> d.getCalories() >= 1000);
}
//findAny返回一个Optional容器实例，找不到元素避免使用null
//isPresent :Optional有值返回true
//ifPresent：有值时执行其中代码块
private static Optional<Dish> findVegetarianDish(){
return menu.stream().filter(Dish::isVegetarian).findAny();
}
（4）规约
reduce操作将流中所有元素反复结合。
public static void main(String...args){
List<Integer> numbers = Arrays.asList(3,4,5,1,2);
int sum = numbers.stream().reduce(0, (a, b) -> a + b);//求和
System.out.println(sum);
int sum2 = numbers.stream().reduce(0, Integer::sum);
System.out.println(sum2);
int max = numbers.stream().reduce(0, (a, b) -> Integer.max(a, b));
System.out.println(max);
Optional<Integer> min = numbers.stream().reduce(Integer::min);
min.ifPresent(System.out::println);
//没有初始值，流为空则没有返回，因此返回使用Optional
int calories = menu.stream()
.map(Dish::getCalories)
.reduce(0, Integer::sum);
System.out.println("Number of calories:" + calories);
}
Paste_Image.png
(5)数值流：
java8引入三个原始类型特化流IntStream、DoubleStream、LongSteam，分别将流中元素特化为int、long、double。
boxed()方法则对原始类型进行装箱。
数值流自带sum、max、min、average等方法。
int calories = menu.stream()
.mapToInt(Dish::getCalories)
.sum();
System.out.println("Number of calories:" + calories);
// max and OptionalInt
OptionalInt maxCalories = menu.stream()
.mapToInt(Dish::getCalories)
.max();
int max = maxCalories.orElse(1);//没有最大值，设置默认值1
// numeric ranges
IntStream evenNumbers = IntStream.rangeClosed(1, 100)
.filter(n -> n % 2 == 0);
//rangeClosed包含结束值，而range不包含结束值
System.out.println(evenNumbers.count());
//返回(1,100)符合勾股定理的三元组
Stream<int[]> pythagoreanTriples =
IntStream.rangeClosed(1, 100).boxed()
.flatMap(a -> IntStream.rangeClosed(a, 100)
.mapToObj(b -> new int[]{a, b, (int) Math.sqrt(a * a + b * b)})
.filter(t -> t[2] % 1 == 0)
);
pythagoreanTriples.forEach(t -> System.out.println(t[0] + ", " + t[1] + ", " + t[2]));
(6)构建流
流可以由值、数组、文件创建
// Stream.of
Stream<String> stream = Stream.of("Java 8", "Lambdas", "In", "Action");
stream.map(String::toUpperCase).forEach(System.out::println);
// Stream.empty
Stream<String> emptyStream = Stream.empty();
// Arrays.stream
int[] numbers = {2, 3, 5, 7, 11, 13};
System.out.println(Arrays.stream(numbers).sum());
//文件流回自动关闭
long uniqueWords = Files.lines(Paths.get("lambdasinaction/chap5/data.txt"), Charset.defaultCharset())
.flatMap(line -> Arrays.stream(line.split(" ")))//生成单词流
.distinct()
.count();//
System.out.println("There are " + uniqueWords + " unique words in data.txt");
可以由于Stream.iterate和Stream.generate函数生成无限流(没有固定大小)
// Stream.iterate
Stream.iterate(0, n -> n + 2)
.limit(10)
.forEach(System.out::println);
// fibonnaci with iterate
Stream.iterate(new int[]{0, 1}, t -> new int[]{t[1],t[0] + t[1]})
.limit(10)
.forEach(t -> System.out.println("(" + t[0] + ", " + t[1] + ")"));
Stream.iterate(new int[]{0, 1}, t -> new int[]{t[1],t[0] + t[1]})
.limit(10)
. map(t -> t[0])
.forEach(System.out::println);
// random stream of doubles with Stream.generate
Stream.generate(Math::random)
.limit(10)
.forEach(System.out::println);
// stream of 1s with Stream.generate
IntStream.generate(() -> 1)
.limit(5)
.forEach(System.out::println);
IntStream.generate(new IntSupplier(){
public int getAsInt(){
return 2;
}
}).limit(5)
.forEach(System.out::println);
