jdk8中流的使用（二）

三.查找和匹配
处理思路：看数据集中的某些元素是否匹配一个给定的元素
Stream API通过allMatch、anyMatch、noneMatch、findFirst和findAny方法提供了这样的工具。
1.检查谓词是否至少匹配一个元素
anyMatch():流中是否有一个元素能匹配给定的谓词
需求：看菜单里面是否有素食可供选择
if(menu.stream.anyMatch(Dish::isVegetarian)){
} 
anyMatch()返回一个boolean
2.检查谓词是否匹配所有元素
需求：看看菜品是否有利健康（即所有的量都于1000里）
boolean isHealthy = menu.stream().allMatch(d -> d.getCalories() < 1000); 
noneMatch():流中没有任何元素与给定的谓词匹配
boolean isHealthy = menu.stream().noneMatch(d -> d.getCalories() >= 1000); 
3.查找元素
findAny():返回当前流中的任意元素
需求：从菜品中找到一道素食菜肴
Optional<Dish> dish = menu.stream().filter(Dish::isVegetarian).findAny(); 
4.查找第一个元素
findFirst()
需求：给定一个数字列表，找出第一个平方能被3整除的数
List<Integer> someNumbers = Arrays.asList(1, 2, 3, 4, 5); 
Optional<Integer> firstSquareDivisibleByThree = someNumbers.stream().map(x->x*x).filter(x->x%3==0).findFirst();

四、归约
处理思路：把一个流中的元素组合起来，使用reduce()
1.元素求和
int sum=numbers.stream().reduce(0,(a,b)->a+b);
redece()接收两个参数：
1）一个初始值，这里是0
2）一个BinaryOperator<T>来将两个元素结合起来产生一个新值
执行原理：
首先，0作为Lambda（a）的 第一个参数，从流中获得4作为第二个参数（b）。 0 + 4得到4，它成了新的积值。然后再用 积值和流中下一个元素5调用Lambda，产生新的积值9。接下来，再用积值和下一个元素3 调用Lambda，得到12。后，用12和流中后一个元素9调用Lambda，得到终结果21。 
2.求最大值和最小值
optional<Integer> max=numbers.stream().reduce(Integer::max);
或optional<Integer> max=numbers.stream().reduce((x,y)->x>y?x:y);

optional<Integer> min=numbers.stream().reduce(Integer::min);
或optional<Integer> min=numbers.stream().reduce((x,y)->x<y?x:y);

需求：怎么用map和reduce方法数一数流中用多少个菜呢？
思路：你可以把流中个每个元素都映射成数字1，然后用reduce求和。
int count=menu.stream().map(x->1).reduce(0,(a,b)->a+b);

流使用的实例：
/**
 * 需求： 1.找出2011年发生的所有交易，并按交易额排序（从低到高）。
 * 
 * 2.交易员都在哪些不同的城市工作过
 * 
 * 3.查找所有来自于剑桥的交易员，并按姓名排序
 * 
 * 4.返回所有交易员的姓名字符串，按字母顺序排序
 * 
 * 5. 有没有交易员是在米兰工作的？
 * 
 * 6.打印生活在剑桥的交易员的所有交易额
 * 
 * 7.所有交易中，最高的交易额是多少？
 * 
 * 8.找到交易额最小的交易
 * 
 * @author Administrator
 *
 */
public class TransactionTest1 {

  public static void main(String[] args) {
    // 数据初始化
    Trader raoul = new Trader("Raoul", "Cambridge");
    Trader mario = new Trader("Mario", "Milan");
    Trader alan = new Trader("Alan", "Cambridge");
    Trader brian = new Trader("Brian", "Cambridge");
    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));

    // 1.从低到高
    List<Transaction> list11 = transactions.stream().filter(s -> s.getYear() == 2011)
        .sorted(Comparator.comparing(Transaction::getValue)).collect(Collectors.toList());
    System.out.println("需求1---------------------------------->");
    list11.stream().forEach(System.out::println);

    // 1.从高到低
    List<Transaction> list12 = transactions.stream().filter(s -> s.getYear() == 2011)
        .sorted(Comparator.comparing(Transaction::getValue).reversed()).collect(Collectors.toList());
    list12.stream().forEach(System.out::println);

    // 2.写法一
    List<String> list2 = transactions.stream().map(s -> s.getTrader().getCity()).distinct()
        .collect(Collectors.toList());
    System.out.println("需求2---------------------------------->");
    list2.stream().forEach(System.out::println);

    // 2.写法二
    Set<String> list22 = transactions.stream().map(s -> s.getTrader().getCity()).collect(Collectors.toSet());
    list22.stream().forEach(System.out::println);

    // 3.
    List<Trader> list3 = transactions.stream().map(s -> s.getTrader()).filter(s -> s.getCity().equals("Cambridge"))
        .sorted(Comparator.comparing(Trader::getName)).collect(Collectors.toList());
    System.out.println("需求3---------------------------------->");
    list3.stream().forEach(System.out::println);

    // 4.
    String list4 = transactions.stream().map(s -> s.getTrader().getName()).distinct().sorted().reduce("",
        (a, b) -> a + b);
    System.out.println("需求4---------------------------------->");
    System.out.println(list4);

    // 5.
    boolean list5 = transactions.stream().anyMatch(s -> s.getTrader().getCity().equals("Milan"));
    System.out.println("需求5---------------------------------->");
    System.out.println("list5=" + list5);

    // 6
    System.out.println("需求6---------------------------------->");
    transactions.stream().filter(s -> s.getTrader().getCity().equals("Cambridge")).map(s -> s.getValue())
        .forEach(System.out::println);

    // 7.写法一
    Optional<Integer> max1 = transactions.stream().map(s -> s.getValue()).reduce(Integer::max);
    System.out.println("需求7---------------------------------->");
    System.out.println("max1=" + max1);

    // 7.写法二
    Optional<Integer> max2 = transactions.stream().map(Transaction::getValue).reduce((a, b) -> a > b ? a : b);
    System.out.println("max2=" + max2);

    // 8.
    Optional<Transaction> list8 = transactions.stream().min(Comparator.comparing(Transaction::getValue));
    System.out.println("需求8---------------------------------->");
    System.out.println("list8=" + list8.toString());

  }

}