stream实用方法api

也许上一次在讲lambda的语法的时候,你们已经体会到了Stream语法的好处,今天就让我详细的来讲解一下c语法的具体结构

Java Stream API 入门篇

你可能没意识到Java对函数式编程的重视程度，
看看Java 8加入函数式编程扩充多少功能就清楚了。Java 8之所以费这么大功夫引入函数式编程，原因有二：

1,代码简洁，函数式编程写出的代码简洁且意图明确，使用stream接口让你从此告别for循环。

2,多核友好，Java函数式编程使得编写并行程序从未如此简单，你需要的全部就是调用一下parallel()方法。

如何进行stream操作 只需要用集合对象去点stream就好了

内置方法 分为两种 中间操作 与结束操作.
1.中间操作总是会惰式执行，调用中间操作只会生成一个标记了该操作的新stream，仅此而已。

2.结束操作会触发实际计算，计算发生时会把所有中间操作积攒的操作以pipeline的方式执行，
这样可以减少迭代次数。计算完成之后stream就会失效。

中间操作:

1.filter 中间 Stream Predicate T -> boolean 筛选

2.distinct 中间 去除重复项

3.skip 中间 limit是获取前面元素, skip获取第几名以后的值 获取固定的个数类对象

4.sorted 排序 排序函数有两个，一个是用自然顺序排序，一个是使用自定义比较器排序，
函数原型分别为Stream　sorted()和Stream　sorted(Comparator<? super T> comparator)。
后面接上reversed() 属于倒序
如果是string需要强转可以这样写
sorted((i1,i2)->Integer.parseInt(i1.getValue())-Integer.parseInt(i2.getValue()))
Comparator接口只有一个方法,可以使用lambda语法写
如果是int可以

5.map 函数原型为 Stream map(Function<? super T,? extends R> mapper)，
作用是返回一个对当前所有元素执行执行mapper之后的结果组成的Stream。直观的说，
就是对每个元素按照某种操作进行转换，转换前后Stream中元素的个数不会改变，
但元素的类型取决于转换之后的类型。

6.flatMap 函数原型为 Stream flatMap(Function<? super T,? extends Stream<? extends R>> mapper)，
通俗的讲flatMap()的作用
就相当于把原stream中的所有元素都”摊平”之后组成的Stream，
转换前后元素的个数和类型都可能会改变。
经典应用 将数组string 转换为 普通的字符串
Arrays.stream()的方法可以接受一个数组并且产生一个流
String [] a= {“dfg”,“Sdas”,“ASFasf”};
String [] b= {“dfg”,“Sdas”,“ASFasf”};
String [] p= {“dfg”,“Sdas”,“ASFasf”};
String [] d= {“dfg”,“Sdas”,“ASFasf”};
String [] c= {“dfg”,“Sdas”,“ASFasf”};
List<String[]> asList = Arrays.asList(a,b,p,d,c);
asList.stream().flatMap(Arrays :: stream).forEach(System.out::println);

终端操作
1.collect方法,是一个收集器,一般用 util包里面的Collectors的静态方法比如
collect(Collectors.tolist) 收集list对象
2.anyMatch 只要查找到一个属性存在就返回true
3.allMatch 所有属性匹配 才返回true
4.noneMatch 没有任何元素匹配 返回true
5.findAny 方法将返回当前流中的任意元素。 只要找到就返回,
6.findany 方法,返回第一个找到的元素
因为是并行,所有并没有运行顺序,所以他们返回的值很有可能是不一样的
7.forEach 循环每一个通过中间操作的对象, 函数描述符 Consumer T -> void
8.count 获取通过中间操作的数量
9.Reduce 自定义运算规则 用法
10.Optional reduce = menu.stream().map(Dish :: getCalories)
.reduce(Integer :: sum);
System.out.println(reduce.get());

经典解答,去除实体类集合里面的重复项,比如Transaction里面的name出现重复
     List<Transaction> distinctList = tr2011.stream().collect(
            Collectors.collectingAndThen(Collectors.toCollection(() -> new TreeSet(Comparator.comparing(o -> o.getName()))),
                    ArrayList::new));

作业:
// (1) 找出2011年发生的所有交易，并按交易额排序（从低到高）。
// (2) 交易员都在哪些不同的城市工作过？
// (3) 查找所有来自于剑桥的交易员，并按姓名排序。
// (4) 返回所有交易员的姓名字符串，按字母顺序排序。
// (5) 有没有交易员是在米兰工作的？
// (6) 打印生活在剑桥的交易员的所有交易额。
// (7) 所有交易中，最高的交易额是多少？
// (8) 找到交易额最小的交易。

提供:
private static List<Transaction> tolist() {
	// TODO Auto-generated method stub
	Trader raoul = new Trader("犯贱", "美国");
	Trader mario = new Trader("小明", "洛杉矶");
	Trader alan = new Trader("小白", "北京");
	Trader brian = new Trader("大白兔", "西伯利亚");
	List<Transaction> transactions = Arrays.asList(new Transaction(brian, 2011, 300),
			new Transaction(raoul, 2012, 1000), new Transaction(raoul, 2011, 400),
			new Transaction(mario, 2012, 710), new Transaction(mario, 2012, 700), new Transaction(alan, 2012, 950));
	return transactions;
}

第一个类
public class Transaction {
private final Trader trader;
private final int year;
private final int value;
public Transaction(Trader trader, int year, int value){
this.trader = trader;
this.year = year;
this.value = value;
}
public Trader getTrader(){
return this.trader;
}
public int getYear(){
return this.year;
}
public int getValue(){
return this.value;
}
public String toString(){
return “{” + this.trader + “, " +
“year: “+this.year+”, " +
“value:” + this.value +”}”;
}
}

第二个实体类

    private String name;
private String city;

public Trader(String n, String c) {
	this.name = n;
	this.city = c;
}

public String getName() {
	return this.name;
}

public String getCity() {
	return this.city;
}

public String toString() {
	return "Trader:" + this.name + " in " + this.city;
}