本示例根据Java8实战(Java 8 In Action)书中第五章末尾的练习题进行解读并扩展
/**
- 类名称：Trader 交易员
- 类描述：
- 创建时间：2018年04月26日
- @author gongdian
- @version 1.0.0
*/public class Trader{
private final String name;
private final String city;
private final Integer age;
public Trader(String n, String c,Integer a){
this.name = n;
this.city = c;
this.age = a;
}
public String getName(){
return this.name;
}
public String getCity(){
return this.city;
}
public Integer getAge() {
return age;
}
public String toString(){
return "Trader:"+this.name + " in " + this.city;
}
}
/**
- 类名称：Transaction 交易
- 类描述：
- 创建时间：2018年04月26日
- @author gongdian
- @version 1.0.0
*/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 +"}";
}
}
/**
- 类名称：TraderMain
- 类描述：
- 创建时间：2018年04月26日
- @author gongdian
- @version 1.0.0
- /* * (1) 找出2011年发生的所有交易，并按交易额排序（从低到高）。
- (2) 交易员都在哪些不同的城市工作过？
- (3) 查找所有来自于剑桥的交易员，并按姓名排序。
- (4) 返回所有交易员的姓名字符串，按字母顺序排序。
- (5) 有没有交易员是在米兰工作的？
- (6) 打印生活在剑桥的交易员的所有交易额。
- (7) 所有交易中，最高的交易额是多少？
- (8) 找到交易额最小的交易。
*/public class TraderMain {
public static void main(String... args) {
Trader raoul = new Trader("Raoul", "Cambridge",35);
Trader mario = new Trader("Mario","Milan",36);
Trader alan = new Trader("Alan","Cambridge",28);
Trader brian = new Trader("Brian","Cambridge",36);
Trader gongdear = new Trader("Gongdear","Milan",28);
List
new Transaction(brian, 2011, 300),
new Transaction(raoul, 2012, 1000),
new Transaction(raoul, 2011, 1400),
new Transaction(mario, 2012, 710),
new Transaction(mario, 2012, 700),
new Transaction(alan, 2012, 950),
new Transaction(gongdear,2011,5800)
);
//(1) 找出2011年发生的所有交易，并按交易额排序（从低到高）。
List
.filter(transaction -> transaction.getYear()==2011)
.sorted(Comparator.comparing(Transaction::getValue))
.collect(toList());
System.out.println("(1) 找出2011年发生的所有交易，并按交易额排序（从低到高）。");
System.out.println(transactions2011);
//(2) 交易员都在哪些不同的城市工作过？
List
.distinct().collect(toList());
System.out.println("(2) 交易员都在哪些不同的城市工作过？");
System.out.println(transactionscity);
//(3) 查找所有来自于剑桥的交易员，并按姓名排序。
List
.distinct()
.filter(trader -> "Cambridge".equals(trader.getCity()))
.sorted(Comparator.comparing(Trader::getName)).collect(toList());
System.out.println("(3) 查找所有来自于剑桥的交易员，并按姓名排序。");
System.out.println(traderList);
//(4) 返回所有交易员的姓名字符串，按字母顺序排序。
String tradernameList = transactions.stream().map(transaction -> transaction.getTrader().getName())
.distinct()
//.sorted(String::compareTo)
.sorted()
.reduce("",(name1,name2)->name1+""+name2);
System.out.println("(4) 返回所有交易员的姓名字符串，按字母顺序排序。");
System.out.println(tradernameList);
//(5) 有没有交易员是在米兰工作的？
//方法1
// Boolean hasmilan=transactions.stream().map(transaction -> transaction.getTrader().getCity())
// .anyMatch((city)->city.equals("Milan"));
//方法2
Boolean hasmilan = transactions.stream()
.anyMatch(transaction -> transaction.getTrader()
.getCity()
.equals("Milan"));
System.out.println("(5) 有没有交易员是在米兰工作的？");
System.out.println(hasmilan);
//(6) 打印生活在剑桥的交易员的所有交易额。
//方法1 （装箱成本）
// Integer sum=transactions.stream().filter(transaction -> transaction.getTrader().getCity().equals("Cambridge"))
// .map(Transaction::getValue)
// .reduce(0,Integer::sum);
//方法2 (直接转为特化流-优化装箱成本)
Integer sum=transactions.stream().filter(transaction -> transaction.getTrader().getCity().equals("Cambridge"))
.mapToInt(Transaction::getValue)
.sum();
System.out.println("(6) 打印生活在剑桥的交易员的所有交易额。");
System.out.println(sum);
//(7) 所有交易中，最高的交易额是多少？
//方法1
//Optional max=transactions.stream().map(Transaction::getValue).max(Integer::compareTo); //方法2--
Optional
System.out.println("(7) 所有交易中，最高的交易额是多少？");
System.out.println(max);
//(8) 找到交易额最小的交易。
//方法1
Optional
.min(Comparator.comparing(Transaction::getValue));
//方法2--
// Optional mintransaction=transactions.stream()
// .reduce((transaction, transaction2) -> transaction.getValue()
System.out.println("(8) 找到交易额最小的交易。");
System.out.println(mintransaction);
// 求所有交易金额的平均值
OptionalDouble avge=transactions.stream().map(transaction -> transaction.getValue())
.mapToInt(Integer::intValue)
.average();
System.out.println("求所有交易金额的平均值");
System.out.println(avge);
// 求所有交易员的个数
//方法1
// Optional counttranc=transactions.stream().map(transaction -> transaction.getTrader().getName())
// .distinct()
// .map(s -> 1)
// .reduce((integer, integer2) -> integer+integer2);
//方法2
Long counttranc=transactions.stream().map(transaction -> transaction.getTrader().getName())
.distinct()
.count();
System.out.println("求所有交易员的个数");
System.out.println(counttranc);
//求所有交易员的平均年龄
OptionalDouble average = transactions.stream().map(transaction -> transaction.getTrader().getAge())
.mapToInt(Integer::intValue).average();
System.out.println("求所有交易员的平均年龄");
System.out.println(average);
//求年龄相同的交易员
Map<Integer, List
.map(transaction -> transaction.getTrader())
.distinct()
.collect(groupingBy(Trader::getAge));
System.out.println("求年龄相同的交易员");
System.out.println(agetrader);
//求生活在米兰的交易员的平均年龄
OptionalDouble milanaverage=transactions.stream()
.map(transaction -> transaction.getTrader())
.filter(trader -> trader.getCity().equals("Milan"))
.distinct()
.mapToInt(trader -> trader.getAge())
.average();
System.out.println("求生活在米兰的交易员的平均年龄");
System.out.println(milanaverage);
//求交易金额大于1000的交易员的平均年龄
OptionalDouble trader1000average=transactions.stream()
.filter(transaction -> transaction.getValue() > 1000)
.mapToInt(transaction -> transaction.getTrader().getAge())
.average();
System.out.println("求交易金额大于1000的交易员的平均年龄");
System.out.println(trader1000average);
//求年龄小于30的交易员的平均交易金额
OptionalDouble age30trans=transactions.stream()
.filter(transaction -> transaction.getTrader().getAge()<30)
.mapToInt(transaction->transaction.getValue())
.average();
System.out.println("求年龄小于30的交易员的平均交易金额");
System.out.println(age30trans);
}
}