课程设计--哈希表实现Java关键字存储

package 散列映射;

public class SinglyList<T> extends Object //implements List<T>

{
    public Node<T> head;
    public SinglyList()
    {
        this.head = new Node<T>();
    }

    public SinglyList(T[] values)
    {
        this();
        Node<T> rear = this.head;
        for(int i=0; i<values.length; i++)
        {
        	if(values[i]!=null)
            {
                rear.next = new Node<T>(values[i], null);  
                rear = rear.next;                
            }
        }
    }

   
    public boolean isEmpty()                    
    {
        return this.head.next==null;
    }

    public T get(int i)                          //
    {
        Node<T> p=this.head.next;
        for(int j=0;  p!=null && j<i;  j++)     
            p = p.next;
        return (i>=0 && p!=null) ? p.data : null;
    }
   

    public void set(int i, T x)
    {
        if(x==null)
            throw new NullPointerException("x==null");    
        else
        {
            Node<T> p=this.head.next;
            for(int j=0;  p!=null && j<i;  j++) 
               p = p.next;
            if(i>=0 && p!=null)
               p.data = x;                      
            else throw new IndexOutOfBoundsException(i+"");쳣
        }
    }
    
 
    public String toString()
    {
        String str="(";
//        String str=this.getClass().getName()+"(";
        for(Node<T> p=this.head.next;  p!=null;  p=p.next) 
        {
//            str += p.data.toString();
//            if(p.next!=null) 
//                str += ","; 
            str += p.data.toString()+(p.next!=null?",":"");//
        }
        return str+")";                      
    }
    
    public int size()                          
    {
        int i=0; 
        for(Node<T> p=this.head.next;  p!=null;  p=p.next) 
            i++;
        return i;
    }
    

    public Node<T> insert(int i, T x)
    {
        if(x==null)
            return null;
        Node<T> front=this.head;
        for(int j=0;  front.next!=null && j<i;  j++)
            front = front.next;
        front.next = new Node<T>(x, front.next);
        return front.next;
    }
    public Node<T> insert(T x)
    {

        return insert(Integer.MAX_VALUE, x);
    }

    public T remove(int i)
    {
        Node<T> front=this.head;
        for(int j=0;  front.next!=null && j<i;  j++)
            front = front.next;
        if(i>=0 && front.next!=null)
        {
            T x = front.next.data;
            front.next = front.next.next;
            return x;
        }
        return null;
    }

    public void clear()
    {
        this.head.next = null;
    }


    public Node<T> search(T key)
    {

        for(Node<T> p=this.head.next;  p!=null;  p=p.next)
        {

            if(key.equals(p.data))
              return p;
        }
        return null;
    }


    public T remove(T key)
    {

        for(Node<T> front=this.head, p=front.next; p!=null; front=p, p=p.next)
        {
            if(key.equals(p.data))
            {
                front.next = p.next;
                return p.data;
            }
        }
        return null;
    }

    
    public SinglyList(SinglyList<T> list)
    {
        this();
        this.copy(list);
    }
    public void copy(SinglyList<T> list)
    {
    	this.clear();
    	Node<T> rear=this.head;
        for(Node<T> p=list.head.next; p!=null; p=p.next)
        {
            rear.next = new Node<T>(p.data, null);
            rear = rear.next;
        }
    }
    
    public boolean equals(Object obj)
    {
        System.out.print(this.getClass().getName()+".equals("+obj.getClass().getName()+")��");
        if(this==obj)
            return true;
        if(obj instanceof SinglyList<?>)
        {
            Node<T> p=this.head.next;
            Node<T> q=((SinglyList<T>)obj).head.next;
            while(p!=null && q!=null && p.data.equals(q.data))
            {
                p=p.next;
                q=q.next;
            }
            return p==null && q==null;
        }
        return false;
    }   
    

    public void concat(SinglyList<T> list)
    {
        Node<T> rear=this.head;
        while(rear.next!=null)
            rear = rear.next;
        rear.next = list.head.next;
        list.head.next = null;
    }


    public void addAll(SinglyList<T> list)
    {
        this.concat(new SinglyList<T>(list));
    }


    public SinglyList<T> union(SinglyList<T> list)
    {
        SinglyList<T> result = new SinglyList<T>(this);
        result.addAll(list);
        return result;
    }

   
   

    public java.util.Iterator<T> iterator()
    {
        return new SinglyIterator();
    }

    private class SinglyIterator implements java.util.Iterator<T>
    {
        Node<T> current=SinglyList.this.head;
        Node<T> front=null;

        public boolean hasNext()
        {
            return this.current!=null && this.current.next!=null;
        }

        public T next()
        {
            if(this.hasNext())
            {
                this.front = this.current;
                this.current = this.current.next;
                return this.current.data;
            }
            else
                throw new java.util.NoSuchElementException();
        }

        public void remove()
        {
            if(this.front!=null)
            {
                this.front.next = this.current.next;
                this.current = this.front;
                this.front=null;
            }
            else
                throw new IllegalStateException();
        }
    }
}

Node节点类

package 散列映射;
public class Node<T>
{
    public T data;
    public Node<T> next;

    public Node(T data, Node<T> next)
    {
        this.data = data;
        this.next = next;
    }
    public Node()
    {
        this(null, null);
    }


    public String toString()
    {
        return this.data.toString();
    }
    

}

Map接口

package 散列映射;

public interface Map<K, V>
{
    public abstract V get(K key);
    public abstract V put(K key, V value);
    public abstract V remove(K key);
}

键值类

package 散列映射;

public class KeyValue<K, V>
{
    final K key;
    V value;
    
    public KeyValue(K key, V value)
    {
        this.key = key;
        this.value = value;
    }
    public String toString()
    {
        return "("+this.key+","+this.value+")";
    }
    public final int hashCode()
    {
        return this.key.hashCode();
    }
    public boolean equals(Object obj)
    {
        return obj==this ||
               obj instanceof KeyValue<?,?> && this.key.equals(((KeyValue<K,V>)obj).key);
    }
}

hashset类

package 散列映射;

import java.util.Set;


public  class HashSet<T>

{
    private SinglyList<T>[] table;//单链表
    private int count = 0;
    public static final float LOAD_FACTOR=0.75f;//填装因子
    private static final int CAPACITY = 1<<4;
    
    public HashSet(int length)
    {
        if(length<10)
            length=10;
        
        this.table = new SinglyList[length];
        for(int i=0; i<this.table.length; i++)
            this.table[i] = new SinglyList<T>();
    }
    public HashSet()
    {
        this(CAPACITY); 
    }
    public HashSet(T[] values)
    {

        this(10);
        for(int i=0; i<values.length; i++)
            this.add(values[i]);
    }


    private int hash(T x)
    {
        int k = Math.abs(x.hashCode());//每个对象的haashcode返回（）int
        return k % this.table.length;//除留余数法 除数是散列表容量
    }
    
    public T search(T key)
    {

        Node<T> find = this.table[this.hash(key)].search(key);
        return find==null ? null : find.data;
    }


    public boolean add(T x)
    {
        if(x==null || this.search(x)!=null)
            return false;
        if(this.count>this.table.length*LOAD_FACTOR)
        {


            SinglyList<T>[] source = this.table;
            this.table = new SinglyList[this.table.length*2];
            for(int i=0; i<this.table.length; i++)
                this.table[i] = new SinglyList<T>();

            for(int i=0; i<source.length; i++)
                for(Node<T> p=source[i].head.next; p!=null; p=p.next)
                    this.table[this.hash(p.data)].insert(0, p.data);

        }
        this.count++;
        return this.table[this.hash(x)].insert(0,x)!=null;
    }         
    
    public T remove(T key)
    {
        T x = this.table[this.hash(key)].remove(key);
        if(x!=null)
            this.count--;
        return x;
    }
    
      public boolean isEmpty()
    {
        return this.count==0;
    }
    public int size()
    {
        return count;
    }
    
    public boolean contains(T key)
    {
        return this.search(key)!=null;
    }
    
    public void clear()
    {
        for(int i=0; i<this.table.length; i++)
            this.table[i].clear();
    }
    

    public void addAll(T[] values)
    {
        for(int i=0; i<values.length; i++)
            this.add(values[i]);
    }
    

    public String toString()
    {
        String str=this.getClass().getName()+"(";
        boolean first=true;
        for(int i=0; i<this.table.length; i++)
            for(Node<T> p=this.table[i].head.next;  p!=null;  p=p.next)
            {
                if(!first)
                    str += ",";
                first=false;
                str += p.data.toString();
            }
        return str+")";
    }

//    public void printAll()
//    {
//        System.out.println("ɢ�б�����="+this.table.length+"��"+this.count+"��Ԫ��"+
//                           "��hash(key)=key % "+this.table.length+"��"+this.toString());
//        for(int i=0;  i<this.table.length;  i++) //������ͬ��ʵ�����
//            System.out.println("table["+i+"]="+this.table[i].toString());
//
//        System.out.print("ASL�ɹ�=(");
//        int asl=0;
//        for(int i=0;  i<this.table.length;  i++)
//        {
//            int j=1;
//            for(Node<T> p=this.table[i].head.next;  p!=null;  p=p.next,j++)
//            {
//                System.out.print((asl==0 ? "" : "+")+j);
//                asl+=j;
//            }
//        }
//        if(count==0)
//            System.out.println(") = 0\n");
//        else
//            System.out.println(")/"+count+" ="+asl+"/"+count+" ="+((asl+0.0)/count)+"\n");
//    }
//
//
    

    public Object[] toArray()
    {
        Object[] values = new Object[this.size()];
        int j=0;
        for(int i=0; i<this.table.length; i++)
            for(Node<T> p=this.table[i].head.next;  p!=null;  p=p.next)
                values[j++] = p.data;
        return values;
    }
    

    public void enlarge(int length)
    {
        this.table = new SinglyList[length];
        for(int i=0; i<this.table.length; i++)
            this.table[i] = new SinglyList<T>();
    }
    

    public boolean equals(Object obj)
    {return false;}
    public boolean containsAll(Set<? extends T> set)
    {return false;}
    public boolean addAll(Set<? extends T> set)
    {return false;}    
    public boolean removeAll(Set<? extends T> set)
    {return false;}
    public boolean retainAll(Set<? extends T> set)
    {return false;}
}

Hashmap类

package 散列映射;

public class HashMap<K, V> implements Map<K,V>
{
    HashSet<KeyValue<K,V>> set;

    public HashMap(int length)
    {
        this.set = new HashSet<KeyValue<K,V>>(length);
    }
    public HashMap()
    {
        this.set = new HashSet<KeyValue<K,V>>();
    }

    public V get(K key)
    {
        KeyValue<K,V> find=this.set.search(new KeyValue<K,V>(key,null));

        return find!=null ? find.value : null;
    }
    
    public V put(K key, V value)
    {
        KeyValue<K,V> kv = new KeyValue<K,V>(key,value);
        if (!this.set.add(kv))
            this.set.search(kv).value = value;
        return value;
    }
    
    public V remove(K key)
    {
        return this.set.remove(new KeyValue<K,V>(key,null)).value; 
    }
    

    public String toString()
    {
        return this.set.toString(); 
    }
    
//    public void printAll()
//    {
//        this.set.printAll();
//    }

    public static void main(String[] args) {
         String  [] list={"int","double","boolean","char","byte","short","if","else","for","while","do"};
        HashMap hashMap=new HashMap();
        hashMap.set=new HashSet<>(list);
        System.out.println(hashMap); //set里面有值的

        System.out.println(hashMap.set.contains("int"));
        System.out.println(hashMap.set.contains("aaa"));
        System.out.println(hashMap.set.search("int"));
        System.out.println(hashMap.set.search("byte"));


    }
}