java容器

1. 泛型

伪泛型(类型擦除)

java中的泛型是伪泛型，编译后转变为与泛型类同名的（非泛型）原始类。
将运行时器的classCaseException转移到编译时期的编译失败；避免了类型转化的麻烦。

泛型声明

泛型类

修饰符 class 类名<代表泛型的变量>{}

泛型方法

修饰符<代表泛型的变量> 返回值类型 方法名（参数）{}

泛型接口

public interface List<E>{
abstract boolean add(E e){}
}
//实现类
	//1. 先实现接口，不理会泛型
	public calss ArrayList<E> implements List<E>{}
		//调用者后期创建对象时，指定数据类型
		new ArrayList<String>()
	//2. 实现接口的同时，指定数据类型
	public class ArrayList<E> implements List<String>{}

类型限界

<? extends A>：上限限定，可传递类A及其子类对象
<? super A>：下限限定，可传递类A及其父类对象

对泛型的限制

• 基本类型不能用作类型参数。
• instanceof检测和类型转换只对原始类型进行。
• static方法和static域均不可引用类的类型变量，因为类型擦除后类型变量就不存在了。另外，由于实际只存在一个原始类，，故是static域在该类的诸泛型实例之间是共享的。
• 不能创建一个泛型类型的实例。
• 不能创建一个泛型类型的数组。
• 参数化类型的数组的实例化是非法的。

2. 增强for循环

for(数据类型 变量名:数组或集合){
	sop(变量)；
}

• jdk1.5之后，出现java.lang.Iterable，Collection开始继承Iterable，实现增强for循环，能遍历Set，不能遍历Map
• 对对象数组遍历，可以调用对象方法
• 优：代码少，方便遍历容器
• 缺：无索引，不能操作容器内的元素

3. 集合常用接口类

3.1. 接口 Iterator< E >

boolean hasNext()
E next()
void remove()

3.2. 接口Collection< E >

boolean add(E e)
boolean addAll(Collection<? extends E> c)
void clear()
boolean contains(Object o)
boolean containsAll(Collection<?> c)
boolean equals(Object o)
int hashCode()
boolean isEmpty()
Iterator<E> iterator()
boolean remove(Object o)
boolean removeAll(Collection<?> c)
boolean retainAll(Collection<?> c)
int size()
Object[] toArray()
<T> T[] toArray(T[] a)

3.2.1 接口 Set< E >

3.2.1.1 类 HashSet< E >

//构造方法
HashSet() 
HashSet(Collection<? extends E> c) 
HashSet(int initialCapacity) 
HashSet(int initialCapacity, float loadFactor) 
//方法
 Object clone() 

• 由哈希表支持，不能保证迭代次序与存储次序一致
• 保证元素唯一性的方法：hashCode() equals()
• 在给哈希表存放对象时，调用hashcode方法，算出对象的有效位置，若两个对象的hashCode结果一致，则为哈希冲突。此时调用对象的equals办法，比较两个对象是否为同一个对象，若true，不把对象存在哈希表中；若false，存！
• 若往集合中存放自定义对象，为保证其唯一性，许重写hashCode和equals，建立属于当前对象的比较方法；若不重写，每次运行得到的hash值不一样。
• hashCode相等->equals不一定相等;
• equals相等->hashCode一定相等.

3.2.2 接口 Queue< E >

boolean offer(E e)
E peek()
E poll() 

3.2.2.1 类 PriorityQueue

//构造方法
PriorityQueue()
PriorityQueue(Collection<? extends E> c)
PriorityQueue(int initialCapacity)
PriorityQueue(int initialCapacity, Comparator<? super E> comparator)
PriorityQueue(PriorityQueue<? extends E> c)
PriorityQueue(SortedSet<? extends E> c) 
//方法
 Comparator<? super E> comparator() 

3.2.2.2 接口 Deque< E >

void addFirst(E e)
void addLast(E e)
Iterator<E> descendingIterator()//返回以逆向顺序在此双端队列的元素上进行迭代的迭代器。 
E getFirst()
E getLast()
boolean offerFirst(E e)
boolean offerLast(E e)
E peekFirst() 
E peekLast()
E pollFirst()
E pollLast()
E pop() //从此双端队列所表示的堆栈中弹出一个元素
void push(E e)// 将一个元素推入此双端队列所表示的堆栈（换句话说，此双端队列的头部）
E removeFirst()
boolean removeFirstOccurrence(Object o)
E removeLast()
boolean removeLastOccurrence(Object o)  

3.2.2.2.1 类 LinkedList< E >

//构造方法
LinkedList()  
LinkedList(Collection<? extends E> c) 
//方法
Object clone()   

3.2.3 接口List< E >

void add(int index, E element)
boolean addAll(int index, Collection<? extends E> c)
E get(int index)
int indexOf(Object o)
int lastIndexOf(Object o)
ListIterator<E> listIterator(int index) 
E remove(int index)
E set(int index, E element) 
List<E> subList(int fromIndex, int toIndex) 

Iterator并发修改异常：

在Iterator迭代器中，不能使用集合的方法对元素进行增删操作（List.remove()等），这会导致迭代器并不知道集合中的变化，引发数据的不确定性。可以用Iterator本身的remove（）方法。

3.2.3.1 类 ArrayList< E >

//构造方法
ArrayList()
ArrayList(Collection<? extends E> c)
ArrayList(int initialCapacity) 
// 方法
Object clone()
protected void removeRange(int fromIndex, int toIndex)
void trimToSize() 
 //将此 ArrayList 实例的容量调整为列表的当前大小。

ArrayList	Vector
迭代器	枚举
add	addElement
Iterator	Enumeration
hasNext	hasMoreElements
next	nextElements

3.2.3.2 类 LinkedList< E >

3.2.3.3 类 Stack< E >

//构造方法
Stack()
//方法 
boolean empty()
E peek()
E pop()
E push(E item)
int search(Object o)

3.3 接口Map<K, V>

//嵌套类
static interface Map.Entry<K,V>
//方法摘要 
void clear()
boolean containsKey(Object key)
boolean containsValue(Object value)
Set<Map.Entry<K,V>> entrySet()
boolean equals(Object o)
V get(Object key)
int hashCode()
boolean isEmpty()
Set<K> keySet()
V put(K key, V value)
void putAll(Map<? extends K,? extends V> m)
V remove(Object key)
int size()
Collection<V> values() 

3.3.1 接口 Map.Entry<K,V>

//方法摘要 
boolean equals(Object o)
K getKey()
V getValue()
int hashCode()
V setValue(V value) 

3.3.2 类HashMap<K,V>

//构造方法 
HashMap() 
HashMap(int initialCapacity)
HashMap(int initialCapacity, float loadFactor) 
HashMap(Map<? extends K,? extends V> m)
//方法
Object clone()

3.3.3 类LinkedHashMap<K,V>

//构造方法
LinkedHashMap()
LinkedHashMap(int initialCapacity) 
LinkedHashMap(int initialCapacity, float loadFactor)
LinkedHashMap(int initialCapacity, float loadFactor, boolean accessOrder) 
LinkedHashMap(Map<? extends K,? extends V> m) 
//方法
protected  boolean removeEldestEntry(Map.Entry<K,V> eldest) 

• HashMap存取不一致；LinkedHashMap存取一致
• 若键为自定义对象，需保证唯一性->重写hashCode() equals()
• Map集合遍历键招值的方式

  法1：

  1. Set keySet()
  2. 遍历键的集合，得到每一个键
  3. 根据键找对应的值：V get(Object key)

  法2：

  1. Set<Map.Entry<K,V>> entrySet()
  2. 遍历键值对对象的Set集合，得到每一个键值对对象
  3. K getKey() V getValue()

3.4 类 Collections

//静态成员
static List EMPTY_LIST//空的列表（不可变的）。 
static Map EMPTY_MAP//空的映射（不可变的）。 
static Set EMPTY_SET//空的 set（不可变的）。 
//方法 
static <T> boolean addAll(Collection<? super T> c, T... elements) 
	//将所有指定元素添加到指定 collection 中。 
static <T> int binarySearch(List<? extends Comparable<? super T>> list, T key)
	//使用二分搜索法搜索指定列表，以获得指定对象。 
static <T> int binarySearch(List<? extends T> list, T key, Comparator<? super T> c) 
	//使用二分搜索法搜索指定列表，以获得指定对象。 
static <T> void copy(List<? super T> dest, List<? extends T> src) 
static boolean disjoint(Collection<?> c1, Collection<?> c2) 
	//如果两个指定 collection 中没有相同的元素，则返回 true。 
static <T> List<T> emptyList() //返回空的列表（不可变的）。 
static <K,V> Map<K,V> emptyMap()       
static <T> Set<T> emptySet()          
static <T> void fill(List<? super T> list, T obj) 
	//使用指定元素替换指定列表中的所有元素。 
static int frequency(Collection<?> c, Object o) 
	//返回指定 collection 中等于指定对象的元素数。 
static int indexOfSubList(List<?> source, List<?> target) 
	//返回指定源列表中第一次出现指定目标列表的起始位置；如果没有出现这样的列表，则返回 -1。 
static int lastIndexOfSubList(List<?> source, List<?> target)  
static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll)        
static <T> T max(Collection<? extends T> coll, Comparator<? super T> comp) 
static <T extends Object & Comparable<? super T>> T min(Collection<? extends T> coll) 
static <T> T min(Collection<? extends T> coll, Comparator<? super T> comp)      
static <T> List<T> nCopies(int n, T o) 
	//返回由指定对象的 n 个副本组成的不可变列表。  
static <T> boolean replaceAll(List<T> list, T oldVal, T newVal)       
static void reverse(List<?> list)   
static <T> Comparator<T> reverseOrder() 
	//返回一个比较器，它强行逆转实现了 Comparable 接口的对象 collection 的自然顺序。 
static <T> Comparator<T> reverseOrder(Comparator<T> cmp) 
   //返回一个比较器，它强行逆转指定比较器的顺序。 
static void rotate(List<?> list, int distance) 
   //根据指定的距离轮换指定列表中的元素。 
static void shuffle(List<?> list) 
   //使用默认随机源对指定列表进行置换。 
static void shuffle(List<?> list, Random rnd) 
  //使用指定的随机源对指定列表进行置换。 
static <T> Set<T> singleton(T o) 
   //返回一个只包含指定对象的不可变 set。 
static <T> List<T> singletonList(T o)           
static <K,V> Map<K,V> singletonMap(K key, V value)         
static <T extends Comparable<? super T>> void  sort(List<T> list) 
	//根据元素的自然顺序对指定列表按升序进行排序。 
static <T> void sort(List<T> list, Comparator<? super T> c) 
	//根据指定比较器产生的顺序对指定列表进行排序。 
static void swap(List<?> list, int i, int j) 
	//在指定列表的指定位置处交换元素。    

3.5 类Arrays

static int binarySearch(byte[] a, byte key)       
static int binarySearch(byte[] a, int fromIndex, int toIndex, byte key) 
static <T> int binarySearch(T[] a, int fromIndex, int toIndex, T key, Comparator<? super T> c)         
static <T> int binarySearch(T[] a, T key, Comparator<? super T> c)  
	//byte : char double float int long Object short
          使用二分搜索法来搜索指定的 byte 型数组的范围，以获得指定的值。 
                  
static boolean[] copyOf(boolean[] original, int newLength) 
static <T> T[] copyOf(T[] original, int newLength)          
static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) 
 	
static boolean[] copyOfRange(boolean[] original, int from, int to) 
static <T> T[] copyOfRange(T[] original, int from, int to) 
static <T,U> T[] copyOfRange(U[] original, int from, int to, Class<? extends T[]> newType)
	//boolean : byte char double float int long Object short

static boolean equals(boolean[] a, boolean[] a2) 
	//boolean : byte char double float int long Object short
          
static void fill(boolean[] a, boolean val)          
static void fill(boolean[] a, int fromIndex, int toIndex, boolean val) 
	//boolean : byte char double float int long Object short           

static int hashCode(boolean[] a) 
	//boolean : byte char double float int long Object short 
 
static void sort(byte[] a)         
static void sort(byte[] a, int fromIndex, int toIndex) 
static <T> void sort(T[] a, Comparator<? super T> c)          
static <T> void sort(T[] a, int fromIndex, int toIndex, Comparator<? super T> c)       
	//byte : char double float int long Object short        

static String toString(boolean[] a) 
	//boolean : byte char double float int long Object short