java实现B+树数据结构,且构造100条数据，读入内存，把地址加到B+树的叶子结点中，构造测试用例

好的，我可以给你提供一些参考代码。以下是Java实现B+树数据结构的代码示例：

public class BPlusTree {
    // B+树的阶数
    private int order;

    // B+树的根节点
    private BPlusTreeNode root;

    // 构造函数
    public BPlusTree(int order) {
        this.order = order;
        this.root = new BPlusTreeNode(order, true);
    }

    // 插入操作
    public void insert(int key, Object value) {
        root.insert(key, value);
    }

    // 查找操作
    public Object search(int key) {
        return root.search(key);
    }

    // 删除操作
    public void remove(int key) {
        root.remove(key);
    }
}

// B+树中的节点类
class BPlusTreeNode {
    // 节点中存储的键值对数量
    private int size;

    // 节点中存储的键值对数组
    private Entry[] entries;

    // 是否为叶子节点
    private boolean isLeaf;

    // 父节点
    private BPlusTreeNode parent;

    // 子节点数组
    private BPlusTreeNode[] children;

    // 构造函数
    public BPlusTreeNode(int order, boolean isLeaf) {
        this.size = 0;
        this.entries = new Entry[order - 1];
        this.isLeaf = isLeaf;
        this.parent = null;
        this.children = new BPlusTreeNode[order];
    }

    // 插入操作
    public void insert(int key, Object value) {
        if (isLeaf) {
            insertLeaf(key, value);
        } else {
            insertNonLeaf(key, value);
        }
    }

    // 插入叶子节点
    public void insertLeaf(int key, Object value) {
        int index = 0;
        while (index < size && entries[index].key < key) {
            index++;
        }
        System.arraycopy(entries, index, entries, index + 1, size - index);
        entries[index] = new Entry(key, value);
        size++;
    }

    // 插入非叶子节点
    public void insertNonLeaf(int key, Object value) {
        int index = 0;
        while (index < size && entries[index].key < key) {
            index++;
        }
        children[index].insert(key, value);
    }

    // 查找操作
    public Object search(int key) {
        if (isLeaf) {
            int index = 0;
            while (index < size && entries[index].key < key) {
                index++;
            }
            if (index < size && entries[index].key == key) {
                return entries[index].value;
            } else {
                return null;
            }
        } else {
            int index = 0;
            while (index < size && entries[index].key < key) {
                index++;
            }
            return children[index].search(key);
        }
    }

    // 删除操作
    public void remove(int key) {
        if (isLeaf) {
            removeLeaf(key);
        } else {
            removeNonLeaf(key);
        }
    }

    // 删除叶子节点
    public void removeLeaf(int key) {
        int index = 0;
        while (index < size && entries[index].key != key) {
            index++;
        }
        if (index < size) {
            System.arraycopy(entries, index + 1, entries, index, size - index - 1);
            size--;
        }
    }

    // 删除非叶子节点
    public void removeNonLeaf(int key) {
        int index = 0;
        while (index < size && entries[index].key < key) {
            index++;
        }
        children[index].remove(key);
    }
}

// B+树中的键值对类
class Entry {
    // 键
    public int key;

    // 值
    public Object value;

    // 构造函数
    public Entry(int key, Object value) {
        this.key = key;
        this.value = value;
    }
}

接下来是构造100条数据，读入内存，把地址加到B+树的叶子结点中的代码示例：

public static void main(String[] args) {
    // 创建B+树实例
    BPlusTree bPlusTree = new BPlusTree(4);

    // 读取100条地址并加入B+树
    try (BufferedReader reader = new BufferedReader(new FileReader("data.txt"))) {
        String line = reader.readLine();
        while (line != null) {
            String[] tokens = line.split(",");
            int key = Integer.parseInt(tokens[0]);
            String value = tokens[1];
            bPlusTree.insert(key, value);
            line = reader.readLine();
        }
    } catch (IOException e) {
        e.printStackTrace();
    }

    // 测试B+树是否正常工作
    String value = (String) bPlusTree.search(10);
    System.out.println(value);
}

最后是构造测试用例的代码示例。这里我们构造了四个测试用例，分别是插入一个已存在的键、查询一个不存在的键、删除一个已存在的键、随机删除若干个键。

public static void test() {
    // 创建B+树实例
    BPlusTree bPlusTree = new BPlusTree(4);

    // 插入一个已存在的键
    bPlusTree.insert(10, "value1");
    bPlusTree.insert(20, "value2");
    bPlusTree.insert(30, "value3");
    bPlusTree.insert(40, "value4");
    bPlusTree.insert(50, "value5");
    bPlusTree.insert(60, "value6");
    bPlusTree.insert(70, "value7");
    bPlusTree.insert(80, "value8");
    bPlusTree.insert(90, "value9");
    bPlusTree.insert(100, "value10");
    bPlusTree.insert(10, "value11");

    // 查询一个不存在的键
    String value = (String) bPlusTree.search(110);
    System.out.println(value);

    // 删除一个已存在的键
    bPlusTree.remove(50);

    // 随机删除若干个键
    for (int i = 0; i < 5; i++) {
        int key = (int) (Math.random() * 100 + 1);
        bPlusTree.remove(key);
    }
}