JAVA浅谈Pair抽象类

心已赠人 2023-10-16 15:19 14阅读 0赞

1.业务场景  
业务开发中会遇到一种情况，返回两个参数值，这两个参数值都有用到，所以我们一般都会用map集合进行key-value封装，或者写一个类来封装两个属性来返回，还有一种方式就是用org.apache.commons.lang3.tuple 包中提供Pair抽象类，这种方式更加的优雅美观。

2.Pair简单的使用  
Pair抽象类，不能被直接实例化，可以通过Pair.of(L,R)实例化，提供了getLeft()和getRight()方法。

**Pair、Triple  
org.apache.commons.lang3 提供了返回多个值的工具类，返回2个值用Pair，3个值用Triple**

<dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-lang3</artifactId>
        <version>3.12.0</version>
    </dependency>

**cn.hutool.core.lang包中也提供了关于Pair的工具包**

<dependency>
    	<groupId>cn.hutool</groupId>
    	<artifactId>hutool-all</artifactId>
    	<version>5.5.3</version>
    </dependency>

List<String> list = Lists.newArrayList();
            list.add("key-value");
            boolean bool = true;
            Pair<Boolean, List<String>> pair = Pair.of(bool, list);
            System.out.println(pair.getLeft());
            System.out.println(pair.getRight());
            System.out.println(pair.getKey());
            System.out.println(pair.getValue());

输出结果：

true
    [key-value]
    true
    [key-value]

注：  
**lists.newarraylist()**

List<Integer> list = new ArrayList<Integer>();
    List<Integer> list = Lists.newArrayList();

Lists.newArrayList() 其实和 new ArrayList() 几乎一模一样, 唯一它帮你做的(其实是javac帮你做的), 就是自动推导(不是"倒")尖括号里的数据类型。Lists是一个工具类，同样的Maps也是一个工具类，同样也可以这么使用。

Map<String,Object> map = Maps.newHashMap();

3.源码  
其有两个子类，分别代表可变与不可变配对：ImmutablePair 和 MutablePair。三者都实现了访问key/value以及setter和getter方法和getLeft()和getRight()方法：

package org.apache.commons.lang3.tuple;
    
    import java.io.Serializable;
    import java.util.Objects;
    import java.util.Map.Entry;
    import org.apache.commons.lang3.builder.CompareToBuilder;
    
    public abstract class Pair<L, R> implements Entry<L, R>, Comparable<Pair<L, R>>, Serializable {
        
        private static final long serialVersionUID = 4954918890077093841L;
    
        public Pair() {
        
        }
        // 默认用的是子类ImmutablePair，
        public static <L, R> Pair<L, R> of(L left, R right) {
        
            return new ImmutablePair(left, right);
        }
        // 定义了抽象方法，目的子类去实现
        public abstract L getLeft();
        // 定义了抽象方法，目的子类去实现
        public abstract R getRight();
        // 这里的获取key其实就是获取getLeft()方法的值
        public final L getKey() {
        
            return this.getLeft();
        }
        // 这里的获取value  其实就是获取getRight()方法的值
        public R getValue() {
        
            return this.getRight();
        }
        // 这里就是比较两个Pair
        public int compareTo(Pair<L, R> other) {
        
            return (new CompareToBuilder()).append(this.getLeft(), other.getLeft()).append(this.getRight(), other.getRight()).toComparison();
        }
    
        public boolean equals(Object obj) {
        
            if (obj == this) {
        
                return true;
            } else if (!(obj instanceof Entry)) {
        
                return false;
            } else {
        
                Entry<?, ?> other = (Entry)obj;
                return Objects.equals(this.getKey(), other.getKey()) && Objects.equals(this.getValue(), other.getValue());
            }
        }
    
        public int hashCode() {
        
            return (this.getKey() == null ? 0 : this.getKey().hashCode()) ^ (this.getValue() == null ? 0 : this.getValue().hashCode());
        }
    
        public String toString() {
        
            return "(" + this.getLeft() + ',' + this.getRight() + ')';
        }
    
        public String toString(String format) {
        
            return String.format(format, this.getLeft(), this.getRight());
        }
    }

Pair类中 getLeft()和getRight()方法是子类去实现的，父类默认采用的是ImmutablePair子类，Pair还实现了Entry<L,R>,可以使用getKey()和getValue()，其实它们都是调用了getLeft()和getRight()方法，继承了Comparable，可以比较两个Pair。继承了Serializable，可以被序列化。

4.其他多元组方法  
Triple类，类定义中abstract class Triple<L, M, R>。定义了3个泛型同样提供了ImmutableTriple和MutableTriple一对不可变和可变的实现类

vavr库，支持Tuple1到Tuple8，八个元组