请使用java 写一个b+树

以下是一个简单的B+树的Java实现：

import java.util.ArrayList;
import java.util.List;

// B+树节点
class BPlusTreeNode {
    List<Integer> keys;
    List<Object> values;
    List<BPlusTreeNode> children;
    BPlusTreeNode parent;
    boolean isLeaf;

    public BPlusTreeNode() {
        keys = new ArrayList<>();
        values = new ArrayList<>();
        children = new ArrayList<>();
        parent = null;
        isLeaf = false;
    }
}

// B+树
class BPlusTree {
    private BPlusTreeNode root;
    private int degree;

    public BPlusTree(int degree) {
        this.degree = degree;
        root = new BPlusTreeNode();
        root.isLeaf = true;
    }

    // 插入键值对
    public void insert(int key, Object value) {
        BPlusTreeNode leafNode = findLeafNode(key);
        insertIntoLeafNode(leafNode, key, value);
        if (leafNode.keys.size() == degree) {
            splitLeafNode(leafNode);
        }
    }

    // 在叶子节点插入键值对
    private void insertIntoLeafNode(BPlusTreeNode leafNode, int key, Object value) {
        int index = 0;
        while (index < leafNode.keys.size() && leafNode.keys.get(index) < key) {
            index++;
        }
        leafNode.keys.add(index, key);
        leafNode.values.add(index, value);
    }

    // 分裂叶子节点
    private void splitLeafNode(BPlusTreeNode leafNode) {
        int midIndex = leafNode.keys.size() / 2;
        int midKey = leafNode.keys.get(midIndex);

        BPlusTreeNode newLeafNode = new BPlusTreeNode();
        newLeafNode.isLeaf = true;

        for (int i = midIndex; i < leafNode.keys.size(); i++) {
            newLeafNode.keys.add(leafNode.keys.get(i));
            newLeafNode.values.add(leafNode.values.get(i));
        }

        for (int i = midIndex; i < leafNode.keys.size(); i++) {
            leafNode.keys.remove(midIndex);
            leafNode.values.remove(midIndex);
        }

        newLeafNode.parent = leafNode.parent;
        leafNode.parent = newLeafNode.parent;

        if (leafNode.parent == null) {
            BPlusTreeNode newRoot = new BPlusTreeNode();
            newRoot.keys.add(midKey);
            newRoot.children.add(leafNode);
            newRoot.children.add(newLeafNode);
            root = newRoot;
        } else {
            int index = leafNode.parent.children.indexOf(leafNode);
            leafNode.parent.keys.add(index, midKey);
            leafNode.parent.children.add(index + 1, newLeafNode);
            if (leafNode.parent.keys.size() == degree) {
                splitInternalNode(leafNode.parent);
            }
        }
    }

    // 分裂内部节点
    private void splitInternalNode(BPlusTreeNode internalNode) {
        int midIndex = internalNode.keys.size() / 2;
        int midKey = internalNode.keys.get(midIndex);

        BPlusTreeNode newInternalNode = new BPlusTreeNode();

        for (int i = midIndex + 1; i < internalNode.keys.size(); i++) {
            newInternalNode.keys.add(internalNode.keys.get(i));
            newInternalNode.children.add(internalNode.children.get(i));
            internalNode.children.get(i).parent = newInternalNode;
        }

        newInternalNode.children.add(internalNode.children.get(internalNode.children.size() - 1));
        internalNode.children.get(internalNode.children.size() - 1).parent = newInternalNode;

        for (int i = midIndex; i < internalNode.keys.size(); i++) {
            internalNode.keys.remove(midIndex);
            internalNode.children.remove(midIndex + 1);
        }

        newInternalNode.parent = internalNode.parent;
        internalNode.parent = newInternalNode.parent;

        if (internalNode.parent == null) {
            BPlusTreeNode newRoot = new BPlusTreeNode();
            newRoot.keys.add(midKey);
            newRoot.children.add(internalNode);
            newRoot.children.add(newInternalNode);
            root = newRoot;
        } else {
            int index = internalNode.parent.children.indexOf(internalNode);
            internalNode.parent.keys.add(index, midKey);
            internalNode.parent.children.add(index + 1, newInternalNode);
            if (internalNode.parent.keys.size() == degree) {
                splitInternalNode(internalNode.parent);
            }
        }
    }

    // 查找叶子节点
    private BPlusTreeNode findLeafNode(int key) {
        BPlusTreeNode node = root;
        while (!node.isLeaf) {
            int index = 0;
            while (index < node.keys.size() && node.keys.get(index) <= key) {
                index++;
            }
            node = node.children.get(index);
        }
        return node;
    }

    // 根据键查找值
    public Object search(int key) {
        BPlusTreeNode leafNode = findLeafNode(key);
        int index = leafNode.keys.indexOf(key);
        if (index != -1) {
            return leafNode.values.get(index);
        }
        return null;
    }
}

public class Main {
    public static void main(String[] args) {
        BPlusTree bPlusTree = new BPlusTree(3);
        bPlusTree.insert(1, "A");
        bPlusTree.insert(2, "B");
        bPlusTree.insert(3, "C");
        bPlusTree.insert(4, "D");
        bPlusTree.insert(5, "E");

        System.out.println(bPlusTree.search(3));  // Output: C
        System.out.println(bPlusTree.search(6));  // Output: null
    }
}

这是一个简单的B+树实现，其中包含了插入和搜索功能。在这个实现中，树的度为3，即每个节点最多可以包含3个键和4个子节点（叶子节点除外）。可以根据需要调整度数。