java基础-----集合

集合

循环数组与链表

循环数组比链表更高效，但是循环数组是一个有界的集合，容量有限

Collection接口：集合类的基本接口

Iterator接口

迭代器的用法

Collection<String> c = ...

Iterator<String> iter =c.iterator();

while(iter.hasNext()){

String element = iter.next();

do something with element

}

hasNext()方法是为了判断下一个数是否存在，如果不用这个方法直接next()方法，当集合到末尾时，没有数据可取，会报一个NoSuchElementException

上述表达式也可以用foreach来表示

for(String element : c){

do something with element

}

当调用next时，迭代器就越过下一个元素，并返回刚刚越过的那个元素的引用

调用remove之前，必须先调用next，否则抛出IllegalStateException

具体集合：

collection

list set Map

ArrayList Hashset HashMap

LinkedList Treeset TreeMap

所有集合

ArrayList

LinkedList

ArrayDeque

HashSet

TreeSet

EnumSet

LinkedHashSet

PriorityQueue

HashMap

TreeMap

EnumMap

LinkedHashMap

WeakHashMap

IdentityHashMap

对于迭代器遍历集合，根据需要给容器附加许多迭代器，但是这些迭代器只能读取列表，另外，再单独附加一个既能读又能写的迭代器。

API

java.util.List<E>

ListIterator<E>listIterator() 返回一个列表迭代器

ListIterator<E>listIterator(int index) 返回一个列表迭代器，这个元素是第一次调用Next返回的给定索引的元素

void add(int I, Eelement) 在给定位置添加元素

void addAll(int I,Collection<? extends E> elements) 将某个集合中的所有元素添加到给定位置

E remove(int i) 删除给定位置的元素并返回这个元素

E set(int i , Eelement) 用新元素取代给定位置的元素，并返回原来的那个元素

intindextOf(Object element) 返回与指定元素相等的元素在列表中第一次出现的位置，没有就返回-1

intlastIndexOf(Object element) 返回与指定元素相等的元素在列表中最后一次出现的位置，没有就返回-1

java.util.ListItertor<E>

void add (Eelement) 在当前位置添加一个元素

void set (EnewElement) 用新元素取代next或previous上次访问的元素

booleanhasPrevious() 当反向迭代列表时，还可供访问的元素，返回true

E previous()返回前一个对象

int nextIndex()返回下一次调用next方法时将返回的元素索引

intprevoiusIndex() 返回下一次调用previous方法时将返回的元素索引

java.util.LinkedList

LinkedList() 构造一个空链表

LinkedList(Collection<? extend E> elements )构造一个链表，并将集合中所有的元素添加到这个链表中

void addFirst(E element )

void addLast(Eelement )

E getFirst()

E getLast()

E removeFirst()

E removeLast()

数组列表

散列表：HashSet

API：

HashSet() 构建一个空的散列集

HashSet(Collection<?extends E> element) 构建一个散列集，并将集合中的所有元素添加到这个散列集中

HashSet(intinitialCapacity) 构建一个空的具有指定容量的散列集

HashSet(intinitialCapacity , float loadFactor) 构建一个空的具有指定容量和填充因子的散列集

填充因子：一个0.0～1.0之间的数值，确定散列集填充的百分比

注：如果equals()相等，hashCode()也必须相等，equals()不相等，hashCode()尽量不相等

树集：TreeSet

与hashSet相似，只是树集是一个有序集合

对象比较

compareTo

compare

comparator

队列和双端队列

API

java.util.Queue<E>

boolean add (Eelement)

boolean offer(Eelement)

如何队列没有满，将给定的元素添加到这个双端队列的尾部并返回true。如果队列满了，第一个方法抛出IllegaStateException，第二个方法返回false

E remove()

E poll()

假如队列不空，删除并返回这个队列头部的元素。如果队列为空，第一个方法抛出NosuchElementException，第二个方法返回null

E element()

E peek()

假如队列不空，返回这个队列头部元素，但不删除。如果队列为空，第一个方法抛出NosuchElementException，第二个方法返回null

java.util.Deque<E>

void addFirst(Eelement)

void addLast(Eelement)

booleanofferFirst(E element)

booleanofferLast(E element)

将给定的对象添加到双端队列的头部或者尾部。如果队列满了，前面两个方法抛出IllegaStateException，后面两个方法返回false

E removeFirst()

E removeLast()

E pollFirst()

E pollLast()

假如队列不空，删除并返回这个队列头部的元素。如果队列为空，前面两个方法抛出NosuchElementException，后面两个方法返回null

E getFirst()

E getLast()

E peekFirst()

E peekLast()

假如队列不空，返回这个队列头部元素，但不删除。如果队列为空，前面两个方法抛出NosuchElementException，后面两个方法返回null

java.util.ArrayDeque<E>

ArrayDeque()

ArrayDeque(intinitialcapacity)

用初始容量16或者给定的初始容量构造一个无限双端队列

优先级队列

priority queue中的元素可以按照任意的顺序插入，却总是按照排序的顺序进行检索

map

API

java.util.Map<K,V>

V get(Object key) 获得与键对应的值

V put(K key, V value) 将键和值放到映射表

void putAll(Map<? extends K,?extends V > entries)在映射表中添加映射表

boolean containKey(Object key)

boolean containValue(Objectvalue)

Set<Map.Entry<K, V>> entrySet()获得所有entry(包括键和值)的集合

Set<K> keySet() 获得所有键的集合

Collection<V> values()获得所有值的集合

java.util.Map.Entry<K, V>

K getKey()

V getValue()

V setValue(V newValue) 设置在映射表中与新值对应的值，返回旧值

java.util.HashMap<K, V>

HashMap()

HashMap(int initialCapacity)

HashMap(int initialCapacity,Loadfloat)

构建一个散列映射表

构建一个空的具有指定容量的散列映射表

构建一个空的具有指定容量和填充因子的散列映射表

填充因子：一个0.0～1.0之间的数值，确定散列散列映射表填充的百分比，默认是0.75

java.util.TreeMap<K, V>

TreeMap(comparator< ? super K > c)构造一个树映射表，并使用一个指定的比较器对键进行排序

TreeMap(Map< ? extends K, ?extends V > entries )构造一个树映射表,并将某个映射表中的所有条目添加到树映射表中

TreeMap( SortedMap<? extendsK, ? extends V> entires)

构建一个树映射表，将某个映射表中的所有条目添加到树映射表中，并使用与给定的有序映射表相同的比较器

java.util.SortedMap< K，V>

Comparator<? super K> comparator()

返回对键排序的比较器，如果键是用Comparable接口的compareTo方法进行比较的，返回null

K firstKey()

K lastKey()

返回映射表中最小元素和最大元素

弱散列映射表WeakHashMap

链接散列集LinkedHashSet

链接映射表LinkedHashMap

EnumSet 枚举集 一个枚举类型元素集的高效实现

EnumMap 映射表 一个键类型为枚举类型的映射表

API

java.util.WeakHashMap<K, V>

WeakHashMap() 构建一个散列映射表

WeakHashMap(int initialCapacity)构建一个空的具有指定容量的散列映射表

WeakHashMap(int initialCapacity,Loadfloat)构建一个空的具有指定容量和填充因子的散列映射表

java.util.LinkedHashSet<E>

LinkedHashSet() 构建一个空链接散列集

LinkedHashSet(intinitialCapacity)构建一个空的具有指定容量的空链接散列集

LinkedHashSet(intinitialCapacity, Loadfloat)构建一个空的具有指定容量和填充因子的空链接散列集

java.util.LinkedHashMap<K, V>

LinkedHashSet()

LinkedHashSet(intinitialCapacity)

LinkedHashSet(intinitialCapacity, Loadfloat)

LinkedHashSet(intinitialCapacity, Loadfloat，booleanaccessOrder)

构建一个空的具有指定容量和填充因子和顺序的空链接散列映射表

protected booleanremoveEldestEntry(Map.Entry<K, V> eldest)

如果想删除eldest元素，并返回true,就应该覆盖这个方法。

Java.util.EnumSet<E extendsEnum<E>>

static <E extends Enum<E>> EnumSet<E> allOf(Class<E> enumType)

返回一个包含给定枚举类型的所有值的集合

static <E extends Enum<E>> EnumSet<E> noneOf(Class<E> enumType)

返回一个空集，并有足够的空间保存给定的枚举类型的所有值

static <E extends Enum<E>> EnumSet<E> range(E from, E to)

返回一个包含from~ to之间的所有值(包含两个边界)的集

static <E extends Enum<E>> EnumSet<E> range(E value)

static <E extends Enum<E>> EnumSet<E> range(E value，E …values)

返回包括给定值的集

java.util.EnumMap<K extendsEnum<K>, V>

EnumMap(Class<K> keyType)

构造一个键为给定类型的空映射集

java.util.IdentityHashMap<K,V>

IdentityHashMap()

IdentityHashMap(intexpectedMaxSize)

构造一个空的标识散列映射集，其容量是大于1.5*expectedMaxSize的2的最小次幂，默认expectedMaxSize为21

java.lang.System

static intidentityHashCode(Object obj)

返回Object.hashCode计算出来的相同散列码