List Kotlin-collection plus（）×；plusElement（）差分

实际上，

plus

和

pluseElement

（

减

，

minusElement

）函数在（不可变的）

列表

上有什么区别

operator fun <T> Collection<T>.plus(element: T): List<T>

fun <T> Collection<T>.plusElement(element: T): List<T>

operator fun Collection.plus（元素：T）：列表
有趣的集合。pluseElement（元素：T）：列表

第一个是重载运算符，如

运算符

关键字所示。它允许您将

+

运算符与

列表一起使用

第二个是常规函数，以常规函数调用样式调用

两者都返回一个新的
列表
，并附加
元素

Kotlin回复的文字记录：

>>>val a = listOf(1, 2, 3)
>>>a + 4
[1, 2, 3, 4]
>>> a.plusElement(4)
[1, 2, 3, 4]

有关Kotlin运算符重载的更多信息，请参见。
除了可分别简化为
+
和
-
之外，我还想与大家分享一个示例，让大家更清楚地了解为什么要使用它，或者使用它也有意义。基本上，当您不希望调用重载运算符方法时就是这种情况（例如），在处理列表列表时可能就是这种情况

也许下面的示例更清楚地说明了这一点。在示例中，所有变量分配都显示了调用相应函数时分配的类型，并在行尾的注释中包含结果。变量~结束命名约定如下：


PlusT
显示对
plus（元素：T）
PlusIterable
显示对
plus（元素：Iterable）
PlusElementT
显示对
plusElement（元素：T）

样本：

val someEntry = "some entry"
val listOfSomeEntry = listOf(someEntry)

val los : List<String> = listOf("listOfString")
val lsPlusT         : List<String> = los.plus(someEntry)               // [listOfString, some entry]
val lsPlusIterable1 : List<String> = los.plus(listOfSomeEntry)         // [listOfString, some entry]
val lsPlusIterable2 : List<Any>    = los.plus(listOf(listOfSomeEntry)) // [listOfString, [some entry]]
val lsPlusElementT1 : List<String> = los.plusElement(someEntry)        // [listOfString, some entry]
val lsPlusElementT2 : List<Any>    = los.plusElement(listOfSomeEntry)  // [listOfString, [some entry]]

val lol : List<List<String>> = listOf(listOf("listOfList"))
// the following is basically not really correct as we are now dealing with a list of lists of strings, but it shows that llPlusT and llPlusIterable lead to the same (in this case probably wrong) result..
val llPlusT         : List<Any>          = lol.plus(someEntry)               // [[listOfList], some entry]
val llPlusIterable  : List<Any>          = lol.plus(listOfSomeEntry)         // [[listOfList], some entry]
val llPlusIterable2 : List<List<String>> = lol.plus(listOf(listOfSomeEntry)) // [[listOfList], [some entry]]
val llPlusElement1  : List<Any>          = lol.plusElement(someEntry)        // [[listOfList], some entry]
val llPlusElement2  : List<List<String>> = lol.plusElement(listOfSomeEntry)  // [[listOfList], [some entry]]

val someEntry=“some entry”
val listOfSomeEntry=listOf（someEntry）
val los:List=listOf（“listOfString”）
val lsPlusT:List=los.plus（someEntry）/[listOfString，someEntry]
val lsPlusIterable1:List=los.plus（listOfSomeEntry）/[listOfString，SomeEntry]
val lsPlusIterable2:List=los.plus（listOf（listOfSomeEntry））/[listOfString[some entry]]
val lsPlusElementT1:List=los.plusElement（someEntry）/[listOfString，someEntry]
val lsPlusElementT2:List=los.plusElement（listOfSomeEntry）/[listOfString，[some entry]]
val lol:List=listOf（listOf（“listOf列表”））
//下面的内容基本上并不正确，因为我们现在处理的是字符串列表，但它表明llPlusT和llPlusIterable会导致相同的结果（在本例中可能是错误的）。。
val llPlusT:List=lol.plus（someEntry）/[[listOfList]，someEntry]
val llPlusIterable:List=lol.plus（listOfSomeEntry）/[[listOfList]，SomeEntry]
val llPlusIterable2:List=lol.plus（listOf（listOfSomeEntry））/[[listOfList]，[SomeEntry]]
val llPlusElement1:List=lol.plusElement（someEntry）/[[listOfList]，someEntry]
val llPlusElement2:List=lol.plusElement（listOfSomeEntry）/[[listOfList]，[SomeEntry]]

正如您在使用
+
时所看到的，可能会使用重载变量
plus（elements:Iterable）
，这在大多数情况下可能有意义，但在某些情况下可能没有意义，例如（大多数情况下）在处理列表列表时。与其通过使用
+listOf（anotherList）
强制
+
添加列表列表，不如使用
plusElement
（
plusElement（anotherList）
），或者如果确定只添加单个元素，可以省略
plus
，而代之以
plusElement
（可能是一个非常罕见且非常特殊的用例……这将通过variant
llPlusElement1
反映出来）

最后，
pluseElement
或
minusElement
从命名中可以清楚地看出，您传递的内容反映了列表中的一个项目，而
+
基本上是打开的…（但是，您应该从上下文中看到，有列表的上下文可能并不那么清楚；-）。最后还有一个免责声明：这并不意味着您应该使用列表列表，但只是为了防止您发现类似的东西，您手头有
plus/minusElement
；-）
 语法
coll+元素
就是区别所在，我认为这是错误的。
plus（）
是运算符重载这一事实并不能解释这一区别（您也可以显式调用
.plus（）
）@Roland的回答是正确的，真正的区别在于，如果您有一个集合集合，那么
plus（）
函数调用可能有两种解释。
plusElement（）
函数提供了一种方法，可以强制将列表添加到列表列表中，而不单独添加其元素。