Kotlin 运行代码HashMap（it）时发生了什么？

以下示例代码来自Kotlin for Android开发者

我不能完全理解代码

DayForecast（HashMap（it））

。“它”是什么意思

还有，当执行

parseList{DayForecast（HashMap（it））}

时会发生什么

override fun requestForecastByZipCode(zipCode: Long, date: Long) = forecastDbHelper.use {

        val dailyRequest = "${DayForecastTable.CITY_ID} = ? AND ${DayForecastTable.DATE} >= ?"
        val dailyForecast = select(DayForecastTable.NAME)
                .whereSimple(dailyRequest, zipCode.toString(), date.toString())
                .parseList { DayForecast(HashMap(it)) }
}



class DayForecast(var map: MutableMap<String, Any?>) {
    var _id: Long by map
    var date: Long by map
    var description: String by map
    var high: Int by map
    var low: Int by map
    var iconUrl: String by map
    var cityId: Long by map

    constructor(date: Long, description: String, high: Int, low: Int, iconUrl: String, cityId: Long)
            : this(HashMap()) {
        this.date = date
        this.description = description
        this.high = high
        this.low = low
        this.iconUrl = iconUrl
        this.cityId = cityId
    }
}

---

它是单个参数的隐式名称。检查文档。

它是单个参数的隐式名称。检查文档。

正如Lym Zoy所说，它是闭包的单个参数的隐式名称

如果您不熟悉Kotlin中的闭包和高阶函数，可以阅读它们。接受闭包/函数/lambda的函数基本上是请求帮助来完成其工作的函数

我喜欢用它作为一个很好的例子

sortedBy

是Kotlin collections库中的一个函数，用于对集合进行排序，但为了使其正常工作，需要为每个项目提供一个可比较的属性。解决这个问题的方法是，它要求sortedBy函数的用户提供一个函数，该函数接受集合的一个成员并返回一个可比较的属性。例如，如果集合是Person对象的列表，则如果要按名字、姓氏或年龄排序，可以提供不同的闭包

下面是一个您也可以找到的快速示例，它显示了

sortedBy

如何接受一个闭包参数，该闭包参数接受一个成员并返回一个可比较的属性，

sortedBy

可以使用该属性对集合的各个成员进行排序。在第一种情况下，闭包/函数返回成员的年龄，在第二种情况下，闭包返回lastName（使用隐式形式），两者都是可比较的，一个Int和一个字符串

data class Person(val firstName: String, val lastName: String, val age: Int)

fun main(args: Array<String>) {

  val people = listOf( Person("Jane", "Jones", 27), Person("Johm", "Smith", 22), Person("John", "Jones", 29))
  val byAge = people.sortedBy { person -> person.age  }  // explicit argument: person is a memeber of the List of Persons
  val byLastName = people.sortedBy { it.lastName } // implict argument: "it" is also a member of the List of Persons 
  println(people)
  println(byAge)
  println(byLastName)

其中，

{DayForecast（HashMap（it））}

是预期传递给parseList的闭包，
长格式

{arg->DayForecast（HashMap（arg）}

也可以使用，但是短格式

{DayForecast（HashMap（it））}

是更惯用的格式，使用

it

作为参数可以跳过

arg->

部分

---

因此，在本例中，

it

是由

parseList

函数提供的映射对象。然后，

it

引用的对象作为单独的参数传递给构造函数（这并不奇怪，构造函数需要映射），该构造的结果，然后被传递给

DayForecast

的构造函数，正如Lym Zoy所说的

它是闭包的单个参数的隐式名称

如果您不熟悉Kotlin中的闭包和高阶函数，可以阅读它们。接受闭包/函数/lambda的函数基本上是请求帮助来完成其工作的函数

我喜欢用它作为一个很好的例子。
sortedBy
是Kotlin collections library中的一个函数，它将对集合进行排序，但为了使集合正常工作，它需要每个项目都有一个可比较的属性。解决这个问题的方法是，它要求sortedBy函数的用户提供一个函数，该函数将集合中的一个成员作为d返回一个可比较的属性。例如，如果集合是一个Person对象列表，则如果要按名字、姓氏或年龄排序，可以提供不同的闭包

下面是一个您也可以找到的快速示例，它显示了
sortedBy
如何接受一个闭包参数，这个闭包参数接受一个成员并返回一个可比较的属性，
sortedBy
可以使用该属性对集合的各个成员进行排序。在第一种情况下，闭包/函数返回成员的年龄，在第二种情况下返回成员的年龄e闭包返回lastName（使用隐式形式），两者都是可比较的，一个Int和一个String

data class Person(val firstName: String, val lastName: String, val age: Int)

fun main(args: Array<String>) {

  val people = listOf( Person("Jane", "Jones", 27), Person("Johm", "Smith", 22), Person("John", "Jones", 29))
  val byAge = people.sortedBy { person -> person.age  }  // explicit argument: person is a memeber of the List of Persons
  val byLastName = people.sortedBy { it.lastName } // implict argument: "it" is also a member of the List of Persons 
  println(people)
  println(byAge)
  println(byLastName)

其中，
{DayForecast（HashMap（it））}
是预期传递给parseList的闭包，

长格式
{arg->DayForecast（HashMap（arg）}
也可以使用，但是短格式
{DayForecast（HashMap（it））}
是更惯用的格式，使用
it
作为参数可以跳过
arg->
部分

因此，在本例中，
it
是由
parseList
函数提供的映射对象。然后，
it
引用的对象作为单独的参数传递给构造函数（这并不奇怪，构造函数需要映射），该构造的结果，然后被传递给
DayForecast
的构造函数，谢谢，但是单个参数的隐式名称应该是{}，例如ints.map{it*2}，在我的代码中，它是HashMap（it）
map
，当使用map{it*2}时，它的签名是
map（transform:->R）
，这意味着参数
transform
这里是
（it）->{it*2}
。它是单个参数T的名称。谢谢，但是单个参数的隐式名称应该是{}，例如ints.map{it*2}，在我的代码中，它是HashMap（it）
map
的签名是
map（transform:（T）->R）
。使用map{it*2}，这意味着参数
transform
这里是
（it）->{it*2}
。它是单个参数T的名称。谢谢！您的意思是HashMap（it）将闭包转换为Map吗？不，我的意思是闭包/函数接受parseList提供给它的映射，并返回给parseList一个DayForecast。它通过将函数{DayForecast（HashMap（it））}中的Map对象作为“it”传递来实现从您的评论来看，似乎您需要更多关于整个闭包、高阶函数概念的背景知识。我添加了一些背景知识、示例和一些链接。谢谢！如果“在本例中它是由parseList函数提供的映射对象”，为什么我不能使用.parseList{DayForecast（it）}而不是.parseList{DayForecast（HashMap（it））}我想这是另一个问题。你会的
fun <T : Any> SelectQueryBuilder.parseList(parser: (Map<String, Any?>) -> T): List<T> =
        parseList(object : MapRowParser<T> {
            override fun parseRow(columns: Map<String, Any?>): T = parser(columns)
        })

.parseList { DayForecast(HashMap(it)) }