Revised all jgrapht.org.alg.* classes and corresponding test classes. All classes in jgrapht should now be ready for the next java 8 release

Author: jkinable

jgrapht-core/src/main/java/org/jgrapht/alg/AStarShortestPath.java

@@ -106,11 +106,11 @@ public AStarShortestPath(Graph<V, E> graph)
     private void initialize(AStarAdmissibleHeuristic<V> admissibleHeuristic)
     {
         this.admissibleHeuristic = admissibleHeuristic;
-        openList = new FibonacciHeap<V>();
-        vertexToHeapNodeMap = new HashMap<V, FibonacciHeapNode<V>>();
-        closedList = new HashSet<V>();
-        gScoreMap = new HashMap<V, Double>();
-        cameFrom = new HashMap<V, E>();
+        openList = new FibonacciHeap<>();
+        vertexToHeapNodeMap = new HashMap<>();
+        closedList = new HashSet<>();
+        gScoreMap = new HashMap<>();
+        cameFrom = new HashMap<>();
         numberOfExpandedNodes = 0;
     }
 
@@ -140,7 +140,7 @@ public GraphPath<V, E> getShortestPath(
 
         this.initialize(admissibleHeuristic);
         gScoreMap.put(sourceVertex, 0.0);
-        FibonacciHeapNode<V> heapNode = new FibonacciHeapNode<V>(sourceVertex);
+        FibonacciHeapNode<V> heapNode = new FibonacciHeapNode<>(sourceVertex);
         openList.insert(heapNode, 0.0);
         vertexToHeapNodeMap.put(sourceVertex, heapNode);
 
@@ -174,7 +174,7 @@ private void expandNode(FibonacciHeapNode<V> currentNode, V endVertex)
             outgoingEdges = graph.edgesOf(currentNode.getData());
         } else if (graph instanceof DirectedGraph) {
             outgoingEdges =
-                ((DirectedGraph) graph).outgoingEdgesOf(currentNode.getData());
+                ((DirectedGraph<V,E>) graph).outgoingEdgesOf(currentNode.getData());
         }
 
         for (E edge : outgoingEdges) {
@@ -200,7 +200,7 @@ private void expandNode(FibonacciHeapNode<V> currentNode, V endVertex)
                     + admissibleHeuristic.getCostEstimate(successor, endVertex);
                 if (!vertexToHeapNodeMap.containsKey(successor)) {
                     FibonacciHeapNode<V> heapNode =
-                        new FibonacciHeapNode<V>(successor);
+                            new FibonacciHeapNode<>(successor);
                     openList.insert(heapNode, fScore);
                     vertexToHeapNodeMap.put(successor, heapNode);
                 } else {
@@ -227,12 +227,12 @@ private GraphPath<V, E> buildGraphPath(
         double pathLength)
     {
         List<E> edgeList = this.buildPath(targetVertex);
-        return new GraphPathImpl<V, E>(
-            graph,
-            startVertex,
-            targetVertex,
-            edgeList,
-            pathLength);
+        return new GraphPathImpl<>(
+                graph,
+                startVertex,
+                targetVertex,
+                edgeList,
+                pathLength);
     }
 
     /**
@@ -256,7 +256,7 @@ private List<E> buildPath(V currentNode)
             path.add(cameFrom.get(currentNode));
             return path;
         } else {
-            return new ArrayList<E>();
+            return new ArrayList<>();
         }
     }
 

jgrapht-core/src/main/java/org/jgrapht/alg/AbstractPathElement.java

@@ -134,7 +134,7 @@ protected AbstractPathElement(V vertex)
      */
     public List<E> createEdgeListPath()
     {
-        List<E> path = new ArrayList<E>();
+        List<E> path = new ArrayList<>();
         AbstractPathElement<V, E> pathElement = this;
 
         // while start vertex is not reached.

jgrapht-core/src/main/java/org/jgrapht/alg/AbstractPathElementList.java

@@ -63,7 +63,7 @@ abstract class AbstractPathElementList<V,
     /**
      * Stored paths, list of <code>AbstractPathElement</code>.
      */
-    protected ArrayList<T> pathElements = new ArrayList<T>();
+    protected ArrayList<T> pathElements = new ArrayList<>();
 
     /**
      * Target vertex of the paths.

jgrapht-core/src/main/java/org/jgrapht/alg/AllDirectedPaths.java

@@ -120,23 +120,21 @@ public List<GraphPath<V, E>> getAllPaths(
         }
 
         if ((sourceVertices.isEmpty()) || (targetVertices.isEmpty())) {
-            return new ArrayList();
+            return Collections.emptyList();
         }
 
         // Decorate the edges with the minimum path lengths through them
         Map<E, Integer> edgeMinDistancesFromTargets =
             edgeMinDistancesBackwards(targetVertices, maxPathLength);
 
         // Generate all the paths
-        List<GraphPath<V, E>> allPaths =
-            generatePaths(
-                sourceVertices,
-                targetVertices,
-                simplePathsOnly,
-                maxPathLength,
-                edgeMinDistancesFromTargets);
-
-        return allPaths;
+
+        return generatePaths(
+            sourceVertices,
+            targetVertices,
+            simplePathsOnly,
+            maxPathLength,
+            edgeMinDistancesFromTargets);
     }
 
     /**
@@ -159,9 +157,9 @@ private Map<E, Integer> edgeMinDistancesBackwards(
          * vertices, marking edges and vertices with their minimum
          * distances as we go.
          */
-        Map<E, Integer> edgeMinDistances = new HashMap();
-        Map<V, Integer> vertexMinDistances = new HashMap();
-        Queue<V> verticesToProcess = new LinkedList();
+        Map<E, Integer> edgeMinDistances = new HashMap<>();
+        Map<V, Integer> vertexMinDistances = new HashMap<>();
+        Queue<V> verticesToProcess = new LinkedList<>();
 
         // Input sanity checking
         if (maxPathLength != null) {
@@ -245,8 +243,8 @@ private List<GraphPath<V, E>> generatePaths(
          * vertices, exploring all outgoing edges whose minimum
          * distances is small enough.
          */
-        List<GraphPath<V, E>> completePaths = new ArrayList();
-        Deque<List<E>> incompletePaths = new LinkedList();
+        List<GraphPath<V, E>> completePaths = new ArrayList<>();
+        Deque<List<E>> incompletePaths = new LinkedList<>();
 
         // Input sanity checking
         if (maxPathLength != null) {
@@ -265,7 +263,7 @@ private List<GraphPath<V, E>> generatePaths(
                 assert graph.getEdgeSource(edge).equals(source);
 
                 if (edgeMinDistancesFromTargets.containsKey(edge)) {
-                    List<E> path = Arrays.asList(edge);
+                    List<E> path = Collections.singletonList(edge);
                     incompletePaths.add(path);
                 }
             }
@@ -282,7 +280,7 @@ private List<GraphPath<V, E>> generatePaths(
             E leafEdge = incompletePath.get(lengthSoFar - 1);
             V leafNode = graph.getEdgeTarget(leafEdge);
 
-            Set<V> pathVertices = new HashSet();
+            Set<V> pathVertices = new HashSet<>();
             for (E pathEdge : incompletePath) {
                 pathVertices.add(graph.getEdgeSource(pathEdge));
                 pathVertices.add(graph.getEdgeTarget(pathEdge));
@@ -296,7 +294,7 @@ private List<GraphPath<V, E>> generatePaths(
                         || ((edgeMinDistancesFromTargets.get(outEdge)
                                 + lengthSoFar) <= maxPathLength)))
                 {
-                    List<E> newPath = new ArrayList(incompletePath);
+                    List<E> newPath = new ArrayList<>(incompletePath);
                     newPath.add(outEdge);
 
                     // If requested, make sure this path isn't self-intersecting
@@ -349,7 +347,7 @@ private GraphPath<V, E> makePath(List<E> edges)
         V source = graph.getEdgeSource(edges.get(0));
         V target = graph.getEdgeTarget(edges.get(edges.size() - 1));
         double weight = edges.size();
-        return new GraphPathImpl<V, E>(graph, source, target, edges, weight);
+        return new GraphPathImpl<>(graph, source, target, edges, weight);
     }
 }
 

jgrapht-core/src/main/java/org/jgrapht/alg/BellmanFordIterator.java

@@ -70,7 +70,7 @@ class BellmanFordIterator<V, E>
      * Vertices whose shortest path cost have been improved during the previous
      * pass.
      */
-    private List<V> prevImprovedVertices = new ArrayList<V>();
+    private List<V> prevImprovedVertices = new ArrayList<>();
 
     private Map<V, BellmanFordPathElement<V, E>> prevVertexData;
 
@@ -140,7 +140,7 @@ public BellmanFordPathElement<V, E> getPathElement(V endVertex)
         }
 
         if (hasNext()) {
-            List<V> improvedVertices = new ArrayList<V>();
+            List<V> improvedVertices = new ArrayList<>();
             for (int i = this.prevImprovedVertices.size() - 1; i >= 0; i--) {
                 V vertex = this.prevImprovedVertices.get(i);
                 for (
@@ -297,7 +297,7 @@ protected BellmanFordPathElement<V, E> putPrevSeenData(
     {
         if (this.prevVertexData == null) {
             this.prevVertexData =
-                new HashMap<V, BellmanFordPathElement<V, E>>();
+                    new HashMap<>();
         }
 
         return this.prevVertexData.put(vertex, data);
@@ -318,7 +318,7 @@ protected BellmanFordPathElement<V, E> putSeenData(
         BellmanFordPathElement<V, E> data)
     {
         if (this.vertexData == null) {
-            this.vertexData = new HashMap<V, BellmanFordPathElement<V, E>>();
+            this.vertexData = new HashMap<>();
         }
 
         return this.vertexData.put(vertex, data);
@@ -350,23 +350,20 @@ private BellmanFordPathElement<V, E> createSeenData(
             getPrevSeenData(
                 Graphs.getOppositeVertex(graph, edge, vertex));
 
-        BellmanFordPathElement<V, E> data =
-            new BellmanFordPathElement<V, E>(
+        return new BellmanFordPathElement<>(
                 graph,
                 prevPathElement,
                 edge,
                 cost,
                 epsilon);
-
-        return data;
     }
 
     private void encounterStartVertex()
     {
         BellmanFordPathElement<V, E> data =
-            new BellmanFordPathElement<V, E>(
-                this.startVertex,
-                epsilon);
+                new BellmanFordPathElement<>(
+                        this.startVertex,
+                        epsilon);
 
         // first the only vertex considered as improved is the start vertex.
         this.prevImprovedVertices.add(this.startVertex);
@@ -426,7 +423,7 @@ private void savePassData(List<V> improvedVertices)
         for (V vertex : improvedVertices) {
             BellmanFordPathElement<V, E> orig = getSeenData(vertex);
             BellmanFordPathElement<V, E> clonedData =
-                new BellmanFordPathElement<V, E>(orig);
+                    new BellmanFordPathElement<>(orig);
             putPrevSeenData(vertex, clonedData);
         }
 

jgrapht-core/src/main/java/org/jgrapht/alg/BellmanFordShortestPath.java

@@ -183,10 +183,10 @@ private void lazyCalculate()
     {
         if (this.iter == null) {
             this.iter =
-                new BellmanFordIterator<V, E>(
-                    this.graph,
-                    this.startVertex,
-                    epsilon);
+                    new BellmanFordIterator<>(
+                            this.graph,
+                            this.startVertex,
+                            epsilon);
         }
 
         // at the i-th pass the shortest paths with less (or equal) than i edges
@@ -217,9 +217,9 @@ public static <V, E> List<E> findPathBetween(
         V endVertex)
     {
         BellmanFordShortestPath<V, E> alg =
-            new BellmanFordShortestPath<V, E>(
-                graph,
-                startVertex);
+                new BellmanFordShortestPath<>(
+                        graph,
+                        startVertex);
 
         return alg.getPathEdgeList(endVertex);
     }

jgrapht-core/src/main/java/org/jgrapht/alg/BiconnectivityInspector.java

@@ -60,21 +60,16 @@ public class BiconnectivityInspector<V, E>
     public BiconnectivityInspector(UndirectedGraph<V, E> graph)
     {
         super();
-        this.blockCutpointGraph = new BlockCutpointGraph<V, E>(graph);
+        this.blockCutpointGraph = new BlockCutpointGraph<>(graph);
     }
 
     /**
      * Returns the biconnected vertex-components of the graph.
      */
     public Set<Set<V>> getBiconnectedVertexComponents()
     {
-        Set<Set<V>> biconnectedVertexComponents = new HashSet<Set<V>>();
-        for (
-            Iterator<UndirectedGraph<V, E>> iter =
-                this.blockCutpointGraph.vertexSet().iterator();
-            iter.hasNext();)
-        {
-            UndirectedGraph<V, E> subgraph = iter.next();
+        Set<Set<V>> biconnectedVertexComponents = new HashSet<>();
+        for (UndirectedGraph<V, E> subgraph : this.blockCutpointGraph.vertexSet()) {
             if (!subgraph.edgeSet().isEmpty()) {
                 biconnectedVertexComponents.add(subgraph.vertexSet());
             }
@@ -95,12 +90,8 @@ public Set<Set<V>> getBiconnectedVertexComponents()
      */
     public Set<Set<V>> getBiconnectedVertexComponents(V vertex)
     {
-        Set<Set<V>> vertexComponents = new HashSet<Set<V>>();
-        for (
-            Iterator<Set<V>> iter = getBiconnectedVertexComponents().iterator();
-            iter.hasNext();)
-        {
-            Set<V> vertexComponent = iter.next();
+        Set<Set<V>> vertexComponents = new HashSet<>();
+        for (Set<V> vertexComponent : getBiconnectedVertexComponents()) {
             if (vertexComponent.contains(vertex)) {
                 vertexComponents.add(vertexComponent);
             }