第二十二讲 HashSet和HashMap、迭代器、TreeMap集合、Collections工具类、JDK8之Optional类

导读

HashSet：无序集合，而且HashSet继承AbstractSet类，实现Set、Cloneable、Serializable接口。

HashMap：键与值的对应存储模式。

迭代器：基于集合上的“游标”指示符。

TreeMap：有序Map集合。

Collections：集合元素操作工具类。

Option类是属于JDK8的新特性。

一、HashSet的应用

//基于HashMap实现，底层使用HashMap保存所有元素  
private transient HashMap<E,Object> map;  
 
  //定义一个Object对象作为HashMap的value  
 private static final Object PRESENT = new Object();  

/** 
         * 默认构造函数 
         * 初始化一个空的HashMap，并使用默认初始容量为16和加载因子0.75。 
         */  
        public HashSet() {  
            map = new HashMap<>();  
        }  
          
        /** 
         * 构造一个包含指定 collection 中的元素的新 set。 
         */  
        public HashSet(Collection<? extends E> c) {  
            map = new HashMap<>(Math.max((int) (c.size()/.75f) + 1, 16));  
            addAll(c);  
        }  
          
        /** 
         * 构造一个新的空 set，其底层 HashMap 实例具有指定的初始容量和指定的加载因子 
         */  
        public HashSet(int initialCapacity, float loadFactor) {  
            map = new HashMap<>(initialCapacity, loadFactor);  
        }  
             
        /** 
         * 构造一个新的空 set，其底层 HashMap 实例具有指定的初始容量和默认的加载因子（0.75）。 
         */  
        public HashSet(int initialCapacity) {  
           map = new HashMap<>(initialCapacity);  
        }  
             
        /** 
         * 在API中我没有看到这个构造函数，今天看源码才发现（原来访问权限为包权限，不对外公开的） 
         * 以指定的initialCapacity和loadFactor构造一个新的空链接哈希集合。 
         * dummy 为标识 该构造函数主要作用是对LinkedHashSet起到一个支持作用 
         */  
        HashSet(int initialCapacity, float loadFactor, boolean dummy) {  
           map = new LinkedHashMap<>(initialCapacity, loadFactor);  
        }  

HashSet常用方法一览——

public int size() {  
        return map.size();  
}  


public boolean isEmpty() {  
        return map.isEmpty();  
}  


public boolean contains(Object o) {  
        return map.containsKey(o);  
}


public boolean add(E e) {  
        return map.put(e, PRESENT)==null;  
}    


public boolean remove(Object o) {  
        return map.remove(o)==PRESENT;  
}  


public void clear() {  
        map.clear();  
} 


public Object clone() {  
   try {  
        HashSet<E> newSet = (HashSet<E>) super.clone();  
newSet.map = (HashMap<E, Object>) map.clone();  
         return newSet;  
} catch (CloneNotSupportedException e) {  
        throw new InternalError();  
          }  
}   

HashMap相关代码如下：

/** JNI，调用底层其它语言实现 */  
public native int hashCode();  
  
/** 默认同==，直接比较对象 */  
public boolean equals(Object obj) {  
    return (this == obj);  
}  

public boolean equals(Object anObject) {  
    if (this == anObject) {  
        return true;  
    }  
    if (anObject instanceof String) {  
        String anotherString = (String) anObject;  
        int n = value.length;  
        if (n == anotherString.value.length) {  
            char v1[] = value;  
            char v2[] = anotherString.value;  
            int i = 0;  
            // 逐个判断字符是否相等  
            while (n-- != 0) {  
                if (v1[i] != v2[i])  
                        return false;  
                i++;  
            }  
            return true;  
        }  
    }  
    return false;  
}

HashMap示意图如下——

添加元素的put方法详解代码如下——

public V put(K key, V value) {  
    // 处理key为null，HashMap允许key和value为null  
    if (key == null)  
        return putForNullKey(value);  
    // 得到key的哈希码  
    int hash = hash(key);  
    // 通过哈希码计算出bucketIndex  
    int i = indexFor(hash, table.length);  
    // 取出bucketIndex位置上的元素，并循环单链表，判断key是否已存在  
    for (Entry<K,V> e = table[i]; e != null; e = e.next) {  
        Object k;  
        // 哈希码相同并且对象相同时  
        if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {  
            // 新值替换旧值，并返回旧值  
            V oldValue = e.value;  
            e.value = value;  
            e.recordAccess(this);  
            return oldValue;  
        }  
    }  
  
    // key不存在时，加入新元素  
    modCount++;  
    addEntry(hash, key, value, i);  
    return null;  
}  

     Java迭代器——

概念：迭代器是一种设计模式，它是一个对象，它可以遍历并选择序列中的对象，而开发人员不需要了解该序列的底层结构。

Java中的Iterator功能比较简单，并且只能单向移动：注意：iterator()方法是java.lang.Iterable接口,被Collection继承。

(1) 使用方法iterator()要求容器返回一个Iterator。第一次调用Iterator的next()方法时，它返回序列的第一个元素。

(2) 使用next()获得序列中的下一个元素。
(3) 使用hasNext()检查序列中是否还有元素。
(4) 使用remove()将迭代器新返回的元素删除。

代码如下：

 list l = new ArrayList();
 l.add("aa");
 l.add("bb");
 l.add("cc");

 for (Iterator iter = l.iterator(); iter.hasNext();) {
  String str = (String)iter.next();
  System.out.println(str);
 }

 /*迭代器用于while循环
 Iterator iter = l.iterator();
 while(iter.hasNext()){
  String str = (String) iter.next();
  System.out.println(str);
 }
 */