// 對蘋果按顏色匯總并績數(shù)量
Map<String, Long> appleCount = apples.stream()
 .collect(groupingBy(Apple::getColor, counting()));
// 過濾掉顏色為黑色的蘋果，并匯總好蘋果的總金額
Double sum = apples.stream()
 .filter(i->"black".equals(i.getColor()))
 .collect(toList);

// 普通函數(shù)
public void run(String s){
 System.out.print(s+"哈哈");
}
// 我不要名字啦?。?！
(s)->System.out.print(s+"哈哈")

// 實現(xiàn)Runnable中的run方法，替代匿名內(nèi)部類。
Runnable r = ()->System.out.print("哈哈");
// 作為參數(shù)傳遞。
new Thread(()-> System.out.println("haha")).start();

ArrayList<Apple> list = new ArrayList<>();
list.forEach(i-> System.out.println(i.getWeight()));


// 簡化策略模式
public static List<Apple> filterApples(List<Apple> inventory,ApplePredicate p){
 List<Apple> apples = new ArrayList<>();
 for(Apple apple : inventory){
 if(p.test(apple)){
 apples.add(apple);
 }
 }
 return apples;
}
public class BigApple implement ApplePredicate{
 @Override
 public boolean test(Apple a){
 if(a.getWeight>10){
 return a
 }
 }
}
// 這是個簡單的策略模式，根據(jù)用戶的需要，創(chuàng)建不同的接口ApplePredicate實現(xiàn)類,調(diào)用時傳入不同的實現(xiàn)類就可以，但問題是如果需求過多，創(chuàng)建的實現(xiàn)類也會很多，過于臃腫不方便管理。
xx.filterApple(inventory,new BigApple);
// 使用lambda表達式，不在需要創(chuàng)建BigApple類
xx.filterApple(inventory,i->(i.getWeight>10));

//入?yún),返回void
(s)->System.out.println(s);
//入?yún)⒖眨祷豽oid
()->System.out.print("haha");
//入?yún),返回i+1
i->i+1
//后面寫代碼塊
apple->{if(apple.getWeiht>5) return "BIG";
 else return "small";
 }

List<Double> collect = list.stream()
 // 過濾掉黑色的蘋果
 .filter(i -> "black".equals(i.getColor()))
 // 讓蘋果按照重量個價格排序
 .sorted(Comparator.comparing(Apple::getWeight)
 .thenComparing(i->i.getPrice()))
 // 篩選掉重復(fù)的數(shù)據(jù)
 .distinct()
 // 只要蘋果的價格
 .map(Apple::getPrice)
 // 只留下前兩條數(shù)據(jù)
 .limit(2)
 // 以集合的形式返回
 .collect(toList());
// 循環(huán)打印列表中元素
list.forEach(i->System.out.print(i));

List<String> strings = Arrays.asList("Hello", "World");
List<String> collect1 = strings.stream()
 // String映射成String[]
 .map(i -> i.split(""))
 // Arrays::Stream 數(shù)據(jù)數(shù)組，返回一個流String[]->Stream<String>
 // flatMap各數(shù)組并不分別映射成一個流，而是映射成流的內(nèi)容 Stream<String>->Stream
 .flatMap(Arrays::stream)
 .collect(toList());
System.out.println(collect);
----->輸出 [H, e, l, l, o, W, o, r, l, d]

List<Integer> integers = Arrays.asList(12, 3, 45, 3, 2,-1);
// 有初始值的疊加操作
Integer reduce = integers.stream().reduce(3, (i, j) -> i + j);
Integer reduce2 = integers.stream().reduce(5, (x, y) -> x < y ? x : y);
// 無初始值的疊加操作
Optional<Integer> reduce1 = integers.stream().reduce((i, j) -> i + j);
// 無初始值的最大值
Optional<Integer> reduce4 = integers.stream().reduce(Integer::min);
// 無初始值的最大值
Optional<Integer> reduce5 = integers.stream().reduce(Integer::max);
// 求和
Optional<Integer> reduce6 = integers.stream().reduce(Integer::sum);

// 數(shù)值流求平均值
OptionalDouble average = apples.stream()
 .mapToDouble(Apple::getPrice)
 .average();
// 數(shù)值流求和
OptionalDouble average = apples.stream()
 .mapToDouble(Apple::getPrice)
 .sum();
// 數(shù)值流求最大值，沒有則返回2
double v = apples.stream()
 .mapToDouble(Apple::getPrice)
 .max().orElse(2);
// 生成隨機數(shù)
IntStream s = IntStream.rangeClosed(1,100);

Stream<String> s = Stream.of("java","python");

int[] i = {2,3,4,5};
Stream<int> = Arrays.stream(i);

Stream<String> s = Files.lines(Paths.get("data.txt"),Charset.defaultCharset());

// 迭代
Stream.iterate(0,n->n+2)
 .limit(10)
 .forEach(System.out::println);
// 生成,需要傳遞實現(xiàn)Supplier<T>類型的Lambda提供的新值
Stream.generate(Math.random)
 .limit(5)
 .forEach(System.out::println);