Java函数式编程中递归式数据遍历的技巧

java 函数式编程中递归式数据遍历的技巧：linkedlist 的递归遍历：使用 stream.iterate() 创建无限流并使用 foreach() 遍历。tree 的递归遍历：使用 optional.ifpresent() 进行递归遍历，遍历节点及其子节点。实战案例：解析 json 数据，使用递归遍历提取嵌套对象中的子项名称。

Java 函数式编程中递归式数据遍历的技巧

函数式编程提供了处理递归数据结构的强大工具，例如链表和树。递归遍历这些结构涉及以递归方式分解数据，并在每个子部分上操作。

LinkedList 的递归遍历

Stream.iterate() 方法可以创建无限流，并使用 forEach() 方法对其进行操作。该示例展示了如何遍历并打印链表：

class Node {
    int data;
    Node next;
}

public class LinkedListTraversal {
    public static void main(String[] args) {
        // 创建链表
        Node head = new Node();
        head.data = 1;
        head.next = new Node();
        head.next.data = 2;
        head.next.next = new Node();
        head.next.next.data = 3;

        // 递归遍历链表
        Stream.iterate(head, Node::getNext) // 创建无限流
                .forEach(node -> System.out.println(node.data)); // 遍历流并打印数据
    }
}

Tree 的递归遍历

树结构可以表示为嵌套对象，其中每个节点包含对子节点的引用。使用 Optional.ifPresent() 进行递归遍历的示例如下：

class TreeNode {
    int data;
    List<TreeNode> children;
}

public class TreeTraversal {
    public static void main(String[] args) {
        // 创建树
        TreeNode root = new TreeNode();
        root.data = 1;
        root.children = List.of(
                new TreeNode(2),
                new TreeNode(3),
                new TreeNode(4)
        );
        root.children.get(0).children = List.of(new TreeNode(5));
        root.children.get(2).children = List.of(new TreeNode(6));

        // 递归遍历树
        traverse(root);
    }

    private static void traverse(TreeNode node) {
        if (node == null) return;
        System.out.println(node.data);
        for (TreeNode child : node.children) {
            traverse(child);
        }
    }
}

实战案例

考虑以下 JSON 数据：

{
  "name": "John",
  "age": 30,
  "children": [
    {
      "name": "Alice",
      "age": 10
    },
    {
      "name": "Bob",
      "age": 12
    }
  ]
}

使用递归遍历，可以很容易地提取所有子项的名称：

import com.google.gson.Gson;

class Main {
    public static void main(String[] args) {
        // 将 JSON 数据解析为对象
        JsonObject json = new Gson().fromJson(jsonStr, JsonObject.class);

        // 递归提取子项名称
        List<String> names = new ArrayList<>();
        traverse(json.get("children"), names);

        // 打印子项名称
        for (String name : names) {
            System.out.println(name);
        }
    }

    private static void traverse(JsonElement element, List<String> names) {
        if (element.isJsonObject()) {
            JsonObject obj = element.getAsJsonObject();
            names.add(obj.get("name").getAsString());
            traverse(obj.get("children"), names);
        }
    }
}

以上就是Java函数式编程中递归式数据遍历的技巧的详细内容，更多请关注其它相关文章！