Kotlin 中的解构

解构声明是 Kotlin 语言的一个特性，它允许我们从一个数据结构中提取多个变量，这样可以让我们的代码更加简洁易读，同时也提高了代码的可维护性。

在 Kotlin 中，解构可以用于多种数据类型，例如，列表（List）、数组（Array）、对象等。

下面是 Kotlin 解构的一些示例。

解构列表：

val list = listOf("Apple", "Banana", "Cherry")
val (first, second, third) = list
println("first = $first; second = $second; third = $third")

// first = Apple; second = Banana; third = Cherry

解构数组：

val array = arrayOf("Apple", "Banana", "Cherry")
val (first, second, third) = array
println("first = $first; second = $second; third = $third")

// first = Apple; second = Banana; third = Cherry

解构数据类：

data class Person(val name: String, val age: Int)

val p = Person("Eileen", 30)
val (name, age) = p
println("name = $name, age = $age")

一个解构声明看起来像一个普通的变量声明，但它的括号中有多个变量。

要在解构声明中初始化每个变量，将调用名为 componentN 的函数，其中，N 是声明中变量的位置。

对于数据类，编译器为每个在主构造函数中声明的属性生成一个 componentN 函数。 将 Person 类反编译成 Java 代码：

public final class Person {
   @NotNull
   private final String name;
   private final int age;

   @NotNull
   public final String getName() {
      return this.name;
   }

   public final int getAge() {
      return this.age;
   }

   public Person(@NotNull String name, int age) {
      Intrinsics.checkNotNullParameter(name, "name");
      super();
      this.name = name;
      this.age = age;
   }

   @NotNull
   public final String component1() { // 1
      return this.name;
   }

   public final int component2() { // 2
      return this.age;
   }

   @NotNull
   public final Person copy(@NotNull String name, int age) {
      Intrinsics.checkNotNullParameter(name, "name");
      return new Person(name, age);
   }

   // $FF: synthetic method
   public static Person copy$default(Person var0, String var1, int var2, int var3, Object var4) {
      if ((var3 & 1) != 0) {
         var1 = var0.name;
      }

      if ((var3 & 2) != 0) {
         var2 = var0.age;
      }

      return var0.copy(var1, var2);
   }

   @NotNull
   public String toString() {
      return "Person(name=" + this.name + ", age=" + this.age + ")";
   }

   public int hashCode() {
      String var10000 = this.name;
      return (var10000 != null ? var10000.hashCode() : 0) * 31 + Integer.hashCode(this.age);
   }

   public boolean equals(@Nullable Object var1) {
      if (this != var1) {
         if (var1 instanceof Person) {
            Person var2 = (Person)var1;
            if (Intrinsics.areEqual(this.name, var2.name) && this.age == var2.age) {
               return true;
            }
         }

         return false;
      } else {
         return true;
      }
   }
}

这里需要注意的是，不能定义无限数量的 componetN 函数，标准库只允许使用此语法来访问一个对象的前 5 个元素。