jdk8中流的使用（二）

电玩女神 2021-10-01 05:42 197阅读 0赞

三.查找和匹配  
处理思路：看数据集中的某些元素是否匹配一个给定的元素  
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());