一、前言：

在之前的学习中通常我们对变量赋值时，只带一个值，比如

val name = "alfred"

比如我们有时候处理一些复杂情况的话，就只能进行分割处理，比如表述学生的 姓名、性别、年龄，就需要用到对象了。

此处我们以Java为例，有的场合我们需要使用学生的（姓名 性别 年龄），有的时候只需要使用（姓名 性别）再或者只使用（姓名 年龄）。可以使用如下处理方案（使用了部分面向对象的知识，不懂也没关系，后续课程里也会介绍）

    public class Student {
        private String name;
        private String sex;
        private int age;
     
        //构造方法，包含姓名、性别、年龄
        public Student(String name, String sex, int age) {
            this.name = name;
            this.sex = sex;
            this.age = age;
        }
     
        //构造方法，包含姓名、年龄
        public Student(String name, int age) {
            this.name = name;
            this.age = age;
        }
     
        //构造方法，包含姓名、性别
        public Student(String name, String sex) {
            this.name = name;
            this.sex = sex;
        }
     
        public String getName() {
            return name;
        }
     
        public String getSex() {
            return sex;
        }
     
        public int getAge() {
            return age;
        }
    }
     
     

 

    public class Person {
        public static void main(String[] args) {
            Student student = new Student("Alfred","男",29);
            System.out.println(student.getName());
            System.out.println(student.getSex());
            System.out.println(student.getAge());
     
            Student student1 = new Student("Thomas",21);
            System.out.println(student1.getName());
            System.out.println(student1.getAge());
     
            Student student2 = new Student("Jack","男");
            System.out.println(student2.getName());
            System.out.println(student2.getSex());
        }
    }

结果：

    Alfred
    男
    29
    Thomas
    21
    Jack
    男

这个就是常规解决方案，但是在简单的使用场合有必要这么复杂吗？下面就来看看元组
元组

可以把多个值同时赋给一个变量，或者同时给多个变量赋值。kotlin中元组分为二元元组（Pair）和三元元组（Triple），在新版Kotlin中已经删除了多元元组。也就是只有Pair和Triple。

先来看看API。

    /**
     * Represents a triad of values
     *
     * There is no meaning attached to values in this class, it can be used for any purpose.
     * Triple exhibits value semantics, i.e. two triples are equal if all three components are equal.
     * An example of decomposing it into values:
     * @sample samples.misc.Tuples.tripleDestructuring
     *
     * @param A type of the first value.
     * @param B type of the second value.
     * @param C type of the third value.
     * @property first First value.
     * @property second Second value.
     * @property third Third value.
     */
    public data class Triple<out A, out B, out C>(
        public val first: A,
        public val second: B,
        public val third: C
    ) : Serializable {
     
        /**
         * Returns string representation of the [Triple] including its [first], [second] and [third] values.
         */
        public override fun toString(): String = "($first, $second, $third)"
    }
     
    /**
     * Represents a generic pair of two values.
     *
     * There is no meaning attached to values in this class, it can be used for any purpose.
     * Pair exhibits value semantics, i.e. two pairs are equal if both components are equal.
     *
     * An example of decomposing it into values:
     * @sample samples.misc.Tuples.pairDestructuring
     *
     * @param A type of the first value.
     * @param B type of the second value.
     * @property first First value.
     * @property second Second value.
     * @constructor Creates a new instance of Pair.
     */
    public data class Pair<out A, out B>(
        public val first: A,
        public val second: B
    ) : Serializable {
     
        /**
         * Returns string representation of the [Pair] including its [first] and [second] values.
         */
        public override fun toString(): String = "($first, $second)"
    }

很简单不做过多的解释，直接看例子就明白了。

    fun main() {
        val student1 = Triple<String, String, Int>("Alfred", "男", 29)
        val student2 = Pair<String,Int>("Thomas",21)
        val student3 = Pair<String,String>("jack","男")
        println(student1.first)
        println(student1.second)
        println(student1.third)
        println(student2.first)
        println(student2.second)
        println(student3.first)
        println(student3.second)
    }

结果：

    Alfred
    男
    29
    Thomas
    21
    jack
    男

看看激动不，实现结果跟Java面向对象实现结果一致。
————————————————
原文链接：https://blog.csdn.net/alfredkao/article/details/106550141