[size=medium][/size][color=blue][/color]
最近自己做了一类似于hashSet集合的小程序。该程序通过模仿法hashSet特征,同时也根据自己的一些需要自定义了一些格式内容放里面,实现了add()、search()、remove()等方法。好啦 !废话就少说啦,下面是我对hashSet的一些总结。欢迎各位大侠指点。。。
1. HashSet概述:
HashSet实现Set接口,由哈希表(实际上是一个HashMap实例)支持。它不保证set 的迭代顺序;特别是它不保证该顺序恒久不变。此类允许使用null元素。
2. HashSet的实现:
对于HashSet而言,它是基于HashMap实现的,HashSet底层使用HashMap来保存所有元素,因此HashSet 的实现比较简单,相关HashSet的操作,基本上都是直接调用底层HashMap的相关方法来完成, HashSet的源代码如下:
Java代码
public class HashSet<E>
extends AbstractSet<E>
implements Set<E>, Cloneable, java.io.Serializable
{
static final long serialVersionUID = -5024744406713321676L;
// 底层使用HashMap来保存HashSet中所有元素。
private transient HashMap<E,Object> map;
// 定义一个虚拟的Object对象作为HashMap的value,将此对象定义为static final。
private static final Object PRESENT = new Object();
/**
* 默认的无参构造器,构造一个空的HashSet。
*
* 实际底层会初始化一个空的HashMap,并使用默认初始容量为16和加载因子0.75。
*/
public HashSet() {
map = new HashMap<E,Object>();
}
/**
* 构造一个包含指定collection中的元素的新set。
*
* 实际底层使用默认的加载因子0.75和足以包含指定
* collection中所有元素的初始容量来创建一个HashMap。
* @param c 其中的元素将存放在此set中的collection。
*/
public HashSet(Collection<? extends E> c) {
map = new HashMap<E,Object>(Math.max((int) (c.size()/.75f) + 1, 16));
addAll(c);
}
/**
* 以指定的initialCapacity和loadFactor构造一个空的HashSet。
*
* 实际底层以相应的参数构造一个空的HashMap。
* @param initialCapacity 初始容量。
* @param loadFactor 加载因子。
*/
public HashSet(int initialCapacity, float loadFactor) {
map = new HashMap<E,Object>(initialCapacity, loadFactor);
}
/**
* 以指定的initialCapacity构造一个空的HashSet。
*
* 实际底层以相应的参数及加载因子loadFactor为0.75构造一个空的HashMap。
* @param initialCapacity 初始容量。
*/
public HashSet(int initialCapacity) {
map = new HashMap<E,Object>(initialCapacity);
}
3.以上是我参考了hashSet 源代码再结合自己的一些经验给出的几点看法。下面是我这次对hashSet的亲身体验:
/**
* 主类 用来处理各种哈希事件
* @author
*
*/
public class HashMain {
//定义一个具有初始长度的数组
private InfoNode[] nodeArray = new InfoNode[300];
public static int sum = 100;
/**
* add()方法 添加用户
*/
public void add(int i ,InfoNode node){
int index = hashFuction(i);
if(nodeArray[index]==null){//如果该索引位置的数组值为空
nodeArray[index]=node;
}else{
InfoNode root = nodeArray[index];//根节点
InfoNode next = root.getChild();//此时根节点的下一个节点
root.setChildNode(node);//设置当前节点为子节点
node.setFatherNode(root);
if(next!=null){
//root.getChild().setChildNode(next);
node.setChildNode(next);
next.setFatherNode(node);
}
}
}
/**
* 定义一个查找用户的方法(根据用户名字)
*/
public UserInfo search(String name){
for(int i=0;i<nodeArray.length;i++){
InfoNode root = nodeArray[i];
if(root==null) continue;//如果该数组元素为空 则直接进入下一个循环
while(root!=null){
if(root.getInfo().getName().equals(name)){
return root.getInfo();
}
root = root.getChild();
}
}
return null;
}
/**
* 重载一个查找用户的方法(根据编号)
*/
public UserInfo search(int number){
int index = hashFuction(number);//获得该元素在数组中的索引
InfoNode root = nodeArray[index];
while(root!=null){
if(root.getInfo().getNum()==number){
return root.getInfo();
}
}
return null;
}
/**
* 定义删除某一个用户的方法(根据该用户的名字)
*/
public void remove(String name){
for(int i=0;i<nodeArray.length;i++){
InfoNode root = nodeArray[i];
if(root==null) continue;//如果数组元素为空 则直接进行下一次循环
//如果数组本省的元素就是要找的用户的话
if(root.getInfo().getName().equals(name)){
InfoNode next = root.getChild();
if(next!=null){
nodeArray[i]=next;
System.out.println("删除了名为"+name+"的学生,该学生人气指数为:"+root.getInfo().getNum());
break;
}else{
nodeArray[i]=null;
System.out.println("删除了名为"+name+"的学生,该学生人气指数为:"+root.getInfo().getNum());
break;
}
}
//遍历整个数组以及数组中原所包含的所有节点
while(root!=null){
String userName = root.getInfo().getName();
if(userName.equals(name)){
InfoNode child = root.getChild();
InfoNode father = root.getFather();
if(child!=null){//如果当前root不是最后一个节点
father.setChildNode(child);
child.setFatherNode(father);
}else{//如果当前root是链表末尾节点
father.setChildNode(null);
}
System.out.println("删除了名为"+name+"的学生,该学生人气指数为:"+root.getInfo().getNum());
break;
}
root = root.getChild();
}
}
}
/**
* 哈希函数
*/
public int hashFuction(int i){
int index = i%(nodeArray.length-1);
return index;
}
/**
* 定义重建哈希集合的方法
*/
public void reSetHash(){
InfoNode[] reNodeArray = new InfoNode[sum];
nodeArray = reNodeArray;//,新建一个数组指向原来的数组
init();
}
/**
* 打印数组的方法
*/
public int printArray(){
int count1=0;
int count2=0;
for(int i=0;i<nodeArray.length;i++){
InfoNode nextNode = nodeArray[i];
//遍历整个数组以及数组中原所包含的所有节点
while(nextNode!=null){
String name = nextNode.getInfo().getName();
int number = nextNode.getInfo().getNum();
System.out.println(name+"的人气指数是:"+number);
nextNode = nextNode.getChild();
count1++;
}
//遍历数组本身的元素
if(nodeArray[i]!=null){
count2++;
}
}
return count1-count2;//返回幅值
}
/**
* 初始化数组
* @param userArray
*/
public void init(){
for(int i=0;i<sum;i++){//循环创建用户对象
int number = (int)(Math.random()*400);//产生随机数
String name = "学生"+String.valueOf(i);
UserInfo user = new UserInfo(number,name);
InfoNode node = new InfoNode(user);
add(number,node);//向数组中添加元素
}
}
/**
* 主类
* @param args
*/
public static void main(String[] args) {
HashMain hash = new HashMain();
hash.init();
//***********************建立hash集合
int count = hash.printArray();
System.out.println("幅值为"+count);
//***********************删除某个元素
hash.remove("学生49");
//***********************根据用户名查找某个元素(遍历查找)
int time = (int) System.currentTimeMillis();
UserInfo user = hash.search("学生56");
int last = ((int) System.currentTimeMillis()-time)*1000;
if(user!=null){
System.out.println("查找到了"+user.getName()+"该学生的人气指数是:"+user.getNum()+"用时"+last);
}else{
System.out.println("该hash集合中没有要查找的元素!");
}
//***********************根据编号查找某个元素(索引查找)
int time2 = (int) System.currentTimeMillis();
UserInfo user2 = hash.search(278);
int last2 = ((int) System.currentTimeMillis()-time2)*1000;
if(user2!=null){
System.out.println("查找到了"+user2.getName()+"该学生的人气指数是:"+user2.getNum()+"用时"+last2);
}else{
System.out.println("该hash集合中没有要查找的元素!");
}
//如果链表元素的数目太多则重建hash
if(count>sum*(1.25)){
hash.reSetHash();
System.out.println("重建了hash集合!!!");
}
}
}
这是hashSet的主类,这段代码里面还包含大家最熟悉的InfoNode(用户节点类),以及UserInfo(用户类,即用户节点类的数据域),在这里就不再罗嗦了 :) 。