java8 流的使用学习笔记

中间操作和终端操作

操作	类型	返回类型	使用的类型/函数式接口	函数描述符	作用
filter	中间	Stream< T >	Predicate< T>	T->boolean	筛选
distinct	中间	Stream< T >		T->boolean	去重复
skip	中间	Stream< T >	long	T->boolean	跳过N个元素
limit	中间	Stream< T >	long	T->boolean	截取N个元素
map	中间	Stream< R >	Function< T,R >	T->R	映射
flatMap	中间	Stream< R >	Function< T,Stream< R > >	T->Stream< R >	扁平流映射
sorted	中间	Stream< T >	Comparator< T >	(T,T)->int	排序
anyMatch	终端	boolean	Predicate< T>	T->boolean	查找匹配
noneMatch	终端	boolean	Predicate< T>	T->boolean	查找匹配
allMatch	终端	boolean	Predicate< T>	T->boolean	查找匹配
findAny	终端	Optional< T>			查找匹配
findFurst	终端	Optional< T>			查找匹配
forEach	终端	void	Consumer< T>	T->void	循环
collect	终端	R	Collector< T,A,R>		返回list
reduce	终端	boolean	Predicate< T>	(T,T)->T	归纳总结
count	终端	long			返回集合大小

练习题

创建基础数据（实体类在下面）

    Trader trader=new Trader("范冰冰","南昌");
    Trader trader1=new Trader("金晨","南京");
    Trader trader2=new Trader("林志玲","南昌");
    Trader trader3=new Trader("江一燕","深圳");
    List<Transaction> transactions=Arrays.asList(
            new Transaction(trader,2011,300),
            new Transaction(trader1,2012,1000),
            new Transaction(trader2,2011,400),
            new Transaction(trader3,2012,710),
            new Transaction(trader2,2012,700),
            new Transaction(trader1,2012,950)
    );

练习题答案

System.out.println("2011年发生的所有交易，并按交易额排序（从低到高）："
+transactions.stream()
.filter(a>a.getYear()==2011)
.sorted(Comparator.comparing(Transaction::getValue)).collect(Collectors.toList()));

System.out.println("交易员都在那些不同的城市工作过："
+transactions.stream().map(o->o.getTrader().getCity())
.distinct().collect(Collectors.toList()));

System.out.println("所有来自南昌的交易员，并按姓名排序："
.map(o->o.getTrader().getName()).distinct().sorted().collect(Collectors.toList()));


 System.out.println("返回所有交易员的姓名字符串，按首字母顺序排列："
.distinct().sorted().reduce("",(a,b)->a+" "+b));


 System.out.println("有没有交易员是在南京工作的："
.map(Transaction::getTrader).findAny().get().getName());


System.out.println("打印生活在南昌的交易员的所有交易额--------------开始");
    transactions.stream().filter(a->a.getTrader().getCity().equals("南昌"))
    .forEach(a-> System.out.println(a.getTrader().getName()+" "+a.getValue()));     
System.out.println("打印生活在南昌的交易员的所有交易额--------------结束");

System.out.println("所有交易中最高的交易额："
+transactions.stream().map(Transaction::getValue).reduce(Integer::max).get());

 System.out.println("所有交易中最小的交易额："
 +transactions.stream().map(Transaction::getValue).reduce(Integer::min).get());


public class Trader {
private String name;
private String city;

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

public String getName() {
    return name;
}

public void setName(String name) {
    this.name = name;
}

public String getCity() {
    return city;
}

public void setCity(String city) {
    this.city = city;
}

@Override
public String toString() {
    return "交易员："+this.name+" 来自 "+this.city;
}

}

public class Transaction {
private Trader trader;
private int year;
private int value;

public Transaction(Trader trader, int year, int value) {
    this.trader = trader;
    this.year = year;
    this.value = value;
}

public Trader getTrader() {
    return trader;
}

public void setTrader(Trader trader) {
    this.trader = trader;
}

public int getYear() {
    return year;
}

public void setYear(int year) {
    this.year = year;
}

public int getValue() {
    return value;
}

public void setValue(int value) {
    this.value = value;
}

@Override
public String toString() {
    return "{"+this.trader+", "+"时间："+this.year+", "+" 交易额："+this.value+"}";
}

}