Collection 的常用方法

public interface Collection<E> extends Iterable<E> {
    int size();
    boolean isEmpty();
    boolean contains(Object o);
    Iterator<E> iterator();
    boolean containsAll(Collection<?> c);
    boolean addAll(Collection<? extends E> c);//添加
    boolean removeAll(Collection<?> c);//删除
    boolean retainAll(Collection<?> c);
    void clear();
}

List 的常用方法

public interface List<E> extends Collection<E> {
    Object[] toArray();
    ......
    增删改查
    add(元素)、
    add(索引，元素)、
    remove(元素)、
    remove(索引)、
    set(索引，元素)、
    get(索引)、
    ......

Set 的常用方法

add(元素)、remove(元素)、foreach()、Iterator

Map 的常用方法

put(k,v)
remove(k)
get(K)
containsKey
containsValue
values()//
keySet//获取键
entrySet() //getKey() getValue()

Properies 常用方法

Properies p=new Properties("")  
||setProperty(String key,String value)||
||getProperty(String key)||
||getProperty(String key,String defaultValue)||
||store(OutputStream out,String comment)|默认相对路径，当前工程，指定相对路径：src/,src/com/iecas。|
||store(Writer writer,String comment)||
||load(InputStream in)||
||load(Reader reader)||

1. 迭代器

1.1 概念

迭代器又称为游标，提供一种方法访问一个容器中的各个元素，又不暴露该对象的内部细节。所有实现了 Collection 接口的容器类都有一个 iterator 方法返回一个实现了 Iterator 接口的实现类。 Iterator 接口定义了如下三个方法：

1.2 功能

1.3 实现

2. 比较器

3. 有序性

4. 同步容器

4.1 ArrayList、Vector 与 Stack

• Vector 和 ArrayList 功能相同。

  public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable
  

  public class Vector<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable
  

• 使用 synchronized 关键字对方法进行同步。
• Stack 基于 Vector 实现,Stack 也是同步容器。 ``` public class Stack extends Vector {

}

## 4.2 HashTable、HashMap 和 ConcurrentHashMap
* HashTable 与 HashMap 实现了 Map 接口，功能相同。

public class Hashtable extends Dictionary implements Map, Cloneable, java.io.Serializable

```
public class HashMap<K,V> extends AbstractMap<K,V>
    implements Map<K,V>, Cloneable, Serializable

4.3 调用 Collections.synchronizedList(Set、Map) 方法

public static <T> List<T> synchronizedList(List<T> list) {
        return (list instanceof RandomAccess ?
                new SynchronizedRandomAccessList<>(list) :
                new SynchronizedList<>(list));
    }

5. 并发容器

5.1 CopyOnWriteArrayList

5.1.1 含义

对写操作进行加锁，写操作时复制，设计思想，最终一致性，读写分离，即读操作和写操作针对两个集合。

public boolean add(E e) {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            Object[] elements = getArray();
            int len = elements.length;
            Object[] newElements = Arrays.copyOf(elements, len + 1);
            newElements[len] = e;
            setArray(newElements);
            return true;
        } finally {
            lock.unlock();
        }
    }

public E get(int index) {
        return get(getArray(), index);
    }

5.1.2 优点

• 无需对读操作进行同步操作。

  5.1.3 缺点

• 消耗内存。
• 实时读。

• CopyOnWriteArraySet 基于 CopyOnWriteArrayList 实现

  public class CopyOnWriteArraySet<E> extends AbstractSet<E> implements java.io.Serializable {
    private static final long serialVersionUID = 5457747651344034263L;
  
    private final CopyOnWriteArrayList<E> al;
  }
  

  5.2 不可变容器

• 使用 Collections.unmodifiableXXX（Collection、List、Set、Map） 方法:将 Collection、List、Set、Map传入对应方法中，容器便不能修改。原理，在初始化时将数值拷贝到UnmodifiableMap中，并使用UnSupportedOperationException。
• Guava:ImmutableXXX: Collection、List、Set、Map:提供带初始化数据的申明方法。

6. 容器工具类

参考资料

• Java集合---ConcurrentHashMap原理分析