N
 Node parameter type@Beta public abstract class AbstractGraph<N> extends Object implements Graph<N>
Graph
. It is recommended to extend this
class rather than implement Graph
directly.Constructor and Description 

AbstractGraph() 
Modifier and Type  Method and Description 

int 
degree(N node)
Returns the count of
node 's incident edges, counting selfloops twice (equivalently,
the number of times an edge touches node ). 
protected long 
edgeCount()
Returns the number of edges in this graph; used to calculate the size of
edges() . 
Set<EndpointPair<N>> 
edges()

boolean 
equals(@Nullable Object obj)
Returns
true iff object is a Graph that has the same elements and the
same structural relationships as those in this graph. 
boolean 
hasEdgeConnecting(EndpointPair<N> endpoints)
Returns true if there is an edge that directly connects
endpoints (in the order, if
any, specified by endpoints ). 
boolean 
hasEdgeConnecting(N nodeU,
N nodeV)
Returns true if there is an edge that directly connects
nodeU to nodeV . 
int 
hashCode()
Returns the hash code for this graph.

Set<EndpointPair<N>> 
incidentEdges(N node)
Returns the edges in this graph whose endpoints include
node . 
int 
inDegree(N node)
Returns the count of
node 's incoming edges (equal to predecessors(node).size() )
in a directed graph. 
protected boolean 
isOrderingCompatible(EndpointPair<?> endpoints) 
int 
outDegree(N node)
Returns the count of
node 's outgoing edges (equal to successors(node).size() )
in a directed graph. 
String 
toString()
Returns a string representation of this graph.

protected void 
validateEndpoints(EndpointPair<?> endpoints)
Throws
IllegalArgumentException if the ordering of endpoints is not compatible
with the directionality of this graph. 
clone, finalize, getClass, notify, notifyAll, wait, wait, wait
adjacentNodes, allowsSelfLoops, degree, edges, hasEdgeConnecting, hasEdgeConnecting, incidentEdges, inDegree, isDirected, nodeOrder, nodes, outDegree, predecessors, successors
public AbstractGraph()
public final boolean equals(@Nullable Object obj)
Graph
true
iff object
is a Graph
that has the same elements and the
same structural relationships as those in this graph.
Thus, two graphs A and B are equal if all of the following are true:
directedness
.
node sets
.
edge sets
.
Graph properties besides directedness
do not affect equality.
For example, two graphs may be considered equal even if one allows selfloops and the other
doesn't. Additionally, the order in which nodes or edges are added to the graph, and the order
in which they are iterated over, are irrelevant.
A reference implementation of this is provided by equals(Object)
.
public final int hashCode()
Graph
Graph.edges()
.
A reference implementation of this is provided by hashCode()
.
protected long edgeCount()
edges()
. This
implementation requires O(N) time. Classes extending this one may manually keep track of the
number of edges as the graph is updated, and override this method for better performance.public Set<EndpointPair<N>> edges()
public Set<EndpointPair<N>> incidentEdges(N node)
node
.
This is equal to the union of incoming and outgoing edges.
public int degree(N node)
node
's incident edges, counting selfloops twice (equivalently,
the number of times an edge touches node
).
For directed graphs, this is equal to inDegree(node) + outDegree(node)
.
For undirected graphs, this is equal to incidentEdges(node).size()
+ (number of
selfloops incident to node
).
If the count is greater than Integer.MAX_VALUE
, returns Integer.MAX_VALUE
.
public int inDegree(N node)
node
's incoming edges (equal to predecessors(node).size()
)
in a directed graph. In an undirected graph, returns the degree(Object)
.
If the count is greater than Integer.MAX_VALUE
, returns Integer.MAX_VALUE
.
public int outDegree(N node)
node
's outgoing edges (equal to successors(node).size()
)
in a directed graph. In an undirected graph, returns the degree(Object)
.
If the count is greater than Integer.MAX_VALUE
, returns Integer.MAX_VALUE
.
public boolean hasEdgeConnecting(N nodeU, N nodeV)
nodeU
to nodeV
. This is
equivalent to nodes().contains(nodeU) && successors(nodeU).contains(nodeV)
.
In an undirected graph, this is equal to hasEdgeConnecting(nodeV, nodeU)
.
public boolean hasEdgeConnecting(EndpointPair<N> endpoints)
endpoints
(in the order, if
any, specified by endpoints
). This is equivalent to edges().contains(endpoints)
.
Unlike the other EndpointPair
accepting methods, this method does not throw if the
endpoints are unordered; it simply returns false. This is for consistency with the behavior of
Collection#contains(Object)
(which does not generally throw if the object cannot be
present in the collection), and the desire to have this method's behavior be compatible with
edges().contains(endpoints)
.
protected final void validateEndpoints(EndpointPair<?> endpoints)
IllegalArgumentException
if the ordering of endpoints
is not compatible
with the directionality of this graph.protected final boolean isOrderingCompatible(EndpointPair<?> endpoints)
Copyright © 2010–2019. All rights reserved.