JAVA中的数据结构——集合类（线性表：Vector、Stack、LinkedList、set接口；键值对：Hashtable、Map接口<HashMap类、TreeMap类>）

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());  }