java项目实战之集合框架

				JAVA项目实战案例练习==集合框架的引用
public class HashSet<E> implements Cloneable{
	public static class HashMap1<K,V> implements Cloneable{
		public HashMap1() {
			this.loadFactor = DEFAULT_LOAD_FACTOR ;
			this.modCount = 0 ; 
			this.size = 0 ;
			this.table = null ;
			this.threshold = 0 ;
		}
		/**
		 * 一个集合副本  
		 *//*1460*/
		@SuppressWarnings("unchecked")
		public Object clone() {
			HashMap1<K,V> value ;
			try {
				value = (HashMap1<K,V>)super.clone() ;
			}catch( CloneNotSupportedException e) {
				throw new InternalError(e);
			}
			
			return value ;
		}
		/**
		 * 把集合中的有参数的数值重新组装在新的集合里面
		 * @param <T>
		 * @param v
		 * 新的数组
		 * @return
		 */
		<T> T[] keysArray(T[] v ){
			Object r[] = v ;
			Node1<K,V> node[] = table ; int u = 0 ;
			if (size >0 && node != null) {
				for(Node1<K,V> value : node) {
					for( ; value != null ; value = value.next ) {
						r[u++] = value.key ;
					}
				}
			}
			return v ;
		}
		public Object[] toArray() {
			return keysArray( new Object[size()]);
		}
		/**
		 * 
		 * @param hash
		 * 指定数值的哈希值
		 * @param key
		 * 指定的数值
		 * @param value
		 * 为 null
		 * @param matchValue
		 * 为false
		 * @param movable 
		 * 为 true
		 * @return
		 * 返回一个与其同等的数值
		 */
		final Node1<K,V> removeNode ( int hash , Object key , Object value , boolean matchValue , boolean movable ) {
			Node1<K,V> tab[] ; Node1<K,V> p ; int n , index ;
			if ((tab = table) != null && (n = tab.length) > 0 && ( p = tab[ index = ( n-1) & hash ]) != null) {
				Node1<K,V> node = null , e ; K k ; V v ;
				if ( p.hash == hash &&(( k = p.key ) == key || ( key != null && key.equals( k ))))
					node = p ;
				if ( ( e = p.next) != null)
					do {
						if ( e.hash == hash && ( ( k = e.key ) == key || ( key != null && key.equals( k )))) {
							node = e ;
							break ; 
						}
					}while( ( e = e.next ) != null);
				if ( node != null && ( !matchValue || ( v = node.value) == value || ( value != null && value.equals( v )))) {
					if ( node == p)
						tab[index] = node.next ;
					else 
						p.next = node.next ;
					size-- ;
//					System.out.println(!matchValue);
					return node ;
				}
			}
				
			return null ;
		}
		/**
		 * 从该集合中删除指定的元素（如果存在）
		 * @param key
		 * 指定的元素
		 * @return
		 */
		/*797*/
		 public V remove (Object key) {
			 Node1<K,V> e ;
			 return ( e = removeNode( hash(key) , key , null , false , true ) ) == null ? null : e.value ;
		 }
		 public void reiainitble() {
			 this.table = null ;
			 this.size = 0 ;
			 this.threshold = 0 ;
			 this.modCount = 0 ;
		 }
		/**
		 * 清空元素
		 */
		public void clear() {
			if ((table) != null && size > 0 ) {
				reiainitble();
			}
		}
		/**
		 * 集合中有多少个数值
		 * @return
		 */
		public int size() {
			return size ;
		}
		/**
		 * true : 集合中不包含任何值 否则为false
		 * @return
		 */
		public boolean isEmpty() {
			return size == 0 ;
		}
		/**
		 * 对象在不在集合中
		 * @param key
		 * 我要找的对象
		 * @return
		 * boolean : false 与 true
		 */
		final Node1<K,V> getNode(Object key) {
			Node1<K,V> tab[] ; Node1<K,V> first , e ; int n , hash ; K k ;
			if ((tab = table) != null &&  (n = tab.length) > 0 && (first = tab[(n-1) & (hash = hash(key))]) != null) {
				if (first.hash == hash && ((k = first.key) == key || (key != null && key.equals(k))))
					return first ;
				if ((e = first.next) != null)
					do {
						if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k))))
							return e ;
					}while((e = e.next) != null) ;
			}
			return null ;
		}
		/**
		 * 引用于 getNode, 对象查找
		 * @param key
		 * @return
		 * 
		 */
		public boolean containsKey( Object key) {
			return getNode(key) != null ;
		}
		 transient HashSet<K>        keySet;
		private void afterNodeInsertion (boolean evict ) {}
		private transient int modCount ;
		private transient int size ;
		private void afterNodeAccess(Node1<K,V> p) {}
		/*1287*/
		private Node1<K,V> newNode(int hash , K key , V value , Node1<K,V> next ){
			return new Node1<>(hash , key , value , next);
		}
		private transient int threshold ;
		private static final  int MAXIMUM_CAPACITY = 1 << 30 ;
		private static final int MAX_VALUE = 0x7fffffff ;
		private static final int DEFAULT_INITIAL_CAPACITY = 1 << 4 ;
		private static final float DEFAULT_LOAD_FACTOR = 0.75f ;
		final float loadFactor ;
		private final Node1<K,V>[] resize(){
			Node1<K,V> oldTab[] = table ;
			int oldCap = ( oldTab == null ) ? 0 : oldTab.length ;
			int oldThr = threshold ;
			int newCap , newThr = 0 ;
			if(oldCap > 0 ) {
				if( oldCap >= MAXIMUM_CAPACITY ) {
					threshold = MAX_VALUE ;
					return oldTab ;
				}else if( (newCap = oldCap << 1 ) < MAXIMUM_CAPACITY && oldCap >= DEFAULT_INITIAL_CAPACITY)
					newThr = oldThr << 1 ;
			}
			else if(oldThr > 0 )
				newCap = oldThr ;
			else {
				newCap = DEFAULT_INITIAL_CAPACITY ;
				newThr = (int)( DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY) ;
			}
			if(newThr == 0 ) {
				float ft = (float)newCap * loadFactor ;
				newThr = ( newCap < MAXIMUM_CAPACITY && ft <MAXIMUM_CAPACITY ? (int)ft : MAX_VALUE) ;
			}
			threshold = newThr ;
			@SuppressWarnings("unchecked")
			Node1<K,V> newTab[] = new Node1[newCap] ;
			table = newTab ;
			if(oldTab != null ) {
				for (int j = 0 ; j < oldCap ; ++j) {
					Node1<K,V> e;
					if((e = oldTab[j]) != null ) {
						oldTab[j] = null ;
						if(e.next == null )
							newTab[e.hash & (newCap - 1)] =e ;
							Node1<K,V> loHead = null , loTail = null ;
							Node1<K,V> hiHead = null , hiTail = null ;
							Node1<K,V> next ;
							do {
								next = e.next ;
								if((e.hash & oldCap ) == 0 ) {
									if(loTail == null)
										loHead = e ;
									else
										loTail = e ; 
									loTail = e ;
								}else {
									if(hiTail == null )
										hiHead = e ;
									else 
										hiTail.next = e ;
									hiTail = e ;
								}
							}while((e = next) != null );
							if(loTail != null ) {
								loTail.next = null ;
								newTab[j] = loHead ;
							}
							if(hiTail != null ) {
								hiTail.next = null ; 
								newTab[j+oldCap] = hiHead ;
							}
					}
				}
			}
			return newTab ;
		}
		private transient Node1<K,V>[] table ;
		/*1376*/
		private final V putVal( int hash , K key , V value , boolean only ,boolean evict ) {
			Node1< K ,V > tab[] ; Node1< K, V > p ; int n , i ;
			if(( tab = table) == null || ( n = tab.length ) == 0)
				n = ( tab = resize() ).length ;
			if((p = tab[i = (n - 1) & hash ]) == null)
				tab[i] = newNode(hash , key , value , null) ;
			else {
				Node1<K,V> e =null ; K k ;
				if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k))))
					e = p ;
				if ( e != null) {
					V oldValue = e.value ;
					if (! only || oldValue == null)
						e.value =value ;
					afterNodeAccess(e) ;
					return oldValue ;
				}
			}
			++modCount ;
			++size ;
			if (size > threshold - 2 ) {
				resize();
			}
			afterNodeInsertion(evict);
			return null ;
		}
		private static final int hash(Object key ) {
			int h ;
			return ( key == null ) ? 0 : ( h = key.hashCode() ) ^ ( h >>> 16 ) ;
		} 
		/*1439*/
		public V put( K key , V value ) {
			return putVal( hash( key ) , key , value , false , true ) ;
		}
		public static class Node1<K,V> {
			
			Node1<K,V> next ;
			final int hash ;
			final K key ; 
			V value ;
			Node1(int hash , K key ,V value , Node1<K,V> next){
				this.hash = hash ;
				this.key = key ; 
				this.value = value ; 
				this.next = next ;
			}
			public synchronized String toString() {
				return key + "=" + value ;
			}
			
		}
		
//		@SuppressWarnings("unused")
//		private static final class TreeNode1<K,V> extends LinkedhashMap1.Entry<K, V>{
//			TreeNode1(int hash ,K key , V value , Node1<K,V> next){
//				super(hash ,key ,value , next );
//			}
//		}
	}
	public static class LinkedhashMap1<K,V> extends HashMap1<K,V>{
		
		static class Entry<K,V> extends Node1<K,V>{
			Entry(int hash ,K key , V value , Node1<K,V> next) {
				super(hash , key , value, next);
			}
		}
	}
	public HashSet() {
		this.map = new HashMap1<>();
	}
	private static final Object PRESENT = new Object () ;
	private transient HashMap1< E , Object > map ;
	/**
	 * 把数值存进集合里
	 * @param e
	 * @return
	 */
	public boolean add( E e ) {
		return map.put( e , PRESENT) == null ;
	}
	/**
	 * 删除集合中所有元素 ，集合为空
	 */
	public void clear() {
		map.clear() ;
	}
	/**
	 * true : 如果此集合中不包含任何元素
	 * false ： 如果此集合中包含元素
	 * @return
	 */
	public boolean isEmpty() {
		return map.isEmpty() ;
	}
	/**
	 * 如果此集合包含指定的元素，则返回true。，否则就是false
	 * @param key
	 * 对象
	 * @return
	 * boolean : false 于 true
	 */
	public boolean contains ( Object key ) {
		return map.containsKey(key) ;
	}
	/**
	 * 从该集合中删除指定的元素（如果存在）
	 * @param key
	 * @return
	 */
	public boolean remove(Object key ) {
		return map.remove(key) == PRESENT ;
	}
	/**
	 * 集合中有多少个值
	 * @return
	 */
	public int size() {
		return map.size();
	}
	/**
	 * 返回一组数组，此数组包含集合参数里面的所有元素
	 * @return
	 */
	public Object[] toArray() {
		return map.toArray() ;
	}
	/**
	 * 展现集合里面的参数
	 */
	@SuppressWarnings("unchecked")
	public HashSet<E> clone() {
		try {
			HashSet<E> newSet = (HashSet<E>)super.clone() ;
			newSet.map = (HashMap1<E,Object>)map.clone() ;
			return newSet ;
		} catch ( CloneNotSupportedException e) {
			throw new InternalError(e);
		}
	}
	public String toString() {
		HashMap1.Node1<E, Object> table[] = map.table  ;
        int t = map.size - 1 ; int k = 0 ;
        if (map.size == 0)
            return "[ ]";
        StringBuilder buff = new StringBuilder();
        int r = table.length ;
        buff.append("[ ");
        HashMap1.Node1<E,Object> value ;
        for ( int i = 0;  ; i++) {
        	for(  ; k < r ; k++) {
        		value = table[k] ;
        		if(table[k] != null ) {
        			E key =value.key ;
        			buff.append(key == this ? "?" : key.toString()) ;
        			k++ ;
        			break ;
        		}
        	}
        	if( i == t) {
        		return buff.append(" ]").toString() ;
        	}
        	buff.append(" , ") ;
        }
    }
}

方法的调用
			HashSet<Object> hash = new HashSet<Object>() ; 
			for(int ts = 0 ;ts < 10 ; ts++) {
				hash.add("klfjklasjf" + ts) ;
			}
			/*往集合里面存值*/
			System.out.println(hash.add("kjfksfhkjshf"));
			/*如果此集合包含指定的元素，则返回true。，否则就是false*/
			System.out.println(hash.contains("kjfksfhkjshf")) ;
			/*如果集合为空，就返回true,否则就是false*/
			System.out.println(hash.isEmpty());
			/*从该集合中删除指定的元素（如果存在）*/
			System.out.println(hash.remove("kjfksfhkjshf"));
			/*集合里面一共有多少个值*/
			System.out.println(hash.size());
			/*展现集合里面的参数*/
			System.out.println(hash.clone());