Java的集合可以分为两种，第一种是以数组为代表的线性表，基类是Collection；第二种是以Hashtable为代表的键值对。 。。。
- 线性表，基类是Collection：
数组类：
person[] p; system.out.println(p.length);//报错，不允许对null对象进行任何实际操作。 person[] p=new person[5];
Vector类——数组的改进：
1）四个构造函数
Vector(int initialCapacity,int capacityIncrement);
Vector(int initialCapacity);
Vector();
Vector(<E> c); ==>Vector<String> v=new Vector<String>();
2）注意点
如果使用了泛型，则Vector内只能添加同样类型的对象（泛型指示的对象）；如果没使用泛型，那么我们可以把任意的Object类型对象（Boolean/Character/Byte/Short/Integer/Long/Double/Float）添加进Vector，但是不能把基本数据类型（Boolean/Char/Byte/Short/Int/Long/Double/Float）放入Vector中。 如：int i=10; Integer ig=new Integer(10); Vector v=new Vector(); v.addElement(i);//wrong v.addElement(ig);//write
如果没使用泛型，Vector对象事先不知道会是何种类型的数据放入，所以一切数据皆用Object类型来存储。这就存在Vector中对象丢失原始类型的现象，所以我们得到对象后必须用强制类型转换，将对象还原回它放入Vector之前的类型。
如：Vector boys=new Vector(); boys.addElement(new Boy("wang")); boys.addElement(new Girl("zhang"));//这里不会有错 for(i<boys.size()){((Boy)boys.elementAt(i)).print();}//当i==1时，会出错，显然不能用访问Boy对象的方法去访问Girl对象。 我们可以看到Vector很灵活，同一个Vector可以容纳不同类型的对象，但是这种灵活性是以牺牲存放在其中的对象类型为代价的，这也给访问造成了麻烦。
3）常见操作
v.addElement(E obj);//直接插入后面
v.insertElementAt(E obj,int index);//插入，并，后移
v.setElementAt(E obj,int index);//替换
boolean removeElement(Object obj);//删除第一个obj，返回操作结果（未找到，或，失败，false；找到并成功，true）
void removeElementAt(int index);//
void removeAllElements();//
int size();
E elementAt(int index);//依次访问
Stack类——FILO、继承Vector：
1）构造函数
Stack();
Stack<String> st=new Stack();
2）方法
E pop();//访问栈顶元素，并，弹出 while(st.empty()!=true) { System.out.println(st.pop().toString()); }//注意类型转换
E peek();//访问栈顶元素，但，不弹出。 while(st.empty()!=true) { System.out.println(st.peek().toString()); }//死循环
E push(E item);//
boolean empty();//
链表式的List接口及LinkedList实现类：
1）List接口方法
void add(int index,E element);
booleam add(E obj);//插入后面
E remove(int index);
boolean remove(Object obj);//删除第一个
E get(int index);//注意类型转化
int size();
int indexOf(Object obj);//索引值，或，-1
void clear();
List<E> subList(int fromIndex,int toIndex);
2）LinkedList类构造函数
LinkedList();
LinkedList(Collection c);
LinkedList(<E> c);
3)LinkedList类的方法（除了List接口方法外，增加的方法。即：LinkedList的方法包括List接口方法+自身特有的方法）
void addFirst(E obj); void addLast(E obj);
E getFirst(); Object getLast();
E removeFirst(); Object removeLast();
set接口——不允许有重复元素：
1）set接口方法
boolean add(E o);//无重复元素，且，插入成功，true;有重复元素，或，插入失败，false;
boolean remove(Object o);//有指定元素，且，删除成功，true；无制定元素，或，删除失败，false；
boolean isEmpty();
int size();
2）既然要防止重复，就要找到高效率的结构，一般基于“散列表”（HashSet）或基于“树结构”（TreeSet）。
TreeSet比较复杂；HashSet主要是一个散列函数，两个构造方法：HashSet(); HashSet(<E> c);
- 键值对：
Hashtable类：
1）构造函数
Hashtable();
Hashtable(int initialCapacity);
Hashtable(int initialCapacity,float loadFactor);//初始容量和装载因子，装载因子为0.75为好
Hashtable(<K,V> t);
2）Hashtable方法
V put(K key,V value);//插入，并，返回插入的值value
V get(Object key);//
boolean contains(Object value);//（一定注意类型一致，且，数值一致，且，内存地址一致）：覆写
boolean containsKey(Object key);//（一定注意类型一致，且，数值一致，且，内存地址一致）：覆写
boolean containsValue(Object value);//（一定注意类型一致，且，数值一致，且，内存地址一致）：覆写
3）注意：对于Hashtable的contains系列方法
例如：ht.put(new Integer(1),new String("zhang"));
那么：ht.containtsKey(new String("zhang"))的返回值是false，因为内存地址不一致。
那么：ht.containtsKey(new Integer(1))的返回值是false，因为内存地址不一致。
对策：对于(假设String类型)的value（假设类型、值都一样），系统是通过调用Object的equals方法判断的，该方法要求类型、值、内存地址都相同才返回true。所以我们可以覆写该方法，public boolean equals(Object obj){ return (obj instanceof String)&&( String.equals( ((String)obj).getValue() ) }//即：不判断内存，只判断类型和值。
对于（假设Integer类型）的Key（假设类型、值都一样），除了覆写equals方法，public boolean equals(Object obj){ return (obj instanceof Integer)&&( Integer.equals( ((Integer)obj).getValue() ) }//即：不判断内存，只判断类型和值。 还需要覆写hashCode方法，否则，系统会通过调用Object的hashCode方法判断键值是否一样，该方法返回的是内存地址。 public int hashCode(){ return 1; }
总之：对于Hashtable的contains系列方法，必须要求我们通过覆写equals方法来定义对象相等的条件，同时要要覆写hashCode方法为同一类型的对象定义相同的散列吗。
Map接口——封装了散列表：
1）Map接口方法
V put(K key,V value);//插入，并，返回插入的值value
V get(Object key);//
boolean containsKey(Object key);//（一定注意类型一致，且，数值一致，且，内存地址一致）：覆写
boolean containsValue(Object value);//（一定注意类型一致，且，数值一致，且，内存地址一致）：覆写
V remove(Object key);
int size();
void clear();
boolean equals(Object o);//定义Map对象与Object对象相等的条件。。。。。
int hashCode();//定义此类Map对象拥有的hashCode。。。
Set<Map.Entry<K,V>>entrySet();//返回此键值对所包含的键到值映射关系。
HashMap类、TreeMap类——实现Map接口的类：
HashMap类似Hashtable，是无序的；TreeMap存放数据是有序的，默认升序，而且可以通过subMap方法得到有序的子序列。
两种遍历方法：
1）利用枚举类：
Iterator i=map.keySet().iterator();
while(i.hasNext()){ Object o=i.next(); System.out.println("key="+o+",value="+map.get(0)); }
2）利用Entry对象：
for(Entry<String,Integer> entry:map.entrySet()){ System.out.println("key="+entry.getKey()+",value="+entry.getValue()); }