Java双哈希集泛型问题

作为我现在已结束的问题的后续行动：。我已经实现了对我所描述的数据结构的非常简单的解释

以下是上一个问题的视觉辅助：

输出：

Set<Object> set1 = s.get("C", RIGHT);
Set<Object> set2 = s.get(1, LEFT);

[2, 3, 4]
[A, B]

我认为这些方法签名是不同的

---

代码 DoublyHashSet.java

package Graph;

import java.util.Set;

public class DoublyHashSet<T, U> {
    public static final int LEFT = 0;
    public static final int RIGHT = 1;
    private NodeSet<T, U> leftSet;
    private NodeSet<U, T> rightSet;
    
    public DoublyHashSet() {
        leftSet  = new NodeSet<>();
        rightSet = new NodeSet<>();
        
        leftSet.setCompliment(rightSet);
        rightSet.setCompliment(leftSet);
    }

    public void add(T t, U u) {
        leftSet.add(t, u);
        rightSet.add(u, t);
    }
    
    public Set<Object> get(Object o, int side) {
        boolean value = (side & 1) == 0;
        
        if (value) {
            return (Set<Object>) leftSet.get((T) o);
        } else {
            return (Set<Object>) rightSet.get((U) o);
        }
    }
    
    public static void main(String[] args) {
        DoublyHashSet<Integer, String> s = new DoublyHashSet<Integer, String>();
        
        s.add(1, "A");
        s.add(1, "B");
        s.add(2, "A");
        s.add(2, "C");
        s.add(2, "D");
        s.add(3, "C");
        s.add(4, "C");
        
        Set<Object> set1 = s.get("C", RIGHT);
        Set<Object> set2 = s.get(1, LEFT);
        
        System.out.println(set1);
        System.out.println(set2);
    }
}

package Graph;

import java.util.HashSet;
import java.util.Set;

public class NodeSet<T, U> extends HashSet<Node<T, U>> {
    private static final long serialVersionUID = 1L;
    private NodeSet<U, T> compliment;

    public NodeSet() {
        this(null);
    }

    public NodeSet(NodeSet<U, T> compliment) {
        super();

        this.compliment = compliment;
    }

    public NodeSet<U, T> getCompliment() {
        return compliment;
    }

    public void setCompliment(NodeSet<U, T> compliment) {
        this.compliment = compliment;
    }

    public Node<T, U> find(T data) {
        for (Node<T, U> node : this) {
            if (node.getData() == data) {
                return node;
            }
        }

        return null;
    }

    public void add(T t, U u) {
        Node<T, U> tNode = find(t);
        Node<U, T> uNode = null;

        if (tNode == null) {
            tNode = new Node<T, U>(t);
        }

        if (compliment != null) {
            uNode = compliment.find(u);

            if (uNode == null) {
                uNode = new Node<U, T>(u);
            }
        }

        tNode.getConnections().add(uNode);
        this.add(tNode);
    }

    public Set<U> get(T t) {
        Set<U> set = null;
        Node<T, U> node = find(t);

        if (node != null) {
            set = new HashSet<U>();
            for (Node<U, T> connection : node.getConnections()) {
                if (connection != null)
                    set.add(connection.getData());
            }
        }

        return set;
    }
}

package Graph;

import java.util.HashSet;
import java.util.Set;

public class Node<T, U> implements Comparable<Node<T, U>> {
    private T data;
    private Set<Node<U, T>> connections;

    public Node() {
        this(null);
    }

    public Node(T data) {
        this(data, new HashSet<Node<U, T>>());
    }
    
    public Node(T data, Set<Node<U, T>> connections) {
        this.data = data;
        this.connections = connections;
    }
    
    public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }

    public Set<Node<U, T>> getConnections() {
        return connections;
    }

    public void setConnections(Set<Node<U, T>> connections) {
        this.connections = connections;
    }

    @Override
    public int compareTo(Node<T, U> other) {
        return this.getData().toString().compareTo(other.getData().toString());
    }

    @Override
    public String toString() {
        return "Node [data=" + data + "]";
    }
}

包图；
导入java.util.Set；
公共类双哈希集{
公共静态final int LEFT=0；
公共静态最终整数右=1；
私有节点集左集；
私有节点集权利集；
公共双盲组（）{
leftSet=新节点集（）；
rightSet=新节点集（）；
leftSet.set恭维（righset）；
设置恭维（leftSet）；
}
公共无效添加（T，U）{
leftSet.add（t，u）；
加上（u，t）；
}
公共集get（对象o，int侧）{
布尔值=（边和1）==0；
如果（值）{
return（Set）leftSet.get（（T）o）；
}否则{
return（Set）rightSet.get（（U）o）；
}
}
公共静态void main（字符串[]args）{
DoublyHashSet s=新的DoublyHashSet（）；
s、 添加（1，“A”）；
s、 添加（1，“B”）；
s、 添加（2，“A”）；
s、 添加（2，“C”）；
s、 添加（2，“D”）；
s、 添加（3，“C”）；
s、 添加（4，“C”）；
设置set1=s.get（“C”，右）；
Set set2=s.get（1，左）；
系统输出打印项次（set1）；
系统输出打印项次（set2）；
}
}

NodeSet.java

package Graph;

import java.util.Set;

public class DoublyHashSet<T, U> {
    public static final int LEFT = 0;
    public static final int RIGHT = 1;
    private NodeSet<T, U> leftSet;
    private NodeSet<U, T> rightSet;
    
    public DoublyHashSet() {
        leftSet  = new NodeSet<>();
        rightSet = new NodeSet<>();
        
        leftSet.setCompliment(rightSet);
        rightSet.setCompliment(leftSet);
    }

    public void add(T t, U u) {
        leftSet.add(t, u);
        rightSet.add(u, t);
    }
    
    public Set<Object> get(Object o, int side) {
        boolean value = (side & 1) == 0;
        
        if (value) {
            return (Set<Object>) leftSet.get((T) o);
        } else {
            return (Set<Object>) rightSet.get((U) o);
        }
    }
    
    public static void main(String[] args) {
        DoublyHashSet<Integer, String> s = new DoublyHashSet<Integer, String>();
        
        s.add(1, "A");
        s.add(1, "B");
        s.add(2, "A");
        s.add(2, "C");
        s.add(2, "D");
        s.add(3, "C");
        s.add(4, "C");
        
        Set<Object> set1 = s.get("C", RIGHT);
        Set<Object> set2 = s.get(1, LEFT);
        
        System.out.println(set1);
        System.out.println(set2);
    }
}

package Graph;

import java.util.HashSet;
import java.util.Set;

public class NodeSet<T, U> extends HashSet<Node<T, U>> {
    private static final long serialVersionUID = 1L;
    private NodeSet<U, T> compliment;

    public NodeSet() {
        this(null);
    }

    public NodeSet(NodeSet<U, T> compliment) {
        super();

        this.compliment = compliment;
    }

    public NodeSet<U, T> getCompliment() {
        return compliment;
    }

    public void setCompliment(NodeSet<U, T> compliment) {
        this.compliment = compliment;
    }

    public Node<T, U> find(T data) {
        for (Node<T, U> node : this) {
            if (node.getData() == data) {
                return node;
            }
        }

        return null;
    }

    public void add(T t, U u) {
        Node<T, U> tNode = find(t);
        Node<U, T> uNode = null;

        if (tNode == null) {
            tNode = new Node<T, U>(t);
        }

        if (compliment != null) {
            uNode = compliment.find(u);

            if (uNode == null) {
                uNode = new Node<U, T>(u);
            }
        }

        tNode.getConnections().add(uNode);
        this.add(tNode);
    }

    public Set<U> get(T t) {
        Set<U> set = null;
        Node<T, U> node = find(t);

        if (node != null) {
            set = new HashSet<U>();
            for (Node<U, T> connection : node.getConnections()) {
                if (connection != null)
                    set.add(connection.getData());
            }
        }

        return set;
    }
}

package Graph;

import java.util.HashSet;
import java.util.Set;

public class Node<T, U> implements Comparable<Node<T, U>> {
    private T data;
    private Set<Node<U, T>> connections;

    public Node() {
        this(null);
    }

    public Node(T data) {
        this(data, new HashSet<Node<U, T>>());
    }
    
    public Node(T data, Set<Node<U, T>> connections) {
        this.data = data;
        this.connections = connections;
    }
    
    public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }

    public Set<Node<U, T>> getConnections() {
        return connections;
    }

    public void setConnections(Set<Node<U, T>> connections) {
        this.connections = connections;
    }

    @Override
    public int compareTo(Node<T, U> other) {
        return this.getData().toString().compareTo(other.getData().toString());
    }

    @Override
    public String toString() {
        return "Node [data=" + data + "]";
    }
}

包图；
导入java.util.HashSet；
导入java.util.Set；
公共类节点集扩展哈希集{
私有静态最终长serialVersionUID=1L；
私人点头称赞；
公共节点集（）{
这个（空）；
}
公共节点集（节点集赞美）{
超级（）；
这个。恭维=恭维；
}
公共节点集get恭维（）{
回敬赞美；
}
公共无效设置恭维（NodeSet恭维）{
这个。恭维=恭维；
}
公共节点查找（T数据）{
for（节点：此）{
if（node.getData（）==data）{
返回节点；
}
}
返回null；
}
公共无效添加（T，U）{
节点tNode=find（t）；
Node uNode=null；
if（tNode==null）{
t节点=新节点（t）；
}
if（恭维！=null）{
uNode=赞美。查找（u）；
如果（uNode==null）{
uNode=新节点（u）；
}
}
tNode.getConnections（）.add（uNode）；
添加（tNode）；
}
公共集get（T）{
Set=null；
Node=find（t）；
如果（节点！=null）{
set=新的HashSet（）；
对于（节点连接：Node.getConnections（））{
if（连接！=null）
set.add（connection.getData（））；
}
}
返回集；
}
}

Node.java

package Graph;

import java.util.Set;

public class DoublyHashSet<T, U> {
    public static final int LEFT = 0;
    public static final int RIGHT = 1;
    private NodeSet<T, U> leftSet;
    private NodeSet<U, T> rightSet;
    
    public DoublyHashSet() {
        leftSet  = new NodeSet<>();
        rightSet = new NodeSet<>();
        
        leftSet.setCompliment(rightSet);
        rightSet.setCompliment(leftSet);
    }

    public void add(T t, U u) {
        leftSet.add(t, u);
        rightSet.add(u, t);
    }
    
    public Set<Object> get(Object o, int side) {
        boolean value = (side & 1) == 0;
        
        if (value) {
            return (Set<Object>) leftSet.get((T) o);
        } else {
            return (Set<Object>) rightSet.get((U) o);
        }
    }
    
    public static void main(String[] args) {
        DoublyHashSet<Integer, String> s = new DoublyHashSet<Integer, String>();
        
        s.add(1, "A");
        s.add(1, "B");
        s.add(2, "A");
        s.add(2, "C");
        s.add(2, "D");
        s.add(3, "C");
        s.add(4, "C");
        
        Set<Object> set1 = s.get("C", RIGHT);
        Set<Object> set2 = s.get(1, LEFT);
        
        System.out.println(set1);
        System.out.println(set2);
    }
}

package Graph;

import java.util.HashSet;
import java.util.Set;

public class NodeSet<T, U> extends HashSet<Node<T, U>> {
    private static final long serialVersionUID = 1L;
    private NodeSet<U, T> compliment;

    public NodeSet() {
        this(null);
    }

    public NodeSet(NodeSet<U, T> compliment) {
        super();

        this.compliment = compliment;
    }

    public NodeSet<U, T> getCompliment() {
        return compliment;
    }

    public void setCompliment(NodeSet<U, T> compliment) {
        this.compliment = compliment;
    }

    public Node<T, U> find(T data) {
        for (Node<T, U> node : this) {
            if (node.getData() == data) {
                return node;
            }
        }

        return null;
    }

    public void add(T t, U u) {
        Node<T, U> tNode = find(t);
        Node<U, T> uNode = null;

        if (tNode == null) {
            tNode = new Node<T, U>(t);
        }

        if (compliment != null) {
            uNode = compliment.find(u);

            if (uNode == null) {
                uNode = new Node<U, T>(u);
            }
        }

        tNode.getConnections().add(uNode);
        this.add(tNode);
    }

    public Set<U> get(T t) {
        Set<U> set = null;
        Node<T, U> node = find(t);

        if (node != null) {
            set = new HashSet<U>();
            for (Node<U, T> connection : node.getConnections()) {
                if (connection != null)
                    set.add(connection.getData());
            }
        }

        return set;
    }
}

package Graph;

import java.util.HashSet;
import java.util.Set;

public class Node<T, U> implements Comparable<Node<T, U>> {
    private T data;
    private Set<Node<U, T>> connections;

    public Node() {
        this(null);
    }

    public Node(T data) {
        this(data, new HashSet<Node<U, T>>());
    }
    
    public Node(T data, Set<Node<U, T>> connections) {
        this.data = data;
        this.connections = connections;
    }
    
    public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }

    public Set<Node<U, T>> getConnections() {
        return connections;
    }

    public void setConnections(Set<Node<U, T>> connections) {
        this.connections = connections;
    }

    @Override
    public int compareTo(Node<T, U> other) {
        return this.getData().toString().compareTo(other.getData().toString());
    }

    @Override
    public String toString() {
        return "Node [data=" + data + "]";
    }
}

包图；
导入java.util.HashSet；
导入java.util.Set；
公共类节点实现了可比较的{
私有T数据；
专用集连接；
公共节点（）{
这个（空）；
}
公共节点（T数据）{
这个（数据，新的HashSet（））；
}
公共节点（T数据，设置连接）{
这个数据=数据；
这个。连接=连接；
}
公共T getData（）{
返回数据；
}
公共无效设置数据（T数据）{
这个数据=数据；
}
公共集getConnections（）{
返回连接；
}
公共无效设置连接（设置连接）{
这个。连接=连接；
}
@凌驾
公共整数比较（节点其他）{
返回此.getData（）.toString（）.compareTo（其他.getData（）.toString（））；
}
@凌驾
公共字符串toString（）{
返回“节点[data=“+data+”]”；
}
}

你不能。使用不同的方法名，我知道我可以写：

publicsetgettype1（T）{returnleftset.get（T）；}

和

publicsetgettype2（U）{returnrighset.get（U）；}

，现在我看到了，如果类型相同，那么这可能会导致检查哪个集合的问题？