Java集合

集合框架图



java.lang.Iterable<T> : 实现这个接口允许对象成为 "foreach" 语句的目标
     |     |方法
     |     |------- Iterator<T> iterator() 返回一个在一组 T 类型的元素上进行迭代的迭代器
     |
     |子类
     |--- java.util.Collection<E> Collection 层次结构 中的根接口。
     |                  |             Collection 表示一组对象，这些对象也称为 collection 的元素
     |                  |
     |                  |
     |                  |子类
     |                  |-------- java.util.List<E>
     |                  |                       |
     |                  |                       |------- java.util.ArrayList<E>实现类
     |                  |                       |------- java.util.LinkedList<E>实现类
     |                  |                       |------- java.util.Vector<E>实现类
     |                  |                       |            |子类
     |                  |                       |            |------- java.util.Stack<E>
     |                  |子类
     |                  |-------- java.util.Queue<E>
     |                  |                       |子类
     |                  |                       |------ java.util.Deque<E>
     |                  |                       |           |实现类
     |                  |                       |           |---- java.util.LinkedList<E>
     |                  |   
     |                  | 子类
     |                  |-------- java.util.Set<E>
     |                  |          |------- java.util.HashSet<E>实现类
     |                  |          |------- java.util.TreeSet<E>
     |                  |          |实现NavigableSet,NavigableSet继承SortedSet,SortedSet继承Set
     |                  |          |------- java.util.LinkedHashSet<E>实现类并继承HashSet
     
     
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

java.util.Map<K,V>
     |
     |------ java.util.HashMap<K,V>实现类
     |
     |------ java.util.Hashtable<K,V>实现类
     |                       |子类
     |                       |------ java.util.Properties
     |
     |
     |--- java.util.SortedMap<K,V>子类
     |                  |子类
     |                  |-------- java.util.NavigableMap<K,V>
     |                  |                       |实现类
     |                  |                       |------- java.util.TreeMap<K,V>
     |
     |
     |--- java.util.concurrent.ConcurrentMap<K,V>子类
     |                  |实现类
     |                  |-------- java.util.concurrent.ConcurrentHashMap<K,V>

Iterator:迭代器，它是Java集合的顶层接口（不包括 map 系列的集合，Map接口是 map 系列集合的顶层接口）。

Collection接口是集合类的根接口，Java中没有提供这个接口的直接的实现类。但是却让其被继承。Collection继承的是类 Iterable，Iterable里面封装了 Iterator 接口。所以只要实现了只要实现了Iterable接口的类，就可以使用Iterator迭代器。Collections中containsAll，contains，removeAll，remove是根据equals方法定义的。

List、Set和Queue继承Collection。

Map是Java.util包中的另一个接口，它和Collection接口没有关系，是相互独立的，但是都属于集合类的一部分。Map包含了key-value对。Map不能包含重复的key，但是可以包含相同的value。

HashMap和Hashtable实现接口Map，SortedMap和ConcurrentMap继承接口Map。

List接口特点

1、有序的 collection。
2、可以对列表中每个元素的插入位置进行精确地控制。
3、可以根据元素的索引访问元素，并搜索列表中的元素。
4、列表通常允许重复的元素。
5、允许存在 null 元素。
6、实现List接口的常用类有LinkedList、ArrayList、Vector和Stack。

List排序

1、按照自然顺序排序 : sort( List<T> list )
自然顺序: 实现Comparable接口才能自然排序。 java.lang.Comparable<T>Comparable 接口强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，Comparable类的 compareTo 方法被称为它的自然比较方法。
public int compareTo( T o ) 如果该对象小于、等于或大于指定对象，则分别返回负整数、零或正整数。

package ecut.collection;

// 声明 java.lang.Comparable 接口时，<T> 表示类型参数 ( "形参")
// 在 实现接口 时，<Panda> 也是类型参数 ( "实参" )
public class Panda implements Comparable<Panda>{

    private Integer id;
    private String name;

    public Panda(Integer id, String name) {
        super();
        this.id = id;
        this.name = name;
    }
    //确定比较规则，Integer id比较时不能用==，应该用equals方法
    @Override
    public int compareTo( Panda another ) {
        if( this.id != null && another.id != null ) {
            return  this.id - another.id ; // this.id  和 another.id 不能是负数
            /*
            if( this.id < another.id ){
                return -1 ;
            } else if( this.id.equals(  another.id ) ) {
                return 0 ;
            } else {
                return 1 ;
            }
            */
        }
        return 0;
    }

    @Override
    public String toString() {
        return "(id=" + id + ", name=" + name + ")";
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

}

package ecut.collection;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class SortListTest1 {

    public static void main(String[] args) {
        
        List<Panda> list = new ArrayList<>();
        
        list.add( new Panda( 100 , "桂花" ) );
        list.add( new Panda( 88 , "花菜" ) );
        list.add( new Panda( 200 , "团团" ) );
        list.add( new Panda( 99 , "圆圆" ) );
        
        System.out.println( list );
        
        Collections.sort( list );//列表中的所有元素都必须实现 Comparable 接口。
        
        System.out.println( list );//重写了toString方法，因此可以直接输出。
        
        
    }

}

运行结果如下：

[(id=100, name=桂花), (id=88, name=花菜), (id=200, name=团团), (id=99, name=圆圆)]
[(id=88, name=花菜), (id=99, name=圆圆), (id=100, name=桂花), (id=200, name=团团)]

2、按照比较器进行排序: sort(List<T> list, Comparator<? super T> c)
比较器: java.util.Comparator<T> 强行对某个对象 collection 进行整体排序的比较函数
int compare ( T o1 , T o2 ) 比较用来排序的两个参数:根据第一个参数小于、等于或大于第二个参数分别返回负整数、零或正整数。

package ecut.collection;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class SortListTest2 {

    public static void main(String[] args) {
        
        List<Panda> list = new ArrayList<>(); // "菱形"语法
        
        list.add( new Panda( 100 , "桂花" ) );
        list.add( new Panda( 88 , "花菜" ) );
        list.add( new Panda( 200 , "团团" ) );
        list.add( new Panda( 99 , "圆圆" ) );
        
        System.out.println( list );
        
        // 创建一个用来比较 Panda 类型对象的 比较器 ( 裁判 )
        Comparator<Panda> c = new Comparator<Panda>(){
            @Override
            public int compare(Panda o1, Panda o2) {
                if( o1 != null && o2 != null ) {
                    String name1 = o1.getName() ;
                    String name2 = o2.getName();
                    if( name1 != null ){
                        // String 类实现了 Comparable 接口的 compareTo 方法
                        return name1.compareTo( name2 );
                    }
                }
                return 0;
            }
        };//Comparator是接口因此要用匿名内部类实现抽象的方法

        Collections.sort( list , c ); // 根据给定的比较器来排序
        
        System.out.println( list );
        
        
    }

}

运行结果如下：

[(id=100, name=桂花), (id=88, name=花菜), (id=200, name=团团), (id=99, name=圆圆)]
[(id=200, name=团团), (id=99, name=圆圆), (id=100, name=桂花), (id=88, name=花菜)]

List接口主要实现类

1、java.util.ArrayList<E> : List 接口的大小可变数组的实现类

ArrayList 内部基于数组存储各个元素。
所谓大小可变数组，是指当数组容量不足以存放新的元素时，创建新数组，并将原数组中的内容复制过来。

ArrayList类的add方法测试案例：

package ecut.collection;

import java.util.ArrayList;
import java.util.Arrays;

public class ArrayListTest1 {

    public static void main(String[] args) {
        
        int[] x = { 1 , 2 };
        System.out.println( Arrays.toString( x ) );
        
        // x.length = 10 ; // The final field x.length cannot be assigned
        
        // x[ 2 ] = 3 ; // ArrayIndexOutOfBoundsException
        
        ArrayList<String> list = new ArrayList<>(0); // JDK 1.7 开始支持 "菱形" 语法
        
        System.out.println( list ); // list.toString()，list重写了toString方法，因此可以直接输出。
        list.add( "hello" );
        System.out.println( list );
        
    }

}

源码：

/**
     * 向列表的尾部添加指定的元素（可选操作）。 
     *
     * @param e 要添加到列表的元素 
     * @return <tt>true</tt> (根据 Collection.add(E) 的规定） 
     */
    public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }

运行结果如下：

[1, 2]
[]
[hello]

add()方法开销为分摊的常数，添加n个元素需要O(n)的时间。其他的方法运行时间为线性。每个ArrayList实例都有一个容量（Capactity），即用于存储元素的数组的大小。这个容量可随着不断添加新元素而自动增加，但是增长算法并没有定义。当需要插入大量元素时，在插入之前可以调用ensureCapacity()方法来增加ArrayList容量已提高插入效率确保容量可用后在末尾添加指定元素。

ArrayList类的remove方法测试案例：

package ecut.collection;

import java.util.ArrayList;

public class ArrayListTest2 {

    public static void main(String[] args) {
        
        ArrayList<Integer> list = new ArrayList<>(); 
        
        list.add( 2 ); // auto-boxing : 2 ---> Integer.valueOf( 2 )
        list.add( 200 ) ;
        list.add( 2 ) ;
        list.add( 20 );
        
        System.out.println( list );
        
        // T  remove( int index ) 是 List 接口定义的方法
        Integer removed = list.remove( 2 ); // 根据索引删除，而不是根据 Integer 对象删除
        System.out.println( "被删除的元素:" + removed );
        
        System.out.println( list );
        
        Object o = 2 ; // auto-boxing
        // boolean remove( Object o ) 是 Collection 接口定义的方法
        boolean result = list.remove( o ) ; // 根据元素来删除
        System.out.println( result );
        
        System.out.println( list );
        
    }

}

运行结果如下：

[2, 200, 2, 20]
被删除的元素:2
[2, 200, 20]
true
[200, 20]

自动装箱将基本数据类型包装成Integer对象放入list里。T remove(int index)：删除的是下标位置的对象并返回（List接口中定义的方法）,boolean remove(Object o)：删除对象（Colletion接口中都有的）。

2、java.util.LinkedList<E> :List 接口的实现类和Queue接口子类Deque的实现类

内部基于链表实现，增删快、迭代快，随机访问能力较差。
链表中的每个节点都是 LinkedList.Node 类型的对象。
LinkedList提供额外的get、remove、insert方法在LinkedList的首部或尾部。
这些操作使LinkedList可被用作堆栈（stack），队列（queue）或双向队列（deque）。
LinkedList没有同步方法。如果多个线程想访问同一个List，则必须自己实现访问同步。

LinkedList类的add方法测试案例：

package ecut.collection;

import java.util.LinkedList;

public class LinkedListTest {

    public static void main(String[] args) {
        
        LinkedList<String> list = new LinkedList<>();
        
        list.add( "猴哥" );
        
        list.add( "二师兄" );
        
        list.add( "老沙" );
        
        System.out.println( list );
        
        System.out.println( list.get( 2 ) );
        
        list.add( 1 , "白龙马" );
        
        System.out.println(  list );

    }

}

源码：

    private static class Node<E> {
        E item; // 表示当前节点存放的数据
        Node<E> next; // 指向下一个节点的指针
        Node<E> previous; // 指向前一个节点的指针

        Node(Node<E> previous, E element, Node<E> next) {
            this.item = element;
            this.next = next;
            this.previous = previous;
        }
    }

    /**
     * 将指定元素添加到此列表的结尾。
     *
     * <p>
     * 此方法等效于{@link #addLast}.
     *
     * @param 要添加到此列表的元素
     * @return {@code true} (根据 Collection.add(E) 的规定)
     */
    public boolean add(E e) {
        linkLast(e);
        return true;
    }

    void linkLast(E e) {
        final Node<E> l = last;
        final Node<E> newNode = new Node<>(l, e, null);
        last = newNode;
        if (l == null)
            first = newNode;
        else
            l.next = newNode;
        size++;
        modCount++;
    }

运行结果如下：

[猴哥, 二师兄, 老沙]
老沙
[猴哥, 白龙马, 二师兄, 老沙]

add方法调用linkLast 方法去实现，找到最后的节点，创建新的节点以最后的节点为前节点，新节点作为最后的节点。 list.get( 2 )链表没有索引的说法，不是直接访问2的位置而是实际遍历整个链表去查找，因此随机访问能力较差。插入和删除的效率比较高。

3、java.util.Vector<E> :List 接口的内部用数组存放元素的实现类

内部也是用数组存放元素。
与 ArrayList 不同的是扩容方式不同，Vector 每次增长的容量是固定的，大部分方法都被 synchronized 关键字修饰。
Vector 是线程安全的。

Vector类的测试案例：

package ecut.collection;

import java.util.Enumeration;
import java.util.Vector;

public class VectorTest {

    public static void main(String[] args) {
        
        // 创建一个 Vector 实例，其初始容量为 10 ，容量的增量为 5
        Vector<String> v = new Vector<>( 10 , 5 );
        
        v.add( "hello" );
        
        v.addElement( "world" );
        
        System.out.println( v );
        
        v.add( 1 , "你好" );
        
        System.out.println(  v );
        
        v.insertElementAt( "世界" , 2 );
        
        System.out.println( v );
        
        Enumeration<String> e =  v.elements();//类似迭代器
        
        while( e.hasMoreElements() ) {
            String s = e.nextElement();
            System.out.println( s );
        }

    }

}

源码：

   /**
     * 使用指定的初始容量和容量增量构造一个空的向量。
     *
     * @param   initialCapacity     向量的初始容量 
     * @param   capacityIncrement   当向量溢出时容量增加的量 
     * @throws IllegalArgumentException 如果指定的初始容量为负数 
     */
    public Vector(int initialCapacity, int capacityIncrement) {
        super();
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        this.elementData = new Object[initialCapacity];
        this.capacityIncrement = capacityIncrement;
    }

运行结果如下：

[hello, world]
[hello, 你好, world]
[hello, 你好, 世界, world]
hello
你好
世界
world

4、java.util.Stack<E>:List 接口实现类Vector的子类

表示堆栈。
栈的特点: 后进先出。

Stack类的测试案例：

package ecut.collection;

import java.util.Stack;

public class StackTest {

    public static void main(String[] args) {
        
        Stack<String> stack = new Stack<>();
        
        System.out.println( stack.empty() );
        
        stack.push( "first" );
        stack.push( "second" );
        stack.push( "third" );
        
        System.out.println( stack );
        
        String top = stack.peek();
        System.out.println( "top : " + top );
        System.out.println( stack );
        
        top = stack.pop();
        System.out.println( "top : " + top );
        System.out.println( stack );
        
        System.out.println( stack.empty() );
        
        int index = stack.search( "first" ); // 返回对象在堆栈中的位置，以 1 为基数（只有jdbc和stack.search以 1 为基数）
        System.out.println( index );
        
    }

}

运行结果如下：

true
[first, second, third]
top : third
[first, second, third]
top : third
[first, second]
false
2

Queue接口特点

1、先进先出 ( FIFO , First In , First Out )。
2、Queue接口子类Deque的实现类LinkedList。
3、除了基本的 Collection 操作外，队列还提供其他的插入、提取和检查操作。每个方法都存在两种形式：一种抛出异常（操作失败时），另一种返回一个特殊值（null 或 false，具体取决于操作）。

Queue类可能会抛出异常的测试案例：

package ecut.collection;

import java.util.LinkedList;
import java.util.Queue;

public class QueueTest1 {

    public static void main(String[] args) {
        
        Queue<String> queue= new LinkedList<>();
        
        queue.add( "林冲" );
        
        queue.add( "晁盖" );
        
        queue.add( "武松" );
        
        System.out.println( queue );
        //queue.clear();
        //当无法获取到元素时，element 方法抛出 NoSuchElementException
        String head = queue.element() ; // 获取队列头部的元素，但不删除
        System.out.println( head );
        
        System.out.println( queue );
         //queue.clear();
        //当无法获取到元素时，remove 方法抛出 NoSuchElementException
        head = queue.remove(); // 获取并移除队列头部元素
        System.out.println( head );
        
        System.out.println( queue );

    }

}

运行结果如下：

[林冲, 晁盖, 武松]
林冲
[林冲, 晁盖, 武松]
林冲
[晁盖, 武松]

add(e)插入，remove()移除，element()检查当无法获取到元素时，方法抛出 NoSuchElementException异常。

Queue类返回一个特殊值的测试案例：

package ecut.collection;

import java.util.LinkedList;
import java.util.Queue;

public class QueueTest2 {

    public static void main(String[] args) {
        
        Queue<String> queue= new LinkedList<>();
        
        queue.offer( "林冲" );
        
        queue.offer( "晁盖" );
        
        queue.offer( "武松" );
        
        System.out.println( queue );
        
        queue.clear();
        
        // 当无法获取元素时，返回 null，不会抛出异常
        String head = queue.peek() ; // 获取队列头部的元素，但不删除
        System.out.println( head );
        
        System.out.println( queue );
        
        // 当无法获取元素时，返回 null，不会抛出异常
        head = queue.poll(); // 获取并移除队列头部元素
        System.out.println( head );
        
        System.out.println( queue );

    }

}

运行结果如下：

[林冲, 晁盖, 武松]
null
[]
null
[]

offer(e)插入，poll()移除，peek()检查当无法获取元素时，返回 null，不会抛出异常。

Queue接口主要实现类

1、java.util.Deque<E> : Queue接口的的实现类，表示双端队列

一个线性 collection，支持在两端插入和移除元素。
此接口定义在双端队列两端访问元素的方法。提供插入、移除和检查元素的方法。每种方法都存在两种形式：一种形式在操作失败时抛出异常，另一种形式返回一个特殊值（null 或 false，具体取决于操作），共12个方法。
在将双端队列用作队列时，将得到 FIFO（先进先出）行为。
继承Queue的6个方法以及和栈的3个方法，共21个方法需了解。
方法：

       由于继承了Queue，所以Deque拥有Queue的方法，因此以下方法等价：
           add(e)    <--> addLast(e)
           offer(e) <--> offerLast(e)
           remove() <--> removeFirst()
           poll()    <--> pollFirst()
           element() <--> getFirst()
           peek()    <--> peekFirst()

       也可以用于Stack，因此以下方法等价：
           push(e) <--> addFirst(e)
           pop()   <--> removeFirst()
           peek() <--> peekFirst()

Deque测试案例：

package ecut.collection;

import java.util.Deque;
import java.util.LinkedList;

public class DequeTest1 {

    public static void main(String[] args) {
        
        // 以 输出 deque 的字符串形式 的 "左侧" 为头
        Deque<String> deque = new LinkedList<>();
        //将指定的元素插入此双端队列的末尾
        deque.offerLast( "曹操" ) ;  
        
        deque.offerLast( "曹丕" );
        
        deque.offerLast( "曹爽" );
        
        deque.offerLast( "司马炎" );
        
        System.out.println( deque );
        //获取并移除此双端队列的第一个元素；如果此双端队列为空，则返回 null。 
        String head = deque.pollFirst();
        System.out.println( "移除队列头: " + head );
        System.out.println( deque );
        
        head = deque.pollFirst();
        System.out.println( "移除队列头: " + head );
        System.out.println( deque );
        
        head = deque.pollFirst();
        System.out.println( "移除队列头: " + head );
        System.out.println( deque );
        
        
    }

}

运行结果如下：

[曹操, 曹丕, 曹爽, 司马炎]
移除队列头: 曹操
[曹丕, 曹爽, 司马炎]
移除队列头: 曹丕
[曹爽, 司马炎]
移除队列头: 曹爽
[司马炎]

offerLast插入的元素作为最后一个
       运行过程：
       曹操
       曹操, 曹丕
       曹操, 曹丕, 曹爽
       曹操, 曹丕, 曹爽, 司马炎
       以输出 deque 的字符串形式的 "左侧" 为头（第一个进入的元素）

Deque测试案例：

package ecut.collection;

import java.util.Deque;
import java.util.LinkedList;

public class DequeTest2 {

    public static void main(String[] args) {
        
        // 以 输出 deque 的字符串形式 的 "右侧" 为头
        Deque<String> deque = new LinkedList<>();
        //将指定的元素插入此双端队列的开头
        deque.offerFirst( "曹操" ) ;  
        
        deque.offerFirst( "曹丕" );
        
        deque.offerFirst( "曹爽" );
        
        deque.offerFirst( "司马炎" );
        
        System.out.println( deque );
        //获取并移除此双端队列的最后一个元素；如果此双端队列为空，则返回 null。 
        String head = deque.pollLast();
        System.out.println( "移除队列头: " + head );
        System.out.println( deque );
        
        head = deque.pollLast();
        System.out.println( "移除队列头: " + head );
        System.out.println( deque );
        
        head = deque.pollLast();
        System.out.println( "移除队列头: " + head );
        System.out.println( deque );
        
        
    }

}

运行结果如下：

[司马炎, 曹爽, 曹丕, 曹操]
移除队列头: 曹操
[司马炎, 曹爽, 曹丕]
移除队列头: 曹丕
[司马炎, 曹爽]
移除队列头: 曹爽
[司马炎]

offerFirst插入的元素作为第一个
        运行过程：
        曹操
        曹丕, 曹操
        曹爽, 曹丕, 曹操
        司马炎, 曹爽, 曹丕, 曹操
        以输出 deque 的字符串形式的 "右侧" 为头（第一个进入的元素）

2、java.util.LinkedList<E> :Queue接口的子类Deque的实现类

内部基于链表实现，增删快、迭代快，随机访问能力较差。
链表中的每个节点都是 LinkedList.Node 类型的对象。
LinkedList提供额外的get、remove、insert方法在LinkedList的首部或尾部。
这些操作使LinkedList可被用作堆栈（stack），队列（queue）或双向队列（deque）。双端队列也可用作 LIFO（后进先出）堆栈。
LinkedList没有同步方法。如果多个线程想访问同一个List，则必须自己实现访问同步。

LinkedList 当作 "栈" 来使用测试案例：

package ecut.collection;

import java.util.LinkedList;

/**
 * 将 LinkedList 当作 "栈" 来使用
 * 栈:  后进先出 ( Last In , First Out , LIFO )
 */
public class LinkedListStackTest {

    public static void main(String[] args) {
        
        LinkedList<String> s = new LinkedList<>();
        
        s.push( "Java" );
        
        s.push( "C++" );
        
        s.push( "Go" );
        
        System.out.println( s );
        
        String top = s.peek() ; // 检查栈顶元素 ( 只获取不删除 )
        System.out.println( top );
        
        System.out.println( s );
        
        top = s.pop(); // 弹出栈顶元素 ( 获取并移除 )
        System.out.println( top );
        System.out.println( s );
        
        top = s.pop(); // 弹出栈顶元素 ( 获取并移除 )
        System.out.println( top );
        System.out.println( s );
        
        top = s.pop(); // 弹出栈顶元素 ( 获取并移除 )
        System.out.println( top );
        System.out.println( s );

    }

}

运行结果如下：

[Go, C++, Java]
Go
[Go, C++, Java]
Go
[C++, Java]
C++
[Java]
Java
[]

Set接口特点

1、最接近数学中的 "集" 的概念。
2、元素不重复 ( 必须通过元素的 equals 方法来判断是否存在重复元素 )。
3、并且最多包含一个 null 元素（可能有限制）。

Set接口主要实现类

1、java.util.HashSet<E> : Set接口的的实现类

由哈希表（实际上是一个 HashMap 实例）支持。
元素可以是 null。
元素存放的位置跟添加顺序无关 ( 元素存放的位置跟 element.hashCode() 有关 )。
不支持排序（根据hashcode来确定位置的，所以位置不能改变，因此不支持排序）。

HashSet测试案例：

package ecut.collection;

import java.util.HashSet;

public class HashSetTest {

    public static void main(String[] args) {
        
        HashSet<String> set = new HashSet<>();
        
        set.add( "张三丰" );
        set.add( "张翠山" );
        set.add( "殷素素" );
        set.add( "张无忌" );
        set.add( "谢逊" );
        set.add( "赵敏" );
        
        set.add( "张三丰" );
        
        set.add( null );
        
        System.out.println( set );

    }

}

源码：

private static final Object PRESENT = new Object();
public boolean add(E e) {
     return map.put(e, PRESENT)==null;
}

HashMap实现的因为key 不能重复因此Set元素不重复，value为固定的PRESENT。

运行结果如下：

[null, 殷素素, 张翠山, 张三丰, 谢逊, 赵敏, 张无忌]

2、Java.util.TreeSet<E>: 基于 TreeMap 来实现 Set 接口的实现类

NavigableSet<E>的实现类，NavigableSet<E>继承SortedSet<E>，SortedSet<E>继承Set<E>。
TreeSet基于 TreeMap 来实现TreeMap 内部是基于红黑树（ Red-Black tree）。
SortedSet是有顺序因此TreeSet有顺序 ( 根据元素的自然顺序，元素得实现Comparable接口或比较器排序后存放元素)。
元素不可以是 null（每添加一个元素都得进行一次排序调用compareTo方法，一次不能为null）。
元素存放的位置跟添加顺序无关。

TreeSet测试案例：

package ecut.collection;

import java.util.TreeSet;

public class TreeSetTest1 {

    public static void main(String[] args) {
        
        // 如果构造方法没有指定比较器，则根据元素的 自然顺序 排序
        // java.lang.String 支持 自然比较
        TreeSet<String> ts = new TreeSet<>();
        
        ts.add( "张三丰" );
        ts.add( "张翠山" );
        ts.add( "殷素素" );
        ts.add( "张无忌" );
        ts.add( "谢逊" );
        ts.add( "赵敏" );
        ts.add( "张三丰" );
        
        System.out.println( ts );

    }

}

源码:

public TreeSet() {
        this(new TreeMap<E,Object>());
    }

实际上是创建一个TreeMap，因此TreeSet的元素和treeMap的key特点一样。

运行结果如下：

[张三丰, 张无忌, 张翠山, 殷素素, 谢逊, 赵敏]

3、java.util.LinkedHashSet<E>: Set接口的的实现类

继承HashSet和LinkedList相似。
内部是基于链表。
不能重复。

Map接口特点

1、将键映射到值的对象 ( Map 集合中存放的是 key-value 对 ( Map.Entry ) )。
2、一个映射不能包含重复的键 ( Map 集合中的 key 不能重复 )。
3、每个键最多只能映射到一个值 ( Map 集合中的 key 只能对应一个值 )。
4、几乎所有的map都具有三个视图所有的 key 组成的 Set 集合，所有的 value 组成的 Collection 集合和所有的 entry 对应的 Set 集合

Map接口主要方法

V put( K key, V value ) : 将指定的值(value)与此映射中的指定键(key)关联。

V get( Object key ) : 返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null。

boolean containsKey(Object key)：如果此映射包含指定键的映射关系，则返回 true。

boolean containsValue(Object value)：如果此映射将一个或多个键映射到指定值，则返回 true。。

void clear()：从此映射中移除所有映射关系（可选操作）。

boolean isEmpty()：如果此映射未包含键-值映射关系，则返回 true。

int size() ：返回此映射中的键-值映射关系数。

V remove(Object key)：如果存在一个键的映射关系，则将其从此映射中移除（可选操作）。

void putAll( Map<? extends K,? extends V> m ) ：从指定映射中将所有映射关系复制到此映射中（可选操作）。

Set<K> keySet() ：返回所有的 key 组成的 Set 集合

Collection<V> values()：返回所有的 value 组成的 Collection 集合

Set<Map.Entry<K,V>> entrySet()：返回所有的 entry 对应的 Set 集合

Map接口主要方法的测试案例：

package ecut.collection;

import java.util.HashMap;
import java.util.Map;

public class MapTest1 {

    public static void main(String[] args) {
        
        Map<String,Integer> map = new HashMap<>();
        //以前与 key 关联的值，如果没有针对 key 的映射关系，则返回 null。
        Integer value = map.put( "Java从入门到精通" , 98 );
        System.out.println( "value : " + value );
        
        // 将指定的值(value)与此映射中的指定键(key)关联
        value = map.put( "Java从入门到精通" , 108 );
        System.out.println( "value : " + value );
        
        // 返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null
        System.out.println( map.get( "Java从入门到精通" ) );
        
        System.out.println( map.containsKey( "Java从入门到精通" ) );
        System.out.println( map.containsKey( "Oracle从入门到精通" ) );
        
        System.out.println( map.containsValue( 108 ) );
        
        map.put( "C++大学教程" , 108 );
        
        map.put( "A语言大学教程" , 108 );
        
        System.out.println( map );
        
        
    }

}

运行结果如下：

value : null
value : 98
108
true
false
true
{Java从入门到精通=108, A语言大学教程=108, C++大学教程=108}

Map接口主要方法的测试案例：

package ecut.collection;

import java.util.HashMap;
import java.util.Map;

public class MapTest2 {

    public static void main(String[] args) {
        
        // map 变量的值 不是 null
        // map 集合中没有放入 任何键值对时，isEmpty 返回 true
        Map<String,Integer> map = new HashMap<>();
        
        System.out.println( "size : " +  map.size() + " , isEmpty : " + map.isEmpty() );
        
        map.put( "软件工程" , 500 );
        map.put( "通信工程" , 200 );
        map.put( "土木工程" , 100 );
        
        System.out.println( "size : " +  map.size() + " , isEmpty : " + map.isEmpty() );
        
        System.out.println( map );
        
        // 删除指定的 key 对应的 key-value 对，并返回 该 key 对应的 value
        Integer value = map.remove( "土木工程" );
        System.out.println( value );
        
        System.out.println( map );
        
        map.clear();
        
        System.out.println( "size : " +  map.size() + " , isEmpty : " + map.isEmpty() );
        
        map.put( "信息科学技术" , 100 );
        
        Map<String,Integer> m = new HashMap<>();
        m.put( "幼儿教育" , 5000 );
        m.put( "信息科学技术" , 150 );
        System.out.println( m );
        
        map.putAll( m );
        
        System.out.println( map );
        
    }

}

运行结果如下：

size : 0 , isEmpty : true
size : 3 , isEmpty : false
{通信工程=200, 土木工程=100, 软件工程=500}
100
{通信工程=200, 软件工程=500}
size : 0 , isEmpty : true
{信息科学技术=150, 幼儿教育=5000}
{信息科学技术=150, 幼儿教育=5000}

Map接口主要方法的测试案例：

package ecut.collection;

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

/**
 * keySet()
 * values()
 * entrySet()
 */
public class MapTest3 {

    public static void main(String[] args) {
        
        Map<String,Integer> map = new HashMap<>();
        
        map.put( "软件工程" , 500 );
        map.put( "通信工程" , 200 );
        map.put( "土木工程" , 100 );
        map.put( "幼儿教育" , 300 );
        map.put( "护士护理" , 600 );
        
        // 返回此映射中包含的键的 Set 视图
        Set<String> keys = map.keySet(); // 所有的 key 组成的 Set 集合
        for( String key  : keys ) {
            Integer value = map.get( key );
            System.out.println( key + " : " + value );
        }
        
        System.out.println( "~~~~~~~~~~~~~~~~~~~~~~~~" );
        
        // 返回此映射中包含的值的 Collection 视图
        Collection<Integer> values =  map.values();
        
        for( Integer v  : values ) {
            System.out.println( v );
        }
        
        System.out.println( "~~~~~~~~~~~~~~~~~~~~~~~~" );
        
        // 返回此映射中包含的映射关系的 Set 视图
        Set< Map.Entry<String, Integer> > entries =  map.entrySet();
        
        for(  Map.Entry<String, Integer> entry : entries ){
            System.out.println( entry.getKey() + " : " + entry.getValue() );
        }
        
    }

}

运行结果如下：

通信工程 : 200
土木工程 : 100
护士护理 : 600
软件工程 : 500
幼儿教育 : 300
~~~~~~~~~~~~~~~~~~~~~~~~
200
100
600
500
300
~~~~~~~~~~~~~~~~~~~~~~~~
通信工程 : 200
土木工程 : 100
护士护理 : 600
软件工程 : 500
幼儿教育 : 300

HashCode测试案例：

package ecut.collection;

/**
 * 对于 Object # hashCode()  
 * 
 * 1、由 Object 类定义的 hashCode 方法确实会针对不同的对象返回不同的整数。
 *    （这一般是通过将该对象的内部地址转换成一个整数来实现的，但是 JavaTM 编程语言不需要这种实现技巧。）
 *    
 * 2、这个整数 与 System.identityHashCode 的返回值相同
 * 
 * 3、这个整数的意义:  Identity Hash Code ( 相当于 每个 对象的 身份证编号 )
 *      
 * 4、Object 提供 hashCode 方法是为了提高哈希表（例如 java.util.Hashtable 提供的哈希表）的性能
 * 
 * 5、这个整数 在第一次 访问时 才触发产生
 *
 */
public class IdentityHashCodeTest {

    public static void main(String[] args) {
        
        // 数组也是引用类型变量
        int[] a = new int[ 10 ];
        int[] b = new int[10] ;
        //返回该对象的哈希码值。
        System.out.println( "a : " + a.hashCode() );
        System.out.println( "b : " + b.hashCode() );
        //这个整数 与 System.identityHashCode 的返回值相同
        System.out.println( "b : " + System.identityHashCode( b ) );
        System.out.println( "a : " + System.identityHashCode( a ) );
        
        
        
    }

}

运行结果如下：

a : 366712642
b : 1829164700
b : 1829164700
a : 366712642

Map接口主要实现类

1、java.util.HashMap<K,V> : 基于哈希表的 Map 接口的实现类

key 允许为 null ， value 也允许为 null
不保证映射的顺序，特别是它不保证该顺序恒久不变

HashMap测试案例：

package ecut.collection;

import java.lang.reflect.Array;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.HashMap;

/***
 * hashCode 相同的字符串:
 *  重地 - 通话
 *  方面 - 树人
 *  玉班 - 王环 - 牛顿
 *  王八 - 玌兌
 *  东理 - 两猎 - 二晶 - 伍囗 - 住仙
 *  东华 - 世合
 *  德鹏 - 恢覚
 *  农丰 - 儿女
 *  掌门 - 文境 - 方創
 */
public class MapHelper {
    
    public static void main(String[] args) {
        
        HashMap<String,String> map = new HashMap<String,String>( 1 );
        //根据传入的 HashMap 实例获取其内部的 哈希表 的容量
        int c = capacity( map );
        System.out.println( "容量: " + c );
        
        map.put( "掌门" , "张三丰" );
        map.put( "方創" , "大众创业万众等死" );
        
        map.put( "农丰" , "三轮车" );
        map.put( "儿女" ,  "张无忌" );
        
        map.put( "重地" , "仓库重地" );
        map.put( "通话" , "通话记录");
        
        map.put( null , null );
        //显示给定 HashMap 实例内部的 哈希表中存储的数据 (只处理到链表层次)
        show( map );
        
        c = capacity( map );
        System.out.println( "容量: " + c );
        
        String key = "儿女" ;
        //计算指定的 key 在给定的 map 集合中的位置(在哈希表中的索引)
        int p = position(map, key );
        System.out.println( key + "在哈希表中的位置: " + p );
        
        key = null ;
        p = position(map, key);
        System.out.println( key + "在哈希表中的位置: " + p );
        
    }
    
    private static Class<?> hashMapClass ;
    private static Field tableField;
    private static Method hashMethod ;
    
    static {
        
        hashMapClass = HashMap.class;
        
        try {
            // 通过反射来获得 HashMap 内部的 table 属性
            tableField = hashMapClass.getDeclaredField( "table" );
            // 让本来因为被封装而不能访问的 table 能够被访问
            tableField.setAccessible( true );
            
            // 通过反射获得 HashMap 内部的 hash 方法
            hashMethod = hashMapClass.getDeclaredMethod( "hash" , Object.class );
            // 让本来因为封装而不能访问的 hash 方法能够被访问
            hashMethod.setAccessible( true );
            
        } catch (NoSuchFieldException e) {
            System.out.println( "在 " + hashMapClass.getName() + " 中未找到 table 属性 : " + e.getMessage() );
        } catch (SecurityException e) {
            System.out.println( "无法访问 " + hashMapClass.getName() + " 的 table 属性 : " + e.getMessage() );
        } catch (NoSuchMethodException e) {
            System.out.println( "在 " + hashMapClass.getName() + " 累中未找到 hash 方法 : " + e.getMessage() );
        }
        
    }
    
    /**
     * 计算指定的 key 在给定的 map 集合中的位置(在哈希表中的索引)
     * @param map
     * @param key
     * @return
     */
    public static int position( HashMap<?,?> map , Object key ) {
        int position = -1 ;
        //获取 哈希表的容量
        int capacity = capacity( map );
        // 根据 键 计算哈希值
        int hash = hash( map , key );
        // 根据 HashMap 中的实现思路，计算 键 的存储位置
        position = ( capacity - 1 ) & hash ;
        
        return position ;
    }
    
    /**
     * 计算指定的 key 的 hash 值
     * @param map
     * @param key
     */
    public static int hash( HashMap<?,?> map , Object key ) {
        int hash = -1 ;
        try {
            // 通过反射调用 HashMap 中的 hash 方法
            Object h = hashMethod.invoke( map , key );
            if( h != null ) {
                // 判断 h 是否是 int 类型 或 Integer 类型
                if( h.getClass() == Integer.class || h.getClass() == int.class ) {
                    hash = Integer.class.cast( h )  ; // 通过反射方法，实现强制类型转换
                }
            }
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
        
        return hash ;
    }
    
    /**
     * 根据传入的 HashMap 实例获取其内部的 哈希表 的容量
     * @param map
     */
    public static int capacity( HashMap<?,?> map ) {
        int capacity = 0 ;
        try {
            // 获得给定的 map 实例 中的 table 属性的值 (获取到哈希表)
            Object value = tableField.get( map );
            
            if( value != null ){
                Class<?> valueClass = value.getClass(); // 获得 table 属性的 值 的类型
                if( valueClass.isArray() ){ // 如果是个数组
                    capacity = Array.getLength( value ); // 获取数组长度 (获取哈希表的长度)
                }
            }
            
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        
        return capacity ;
        
    }
    
    /**
     * 显示给定 HashMap 实例内部的 哈希表中存储的数据 (只处理到链表层次)
     * @param map
     */
    public static void show( HashMap<?,?> map ) {
        
        try {
            // 从参数传入的 map 实例中获得 该实例中的 table 属性的值
            Object value = tableField.get( map );
            
            if( value != null ){
                Class<?> valueClass = value.getClass(); // 获得 table 属性的 值 的类型
                if( valueClass.isArray() ){ // 如果是个数组
                    
                    System.out.println( "HashMap 实例中的哈希表:" );
                    
                    StringBuffer buffer = new StringBuffer();
                    
                    // 遍历数组
                    for( int i = 0 , n = Array.getLength( value ) ; i < n ; i++ ){
                        buffer.setLength( 0 );
                        Object e = Array.get( value ,  i ) ; // 从数组中获取 下标是 i 的元素
                        if( e != null ){
                            buffer.append( i ) ;
                            buffer.append( " : " );
                            // 获得 当前循环取得的 元素的类型
                            Class<?> eClass = e.getClass();
                            Field hashField = eClass.getDeclaredField( "hash" ); // 获得 eClass 中 名称是 hash 的属性
                            hashField.setAccessible(true);
                            buffer.append( "[ " );
                            Field keyField = eClass.getDeclaredField( "key" ); // 获得 eClass 中 名称是 key 的属性
                            keyField.setAccessible(true);
                            Field valueField = eClass.getDeclaredField( "value" ); // 获得 eClass 中 名称是 key 的属性
                            valueField.setAccessible(true);
                            Field nextField = eClass.getDeclaredField( "next" ); // 获得 eClass 中 名称是 key 的属性
                            nextField.setAccessible(true);
                            
                            Object hash = hashField.get( e );
                            buffer.append( "<");
                            buffer.append( hash );
                            buffer.append( ">" );
                            
                            Object k = keyField.get( e );
                            buffer.append( k );
                            buffer.append( "=" );
                            Object v = valueField.get( e );
                            buffer.append( v );
                            
                            Object next = nextField.get( e );
                            while( next != null ) {
                                buffer.append( " , " );
                                hash = hashField.get( e );
                                k = keyField.get( next );
                                v = valueField.get( next );
                                buffer.append( "<");
                                buffer.append( hash );
                                buffer.append( ">" );
                                buffer.append( k );
                                buffer.append( "=" );
                                buffer.append( v );
                                next = nextField.get( next ) ; // 继续获得下一个节点
                            }
                            
                            buffer.append( " ]" );
                        } else {
                            buffer.append( i );
                            buffer.append( " : [ empty ]" );
                        }
                        
                        System.out.println( buffer.toString() );
                        
                    }// end of for loop
                }
            } else {
                System.out.println( "null");
            }
            
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        } catch (SecurityException e) {
            e.printStackTrace();
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        
    }

}

package ecut.collection;

import java.util.HashMap;

public class HashMapTest {

    public static void main(String[] args) {
        
        HashMap<String,Integer> map = new HashMap<>( 20 , 0.8F );
        /** 
        this.loadFactor = loadFactor;
        this.threshold = tableSizeFor( initialCapacity );
        **/
        
        // 因为 HashMap 内部用 哈希表来存储 键值对
        // 并且 HashMap 采用 key 的hashCode 来确定 键值对 在哈希表中的位置
        // 因此，添加键值对的顺序，跟它们在哈希表中的存放位置可能不同
        map.put( "软件工程" , 500 );
        map.put( "通信工程" , 200 );
        map.put( "土木工程" , 100 );
        map.put( "幼儿教育" , 300 );
        map.put( "护士护理" , 600 );
        
        map.put( "东理" , 600 );
        map.put( "两猎" , 600 );
        map.put( "二晶" , 600 );
        map.put( "伍囗" , 600 );
        map.put( "住仙" , 600 );
        
        System.out.println( map );
        
        int capacity = MapHelper.capacity( map );
        System.out.println( "HashMap实例内部的哈希表的长度: " + capacity );
        
        int index = MapHelper.position( map ,  "护士护理" );
        System.out.println( "元素在哈希表中的存放位置: " + index  );
        
        MapHelper.show( map );
        
        
    }

}

运行结果如下：

{东理=600, 两猎=600, 二晶=600, 伍囗=600, 住仙=600, 土木工程=100, 软件工程=500, 幼儿教育=300, 通信工程=200, 护士护理=600}
HashMap实例内部的哈希表的长度: 32
元素在哈希表中的存放位置: 24
HashMap 实例中的哈希表:
0 : [ empty ]
1 : [ empty ]
2 : [ empty ]
3 : [ <649571>东理=600 , <649571>两猎=600 , <649571>二晶=600 , <649571>伍囗=600 , <649571>住仙=600 ]
4 : [ empty ]
5 : [ empty ]
6 : [ <690577222>土木工程=100 ]
7 : [ empty ]
8 : [ empty ]
9 : [ empty ]
10 : [ <1114081802>软件工程=500 ]
11 : [ empty ]
12 : [ empty ]
13 : [ <741421005>幼儿教育=300 ]
14 : [ empty ]
15 : [ empty ]
16 : [ empty ]
17 : [ empty ]
18 : [ empty ]
19 : [ empty ]
20 : [ empty ]
21 : [ <1119401141>通信工程=200 ]
22 : [ empty ]
23 : [ empty ]
24 : [ <774976728>护士护理=600 ]
25 : [ empty ]
26 : [ empty ]
27 : [ empty ]
28 : [ empty ]
29 : [ empty ]
30 : [ empty ]
31 : [ empty ]

2、java.util.Hashtable<K,V>: Map接口的的实现类

Properties类继承了Hashtable。
实现一个哈希表，该哈希表将键映射到相应的值
几乎所有的方法都是线程安全的
Hashtable 的 key 和 value 都不能为 null

Hashtable测试案例：

package ecut.collection;

import java.util.Enumeration;
import java.util.Hashtable;

/**
 * 一个 Map 接口的实现类的自我修养:
 *     1、将键映射到值的对象 ( Map 集合中存放的是 key-value 对 ( Map.Entry ) )
       2、一个映射不能包含重复的键 ( Map 集合中的 key 不能重复 )
       3、每个键最多只能映射到一个值 ( Map 集合中的 key 只能对应一个 值 )
       
     Hashtable 的特点:
        1、key 和 value 都不能为 null  
        2、几乎所有的方法都是线程安全的( 几乎所有的方法都被 synchronized 修饰 )
        
 */
public class HashtableTest {
    
    public static void main(String[] args) {
        
        Hashtable<String,Integer> ht = new Hashtable<>();
        
        //ht.put(null, null);//抛出NullPointerException，key 和 value 都不能为 null  
        
        ht.put( "罗玉凤" , 250 );
        
        ht.put( "罗玉龙" , 500 );
        
        System.out.println( ht ); // ht.toString()
        
        System.out.println( ht.get( "罗玉龙" ) );
        
        Enumeration<String> keys =  ht.keys();
        
        while( keys.hasMoreElements() ){
            String key = keys.nextElement();
            Integer value = ht.get( key );
            System.out.println( key + " : " + value );
        }
        
    }

}

Enumeration接口的功能与 Iterator 接口的功能是重复的。此外，Iterator 接口添加了一个可选的移除操作，并使用较短的方法名。新的实现应该优先考虑使用 Iterator 接口而不是 Enumeration 接口。

运行结果如下：

{罗玉龙=500, 罗玉凤=250}
500
罗玉龙 : 500
罗玉凤 : 250

3、java.util.Properties：Hashtable的子类，表示属性集

Properties 可保存在流中或从流中加载。
属性列表中每个键及其对应值都是一个字符串，应该用 setProperty 和 getProperty 方法来操作属性，而不是使用 put 和 get。

Properties测试案例：

package ecut.collection;

import java.util.Properties;

public class PropertiesTest1 {

    public static void main(String[] args) {
        
        Properties props = new Properties();
        
         // props.put(key, value) ;
        props.setProperty( "driver", "com.mysql.jdbc.Driver" );
        props.setProperty( "url" , "jdbc:msyql://127.0.0.1:3306/ecut" );
        
        // props.get(key);
        String d = props.getProperty( "driver" );
        System.out.println( d );
        
        String user = props.getProperty( "user" );
        System.out.println( user );
        
        // 当指定的属性名在集合中不存在时，使用 第二个参数 当作默认值返回
        user = props.getProperty( "user" , "root" );
        System.out.println( user );
        
    }

}

运行结果如下：

com.mysql.jdbc.Driver
null
root

Properties测试案例：

jdbc.url = jdbc:oracle:thin:@127.0.0.1:1521:ecut
jdbc.driver = oracle.jdbc.driver.OracleDriver
jdbc.user = ecut
jdbc.password = ecut2017

package ecut.collection;

import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;

/**
 * 1、从类路径下获得任意资源对应的输入流
 * 2、用 Properties 加载 属性文件 ( 以 .properties 为后缀，其中的内容形式是 key = value )
 */
public class PropertiesTest2 {

    public static void main(String[] args) {
        
        Properties props = new Properties();
        System.out.println( "属性个数: " + props.size() );
        //任何一个类型都可以通过.class来获得自己的类型对应Class 对象
        Class<?> c = PropertiesTest2.class ;// 通过 java.lang.Class 类的 getResourceAsStream 方法获得指定资源名称对应的输入流
        // 如果仅仅指定的是 文件名，则该文件必须跟 当前类在同一个包
        // 如果在 文件名之前使用了 / 则表示 从 当前的 类路径 的根路径开始寻找
        InputStream inStream = c.getResourceAsStream( "/jdbc.properties" ) ;
        
        try {
            props.load( inStream ); // 从指定的流中读取 属性 ，并加入到 属性集合 中
        } catch (IOException e) {
            System.err.println( "加载失败: " + e.getMessage() );
        } catch( NullPointerException e ) {
            System.err.println( "未找到文件: " + e.getMessage() );
        }
        
        if( props.size() > 0 ) {
            System.out.println( props.getProperty( "jdbc.url" ) );
            System.out.println( props.getProperty( "jdbc.driver" ) );
            System.out.println( props.getProperty( "jdbc.user" ) );
            System.out.println( props.getProperty( "jdbc.password" ) );
        }
        
    }

}

运行结果如下：

属性个数: 0
jdbc:oracle:thin:@127.0.0.1:1521:ecut
oracle.jdbc.driver.OracleDriver
ecut
ecut2017

HashMap 和 Hashtable 的相同点
1、内部都是基于哈希表存储数据(内部都有数组table，HashTable是Entry<?,?>[] table，HashMap是Node<K,V>[] table)。
2、HashMap 和 Hashtable 的迭代器都是快速失败 ( fail-fast ) 的
HashMap 和 Hashtable 的区别
1、用来确定元素在哈希表中的位置的方式不同:
HashMap 根据 key.hashCode() 重新计算一个值:

 public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
    }

static final int hash( Object key ) {
           int h;
            return (key == null) ? 0 : ( h = key.hashCode() ) ^ ( h >>> 16 );
}

然后再根据这个值来确定元素在哈希表中的位置:

部分源码

  final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<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);
..................................

源码if ((p = tab[i = (n - 1) & hash]) == null)转换：
            tab[i] = newNode(hash, key, value, null);

 int n = table.length ;
 int hash = hash( key ) ;
 table[ ( n - 1) & hash ] = newNode( hash, key, value, null ) ; // 不是源码

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Hashtable 中的实现:

部分源码：

   public synchronized V put(K key, V value) {
        //确保value 不能为空
        if (value == null) {
            throw new NullPointerException();
        }

        // 确保key不在哈希表
        Entry<?,?> tab[] = table;
        int hash = key.hashCode();
        int index = (hash & 0x7FFFFFFF) % tab.length;
        @SuppressWarnings("unchecked")
......................................

  int hash = key.hashCode(); // key 必须不能为 null，不然抛出空指针异常
  int index = (hash & 0x7FFFFFFF) % tab.length;

2、HashMap 不支持线程安全的 ( 所有的方法都没有 synchronized 修饰 )。
Hashtable 支持线程安全的 ( 几乎所有的方法都被 synchronized 修饰 )。
3、HashMap 的迭代器是快速失败 ( fail-fast ) 的 , Hashtable 的迭代器是也是快速失败 ( fail-fast ) 的，
但是由 Hashtable 的键 ( keys() ) 和元素 ( elements() ) 方法返回的 Enumeration 不是快速失败的，是安全失败。

注意，迭代器的快速失败行为不能得到保证，一般来说，存在非同步的并发修改时，不可能作出任何坚决的保证。快速失败迭代器尽最大努力抛出 ConcurrentModificationException（此异常不一定抛出）。

快速失败测试案例：

package ecut.collection;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Set;

public class FailFastTest {

    public static void main(String[] args) {
        
        HashMap<String,Integer> map = new HashMap<>();
        
        map.put( "炒粉" , 3 );
        map.put( "炒面" , 5 );
        map.put( "包子" , 1 );
        map.put( "皮蛋瘦肉粥" , 2 );
        
        Set<String> keySet = map.keySet();
        
        Iterator<String> itor = keySet.iterator();
        
        while( itor.hasNext() ){
            String key = itor.next() ;
            Integer value = map.get( key );
            System.out.println( key + " : " + value );
            // map.put( "罗玉凤" , 250 ); // 尽最大可能抛出 ConcurrentModificationException
            // map.remove( "包子" ); // 尽最大可能抛出 ConcurrentModificationException
            if( key.equals( "包子" )){
                itor.remove(); // 不抛出 ConcurrentModificationException
            }
        }
        
        System.out.println( "~~~~~~~~~~~~~~~" );
        
        itor = keySet.iterator();

        while (itor.hasNext()) {
            String key = itor.next();
            Integer value = map.get(key);
            System.out.println(key + " : " + value);
        }
        
    }

}

运行结果如下：

包子 : 1
炒粉 : 3
炒面 : 5
皮蛋瘦肉粥 : 2
~~~~~~~~~~~~~~~
炒粉 : 3
炒面 : 5
皮蛋瘦肉粥 : 2

添加和移除元素触发了因快速失败抛出的异常ConcurrentModificationException，是因为我们在使用迭代器对map里的元素进行迭代的时候，对map的结构进行了修改，map发生更改，迭代器是不允许的。

快速失败：我们正在使用迭代器对可以获得迭代器的集合(map不能获得迭代器但是对应的keyset视图可以获得迭代器)，keyset对他进行的迭代的是，如果同时对他进行修改，map的结构发生改变，触发异常ConcurrentModificationException，称之为快速失败。要避免则只能使用迭代器本身的 remove 方法或 add 方法。

安全失败测试案例：

package ecut.collection;

import java.util.Enumeration;
import java.util.Hashtable;

public class FailSafeTest {

    public static void main(String[] args) {
        
        Hashtable<String,Integer> table = new Hashtable<>(); //Alt+Shift+R快速修改某个变量的名称
        
        table.put( "炒粉" , 3 );
        table.put( "炒面" , 5 );
        table.put( "包子" , 1 );
        table.put( "皮蛋瘦肉粥" , 2 );
        
        Enumeration<String> keys = table.keys();
        
        while( keys.hasMoreElements() ){
            String key = keys.nextElement();
            Integer value = table.get( key );
            System.out.println( key + " : " + value  );
            table.put( "拌面" , 3 );
        }

        
        System.out.println( "~~~~~~~~~~~~~~~" );
        
        keys = table.keys();
        
        while( keys.hasMoreElements() ){
            String key = keys.nextElement();
            Integer value = table.get( key );
            System.out.println( key + " : " + value  );
        }
        
    }

}

运行结果如下：

包子 : 1
炒粉 : 3
拌面 : 3
炒面 : 5
皮蛋瘦肉粥 : 2
~~~~~~~~~~~~~~~
包子 : 1
炒粉 : 3
拌面 : 3
炒面 : 5
皮蛋瘦肉粥 : 2

次要的区别:
4、父类不同: Hashtable 的父类 Dictionary ，而 HashMap 的父类是 AbstractMap。
5、对键集、值集、键值对集的处理方式不同:
     HashMap 和 Hashtable 都具有:
            Set<K>   keySet() 返回所有的 key 组成的 Set 集合
           Collection<V>   values() 返回所有的 value 组成的 Collection 集合
           Set<Map.Entry<K,V>>   entrySet() 返回所有的 entry 对应的 Set 集合
   Hashtable 还具有:
           Enumeration<K>   keys() 返回此哈希表中的键的枚举
           Enumeration<V>   elements()   返回此哈希表中的值的枚举
6、因为 Hashtable 是线程安全的，因此在单线程环境下比 HashMap 要慢。

7、HashMap允许存在一个为null的key，多个为null的value 。Hashtable的key和value都不允许为null。

SortedMap接口特点

1、进一步提供关于键的总体排序的 Map。该映射是根据其键的自然顺序进行排序的，或者根据通常在创建有序映射时提供的 Comparator 进行排序。
2、对有序映射的 collection 视图（由 entrySet、keySet 和 values 方法返回）进行迭代时，此顺序就会反映出来。
3、要采用此排序方式，还需要提供一些其他操作（此接口是 SortedSet 的对应映射）。

SortedMap接口主要实现类

1、java.util.TreeMap<K,V>: SortedMap接口的的实现类

NavigableMap类继承了SortedMap，TreeMap实现了NavigableMap。
基于红黑树（ Red-Black tree ）来实现 Map 集合 ( 同时实现了 NavigableMap 、SortedMap )。
该映射根据其键 ( key ,得实现Comparable接口，支持自然排序) 的自然顺序进行排序，或者根据创建映射时提供的 Comparator 进行排序，具体取决于使用的构造方法。
TreeMap 的 key 不可以为 null ，而 value 可以为 null。
TreeMap 中的键值对根据键来排序 ( 根据自然顺序或比较器排序)。

TreeMap测试案例：

package ecut.collection;

public class Fox implements Comparable<Fox> {

    private Integer id ; // 对象标识符 ( Object Identifier )
    private String name ;
    
    public Fox(Integer id, String name) {
        super();
        this.id = id;
        this.name = name;
    }

    @Override
    public int compareTo(Fox o) {
        if( this.id != null && o.id != null ) {
            if( this.id > o.id ){
                return 1 ;
            } else if( this.id == o.id ){
                return 0 ;
            } else {
                return -1 ;
            }
        }
        return 0;
    }
    
    @Override
    public String toString() {
        return "[id=" + id + ", name=" + name + "]";
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

}

package ecut.collection;

import java.util.TreeMap;

public class TreeMapTest1 {

    public static void main(String[] args) {
        
        // 创建 TreeMap 对象时，如果没有指定比较器，则默认按照 key 的 自然顺序排序
        TreeMap<Fox,Double> tm = new TreeMap<>();
        
        Fox fox1 = new Fox( 100 , "妲己" );
        tm.put( fox1 ,  1.0 );
        
        Fox fox2 = new Fox( 200 , "褒姒" );
        tm.put( fox2 ,  0.8 );
        
        System.out.println( tm );
        
        Fox fox3 = new Fox( 150 , "金角大王他干娘" );
        tm.put( fox3 ,  100.0 );
        
        System.out.println( tm );
        
    }

}

运行结果如下：

{[id=100, name=妲己]=1.0, [id=200, name=褒姒]=0.8}
{[id=100, name=妲己]=1.0, [id=150, name=金角大王他干娘]=100.0, [id=200, name=褒姒]=0.8}

TreeMap测试案例：

package ecut.collection;

import java.util.Comparator;
import java.util.TreeMap;

public class TreeMapTest2 {

    public static void main(String[] args) {
        
        Comparator<Fox> c = new Comparator<Fox>(){
            @Override
            public int compare( Fox o1, Fox o2 ) {
                if( o1 != null && o2 != null && o1.getName() != null && o2.getName() != null ){
                    String name1 = o1.getName() ;
                    String name2 = o2.getName() ;
                    return  name1.compareTo( name2 ) ;
                }
                return 0;
            }
        };
        
        // 创建 TreeMap 对象时，指定比较器，则按照 比较器 排序
        TreeMap<Fox,Double> tm = new TreeMap<>( c );
        
        Fox fox3 = new Fox( 150 , "金角大王他干娘" );
        tm.put( fox3 ,  100.0 );
        System.out.println( tm );
        
        Fox fox2 = new Fox( 200 , "褒姒" );
        tm.put( fox2 ,  0.8 );
        System.out.println( tm );
        
        Fox fox1 = new Fox( 100 , "妲己" );
        tm.put( fox1 ,  1.0 );
        System.out.println( tm );
        
    }

}

运行结果如下：

{[id=150, name=金角大王他干娘]=100.0}
{[id=200, name=褒姒]=0.8, [id=150, name=金角大王他干娘]=100.0}
{[id=100, name=妲己]=1.0, [id=200, name=褒姒]=0.8, [id=150, name=金角大王他干娘]=100.0}

ConcurrentMap接口特点

1、,它可以处理并发访问。
2、ConcurrentMap除了继承自java.util.Map的方法，还有一些自己的原子方法。

ConcurrentMap接口主要实现类

1、java.util.concurrent.ConcurrentHashMap<K,V>: ConcurrentMap接口的的实现类

ConcurrentMap接口的的实现类。
ConcurrentHashMap 是安全失败 ( fail-safe )。
ConcurrentHashMap 为了提高并发性能而出现的map集合，支持完全的并发操作，默认支持16个线程。
不会抛出 ConcurrentModificationException，因此不保证数据的一致性。

ConcurrentHashMap测试案例：

package ecut.collection;

import java.util.Enumeration;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;

/**
 * ConcurrentHashMap 是 安全失败 ( fail-safe )
 * ConcurrentHashMap 支持完全的并发操作
 */
public class ConcurrentHashMapTest {

    public static void main(String[] args) {
        
        ConcurrentHashMap<String,Integer> map = new ConcurrentHashMap<>();
        
        map.put( "炒粉" , 3 );
        map.put( "炒面" , 5 );
        map.put( "包子" , 1 );
        map.put( "皮蛋瘦肉粥" , 2 );
        
        Set< Map.Entry<String,Integer>  > entrySet = map.entrySet();
        
        Iterator< Map.Entry<String,Integer> > itor = entrySet.iterator();
        
        while( itor.hasNext() ){
            Map.Entry<String,Integer> entry = itor.next();
            System.out.println( entry.getKey() + " : " + entry.getValue() );
            map.put( "拌面" , 3 );
        }
        
        System.out.println( "~~~~~~~~~~~~~~~" );
        
        Enumeration<String> keys = map.keys();
        
        while( keys.hasMoreElements() ){
            String key = keys.nextElement();
            Integer value = map.get( key );
            System.out.println( key + " : " + value  );
            map.remove( "拌面" );
        }

    }

}

运行结果如下：

包子 : 1
炒粉 : 3
拌面 : 3
炒面 : 5
皮蛋瘦肉粥 : 2
~~~~~~~~~~~~~~~
包子 : 1
炒粉 : 3
炒面 : 5
皮蛋瘦肉粥 : 2

转载请于明显处标明出处

http://www.cnblogs.com/AmyZheng/p/8463722.html

posted @ 2018-02-27 13:42 AmyZheng 阅读(298) 评论(0) 编辑收藏举报

刷新页面返回顶部

AmyZheng

Java集合

公告