Kotlin don'的多重区分；我们不能给出一致的结果

我有一个字符串列表，我试图保留唯一不同的字符串，忽略字母大小写和空格

例如：

listOf（“a”、“a”、“a”、“B”）

=>

listOf（“a”、“B”）

所以我尝试了这个解决方案：

val list = listOf("a", "A", "A  ", "B")
        .distinctBy { it.toLowerCase() }
        .distinctBy { it.trim() }

println("list = ${list}")

输出：列表=[a、a、B]

但是，当我改变

的顺序时，它会出人意料地工作：

val list = listOf("a", "A", "A  ", "B")
        .distinctBy { it.trim() }
        .distinctBy { it.toLowerCase() }

println("list = ${list}")

输出：列表=[a，B]

我希望输出作为第二个，但为什么第一个代码不起作用

当我改变物品的顺序时，我也有同样的问题：

   val list = listOf("a", "A  ", "A", "B")
            .distinctBy { it.toLowerCase() }
            .distinctBy { it.trim() }

    println("list = ${list}")

输出：列表=[a、a、B]

因为首先要修剪，然后要求不同的值

如果首先得到不同的值，结果是
list=[a，a，B]


因此，修剪后给出：
list=[a，a，B]


distinctBy
表示获取所有不同的项目

因为首先要修剪，然后要求不同的值

如果首先得到不同的值，结果是
list=[a，a，B]


因此，修剪后给出：
list=[a，a，B]


distinctBy
意味着在第一种情况下，当您应用
时，获取所有不同的（不同的）项。distinctBy{it.toLowerCase（）}
，它比较
[“a”，“a”，“b”]
值，得到的数组将是
[“a”，“a”，“b”]

调用
.distinctBy{it.trim（）}
时，它将比较
“a”、“a”、“B”
字符串，结果是
[“a”、“a”、“B”]

在第二种情况下，在应用
.distinctBy{it.trim（）}
后，您将得到
[“a”、“a”、“B”]
，然后
。distinctBy{it.toLowerCase（）}
将比较
[“a”、“a”、“B”]
，您将得到所需的结果

此外，您还可以通过块将两种操作组合在一个distinctBy中：

val list=listOf（“a”、“a”、“a”、“B”）
.distinctBy{it.toLowerCase（）.trim（）}
在第一种情况下，当您应用
.distinctBy{it.toLowerCase（）}
时，它比较
[“a”、“a”、“b”]
值，得到的数组将是
[“a”、“a”、“b”]

调用
.distinctBy{it.trim（）}
时，它将比较
“a”、“a”、“B”
字符串，结果是
[“a”、“a”、“B”]

在第二种情况下，在应用
.distinctBy{it.trim（）}
后，您将得到
[“a”、“a”、“B”]
，然后
。distinctBy{it.toLowerCase（）}
将比较
[“a”、“a”、“B”]
，您将得到所需的结果

此外，您还可以通过块将两种操作组合在一个distinctBy中：

val list=listOf（“a”、“a”、“a”、“B”）
.distinctBy{it.toLowerCase（）.trim（）}
distinctBy
不会改变列表的内容，而是使用给定的转换函数比较列表中的每个条目，然后返回一个新列表

因此，尽管
a
和
a
根据您的第一个定义是不同的，但它只返回找到的第一个匹配项（在本例中为
a
）。
在第一个不同的列表之后，您的列表包含以下项目：

[a, A  , B]

下一个distinct将获取这些元素，并通过修剪内容进行比较，这基本上会导致相同的结果，因为基于第二个distinct转换函数，所有元素都是distinct的

您可能想做的是：

listOf("a", "A", "A  ", "B")
   .distinctBy { it.toLowerCase().trim() }

listOf("a", "A", "A  ", "B")
    .map(String::toLowerCase)
    .map(String::trim)
    .distinct()
    .also(::println)

这实际上结合了两种转换功能，并导致：

[a, B]

或者，您可以执行以下操作：

listOf("a", "A", "A  ", "B")
   .distinctBy { it.toLowerCase().trim() }

listOf("a", "A", "A  ", "B")
    .map(String::toLowerCase)
    .map(String::trim)
    .distinct()
    .also(::println)

然后返回：

[a, b]

或者，如果你真的关心你得到了哪些信息：

listOf("a", "A", "A  ", "B")
    .groupBy { it.toLowerCase().trim() }
    .let(::println)

返回：

{a=[a, A, A  ], b=[B]}

从这里您可以获取一个或所有~real输入，例如，您可以添加一个
.map{it.value[0]}
再次返回任何组的第一个真正匹配项。
distinctBy
不会更改列表的内容，而是使用给定的转换函数比较列表中的每个条目，然后返回新列表

因此，尽管
a
和
a
根据您的第一个定义是不同的，但它只返回找到的第一个匹配项（在本例中为
a
）。
在第一个不同的列表之后，您的列表包含以下项目：

[a, A  , B]

下一个distinct将获取这些元素，并通过修剪内容进行比较，这基本上会导致相同的结果，因为基于第二个distinct转换函数，所有元素都是distinct的

您可能想做的是：

listOf("a", "A", "A  ", "B")
   .distinctBy { it.toLowerCase().trim() }

listOf("a", "A", "A  ", "B")
    .map(String::toLowerCase)
    .map(String::trim)
    .distinct()
    .also(::println)

这实际上结合了两种转换功能，并导致：

[a, B]

或者，您可以执行以下操作：

listOf("a", "A", "A  ", "B")
   .distinctBy { it.toLowerCase().trim() }

listOf("a", "A", "A  ", "B")
    .map(String::toLowerCase)
    .map(String::trim)
    .distinct()
    .also(::println)

然后返回：

[a, b]

或者，如果你真的关心你得到了哪些信息：

listOf("a", "A", "A  ", "B")
    .groupBy { it.toLowerCase().trim() }
    .let(::println)

返回：

{a=[a, A, A  ], b=[B]}

从这里，您可以获取一个或所有~real输入，例如，您可以添加一个
.map{it.value[0]}
，再次返回任何组的第一个~real匹配。
这就是我所做的，但它不起作用。查看更新的问题。好的，但是如何将两者结合起来，因为如果你有：listOf（“a”、“a”、“a”、“a”、“a”、“B”）listOf（“a”、“a”、“a”、“a”、“B”）listOf（“a”、“a”、“a”、“B”），那么它将不起作用。无论你做什么，我都会得到list=[a、a、B]我认为这是不适用的。请参阅更新的问题。好的，但是如何将两者结合起来，因为如果您有：listOf（“a”、“a”、“a”、“a”、“a”、“B”）listOf（“a”、“a”、“a”、“a”、“B”）listOf（“a”、“a”、“a”、“B”）我会得到list=[a、a、B]我认为这是不合适的。您可能需要添加一个
。另外（：：println）
在每个
distinctBy
之后查看以前的
distinctBy
已经过滤掉的内容。您可能需要添加
。另外（：：println）
在每个
distinctBy
之后查看以前的
distinctBy
已经过滤掉的内容。