Question

我有一个方法，它以String作为输入并返回一个与其对应的Integer，如下所示：

    fun getPriority(groupValue: String?): Int {
        when (groupValue) {
            "one" -> return 10
            "Two" -> return 9
            "THREE" -> return 8
            else -> return 4
        }
    }

我的问题是，在这种情况下，字符串比较是考虑字符串的大小写还是忽略大小写？

Answer 1

when进行了equals比较，因此确实区分大小写（另请参见String.equals）。

可以通过多种方式来实现区分大小写的方式，其中一种已经由Willi Mentzel展示出来了...其他方式（取决于您要实现的目标）：

fun getPriority(groupValue : String?) = when {
  groupValue == null -> /* handle the null first, so you can concentrate null-safe on the rest later */ 4
  groupValue.equals("one", ignoreCase = true) -> 10 /* ignoreCase = false is the default */
  /* ... */
  else -> 4
}

如果是那样的话，那么简单的Willis方法就足够了。

Answer 2

是的，它是区分大小写的，因为String.equals就像Roland所说的那样被调用。

使其不区分大小写：

fun getPriority(groupValue: String?) = when (groupValue?.toLowerCase()) {
    "one" -> 10
    "two" -> 9
    "three" -> 8
    else -> 4
}

提示：由于when是一个表达式，因此您可以对函数使用表达式主体符号。

替代：

使用Map代替when。如果您的代码应该是动态的，这将变得特别方便。

val priorityMapping = mapOf(
    "one" to 10,
    "Two" to 9,
    "THREE" to 8
)

fun getPriority(groupValue: String?): Int { 

    groupValue?.let {
        priorityMapping.forEach { (key, value) -> 
            if(key.equals(it, true)) {
                return value
            }
        }   
    }

    return 4 // default value
}

Answer 3

正如其他答案所述，when表达式使用equals方法进行比较。 String上的equals方法默认区分大小写。

如果要比较其equals方法以外的对象，则可以使用equals自己的实现创建一个小型包装器类。在您的特定情况下，这可能会有点矫kill过正，但在其他情况下，它可能会有用。

包装器类：

// In Kotlin 1.3, this class could probably be inlined.
class CaseInsensitiveString(val s: String) {
    fun equals(other: Any) = 
        (other as? CaseInsensitiveString)?.s?.equals(s, ignoreCase = true) ?: false

    // Overriding hashCode() just so it's consistent with the equals method.
    override fun hashCode() = s.toLowerCase().hashCode()
}

包装String的便捷扩展属性：

val String.caseInsensitive
    get() = CaseInsensitiveString(this)

现在您可以执行以下操作：

fun getPriority(groupValue: String?): Int {
    when (groupValue?.caseInsensitive) {
        "one".caseInsensitive -> return 10
        "Two".caseInsensitive -> return 9
        "THREE".caseInsensitive -> return 8
        else -> return 4
    }
}

Answer 4

正如其他人已经指出的那样，如果将标量（或标量列表）放在when前面，则equals使用->形成布尔表达式。因此（官方docs of when的摘录-禁止发表评论）

when (x) {
    1 -> print("x == 1") /* same as x.equals(1) or x == 1 */
    2 -> print("x == 2") /* same as x.equals(2) or x == 2 */
    else -> { // Note the block
        print("x is neither 1 nor 2")
    }
}

根据doc of text.equals：

参数

ignoreCase-true，在比较字符时忽略字符大小写。 默认情况下   犯错 e。

如果至少一个字符，则两个字符被视为相同的忽略大小写   以下是正确的：


两个字符相同（与==运算符相比）

将toUpperCase方法应用于每个字符会产生相同的结果

对每个字符应用toLowerCase方法会产生相同的结果

因此，在您情况下，groupValue.equals("one")与groupValue.equals("one", ignoreCase = false)相同，因此答案是肯定的。默认情况下，当您在when上使用String 时，比较将考虑套管。

比较时是否忽略String的大小写？

4 个答案: