diff --git a/maven-resolver-util/src/main/java/org/eclipse/aether/util/graph/visitor/NodeListGenerator.java b/maven-resolver-util/src/main/java/org/eclipse/aether/util/graph/visitor/NodeListGenerator.java
index 44c25d062..c4b38c33b 100644
--- a/maven-resolver-util/src/main/java/org/eclipse/aether/util/graph/visitor/NodeListGenerator.java
+++ b/maven-resolver-util/src/main/java/org/eclipse/aether/util/graph/visitor/NodeListGenerator.java
@@ -20,14 +20,15 @@
 
 import java.io.File;
 import java.util.ArrayList;
-import java.util.Iterator;
 import java.util.List;
+import java.util.Objects;
 import java.util.function.Consumer;
 
 import org.eclipse.aether.artifact.Artifact;
 import org.eclipse.aether.graph.Dependency;
 import org.eclipse.aether.graph.DependencyNode;
 
+import static java.util.stream.Collectors.joining;
 import static java.util.stream.Collectors.toList;
 
 /**
@@ -116,51 +117,27 @@ static List<DependencyNode> getNodesWithDependencies(List<DependencyNode> nodes)
     }
 
     static List<Dependency> getDependencies(List<DependencyNode> nodes, boolean includeUnresolved) {
-        List<Dependency> dependencies = new ArrayList<>(nodes.size());
-        for (DependencyNode node : getNodesWithDependencies(nodes)) {
-            Dependency dependency = node.getDependency();
-            if (includeUnresolved || dependency.getArtifact().getFile() != null) {
-                dependencies.add(dependency);
-            }
-        }
-        return dependencies;
+        return getNodesWithDependencies(nodes).stream()
+                .filter(d -> includeUnresolved || d.getArtifact().getFile() != null)
+                .map(DependencyNode::getDependency)
+                .collect(toList());
     }
 
     static List<Artifact> getArtifacts(List<DependencyNode> nodes, boolean includeUnresolved) {
-        List<Artifact> artifacts = new ArrayList<>(nodes.size());
-        for (DependencyNode node : getNodesWithDependencies(nodes)) {
-            Artifact artifact = node.getDependency().getArtifact();
-            if (includeUnresolved || artifact.getFile() != null) {
-                artifacts.add(artifact);
-            }
-        }
-
-        return artifacts;
+        return getNodesWithDependencies(nodes).stream()
+                .map(d -> d.getDependency().getArtifact())
+                .filter(artifact -> includeUnresolved || artifact.getFile() != null)
+                .collect(toList());
     }
 
     static List<File> getFiles(List<DependencyNode> nodes) {
-        List<File> files = new ArrayList<>(nodes.size());
-        for (DependencyNode node : getNodesWithDependencies(nodes)) {
-            File file = node.getDependency().getArtifact().getFile();
-            if (file != null) {
-                files.add(file);
-            }
-        }
-        return files;
+        return getNodesWithDependencies(nodes).stream()
+                .map(d -> d.getDependency().getArtifact().getFile())
+                .filter(Objects::nonNull)
+                .collect(toList());
     }
 
     static String getClassPath(List<DependencyNode> nodes) {
-        StringBuilder buffer = new StringBuilder(1024);
-        for (Iterator<DependencyNode> it = getNodesWithDependencies(nodes).iterator(); it.hasNext(); ) {
-            DependencyNode node = it.next();
-            Artifact artifact = node.getDependency().getArtifact();
-            if (artifact.getFile() != null) {
-                buffer.append(artifact.getFile().getAbsolutePath());
-                if (it.hasNext()) {
-                    buffer.append(File.pathSeparatorChar);
-                }
-            }
-        }
-        return buffer.toString();
+        return getFiles(nodes).stream().map(File::getAbsolutePath).collect(joining(File.pathSeparator));
     }
 }
diff --git a/maven-resolver-util/src/test/java/org/eclipse/aether/util/graph/visitor/NodeListGeneratorTest.java b/maven-resolver-util/src/test/java/org/eclipse/aether/util/graph/visitor/NodeListGeneratorTest.java
index a805968d7..e8f59fec0 100644
--- a/maven-resolver-util/src/test/java/org/eclipse/aether/util/graph/visitor/NodeListGeneratorTest.java
+++ b/maven-resolver-util/src/test/java/org/eclipse/aether/util/graph/visitor/NodeListGeneratorTest.java
@@ -18,9 +18,17 @@
  */
 package org.eclipse.aether.util.graph.visitor;
 
+import java.io.File;
+import java.util.Arrays;
+import java.util.HashSet;
 import java.util.List;
+import java.util.Objects;
+import java.util.Set;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.stream.Collectors;
 
 import org.eclipse.aether.graph.DependencyNode;
+import org.eclipse.aether.graph.DependencyVisitor;
 import org.eclipse.aether.internal.test.util.DependencyGraphParser;
 import org.junit.jupiter.api.Test;
 
@@ -107,4 +115,107 @@ void testLevelOrderDuplicateSuppression() throws Exception {
 
         assertSequence(nodeListGenerator.getNodes(), "a", "b", "d", "c", "e");
     }
+
+    @Test
+    void testEmptyResolvedClassPath() throws Exception {
+        DependencyNode root = parse("simple.txt");
+
+        NodeListGenerator nodeListGenerator = new NodeListGenerator();
+        LevelOrderDependencyNodeConsumerVisitor visitor =
+                new LevelOrderDependencyNodeConsumerVisitor(nodeListGenerator);
+        root.accept(visitor);
+
+        assertEquals(5, nodeListGenerator.getNodes().size());
+        assertEquals(0, nodeListGenerator.getDependencies(false).size());
+        assertEquals(5, nodeListGenerator.getDependencies(true).size());
+        assertEquals(0, nodeListGenerator.getArtifacts(false).size());
+        assertEquals(5, nodeListGenerator.getArtifacts(true).size());
+        assertEquals(0, nodeListGenerator.getFiles().size());
+        assertEquals("", nodeListGenerator.getClassPath());
+    }
+
+    @Test
+    void testFullyResolvedClassPath() throws Exception {
+        DependencyNode root = parse("simple.txt");
+        DependencyVisitor fileSetter = new DependencyVisitor() {
+            @Override
+            public boolean visitEnter(DependencyNode node) {
+                node.setArtifact(node.getArtifact()
+                        .setFile(new File(node.getDependency().getArtifact().getArtifactId())));
+                return true;
+            }
+
+            @Override
+            public boolean visitLeave(DependencyNode node) {
+                return true;
+            }
+        };
+        root.accept(fileSetter);
+
+        NodeListGenerator nodeListGenerator = new NodeListGenerator();
+        LevelOrderDependencyNodeConsumerVisitor visitor =
+                new LevelOrderDependencyNodeConsumerVisitor(nodeListGenerator);
+        root.accept(visitor);
+
+        Set<String> fileNames = nodeListGenerator.getNodes().stream()
+                .map(n -> n.getArtifact().getFile())
+                .filter(Objects::nonNull)
+                .map(File::getName)
+                .collect(Collectors.toSet());
+        String classPath = nodeListGenerator.getClassPath();
+        String[] splitClassPath = classPath.split(File.pathSeparator);
+        Set<String> classPathNames =
+                Arrays.stream(splitClassPath).map(File::new).map(File::getName).collect(Collectors.toSet());
+
+        assertEquals(5, nodeListGenerator.getNodes().size());
+        assertEquals(5, nodeListGenerator.getDependencies(false).size());
+        assertEquals(5, nodeListGenerator.getDependencies(true).size());
+        assertEquals(5, nodeListGenerator.getArtifacts(false).size());
+        assertEquals(5, nodeListGenerator.getArtifacts(true).size());
+        assertEquals(5, nodeListGenerator.getFiles().size());
+        assertEquals(fileNames, classPathNames);
+    }
+
+    @Test
+    void testIncompletelyResolvedEmptyClassPath() throws Exception {
+        DependencyNode root = parse("simple.txt");
+        AtomicBoolean alternator = new AtomicBoolean(false);
+        HashSet<String> fileNames = new HashSet<>();
+        DependencyVisitor fileSetter = new DependencyVisitor() {
+            @Override
+            public boolean visitEnter(DependencyNode node) {
+                alternator.set(!alternator.get());
+                if (alternator.get()) {
+                    String fileName = node.getDependency().getArtifact().getArtifactId();
+                    fileNames.add(fileName);
+                    node.setArtifact(node.getArtifact().setFile(new File(fileName)));
+                }
+                return true;
+            }
+
+            @Override
+            public boolean visitLeave(DependencyNode node) {
+                return true;
+            }
+        };
+        root.accept(fileSetter);
+
+        NodeListGenerator nodeListGenerator = new NodeListGenerator();
+        LevelOrderDependencyNodeConsumerVisitor visitor =
+                new LevelOrderDependencyNodeConsumerVisitor(nodeListGenerator);
+        root.accept(visitor);
+
+        String classPath = nodeListGenerator.getClassPath();
+        String[] splitClassPath = classPath.split(File.pathSeparator);
+        Set<String> classPathNames =
+                Arrays.stream(splitClassPath).map(File::new).map(File::getName).collect(Collectors.toSet());
+
+        assertEquals(5, nodeListGenerator.getNodes().size());
+        assertEquals(3, nodeListGenerator.getDependencies(false).size());
+        assertEquals(5, nodeListGenerator.getDependencies(true).size());
+        assertEquals(3, nodeListGenerator.getArtifacts(false).size());
+        assertEquals(5, nodeListGenerator.getArtifacts(true).size());
+        assertEquals(3, nodeListGenerator.getFiles().size());
+        assertEquals(fileNames, classPathNames);
+    }
 }