JAVA Key=Key模型（一对一双向唯一）

闲的无聊，自己琢磨了下一对一双向唯一的简易结构，很简单的东西，自己记录下，说不定以后有用。
代码如下：

（一） 定义接口

public interface OTO<K1,K2> {

    /** 得到数据大小 */
    int size();

    /** 判断是否为空 */
    boolean isEmpty();

    /** 判断是否存在key，双向判断 */
    boolean contains(Object key);

    /** 判断 K1 是否存在key */
    boolean containsKey1(K1 key);

    /** 判断 K2是否存在key */
    boolean containsKey2(K2 key);

    /** 通过key（K1或者K2）得到值 */
    Object get(Object key);

    /** 通过K1得到K2值 */
    K2 getK2(K1 key);

    /** 通过K2得到K1值 */
    K1 getK1(K2 key);

    /** 添加数据 */
    void put(K1 k1, K2 k2);

    /** 添加数据，如果数据重复将覆盖 */
    void putWithExist(K1 k1, K2 k2);

    /** 添加多个数据 */
    void putAll(OTO<? extends K1,? extends K2> oto);

    /** 通过key（K1或K2）删除对象 */
    void remove(Object key);

    /** 通过K1删除对象 */
    void removeByKey1(K1 k1);

    /** 通过K2删除对象 */
    void removeByKey2(K2 k2);

    /** 清空数据 */
    void clear();

    /** 重写toString */
    String toString();

    /** 得到遍历对象Iterator */
    Iterator</*? extends */K1,/*? extends*/ K2> getIterator();

    /** 遍历对象Iterator，内部借口 */
    interface Iterator<K1,K2> {

        /** 是否存在下一个对象 */
        boolean hasNext();

        /** 跳到下一个对象 */
        int next();

        /** 跳到index的下一个对象 */
        int next(int index);

        /** 得到K1 */
        K1 getK1();

        /** 得到K2 */
        K2 getK2();

        /** 得到当前遍历的位置 */
        int getIndex();

        /** 设置遍历位置 */
        void setIndex(int index);

        /** 重写hashCode */
        int hashCode();
    }
}

（二）接口实现

import java.util.ArrayList;
import java.util.Objects;

public class OTOTable<K1,K2> implements OTO<K1,K2> {

    private ArrayList<K1> key_1 = null;
    private ArrayList<K2> key_2 = null;

    public OTOTable2() {
        this.key_1 = new ArrayList<K1>();
        this.key_2 = new ArrayList<K2>();
    }

    @Override
    public int size() {
        return key_1.size();
    }

    @Override
    public boolean isEmpty() {
        if(key_1.size() == 0){
            return true;
        }
        return false;
    }

    @SuppressWarnings("unchecked")
    @Override
    public boolean contains(Object key) {
        if(containsKey1((K1)key) || containsKey2((K2)key)) {
            return true;
        }
        return false;
    }

    @Override
    public boolean containsKey1(K1 key) {
        boolean flag = false;
        for (int i = 0; i < key_1.size(); i++) {
            if(key_1.get(i).equals(key)){
                flag = true;
            }
        }
        return flag;
    }

    @Override
    public boolean contains