用radix tree简单实现java.util.Map的功能

RadixTreeNode.java

package com.sk.radixtree;

import java.io.Serializable;
import java.util.Collection;
import java.util.Iterator;
import java.util.TreeSet;

import javax.xml.soap.Node;

public class RadixTreeNode <V extends Serializable> implements Iterable<RadixTreeNode<V>>,
Comparable<RadixTreeNode<V>>
{
//在节点中的前缀
private String prefix;
//存储在节点中的value
private V value;
//该节点是否存储一个值。 这个值主要由RadixTreeVisitor用来判断是否应该访问这个节点。
private boolean hasValue;
//这个节点的孩子节点。请注意，因为我们在这里使用了{@link TreeSet}，所以RadixTree的遍历将按字典顺序排列。
private Collection<RadixTreeNode<V>> children;

/**
* 打印node节点的信息
*/
public void printInfo()
{
if(children!=null)
{
System.out.println("[prefix="+prefix
+",value="+value+
",hasValue="+hasValue+
",numOfChildren"+children.size()+"]");
}
else
{
System.out.println("[prefix="+prefix
+",value="+value+
",hasValue="+hasValue+
"]");
}
}

/**
* 根据给出的prefix构造节点
* @param prefix
*/
public RadixTreeNode(String prefix)
{
this.prefix=prefix;
this.hasValue=false;
}

/**
* Constructs a node from the given prefix and value.
*
* @param prefix  the prefix
* @param value  the value
*/
public RadixTreeNode(String prefix,V value)
{
this.prefix=prefix;
this.value=value;
this.hasValue=true;
}

/**
* Gets the value attached to this node.
*
* @return the value, or <code>null</code> if an internal node
*/
public V getValue()
{
return value;
}

/**
* Sets the value attached to this node.
*
* @param value  the value, or <code>null</code> if an internal node
*/
public void setValue(V value)
{
this.value=value;
}

/**
* Gets the prefix associated with this node.
*
* @return the prefix
*/
String getPrefix()
{
return prefix;
}

/**
* Sets the prefix associated with this node.
*
* @param prefix  the prefix
*/
void setPrefix(String prefix)
{
this.prefix=prefix;
}

/**
* Gets the children of this node.
*
* @return the list of children
*/
Collection<RadixTreeNode<V>> getChildren()
{
//延迟创建children以节约内存
if(children==null)
{
children=new TreeSet<RadixTreeNode<V>>();
}
return children;
}

/**
* Whether or not this node has a value attached to it.
*
* @return whether or not this node has a value
*/
boolean hasValue()
{
return hasValue;
}

/**
* Sets whether or not this node has a value attached to it.
*
* @param hasValue  <code>true</code> if this node will have a value,
*                  <code>false</code> otherwise. If <code>false</code>,
*                  {@link #getValue()} will return <code>null</code>
*                  after this call.
*/
void setHasValue(boolean hasValue)
{
this.hasValue=hasValue;
if(!hasValue)
{
//this.hasValue=(Boolean) null;
}
}

@Override
public int compareTo(RadixTreeNode<V> node)
{
return prefix.toString().compareTo(node.getPrefix().toString());
}

@Override
public Iterator<RadixTreeNode<V>> iterator()
{
if(children==null)
{
return new Iterator<RadixTreeNode<V>>()
{

@Override
public boolean hasNext()
{
return false;
}

@Override
public RadixTreeNode<V> next()
{
return null;
}
};
}
return children.iterator();
}
}

RadixTreeUtil.java

package com.sk.radixtree;

import java.io.Serializable;

/**
* Radix tree utility functions
* @author root
*
*/
public class RadixTreeUtil
{
private RadixTreeUtil()
{

}

static <V extends Serializable> void dumpTree(RadixTreeNode<V> node,String outputPrefix)
{
if(node.hasValue())
{
System.out.format("%s{%s : %s}%n", outputPrefix,node.getPrefix(),node.getValue());
}
else
{
System.out.format("%s{%s}%n", outputPrefix,node.getPrefix(),node.getValue());
}
for (RadixTreeNode<V> child:node)
{
dumpTree(child, outputPrefix+"\t");
}
}

/**
* Prints a radix tree to <code>System.out</code>.
*
* @param tree  the tree
*/
public static <V extends Serializable> void dumpTree(RadixTree <V> tree)
{
dumpTree(tree.root,"");
}

/**
* Finds the length of the largest prefix for two character sequences.
*
* @param a  character sequence
* @param b  character sequence
*
* @return the length of largest prefix of <code>a</code> and <code>b</code>
*
* @throws IllegalArgumentException  if either <code>a</code> or <code>b</code>
*                                   is <code>null</code>
*/
public static int largestPrefixLength(CharSequence a,CharSequence b)
{
int length=0;

for(int i=0;i<Math.min(a.length(), b.length());i++)
{
if(a.charAt(i)!=b.charAt(i))
{
break;
}
length++;
}

return length;
}
}

RadixTreeVisitor.java

package com.sk.radixtree;

public interface RadixTreeVisitor<V,R>
{
/**
* Visits a node in a radix tree.
*
* @param key  the key of the node being visited
* @param value  the value of the node being visited
*/
public abstract void visit(String key,V value);

/**
* An overall result from the traversal of the radix tree.
*
* @return the result
*/
public abstract R getResult();
}

RadixTree.java

package com.sk.radixtree;

import java.util.List;
import java.io.Serializable;
import java.util.AbstractMap;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;

import com.sk.radixtree.*;

/**
* A radix tree. Radix trees are String -> Object mappings which allow quick
* lookups on the strings. Radix trees also make it easy to grab the objects
* with a common prefix.
*
* @see <a href="http://en.wikipedia.org/wiki/Radix_tree">Wikipedia</a>
*
* @param <V>  the type of values stored in the tree
*/
public class RadixTree <V extends Serializable> implements Map<String, V>,Serializable
{
public static final String KEY_CANNOT_BE_NULL="key cannot be null";
public static final String KEYS_MUST_BE_STRING_INSTANCES="keys must be String instaces";

//radix tree 的根节点
RadixTreeNode<V> root;

/**
* Gets a list of values whose associated keys have the given prefix.
*
* @param prefix  the prefix to look for
*
* @return the list of values
*
* @throws NullPointerException if prefix is <code>null</code>
*/
public List<V> getValuesWithPrefix(String prefix)
{
RadixTreeVisitor<V,List<V>> visitor=new RadixTreeVisitor<V, List<V>>()
{
List<V> result=new ArrayList<V>();

@Override
public void visit(String key, V value)
{
result.add(value);
}

@Override
public List<V> getResult()
{
return result;
}

};
visit(visitor,prefix);
return visitor.getResult();
}

/**
* Gets a list of keys with the given prefix.
*
* @param prefix  the prefix to look for
*
* @return the list of prefixes
*
* @throws NullPointerException if prefix is <code>null</code>
*/
public List<String> getKeysWithPrefix(String prefix)
{
RadixTreeVisitor<V, List<String>> visitor=new RadixTreeVisitor<V, List<String>>()
{
List<String> result=new ArrayList<String>();

@Override
public void visit(String key, V value)
{
result.add(key);
}

@Override
public List<String> getResult()
{
return result;
}

};
visit(visitor, prefix);
return visitor.getResult();
}

/**
* Gets a list of entries whose associated keys have the given prefix.
*
* @param prefix  the prefix to look for
*
* @return the list of values
*
* @throws NullPointerException if prefix is <code>null</code>
*/
public List<Map.Entry<String,V>> getEntriesWithPrefix(String prefix)
{
RadixTreeVisitor<V, List<Map.Entry<String,V>>> visitor=new
RadixTreeVisitor<V, List<Map.Entry<String,V>>>()
{
List<Map.Entry<String,V>> result=new ArrayList<Map.Entry<String,V>>();

@Override
public void visit(String key, V value)
{
result.add(new AbstractMap.SimpleEntry(key,value));
}

@Override
public List<java.util.Map.Entry<String, V>> getResult()
{
return result;
}
};
visit(visitor, prefix);
return visitor.getResult();
}

/**
* Visits the given node of this tree with the given prefix and visitor. Also,
* recursively visits the left/right subtrees of this node.
*
* @param node  the node
* @param prefix  the prefix
* @param visitor  the visitor
*/
public void  visit(RadixTreeNode<V> node,String prefixAllowed,String prefix,RadixTreeVisitor<V, ?>visitor)
{
if(node.hasValue() && prefix.startsWith(prefixAllowed))
{
visitor.visit(prefix, node.getValue());
}

for(RadixTreeNode<V> child:node)
{
final int prefixLength=prefix.length();
final String newPrefix=prefix+child.getPrefix();
/**
* 还需要继续查找的条件
*/
if(prefixAllowed.length()<=prefixLength
|| newPrefix.length()<=prefixLength
|| newPrefix.charAt(prefixLength) == prefixAllowed.charAt(prefixLength))
{
visit(child, prefixAllowed, newPrefix, visitor);
}
}
}

/**
* Traverses this radix tree using the given visitor. Only values with
* the given prefix will be visited. Note that the tree will be traversed
* in lexicographical order.
*
* @param visitor  the visitor
* @param prefix  the prefix used to restrict visitation
*/
public void visit(RadixTreeVisitor<V, ?> visitor,String prefix)
{
visit(root,prefix,"",visitor);
}

/**
* Traverses this radix tree using the given visitor. Note that the tree
* will be traversed in lexicographical order.
*
* @param visitor  the visitor
*/
public void visit(RadixTreeVisitor<V, ?> visitor )
{
visit(root,"","",visitor);
}

/**
* 缺省的构造函数
*/
public RadixTree()
{
this.root=new RadixTreeNode<V>("");
}

@Override
public int size()
{
RadixTreeVisitor<V, Integer> visitor=new RadixTreeVisitor<V, Integer>()
{
int count=0;

@Override
public void visit(String key, V value)
{
count++;
}

@Override
public Integer getResult()
{
return count;
}

};
visit(visitor);
return visitor.getResult() ;
}

@Override
public boolean isEmpty()
{
return root.getChildren().isEmpty();
}

@Override
public boolean containsKey(final Object keyToCheck)
{
if (keyToCheck==null)
{
throw new NullPointerException(KEY_CANNOT_BE_NULL);
}
if(!(keyToCheck instanceof String))
{
throw new ClassCastException(KEYS_MUST_BE_STRING_INSTANCES);
}

RadixTreeVisitor<V, Boolean> visitor=new RadixTreeVisitor<V, Boolean>()
{
boolean found =false;

@Override
public void visit(String key, V value)
{
if(key.equals(keyToCheck))
{
found=true;
}
}

@Override
public Boolean getResult()
{
return found;
}
};
visit(visitor, (String)keyToCheck);
return visitor.getResult();

}

@Override
public boolean containsValue(final Object val)
{
RadixTreeVisitor<V, Boolean> visitor=new RadixTreeVisitor<V, Boolean>()
{
boolean found=false;

@Override
public void visit(String key, V value)
{
if(val==value || (value!=null) && value.equals(val))
{
found=true;
}
}

@Override
public Boolean getResult()
{
return found;
}

};
visit(visitor);
return visitor.getResult();
}

@Override
public V get(final Object keyToCheck)
{
if(keyToCheck==null)
{
throw new NullPointerException(KEY_CANNOT_BE_NULL);
}
if(!(keyToCheck instanceof String))
{
throw new ClassCastException(KEYS_MUST_BE_STRING_INSTANCES);
}

RadixTreeVisitor<V, V> visitor=new RadixTreeVisitor<V, V>()
{
V result=null;

@Override
public void visit(String key, V value)
{
if(key.equals(keyToCheck))
{
result=value;
}

}

@Override
public V getResult()
{
return result;
}
};
visit(visitor, (String)keyToCheck);
return visitor.getResult();
}

@Override
public V put(String key, V value)
{
if(key==null)
{
throw new NullPointerException(KEY_CANNOT_BE_NULL);
}

return put(key, value,root);
}

/**
* Remove the value with the given key from the subtree rooted at the
* given node.
*
* @param key  the key
* @param node  the node to start searching from
*
* @return the old value associated with the given key, or <code>null</code>
*         if there was no mapping for <code>key</code>
*/
private V put(String key, V value, RadixTreeNode<V> node)
{
V ret =null;
final int largestPrefixLength=RadixTreeUtil.largestPrefixLength(key, node.getPrefix());

//key就是node的情况
if(largestPrefixLength==node.getPrefix().length() && largestPrefixLength==key.length())
{
ret=node.getValue();
node.setValue(value);
node.setHasValue(true);
}
//key所在节点在node的子节点中
else if(largestPrefixLength==0 ||
(largestPrefixLength<key.length()) && largestPrefixLength>=node.getPrefix().length() )
{
// Key is bigger than the prefix located at this node, so we need to see if
// there's a child that can possibly share a prefix, and if not, we just add
// a new node to this node
final String leftoverKey=key.substring(largestPrefixLength);
boolean found=false;
for(RadixTreeNode<V> child:node)
{
if(child.getPrefix().charAt(0)==leftoverKey.charAt(0))
{
found=true;
ret=put(leftoverKey, value, child);
break;
}
}

if(!found)
{
// No child exists with any prefix of the given key, so add a new one
RadixTreeNode<V> n=new RadixTreeNode<V>(leftoverKey,value);
node.getChildren().add(n);
}
}
// Key and node.getPrefix() share a prefix, so split node
else if(largestPrefixLength<node.getPrefix().length())
{
final String leftoverPrefix=node.getPrefix().substring(largestPrefixLength);

node.printInfo();

//创建一个新的节点
final RadixTreeNode<V> n=new RadixTreeNode<V>(leftoverPrefix,node.getValue());
n.setHasValue(node.hasValue());
n.getChildren().addAll(node.getChildren());

n.printInfo();

//原来的节点升级了(喜当爹)
node.setPrefix(node.getPrefix().substring(0,largestPrefixLength));
node.getChildren().clear();
node.getChildren().add(n);

node.printInfo();

// The largest prefix is equal to the key, so set this node's value
if(largestPrefixLength==key.length())
{
ret=node.getValue();
node.setValue(value);
node.setHasValue(true);
}
//// There's a leftover suffix on the key, so add another child
else
{
final String leftoverKey=key.substring(largestPrefixLength);
final RadixTreeNode<V> n1=new RadixTreeNode<V>(leftoverKey,value);
node.getChildren().add(n1);

node.printInfo();

node.setHasValue(false);
}
}
else
{
// node.getPrefix() is a prefix of key, so add as child
final String leftoverKey=key.substring(largestPrefixLength);
RadixTreeNode<V> n=new RadixTreeNode<V>(leftoverKey,value);
node.getChildren().add(n);
}
return ret;
}

@Override
public V remove(Object key)
{
if(key==null)
{
throw new NullPointerException(KEY_CANNOT_BE_NULL);
}
if(!(key instanceof String))
{
throw new ClassCastException(KEYS_MUST_BE_STRING_INSTANCES);
}

final String sKey=(String)key;
if(sKey.equals(""))
{
final V value=root.getValue();
root.setHasValue(false);
return value;
}
return remove(sKey,root);
}

/**
* Remove the value with the given key from the subtree rooted at the
* given node.
*
* @param key  the key
* @param node  the node to start searching from
*
* @return the value associated with the given key, or <code>null</code>
*         if there was no mapping for <code>key</code>
*/
private V remove(String key,RadixTreeNode<V> node)
{
V ret =null;
final Iterator<RadixTreeNode<V>> iterator=node.getChildren().iterator();
while(iterator.hasNext())
{
final RadixTreeNode<V> child=iterator.next();
final int largestPrefixLen=RadixTreeUtil.largestPrefixLength(key, child.getPrefix());
// Found our match, remove the value from this node
if(largestPrefixLen==key.length() && largestPrefixLen==child.getPrefix().length())
{
if(child.getChildren().isEmpty())
{
ret=child.getValue();
iterator.remove();
break;
}
else if(child.hasValue())
{
//internal node
ret=child.getValue();
child.setHasValue(false);

if(child.getChildren().size()==1)
{
// The subchild's prefix can be reused, with a little modification
final RadixTreeNode<V> subChild=child.getChildren().iterator().next();
final String newPrefix=child.getPrefix()+subChild.getPrefix();

// Merge child node with its single child
child.setValue(subChild.getValue());
child.setHasValue(subChild.hasValue());
child.setPrefix(newPrefix);
child.getChildren().clear();
}
break;
}
}
else if(largestPrefixLen>0 && largestPrefixLen<key.length())
{
// Continue down subtree of child
final String leftoverKey=key.substring(largestPrefixLen);
ret=remove(leftoverKey, child);
break;
}
}
return ret;
}

@Override
public void putAll(Map<? extends String, ? extends V> map)
{
for(Map.Entry<? extends String, ? extends V> entry:map.entrySet())
{
put(entry.getKey(), entry.getValue());
}

}

@Override
public void clear()
{
root.getChildren().clear();
}

@Override
public Set<String> keySet()
{
// TODO documentation Of Map.keySet() specifies that this is a view of
//      the keys, and modifications to this collection should be
//      reflected in the parent structure
//
RadixTreeVisitor<V, Set<String>> visitor=new RadixTreeVisitor<V, Set<String>>()
{
Set<String> result=new TreeSet<String>();

@Override
public void visit(String key, V value)
{
result.add(key);
}

@Override
public Set<String> getResult()
{
// TODO Auto-generated method stub
return result;
}

};
visit(visitor);
return visitor.getResult();
}

@Override
public Collection<V> values()
{
// TODO documentation Of Map.values() specifies that this is a view of
//      the values, and modifications to this collection should be
//      reflected in the parent structure
//
RadixTreeVisitor<V, Collection<V>> visitor=new RadixTreeVisitor<V, Collection<V>>()
{
Collection<V> values=new ArrayList<V>();

@Override
public void visit(String key, V value)
{
values.add(value);
}

@Override
public Collection<V> getResult()
{
return values;
}
};
visit(visitor);
return visitor.getResult();
}

@Override
public Set<java.util.Map.Entry<String, V>> entrySet()
{
// TODO documentation Of Map.entrySet() specifies that this is a view of
//      the entries, and modifications to this collection should be
//      reflected in the parent structure
//
RadixTreeVisitor<V, Set<Map.Entry<String, V>>> visitor=new
RadixTreeVisitor<V, Set<Map.Entry<String, V>>>()
{
Set<Map.Entry<String, V>> result = new HashSet<Map.Entry<String, V>>();

@Override
public void visit(String key, V value)
{
result.add(new AbstractMap.SimpleEntry(key,value));
}

@Override
public Set<java.util.Map.Entry<String, V>> getResult()
{
return result;
}

};

visit(visitor);
return visitor.getResult();
}

}

RadixTreeUtilTest.java

package com.sk.radixtree;

import static org.junit.Assert.*;

import org.junit.Test;

public class RadixTreeUtilTest
{

@Test
public void testDumpTreeRadixTreeNodeOfVString()
{
}

@Test
public void testDumpTreeRadixTreeOfV()
{
}

@Test
public void testLargestPrefixLength()
{
assertEquals(5, RadixTreeUtil.largestPrefixLength("abcdefg", "abcdexyz"));
assertEquals(3, RadixTreeUtil.largestPrefixLength("abcdefg", "abcxyz"));
assertEquals(3, RadixTreeUtil.largestPrefixLength("abcdefg", "abctuvxyz"));
assertEquals(0, RadixTreeUtil.largestPrefixLength("abcdefg", ""));
assertEquals(0, RadixTreeUtil.largestPrefixLength("", "abcxyz"));
assertEquals(0, RadixTreeUtil.largestPrefixLength("xyz", "abcxyz"));
}
}

TestRadixTree.java

package com.sk.radixtree;

import static org.junit.Assert.*;

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.math.BigInteger;
import java.security.SecureRandom;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

import org.junit.Test;

import com.sk.radixtree.*;

public class TestRadixTree
{
private SecureRandom rng=new SecureRandom();

@Test
public void testManyInsertions() {
RadixTree<BigInteger> tree = new RadixTree<BigInteger>();

int n = rng.nextInt(401) + 100; // n in [100, 500]

List<BigInteger> strings = generateRandomStrings(n);
for(BigInteger x : strings)
tree.put(x.toString(32), x);

assertEquals(strings.size(), tree.size());
for(BigInteger x : strings)
assertTrue(tree.containsKey(x.toString(32)));

assertEqualsWithSort(strings, new ArrayList<BigInteger>(tree.values()));
}

private List<BigInteger> generateRandomStrings(int n) {
List<BigInteger> strings = new ArrayList<BigInteger>();
while(n-- > 0) {
final BigInteger bigint = new BigInteger(20, rng);
if(!strings.contains(bigint))
strings.add(bigint);
}
return strings;
}

@Test
public void testRealData() throws IOException {
BufferedReader br = null;

try {
br=new BufferedReader(new InputStreamReader(new FileInputStream("data/dict.dat")));
final RadixTree<String> tree = new RadixTree<String>();

// Read data into a list first, because we want to see how long it
// takes to construct the radix tree but don't want to include
// I/O reads in that time
int numLines = 0;
String line = null;
ArrayList<String[]> lines = new ArrayList<String[]>();
while((line = br.readLine()) != null) {
line = line.trim();
if(line.length() > 0) {
String pieces[] = line.split("\\s+", 2);
if(pieces.length == 2)
lines.add(pieces);
}
}

// Construct tree and time the construction
for(String [] pieces : lines) {
// Just in case the DAT files has multiple of the same key
if(tree.put(pieces[0], pieces[1]) == null)
++numLines;
}

// Perform tests
assertEquals(numLines, tree.size());

assertEqualsWithSort(tree.getValuesWithPrefix("ACCI").toArray(new String[0]), new String[] {
"a269c0caf5ed6edaaf0dfe6af2756256", // ACCIDENT
"cd465f695982b126e418243260f60f9b", // ACCIDENTAL
"e7fdb552e28b0fa234e7f3363d2577ed", // ACCIDENTALLY
"9300fe6261f9198d86879c0925ca652c", // ACCIDENTLY
"6524df69cc016e5d9a3cd03cb8a58815", // ACCIDENTS
"edad4ecb40b0d95df72d3e587692f601", // ACCION
"7868257ae2c6e06f8ccc6841cdc64ff1", // ACCIVAL
});

assertEqualsWithSort(tree.getValuesWithPrefix("OSTEN").toArray(new String[0]), new String[] {
"1eef84bdf3b7307e72b99c0ed0327165", // OSTEN
"5011b15cd7e790336d23b70a48f7bed7", // OSTENDORF
"4ed1b43b743a0dee269d4184880bbffd", // OSTENSIBLE
"d318060019c4f987986e383cf700e7f9", // OSTENSIBLY
"d32a6e75341b4c1797485622bb388c8a", // OSTENSON
"4df4a85a0a9a345a03493c484090002d", // OSTENTATION
"4849c1ab49637b63ba1570b5abf33d1c", // OSTENTATIOUS
"d65f9261a233810f51c73cd38ab1398e", // OSTENTATIOUSLY
});

assertEqualsWithSort(tree.getKeysWithPrefix("OSTEN").toArray(new String[0]), new String[] {
"OSTEN",
"OSTENDORF",
"OSTENSIBLE",
"OSTENSIBLY",
"OSTENSON",
"OSTENTATION",
"OSTENTATIOUS",
"OSTENTATIOUSLY"
});
} finally {
if(br != null)
br.close();
}
}

@Test
public void testRemoval()
{
RadixTree<Integer> tree=new RadixTree<Integer>();
tree.put("test", 1);
tree.put("tent", 2);
tree.put("tank", 3);
assertEquals(3, tree.size());
assertTrue(tree.containsKey("tent"));

tree.remove("key");
assertEquals(3, tree.size());
assertTrue(tree.containsKey("tent"));

tree.remove("tent");
assertEquals(2, tree.size());
assertEquals(1, tree.get("test").intValue());
assertFalse(tree.containsKey("tent"));
assertEquals(3, tree.get("tank").intValue());
}

@Test
public void testSpook()
{
RadixTree<Integer> tree=new RadixTree<Integer>();
tree.put("pook", 1);
tree.put("spook", 2);

assertEquals(2, tree.size());
assertEqualsWithSort(tree.keySet().toArray(new String[0]),
new String[]{"pook","spook"});
}

@Test
public void testPrefixFetch()
{
RadixTree<Integer> tree=new RadixTree<Integer>();
tree.put("test", 1);
tree.put("tent", 2);
tree.put("rest", 3);
tree.put("tank", 4);

assertEquals(4, tree.size());
assertEqualsWithSort(tree.getValuesWithPrefix(""), new ArrayList<Integer>(tree.values()));
assertEqualsWithSort(tree.getValuesWithPrefix("t").toArray(new Integer[0]),
new Integer[]{1,2,4});
assertEqualsWithSort(tree.getValuesWithPrefix("te").toArray(new Integer[0]),
new Integer[]{1,2});
assertEqualsWithSort(tree.getValuesWithPrefix("asd").toArray(new Integer[0]),
new Integer[0]);

}

@Test
public void testMultipleInsertionsOfTheSameKey()
{
RadixTree<Integer> tree=new RadixTree<Integer>();
tree.put("test", 1);
tree.put("tent", 2);
tree.put("tank", 3);
tree.put("rest", 4);

assertEquals(4, tree.size());
assertEquals(1, tree.get("test").intValue());
assertEquals(2, tree.get("tent").intValue());
assertEquals(3, tree.get("tank").intValue());
assertEquals(4, tree.get("rest").intValue());

tree.put("test", 9);
assertEquals(4, tree.size());
assertEquals(9, tree.get("test").intValue());
assertEquals(2, tree.get("tent").intValue());
assertEquals(3, tree.get("tank").intValue());
assertEquals(4, tree.get("rest").intValue());
}

@Test
public void testMultipleInsertions()
{
RadixTree<Integer> tree=new RadixTree<Integer>();
tree.put("test", 1);
tree.put("tent", 2);
tree.put("tank", 3);
tree.put("rest", 4);

assertEquals(4, tree.size());
assertEquals(1, tree.get("test").intValue());
assertEquals(2, tree.get("tent").intValue());
assertEquals(3, tree.get("tank").intValue());
assertEquals(4, tree.get("rest").intValue());
}

@Test
public void testSingleInsertion()
{
RadixTree<Integer> tree=new RadixTree<Integer>();
tree.put("test", 1);
assertEquals(1, tree.size());
assertTrue(tree.containsKey("test"));
}

@Test
public void testEmptyTree()
{
RadixTree<Integer> tree=new RadixTree<Integer>();
assertEquals(0, tree.size());
}

public static <T extends Comparable<? super T>> void assertEqualsWithSort(T[] a,T[] b)
{
Arrays.sort(a);
Arrays.sort(b);
assertArrayEquals(a, b);
}

/**
* A variation of <code>assertEquals</code> that sorts its lists before comparing them.
*
* @param a  one of the lists
* @param b  one of the lists
*/
public static <T extends Comparable<? super T>> void assertEqualsWithSort(
List<T> a,List<T> b)
{
Collections.sort(a);
Collections.sort(b);
assertEquals(a, b);
}

}