简单来说，从the docs：
在Kotlin有两种类型的平等：

• 结构相等（检查equals()）=〉==
• 引用相等（两个引用指向同一对象）=〉===

详细答案：

结构相等（==）

==的求反对应项为!=
按照约定，类似a == b的表达式将转换为：

a?.equals(b) ?: (b === null)

如果a不是null，则它调用equals(Any?)函数，否则它检查b是否参考地等于null。

• 要提供自定义等于检查实现 *，重写equals(other: Any?): Boolean函数。具有相同名称和其他签名的函数，如等于（其他：Foo），则不影响使用运算符==和!=进行的相等性检查。

引用相等（===）

===的求反对应项为!==
当且仅当a和b指向同一对象时，a === b才计算为true。对于在运行时表示为基元类型的值（例如Int），===相等性检查等效于==检查。

代码说明

让我们假设A的定义与您在问题中定义的相同。

代码段1

>>> var a1 = A()
>>> var a2 = A()
>>> a1 == a2 // a1 and a2 are different instances of A
false
>>> a1 == a1
true
>>> a2 == a2
true
>>> a1 === a2 // a1 and a2 have references to different objects
false

对于常规类，equals的实现是从Any继承的，并且只是使对象等于其自身。

代码段2

>>> var a1 = A()
>>> var a2 = A()
>>> a1 = a2 
>>> a1 == a2
true
>>> a1 === a2
true

a1和a2指向同一对象，这就是a1 == a2和a1 === a2返回true的原因。

片段3

让我们重写A的equals(Any?)，如下所示：

class A {
    var foo = 1
    override fun equals(other: Any?): Boolean {
        if (other == null || other !is A)
            return false
        return foo == (other as A).foo
    }
}

现在让我们运行以下代码：

>>> var a1 = A()
>>> var a2 = A()
>>> a1 == a2
true
>>> a1 === a2
false

请注意，a1和a2在结构上是相等的，尽管它们引用了差异对象。

在Kotlin中，有两种类型的等式可用，它们是：结构平等和参照平等。

class A {
  var foo = 1
}

var a1 = A()
var a2 = A()

这里a1和a2是类A的两个示例。

println(a1 == a2)

它打印false，因为a1和a2在结构上不相等。

println(a1 === a2)

它打印false，因为a1和a2没有引用同一个对象。
但是，如果执行以下代码行：a1 = a2那么，
a1和a2在结构上是相同的，a1引用了a2示例，这就是为什么

println(a1 == a2)
println(a1 === a2)

这两行都返回真。

结构平等意味着内容应该相同

"checks for equals() or ==".

引用相等意味着两个示例应指向同一指针。

"two objects points to same reference or ==="

您可以覆盖equals（）并执行以下操作。

class Person(val p : String) {

  override fun toString(): String = "Person(p$p)"
    override fun equals(other: Any?): Boolean {
        if(other == null || other !is Person) {
           return false
        }
       return p == other.p
    }
}

让我们测试一下。

var a = Person("abc")
var b = Person("abc")

Line 1 => println(a == b)
Line 2 => println(a === b)

第1行打印"true"
第2行打印"false"

a = b

第1行打印"true"
第2行打印"true"
最后，
===总是检查引用是否相等，而==检查等效内容，并且基于您的实现。

Kotlin==和===运算符（全新外观：6例）
在Kotlin中，如果a和B代表两个变量，那么println（a==b）检查这两个值在结构上是否相等，而println（a===b）检查a和b是否具有相同的引用，下面的例子可以说明这一点。

// Case 1 : a and b are both Int
// EqCase1.kt
fun main() {
    var a = 5
    var b = 7
    println(a==b) // false
    //println(a===b) // identity equality for Int is deprecated
    a = b
    println(a==b) // true
    //println(a===b) // identity equality for Int is deprecated
}

// Case 2 : a and b are Double and Integer
// EqCase2.kt
fun main() {
    var a = 5.0
    var b = 7
    //println(a==b) //  operator '==' cannot be applied to 'Double' and 'Int'
    //println(a===b) // operator '===' cannot be applied to 'Double' and 'Int'
    //a = b // inferred type is Int but Double was expected
    //println(a==b) //  inferred type is Int but Double was expected
    println(a===b) // identity equality for Int is deprecated
}

// case 3 : a and b are mathematically same but of different types (Double and Any(say Int))
// EqCase3.kt
fun Eq(a: Double,b: Any) =  if (a == b) "(a == b) is true" else "(a == b) is false"
//fun Eq1(a: Double,b: Any) =  if (a === b) "(a === b) is true" else "(a === b) is false"
fun main() {
    println(Eq(5.0,5)) // (a == b) is false
    //println(Eq1(5.0,5)) 
}

/* O/p
EqCase3.kt:5:34: warning: identity equality for arguments of types Double and Any can be unstable because of implicit boxing
fun Eq1(a: Double,b: Any) =  if (a === b) "(a === b) is true" else "(a === b) is false"
*/

// Case 4 : a and b are both Booleans
// EqCase4.kt
fun main() {
    var a = true
    var b = false
    println(a==b) // false
    //println(a===b) // identity equality for arguments of Boolean is deprecated
    a = b
    println(a==b) // true
    //println(a===b) // identity equality for arguments of Boolean is deprecated
}

// Case 5 : a and b are both Strings
// EqCase5.kt
fun main() {
    var a = "Anil"
    var b = "Vijay"
    println(a==b) // false
    println(a===b) // false
    a = b
    println(a==b) // true
    println(a===b) // true
}

// Case 6 : a and b are both of type arrayOf
// EqCase6.kt
fun main() {
    var a = arrayOf("A","B","C")
    var b = arrayOf("a","b","c")
    println(a==b) // false
    println(a===b) // false
    a = b
    println(a==b) // true
    println(a===b)  // true
}