B+树的Java实现

Java实现：

接口：

Java代码  

1. package com.meidusa.test;  
2.   
3. public interface B {  
4.        public Object get(Comparable key);   //查询  
5.        public void remove(Comparable key);    //移除  
6.        public void insertOrUpdate(Comparable key, Object obj); //插入或者更新，如果已经存在，就更新，否则插入  
7. }  

 

B+树：

Java代码  

1. package com.meidusa.test;  
2.   
3. import java.util.Random;  
4.   
5. public class BplusTree implements B {  
6.       
7.     /** 根节点 */  
8.     protected Node root;  
9.       
10.     /** 阶数，M值 */  
11.     protected int order;  
12.       
13.     /** 叶子节点的链表头*/  
14.     protected Node head;  
15.       
16.     public Node getHead() {  
17.         return head;  
18.     }  
19.   
20.     public void setHead(Node head) {  
21.         this.head = head;  
22.     }  
23.   
24.     public Node getRoot() {  
25.         return root;  
26.     }  
27.   
28.     public void setRoot(Node root) {  
29.         this.root = root;  
30.     }  
31.   
32.     public int getOrder() {  
33.         return order;  
34.     }  
35.   
36.     public void setOrder(int order) {  
37.         this.order = order;  
38.     }  
39.   
40.     @Override  
41.     public Object get(Comparable key) {  
42.         return root.get(key);  
43.     }  
44.   
45.     @Override  
46.     public void remove(Comparable key) {  
47.         root.remove(key, this);  
48.   
49.     }  
50.   
51.     @Override  
52.     public void insertOrUpdate(Comparable key, Object obj) {  
53.         root.insertOrUpdate(key, obj, this);  
54.   
55.     }  
56.       
57.     public BplusTree(int order){  
58.         if (order < 3) {  
59.             System.out.print("order must be greater than 2");  
60.             System.exit(0);  
61.         }  
62.         this.order = order;  
63.         root = new Node(true, true);  
64.         head = root;  
65.     }  
66.       
67.     //测试  
68.     public static void main(String[] args) {  
69.         BplusTree tree = new BplusTree(6);  
70.         Random random = new Random();  
71.         long current = System.currentTimeMillis();  
72.         for (int j = 0; j < 100000; j++) {  
73.             for (int i = 0; i < 100; i++) {  
74.                 int randomNumber = random.nextInt(1000);  
75.                 tree.insertOrUpdate(randomNumber, randomNumber);  
76.             }  
77.   
78.             for (int i = 0; i < 100; i++) {  
79.                 int randomNumber = random.nextInt(1000);  
80.                 tree.remove(randomNumber);  
81.             }  
82.         }  
83.   
84.         long duration = System.currentTimeMillis() - current;  
85.         System.out.println("time elpsed for duration: " + duration);  
86.         int search = 80;  
87.         System.out.print(tree.get(search));  
88.     }  
89.   
90. }  

 

节点：

Java代码  

1. package com.meidusa.test;  
2.   
3. import java.util.AbstractMap.SimpleEntry;  
4. import java.util.ArrayList;  
5. import java.util.List;  
6. import java.util.Map.Entry;  
7.   
8. public class Node {  
9.       
10.     /** 是否为叶子节点 */  
11.     protected boolean isLeaf;  
12.       
13.     /** 是否为根节点*/  
14.     protected boolean isRoot;  
15.   
16.     /** 父节点 */  
17.     protected Node parent;  
18.       
19.     /** 叶节点的前节点*/  
20.     protected Node previous;  
21.       
22.     /** 叶节点的后节点*/  
23.     protected Node next;      
24.       
25.     /** 节点的关键字 */  
26.     protected List<Entry<Comparable, Object>> entries;  
27.       
28.     /** 子节点 */  
29.     protected List<Node> children;  
30.       
31.     public Node(boolean isLeaf) {  
32.         this.isLeaf = isLeaf;  
33.         entries = new ArrayList<Entry<Comparable, Object>>();  
34.           
35.         if (!isLeaf) {  
36.             children = new ArrayList<Node>();  
37.         }  
38.     }  
39.   
40.     public Node(boolean isLeaf, boolean isRoot) {  
41.         this(isLeaf);  
42.         this.isRoot = isRoot;  
43.     }  
44.       
45.     public Object get(Comparable key) {  
46.           
47.         //如果是叶子节点  
48.         if (isLeaf) {  
49.             for (Entry<Comparable, Object> entry : entries) {  
50.                 if (entry.getKey().compareTo(key) == 0) {  
51.                     //返回找到的对象  
52.                     return entry.getValue();  
53.                 }  
54.             }  
55.             //未找到所要查询的对象  
56.             return null;  
57.               
58.         //如果不是叶子节点  
59.         }else {  
60.             //如果key小于等于节点最左边的key，沿第一个子节点继续搜索  
61.             if (key.compareTo(entries.get(0).getKey()) <= 0) {  
62.                 return children.get(0).get(key);  
63.             //如果key大于节点最右边的key，沿最后一个子节点继续搜索  
64.             }else if (key.compareTo(entries.get(entries.size()-1).getKey()) >= 0) {  
65.                 return children.get(children.size()-1).get(key);  
66.             //否则沿比key大的前一个子节点继续搜索  
67.             }else {  
68.                 for (int i = 0; i < entries.size(); i++) {  
69.                     if (entries.get(i).getKey().compareTo(key) <= 0 && entries.get(i+1).getKey().compareTo(key) > 0) {  
70.                         return children.get(i).get(key);  
71.                     }  
72.                 }     
73.             }  
74.         }  
75.           
76.         return null;  
77.     }  
78.       
79.     public void insertOrUpdate(Comparable key, Object obj, BplusTree tree){  
80.         //如果是叶子节点  
81.         if (isLeaf){  
82.             //不需要分裂，直接插入或更新  
83.             if (contains(key) || entries.size() < tree.getOrder()){  
84.                 insertOrUpdate(key, obj);  
85.                 if (parent != null) {  
86.                     //更新父节点  
87.                     parent.updateInsert(tree);  
88.                 }  
89.   
90.             //需要分裂    
91.             }else {  
92.                 //分裂成左右两个节点  
93.                 Node left = new Node(true);  
94.                 Node right = new Node(true);  
95.                 //设置链接  
96.                 if (previous != null){  
97.                     previous.setNext(left);  
98.                     left.setPrevious(previous);  
99.                 }  
100.                 if (next != null) {  
101.                     next.setPrevious(right);  
102.                     right.setNext(next);  
103.                 }  
104.                 if (previous == null){  
105.                     tree.setHead(left);  
106.                 }  
107.   
108.                 left.setNext(right);  
109.                 right.setPrevious(left);  
110.                 previous = null;  
111.                 next = null;  
112.                   
113.                 //左右两个节点关键字长度  
114.                 int leftSize = (tree.getOrder() + 1) / 2 + (tree.getOrder() + 1) % 2;   
115.                 int rightSize = (tree.getOrder() + 1) / 2;  
116.                 //复制原节点关键字到分裂出来的新节点  
117.                 insertOrUpdate(key, obj);  
118.                 for (int i = 0; i < leftSize; i++){  
119.                     left.getEntries().add(entries.get(i));  
120.                 }  
121.                 for (int i = 0; i < rightSize; i++){  
122.                     right.getEntries().add(entries.get(leftSize + i));  
123.                 }  
124.                   
125.                 //如果不是根节点  
126.                 if (parent != null) {  
127.                     //调整父子节点关系  
128.                     int index = parent.getChildren().indexOf(this);  
129.                     parent.getChildren().remove(this);  
130.                     left.setParent(parent);  
131.                     right.setParent(parent);  
132.                     parent.getChildren().add(index,left);  
133.                     parent.getChildren().add(index + 1, right);  
134.                     setEntries(null);  
135.                     setChildren(null);  
136.                       
137.                     //父节点插入或更新关键字  
138.                     parent.updateInsert(tree);  
139.                     setParent(null);  
140.                 //如果是根节点      
141.                 }else {  
142.                     isRoot = false;  
143.                     Node parent = new Node(false, true);  
144.                     tree.setRoot(parent);  
145.                     left.setParent(parent);  
146.                     right.setParent(parent);  
147.                     parent.getChildren().add(left);  
148.                     parent.getChildren().add(right);  
149.                     setEntries(null);  
150.                     setChildren(null);  
151.                       
152.                     //更新根节点  
153.                     parent.updateInsert(tree);  
154.                 }  
155.                   
156.   
157.             }  
158.               
159.         //如果不是叶子节点  
160.         }else {  
161.             //如果key小于等于节点最左边的key，沿第一个子节点继续搜索  
162.             if (key.compareTo(entries.get(0).getKey()) <= 0) {  
163.                 children.get(0).insertOrUpdate(key, obj, tree);  
164.             //如果key大于节点最右边的key，沿最后一个子节点继续搜索  
165.             }else if (key.compareTo(entries.get(entries.size()-1).getKey()) >= 0) {  
166.                 children.get(children.size()-1).insertOrUpdate(key, obj, tree);  
167.             //否则沿比key大的前一个子节点继续搜索  
168.             }else {  
169.                 for (int i = 0; i < entries.size(); i++) {  
170.                     if (entries.get(i).getKey().compareTo(key) <= 0 && entries.get(i+1).getKey().compareTo(key) > 0) {  
171.                         children.get(i).insertOrUpdate(key, obj, tree);  
172.                         break;  
173.                     }  
174.                 }     
175.             }  
176.         }  
177.     }  
178.       
179.     /** 插入节点后中间节点的更新 */  
180.     protected void updateInsert(BplusTree tree){  
181.   
182.         validate(this, tree);  
183.           
184.         //如果子节点数超出阶数，则需要分裂该节点     
185.         if (children.size() > tree.getOrder()) {  
186.             //分裂成左右两个节点  
187.             Node left = new Node(false);  
188.             Node right = new Node(false);  
189.             //左右两个节点关键字长度  
190.             int leftSize = (tree.getOrder() + 1) / 2 + (tree.getOrder() + 1) % 2;  
191.             int rightSize = (tree.getOrder() + 1) / 2;  
192.             //复制子节点到分裂出来的新节点，并更新关键字  
193.             for (int i = 0; i < leftSize; i++){  
194.                 left.getChildren().add(children.get(i));  
195.                 left.getEntries().add(new SimpleEntry(children.get(i).getEntries().get(0).getKey(), null));  
196.                 children.get(i).setParent(left);  
197.             }  
198.             for (int i = 0; i < rightSize; i++){  
199.                 right.getChildren().add(children.get(leftSize + i));  
200.                 right.getEntries().add(new SimpleEntry(children.get(leftSize + i).getEntries().get(0).getKey(), null));  
201.                 children.get(leftSize + i).setParent(right);  
202.             }  
203.               
204.             //如果不是根节点  
205.             if (parent != null) {  
206.                 //调整父子节点关系  
207.                 int index = parent.getChildren().indexOf(this);  
208.                 parent.getChildren().remove(this);  
209.                 left.setParent(parent);  
210.                 right.setParent(parent);  
211.                 parent.getChildren().add(index,left);  
212.                 parent.getChildren().add(index + 1, right);  
213.                 setEntries(null);  
214.                 setChildren(null);  
215.                   
216.                 //父节点更新关键字  
217.                 parent.updateInsert(tree);  
218.                 setParent(null);  
219.             //如果是根节点      
220.             }else {  
221.                 isRoot = false;  
222.                 Node parent = new Node(false, true);  
223.                 tree.setRoot(parent);  
224.                 left.setParent(parent);  
225.                 right.setParent(parent);  
226.                 parent.getChildren().add(left);  
227.                 parent.getChildren().add(right);  
228.                 setEntries(null);  
229.                 setChildren(null);  
230.                   
231.                 //更新根节点  
232.                 parent.updateInsert(tree);  
233.             }  
234.         }  
235.     }  
236.       
237.     /** 调整节点关键字*/  
238.     protected static void validate(Node node, BplusTree tree) {  
239.           
240.         // 如果关键字个数与子节点个数相同  
241.         if (node.getEntries().size() == node.getChildren().size()) {  
242.             for (int i = 0; i < node.getEntries().size(); i++) {  
243.                 Comparable key = node.getChildren().get(i).getEntries().get(0).getKey();  
244.                 if (node.getEntries().get(i).getKey().compareTo(key) != 0) {  
245.                     node.getEntries().remove(i);  
246.                     node.getEntries().add(i, new SimpleEntry(key, null));  
247.                     if(!node.isRoot()){  
248.                         validate(node.getParent(), tree);  
249.                     }  
250.                 }  
251.             }  
252.             // 如果子节点数不等于关键字个数但仍大于M / 2并且小于M，并且大于2  
253.         } else if (node.isRoot() && node.getChildren().size() >= 2   
254.                 ||node.getChildren().size() >= tree.getOrder() / 2   
255.                 && node.getChildren().size() <= tree.getOrder()  
256.                 && node.getChildren().size() >= 2) {  
257.             node.getEntries().clear();  
258.             for (int i = 0; i < node.getChildren().size(); i++) {  
259.                 Comparable key = node.getChildren().get(i).getEntries().get(0).getKey();  
260.                 node.getEntries().add(new SimpleEntry(key, null));  
261.                 if (!node.isRoot()) {  
262.                     validate(node.getParent(), tree);  
263.                 }  
264.             }  
265.         }  
266.     }  
267.       
268.     /** 删除节点后中间节点的更新*/  
269.     protected void updateRemove(BplusTree tree) {  
270.           
271.         validate(this, tree);  
272.   
273.         // 如果子节点数小于M / 2或者小于2，则需要合并节点  
274.         if (children.size() < tree.getOrder() / 2 || children.size() < 2) {  
275.             if (isRoot) {  
276.                 // 如果是根节点并且子节点数大于等于2，OK  
277.                 if (children.size() >= 2) {  
278.                     return;  
279.                 // 否则与子节点合并  
280.                 } else {  
281.                     Node root = children.get(0);  
282.                     tree.setRoot(root);  
283.                     root.setParent(null);  
284.                     root.setRoot(true);  
285.                     setEntries(null);  
286.                     setChildren(null);  
287.                 }  
288.             } else {  
289.                 //计算前后节点   
290.                 int currIdx = parent.getChildren().indexOf(this);  
291.                 int prevIdx = currIdx - 1;  
292.                 int nextIdx = currIdx + 1;  
293.                 Node previous = null, next = null;  
294.                 if (prevIdx >= 0) {  
295.                     previous = parent.getChildren().get(prevIdx);  
296.                 }  
297.                 if (nextIdx < parent.getChildren().size()) {  
298.                     next = parent.getChildren().get(nextIdx);  
299.                 }  
300.                   
301.                 // 如果前节点子节点数大于M / 2并且大于2，则从其处借补  
302.                 if (previous != null   
303.                         && previous.getChildren().size() > tree.getOrder() / 2  
304.                         && previous.getChildren().size() > 2) {  
305.                     //前叶子节点末尾节点添加到首位  
306.                     int idx = previous.getChildren().size() - 1;  
307.                     Node borrow = previous.getChildren().get(idx);  
308.                     previous.getChildren().remove(idx);  
309.                     borrow.setParent(this);  
310.                     children.add(0, borrow);  
311.                     validate(previous, tree);  
312.                     validate(this, tree);  
313.                     parent.updateRemove(tree);  
314.                       
315.                 // 如果后节点子节点数大于M / 2并且大于2，则从其处借补  
316.                 } else if (next != null   
317.                         && next.getChildren().size() > tree.getOrder() / 2  
318.                         && next.getChildren().size() > 2) {  
319.                     //后叶子节点首位添加到末尾  
320.                     Node borrow = next.getChildren().get(0);  
321.                     next.getChildren().remove(0);  
322.                     borrow.setParent(this);  
323.                     children.add(borrow);  
324.                     validate(next, tree);  
325.                     validate(this, tree);  
326.                     parent.updateRemove(tree);  
327.                       
328.                 // 否则需要合并节点  
329.                 } else {  
330.                     // 同前面节点合并  
331.                     if (previous != null   
332.                             && (previous.getChildren().size() <= tree.getOrder() / 2 || previous.getChildren().size() <= 2)) {  
333.                           
334.                         for (int i = previous.getChildren().size() - 1; i >= 0; i--) {  
335.                             Node child = previous.getChildren().get(i);  
336.                             children.add(0, child);  
337.                             child.setParent(this);  
338.                         }  
339.                         previous.setChildren(null);  
340.                         previous.setEntries(null);  
341.                         previous.setParent(null);  
342.                         parent.getChildren().remove(previous);  
343.                         validate(this, tree);  
344.                         parent.updateRemove(tree);  
345.                           
346.                     // 同后面节点合并  
347.                     } else if (next != null   
348.                             && (next.getChildren().size() <= tree.getOrder() / 2 || next.getChildren().size() <= 2)) {  
349.   
350.                         for (int i = 0; i < next.getChildren().size(); i++) {  
351.                             Node child = next.getChildren().get(i);  
352.                             children.add(child);  
353.                             child.setParent(this);  
354.                         }  
355.                         next.setChildren(null);  
356.                         next.setEntries(null);  
357.                         next.setParent(null);  
358.                         parent.getChildren().remove(next);  
359.                         validate(this, tree);  
360.                         parent.updateRemove(tree);  
361.                     }  
362.                 }  
363.             }  
364.         }  
365.     }  
366.       
367.     public void remove(Comparable key, BplusTree tree){  
368.         //如果是叶子节点  
369.         if (isLeaf){  
370.               
371.             //如果不包含该关键字，则直接返回  
372.             if (!contains(key)){  
373.                 return;  
374.             }  
375.               
376.             //如果既是叶子节点又是跟节点，直接删除  
377.             if (isRoot) {  
378.                 remove(key);  
379.             }else {  
380.                 //如果关键字数大于M / 2，直接删除  
381.                 if (entries.size() > tree.getOrder() / 2 && entries.size() > 2) {  
382.                     remove(key);  
383.                 }else {  
384.                     //如果自身关键字数小于M / 2，并且前节点关键字数大于M / 2，则从其处借补  
385.                     if (previous != null   
386.                             && previous.getEntries().size() > tree.getOrder() / 2  
387.                             && previous.getEntries().size() > 2  
388.                             && previous.getParent() == parent) {  
389.                         int size = previous.getEntries().size();  
390.                         Entry<Comparable, Object> entry = previous.getEntries().get(size - 1);  
391.                         previous.getEntries().remove(entry);  
392.                         //添加到首位  
393.                         entries.add(0, entry);  
394.                         remove(key);  
395.                     //如果自身关键字数小于M / 2，并且后节点关键字数大于M / 2，则从其处借补     
396.                     }else if (next != null   
397.                             && next.getEntries().size() > tree.getOrder() / 2  
398.                             && next.getEntries().size() > 2  
399.                             && next.getParent() == parent) {  
400.                         Entry<Comparable, Object> entry = next.getEntries().get(0);  
401.                         next.getEntries().remove(entry);  
402.                         //添加到末尾  
403.                         entries.add(entry);  
404.                         remove(key);  
405.                     //否则需要合并叶子节点      
406.                     }else {  
407.                         //同前面节点合并  
408.                         if (previous != null   
409.                                 && (previous.getEntries().size() <= tree.getOrder() / 2 || previous.getEntries().size() <= 2)  
410.                                 && previous.getParent() == parent) {  
411.                             for (int i = previous.getEntries().size() - 1; i >=0; i--) {  
412.                                 //从末尾开始添加到首位  
413.                                 entries.add(0, previous.getEntries().get(i));  
414.                             }  
415.                             remove(key);  
416.                             previous.setParent(null);  
417.                             previous.setEntries(null);  
418.                             parent.getChildren().remove(previous);  
419.                             //更新链表  
420.                             if (previous.getPrevious() != null) {  
421.                                 Node temp = previous;  
422.                                 temp.getPrevious().setNext(this);  
423.                                 previous = temp.getPrevious();  
424.                                 temp.setPrevious(null);  
425.                                 temp.setNext(null);                           
426.                             }else {  
427.                                 tree.setHead(this);  
428.                                 previous.setNext(null);  
429.                                 previous = null;  
430.                             }  
431.                         //同后面节点合并     
432.                         }else if(next != null   
433.                                 && (next.getEntries().size() <= tree.getOrder() / 2 || next.getEntries().size() <= 2)  
434.                                 && next.getParent() == parent){  
435.                             for (int i = 0; i < next.getEntries().size(); i++) {  
436.                                 //从首位开始添加到末尾  
437.                                 entries.add(next.getEntries().get(i));  
438.                             }  
439.                             remove(key);  
440.                             next.setParent(null);  
441.                             next.setEntries(null);  
442.                             parent.getChildren().remove(next);  
443.                             //更新链表  
444.                             if (next.getNext() != null) {  
445.                                 Node temp = next;  
446.                                 temp.getNext().setPrevious(this);  
447.                                 next = temp.getNext();  
448.                                 temp.setPrevious(null);  
449.                                 temp.setNext(null);  
450.                             }else {  
451.                                 next.setPrevious(null);  
452.                                 next = null;  
453.                             }  
454.                         }  
455.                     }  
456.                 }  
457.                 parent.updateRemove(tree);  
458.             }  
459.         //如果不是叶子节点    
460.         }else {  
461.             //如果key小于等于节点最左边的key，沿第一个子节点继续搜索  
462.             if (key.compareTo(entries.get(0).getKey()) <= 0) {  
463.                 children.get(0).remove(key, tree);  
464.             //如果key大于节点最右边的key，沿最后一个子节点继续搜索  
465.             }else if (key.compareTo(entries.get(entries.size()-1).getKey()) >= 0) {  
466.                 children.get(children.size()-1).remove(key, tree);  
467.             //否则沿比key大的前一个子节点继续搜索  
468.             }else {  
469.                 for (int i = 0; i < entries.size(); i++) {  
470.                     if (entries.get(i).getKey().compareTo(key) <= 0 && entries.get(i+1).getKey().compareTo(key) > 0) {  
471.                         children.get(i).remove(key, tree);  
472.                         break;  
473.                     }  
474.                 }     
475.             }  
476.         }  
477.     }  
478.       
479.     /** 判断当前节点是否包含该关键字*/  
480.     protected boolean contains(Comparable key) {  
481.         for (Entry<Comparable, Object> entry : entries) {  
482.             if (entry.getKey().compareTo(key) == 0) {  
483.                 return true;  
484.             }  
485.         }  
486.         return false;  
487.     }  
488.       
489.     /** 插入到当前节点的关键字中*/  
490.     protected void insertOrUpdate(Comparable key, Object obj){  
491.         Entry<Comparable, Object> entry = new SimpleEntry<Comparable, Object>(key, obj);  
492.         //如果关键字列表长度为0，则直接插入  
493.         if (entries.size() == 0) {  
494.             entries.add(entry);  
495.             return;  
496.         }  
497.         //否则遍历列表  
498.         for (int i = 0; i < entries.size(); i++) {  
499.             //如果该关键字键值已存在，则更新  
500.             if (entries.get(i).getKey().compareTo(key) == 0) {  
501.                 entries.get(i).setValue(obj);  
502.                 return;  
503.             //否则插入    
504.             }else if (entries.get(i).getKey().compareTo(key) > 0){  
505.                 //插入到链首  
506.                 if (i == 0) {  
507.                     entries.add(0, entry);  
508.                     return;  
509.                 //插入到中间  
510.                 }else {  
511.                     entries.add(i, entry);  
512.                     return;  
513.                 }  
514.             }  
515.         }  
516.         //插入到末尾  
517.         entries.add(entries.size(), entry);  
518.     }  
519.       
520.     /** 删除节点*/  
521.     protected void remove(Comparable key){  
522.         int index = -1;  
523.         for (int i = 0; i < entries.size(); i++) {  
524.             if (entries.get(i).getKey().compareTo(key) == 0) {  
525.                 index = i;  
526.                 break;  
527.             }  
528.         }  
529.         if (index != -1) {  
530.             entries.remove(index);  
531.         }  
532.     }  
533.       
534.     public Node getPrevious() {  
535.         return previous;  
536.     }  
537.   
538.     public void setPrevious(Node previous) {  
539.         this.previous = previous;  
540.     }  
541.   
542.     public Node getNext() {  
543.         return next;  
544.     }  
545.   
546.     public void setNext(Node next) {  
547.         this.next = next;  
548.     }  
549.   
550.     public boolean isLeaf() {  
551.         return isLeaf;  
552.     }  
553.   
554.     public void setLeaf(boolean isLeaf) {  
555.         this.isLeaf = isLeaf;  
556.     }  
557.   
558.     public Node getParent() {  
559.         return parent;  
560.     }  
561.   
562.     public void setParent(Node parent) {  
563.         this.parent = parent;  
564.     }  
565.   
566.     public List<Entry<Comparable, Object>> getEntries() {  
567.         return entries;  
568.     }  
569.   
570.     public void setEntries(List<Entry<Comparable, Object>> entries) {  
571.         this.entries = entries;  
572.     }  
573.   
574.     public List<Node> getChildren() {  
575.         return children;  
576.     }  
577.   
578.     public void setChildren(List<Node> children) {  
579.         this.children = children;  
580.     }  
581.       
582.     public boolean isRoot() {  
583.         return isRoot;  
584.     }  
585.   
586.     public void setRoot(boolean isRoot) {  
587.         this.isRoot = isRoot;  
588.     }  
589.       
590.     public String toString(){  
591.         StringBuilder sb = new StringBuilder();  
592.         sb.append("isRoot: ");  
593.         sb.append(isRoot);  
594.         sb.append(", ");  
595.         sb.append("isLeaf: ");  
596.         sb.append(isLeaf);  
597.         sb.append(", ");  
598.         sb.append("keys: ");  
599.         for (Entry entry : entries){  
600.             sb.append(entry.getKey());  
601.             sb.append(", ");  
602.         }  
603.         sb.append(", ");  
604.         return sb.toString();  
605.           
606.     }  
607.   
608. }