kotlin 扩展了很多的 to... 方法

映射函数： map{(T) -> R}
根据传入的转换函数将原有的集合转换成一个新的 List 集合

fun Shop.getCitiesCustomersAreFrom(): Set<City> {
    // Return the set of cities the customers are from
    return this.customers.map {
        it.city
    }.toSet()
}

过滤函数： filter{(T) -> Boolean}
根据传入的判断函数返回一个新的 List 集合

fun Shop.getCustomersFrom(city: City): List<Customer> {
    // Return a list of the customers who live in the given city
    return this.customers.filter {
        it.city == city
    }
}

全局判断函数：all {(T)->Boolean}返回 boolean 全部满足才返回 true
等同于list.size == list.filter{(T)->Boolean}.size

包含判断函数：any {(T)->Boolean} 返回 boolean 只要满足lambda即返回 true
等同于：list.fliter{(T)->Boolean}.size>0

判断计数函数 count{(T)->Boolean} 返回满足条件的子集数量
等同于list.fliter{(T)->Boolean}.size

判断首项函数：firstOrNull{(T)->Boolean} 返回子集中第一个满足条件的项（ T 或者 null）
等同于

var r = list.filter{}
return if (r.size>0) r.get(0) else null

铺平函数：flatMap

如果我们的传入参数是一个用户，但是我们最终想要的结果是用户全部订单（List）中的全部商品的集合，这时我们就需要flatMap 铺平。

val Customer.orderedProducts: Set<Product> get() {
    // Return all products this customer has ordered
    //返回用户全部订单中所有的商品种类
    return orders.flatMap {
        it.products
    }.toSet()
}

val Shop.allOrderedProducts: Set<Product> get() {
    // Return all products that were ordered by at least one customer
    //返回商店中全部的至少被一位用户下单过的商品
   customers.flatMap {
        it.orders
    }.flatMap {
        it.products
    }.toSet()

    return customers.flatMap {
        it.orderedProducts
    }.toSet()
}

取最大值函数：max()、maxBy{} 根据传入的选择器找出集合中最大的成员

fun Customer.getMostExpensiveOrderedProduct(): Product? {
    // Return the most expensive product which has been ordered
    return orders.flatMap {
        it.products    //订单铺平成商品
    }.maxBy {
        it.price //取出商品中价格最大的
    }
}

排序函数：sortedBy{} 根据传入的选择器升序排列

fun Shop.getCustomersSortedByNumberOfOrders(): List<Customer> {
    // Return a list of customers, sorted by the ascending number of orders they made
    return this.customers.sortedBy {
        it.orders.size //按照客户的订单数升序排列
    }
}

求和函数：sum()返回Int、 sumBy{}返回 Int、 sumByDouble{} 返回 Double

fun Customer.getTotalOrderPrice(): Double {
   // Return the sum of prices of all products that a customer has ordered.
   // Note: a customer may order the same product for several times.
   orders.flatMap {
       it.products
   }.sumByDouble {
       it.price
   }

   orders.flatMap { it.products }.fold(0.0,{acc, product ->
           acc+product.price
   })
   var result = 0.0
   orders.flatMap { it.products }.forEach {
       result+=it.price
   }
   return  result
}

分组函数 groupBy{} 按照传入的选择器将集合对象分组返回Map<K, List<T>>

fun Shop.groupCustomersByCity(): Map<City, List<Customer>> {
    // fun Shop.groupCustomersByCity(): Map<City, List<Customer>> {
    // Return a map of the customers living in each city
    //不使用groupBy函数的写法
    val map = mutableMapOf<City,List<Customer>>()
    val citys = this.customers.map {
        it.city
    }.toSet().map {
         map.put(it, this.getCustomersFrom(it))
    }
//    return map //效果等同

    return this.customers.groupBy { it.city }
}

折叠函数：Iterable<T>.fold{initial:R, operation: (R,T) -> R}

折叠函数

将一个 T 的集合装换成一个 R ，所以这个方法被称为折叠。

fun Shop.getSetOfProductsOrderedByEachCustomer(): Set<Product> {
    // Return the set of products that were ordered by each of the customers
    //找到商店中每一个用户都下单的商品
    allOrderedProducts.filter { p ->
        customers.all {
            it.orders.flatMap {
                it.products
            }.any {
                it == p
            }
        }
    }.toSet()
    
    return customers.fold(allOrderedProducts, { orderedByAll, customer ->
        //第一次调用该函数时传入值为fold函数的第一个参数 全部被下单的产品集合
        orderedByAll.intersect( //交集运算
                customer.orders.flatMap {
                    it.products
                }.toSet() //传入的用户的全部产品的集合
        )
    })
}