MLDN类集学习笔记

今天所讲的知识点
A 类集设置的目的
B Collection接口
C List接口
D Set接口
E List接口和Set接口的区别
F Queue接口
G Collection集合的输出
H Stack类
I Map接口
J HashMap类
K TreeMap类
L HashTable类
M HashMap类和HashTable类的区别
N Map集合的输出
O Properties类
P Collections类

我对知识点的分析
A 类集设置的目的
类集设置的目的是为处理对象的动态数组。
所有关于类集的操作都放在java.util包中
三大类集接口：Collection<E>接口、Map<E>接口、Iterator<E>接口
B Collection接口
一、Collection接口的定义
public interface Collection<E> extends Iterable<E>
<E>带有泛型，继承了Iterable接口，表示可迭代的

二、Collection接口的抽象方法（15个）
只要是接口，其中定义的方法都是公有的并且是抽象的。
1、public boolean add(E e)
2、public boolean addAll(Collection<? extends E> c)
3、public void clear()
4、public boolean contains(Object o)
5、public boolean containsAll(Collection<?> c)
6、public boolean equals(Object o)
7、public int hashCode()
8、public boolean isEmpty()
9、public Iterator<E> iterator()
10、public boolean remove(Object o)
11、boolean removeAll(Collection<?> c)
12、boolean retainAll(Collection<?> c)
13、public int size()
14、public Object[] toArray()
15、<T> T[] toArray(T[] a)

三、Collection接口常用的三个直接子接口
List、Set、Queue
List 接口的定义：public interface List<E> extends Collection<E>
Set接口的定义：public interface Set<E>extends Collection<E>
Queue接口的定义：public interface Queue<E>extends Collection<E>

C List接口
一、List<E>接口的定义
List 接口的定义：public interface List<E> extends Collection<E>
继承了Collection接口，间接继承了Iterator接口

二、List接口的抽象方法（15继承的Collection +10个扩展的）
下面列出10个扩展的：
1、public void add(int index,E element)
2、boolean addAll(int index,Collection<? extends E> c)
3、public E get(int index)
4、public int indexOf(Object o)
5、public int lastIndexOf(Object o)
6、public ListIterator<E> listIterator()
7、public ListIterator<E> listIterator(int index)
8、public E remove(int index)
9、public E set(int index,E element)
10、List<E> subList(int fromIndex,int toIndex)

三、List接口的子类
AbstractList<E>类、ArrayList<E>类、Vector<E>类、AbstractSequentialList <E>类、LinkedList<E>类
1、AbstractList<E>类：public abstract class AbstractList<E>extends AbstractCollection<E>implements List<E>
其中AbstractCollection<E>类的定义为：public abstract class AbstractCollection<E>extends Object  implements Collection<E>
2、ArrayList<E>类：public class ArrayList<E>extends AbstractList<E>implements List<E>, RandomAccess, Cloneable, Serializable
3、Vector<E>类：public class Vector<E>extends AbstractList<E>implements List<E>, RandomAccess, Cloneable, Serializable
4、AbstractSequentialList <E>类：public abstract class AbstractSequentialList<E>extends AbstractList<E>
5、LinkedList<E>类：public class LinkedList<E>extends AbstractSequentialList<E>implements List<E>, Deque<E>, Cloneable, Serializable

四、AbstractList<E>类
1、AbstractList<E>类是一个抽象类，此处采用了适配器设计模式，这样AbstractList<E>类的子类就可以不用去实现List接口已在AbstractList<E>类中实现过的抽象方法，但是在AbstractList<E>类中没有实现的List接口的抽象方法，AbstractList<E>类其子类（非抽象的）就必须去实现。

因为AbstractList<E>类是一个抽象类，所以可以不一一实现其父接口List的所有抽象方法。但是AbstractList<E>类的具体子类就必须一一实现AbstractList<E>类未实现的父接口List的其他抽象方法和AbstractList<E>类扩展的抽象方法。

2、AbstractList<E>类的子类
AbstractList<E>类的子类有：ArrayList<E>类、Vector<E>类、AbstractSequentialList <E>类

3、AbstractList<E>类子类的特点
ArrayList<E>类、Vector<E>类、AbstractSequentialList <E>类这三个类在继承了AbstractList<E>类同时，又再次显式实现了List接口，原因是想重新实现List的所有抽象方法。或者说指明LinkedList<E>类兼容List接口定义的标准。
这样ArrayList<E>类、Vector<E>类这两个具体的类就必须实现List接口的所有抽象方法和AbstractList<E>类的所有抽象方法。
而AbstractSequentialList <E>类又是抽象类，其可以部分实现List接口的抽象方法和AbstractList<E>类的抽象方法。

4、AbstractSequentialList <E>类
AbstractSequentialList <E>类也是一个抽象方法，其子类有LinkedList<E>类，而这个子类的特点也是在继承了AbstractSequentialList <E>类之后，也显式继承了List接口，同样其原因是想重新实现List的所有抽象方法。或者说指明LinkedList<E>类兼容List接口定义的标准。

5、AbstractList<E>类的构造方法
protected AbstractList()

6、AbstractList<E>类的操作方法（16个）
（1）实现List接口中原来Collection接口就有的（5个）
1、public boolean add(E e)
2、public void clear()
3、public boolean equals(Object o)
4、public int hashCode()
5、public Iterator<E> iterator()

（2）实现List接口中扩展的原来Collection接口没有的（10个）
1、public void add(int index,E element)
2、boolean addAll(int index,Collection<? extends E> c)
3、public E get(int index)
4、public int indexOf(Object o)
5、public int lastIndexOf(Object o)
6、public ListIterator<E> listIterator()
7、public ListIterator<E> listIterator(int index)
8、public E remove(int index)
9、public E set(int index,E element)
10、List<E> subList(int fromIndex,int toIndex)

（3）AbstractList<E>类自己扩展的（1个）
1、protected void removeRange(int fromIndex,int toIndex)

五、ArrayList<E>类
1、ArrayList<E>类的定义
public class ArrayList<E>extends AbstractList<E>implements List<E>, RandomAccess, Cloneable, Serializable
ArrayList<E>类继承了AbstractList<E>类的功能，同时又显式实现了List<E>接口，实现了RandomAccess接口，表示可以支持快速随机访问。
其中RandomAccess接口是个标记接口（即无方法的接口），此处本来List<E>接口中有E  get(int index)方法可以做到快速随机访问，为什么还要单独实现RandomAccess接口呢？
原因是做个标记，在其他地方如果要用到RandomAccess接口类型的参数时或者在某些算法中需要RandomAccess接口标记，则ArrayList<E>类就满足条件了。标记接口学过的还有：Serializable接口和Cloneable接口。
此处ArrayList<E>类也实现了Cloneable接口和Serializable接口，分别表示可克隆的和可被序列化的。

2、ArrayList<E>类的操作方法（3个）
1、public ArrayList()
2、public ArrayList(Collection<? extends E> c)
3、public ArrayList(int initialCapacity)

3、ArrayList<E>类的操作方法（20个）
（1）实现List<E>接口中原来Collectiont<E>接口就有的（9个）
1、public boolean add(E e)
2、public boolean addAll(Collection<? extends E> c)
3、public void clear()
4、public boolean contains(Object o)
5、public boolean isEmpty()
6、public boolean remove(Object o)
7、public int size()
8、public Object[] toArray()
9、<T> T[] toArray(T[] a)

（2）实现List t<E>接口中扩展的原来Collection接口没有的（7个）
1、public void add(int index,E element)
2、boolean addAll(int index,Collection<? extends E> c)
3、public E get(int index)
4、public int indexOf(Object o)
5、public int lastIndexOf(Object o)
6、public E remove(int index)
7、public E set(int index,E element)

（3）覆写Object类的 Object  clone()方法

（4）实现AbstractList<E>类扩展的的抽象方法
1、protected void removeRange(int fromIndex,int toIndex)

（5）ArrayList<E>类自己扩展的（2个）
1、public void ensureCapacity(int minCapacity)
2、public void trimToSize()

六、Vector<E>类
1、Vector<E>类的定义
public class Vector<E>extends AbstractList<E>implements List<E>, RandomAccess, Cloneable, Serializable
说明同ArrayList<E>类

2、Vector<E>类的构造方法
比ArrayList<E>类多一个public Vector(int initialCapacity,int capacityIncrement)

3、其操作方法在（具有和ArrayList<E>类相同的方法）基础上又扩展了更多其他的，详见文档

七、ArrayList<E>类和Vector<E>类的区别
No. 区别点 ArrayList Vector
1 引入时间 是新的类，是在JDK 1.2之后推出的 是旧的类是在JDK 1.0的时候就定义的
2 性能 性能较高，是采用了异步处理 性能较低，是采用了同步处理
3 输出 支持Iterator、ListIterator输出 除了支持Iterator、ListIterator输出，还支持Enumeration输出

八、LinkedList<E>类
1、LinkedList<E>类的定义
public class LinkedList<E> extends AbstractSequentialList<E>  implements List<E>, Deque<E>, Cloneable, Serializable

2、AbstractSequentialList<E>类的操作方法
（1）实现List接口中原来Collection接口就有的（1个）
1、public Iterator<E> iterator()

（2）实现List接口中扩展的原来Collection接口没有的（10个）
1、public void add(int index,E element)
2、boolean addAll(int index,Collection<? extends E> c)
3、public E get(int index)
4、public ListIterator<E> listIterator(int index)
5、public E remove(int index)
6、public E set(int index,E element)

3、LinkedList<E>类的操作方法
此类和ArrayList<E>类比较除了继承的类不同之外，比ArrayList<E>类多实现了一个Deque<E>接口，而Deque<E>接口是Queue<E>接口的子接口，因此比较明显的不同之处是多了如下方法：
1、public boolean add(E e)
2、public E element()
3、public boolean offer(E e)
4、public E peek()
5、public E poll()
6、public E remove()

D Set接口
一、Set<E>接口的定义
Set<E>接口的定义：public interface Set<E>extends Collection<E>

二、Set<E>接口的操作方法
没有对Collection<E>进行扩展，全部方法都是继承的Collection<E>接口的

三、Set<E>接口的子接口
Set<E>接口的直接子接口：SortedSet<E>
其定义：public interface SortedSet<E>extends Set<E>

Set<E>接口的间接子接口：NavigableSet<E>
其定义：public interface NavigableSet<E>extends SortedSet<E>

四、Set<E>接口的子类
Set<E>接口的子类：AbstractSet<E>、HashSet<E>
AbstractSet<E>类的定义：public abstract class AbstractSet<E>extends AbstractCollection<E>implements Set<E>
其中AbstractCollection<E>类的定义：public abstract class AbstractCollection<E>extends Object implements Collection<E>
HashSet<E>类的定义：public class HashSet<E>extends AbstractSet<E>implements Set<E>, Cloneable, Serializable

五、AbstractSet<E>类
1、AbstractSet<E>类是一个抽象类，没有实现Set接口的所有方法，但是其具体子类就必须实现Set接口其他未实现的方法

2、构造方法：protected AbstractSet()

3、操作方法（3个）：全是Collection<E>接口的
1、boolean equals(Object o)
2、int hashCode()
3、boolean removeAll(Collection<?> c)

4、AbstractSet<E>类的子类特点
HashSet<E>类在继承类AbstractSet<E>类的同时，又显示实现了Set<E>接口，同AbstractList处解释相同


六、HashSet<E>类
1、HashSet<E>类的定义
public class HashSet<E>extends AbstractSet<E>implements Set<E>, Cloneable, Serializable

2、HashSet<E>类的操作方法
1、boolean add(E e)
2、void clear()
3、Object clone()      覆写了Object类的clone()方法
4、boolean contains(Object o)
5、boolean isEmpty() 
6、Iterator<E> iterator()
7、boolean remove(Object o)
8、int size()

七、TreeSet<E>类
1、TreeSet<E>类的定义
public class TreeSet<E>extends AbstractSet<E>implements NavigableSet<E>, Cloneable, Serializable

2、TreeSet<E>类的操作方法以Set<E>的为准，其他方法参考文档

E Queue接口
一、Queue接口的定义
public interface Queue<E>extends Collection<E>

二、Queue接口的操作方法
1、public boolean add(E e)
2、public E element()
3、public boolean offer(E e)
4、public E peek()
5、public E poll()
6、public E remove()
这些方法的区别：
         Throws exception     Returns special value
Insert     add(e)               offer(e)
Remove   remove()             poll()
Examine   element()            peek()

F List接口和Set接口的区别、HashSet类和TreeSet类的区别
Set接口也是Collection的子接口，与List接口最大的不同在于，Set接口里面的内容是不允许重复的。

HashSet集合的元素是无序存放的，TreeSet集合的元素是有序存放的。

关于排序的说明：如果TreeSet集合的元素类型本身没有实现Comparable接口（CompareTo方法），则会报无法向Comparable类型转换的异常，因为要加入TreeSet集合的元素类型必须实现Comparable接口；

关于重复值的说明：由于TreeSet集合的元素类型实现Comparable接口，所以借用其CompareTo方法可以简单判断其重复值，但是要完全保证TreeSet集合中无重复值，需要在定义加入TreeSet集合的元素类型的时候覆写Object类中的equals()方法和hashCode()方法。
加入HashSet集合的元素类型必须覆写Object类中的equals()方法和hashCode()方法来保证其无重复值，否则无法去除重复值问题。

G Collection集合的输出
Collection<E>集合有五种输出方法：
1、直接输出集合对象
此种方法会在输出结果两头加上“[   ]”

2、Iterator迭代输出
基本的操作原理：是不断的判断是否有下一个元素，有的话，则直接输出。
（1）Iterator<E>接口的定义
public interface Iterator<E>
（2）Iterator<E>接口的操作方法
1、boolean hasNext()
2、E next()
3、void remove()
（3）实例化方法
用Collection<E>接口的public Iterator<E> iterator()方法

3、ListIterator
（1）ListIterator<E>接口的定义
public interface ListIterator<E> extends Iterator<E>

（2）ListIterator<E>接口的操作方法
除了Iterator的三个操作方法外，还扩展了6个方法：
1、void add(E e)
2、boolean hasPrevious()
3、E previous()
4、void set(E e)
5、int previousIndex()
6、int nextIndex()

4、Enumeration<E>接口
（1）Enumeration <E>接口的定义
public interface Enumeration<E>
（2）Enumeration <E>接口的操作方法
1、boolean hasMoreElements()
2、E nextElement()

5、foreach
语法格式：for(<E>  循环变量 ： 集合名称){}

H Stack类
一、Stack<E>类的定义
public class Stack<E> extends Vector<E>

二、Stack<E>类的构造方法
Public Stack();

三、Stack<E>类的操作方法（5个）
1、boolean empty()
2、E peek()  返回栈顶元素，不出栈
3、E pop()   出栈
4、E push(E item) 入栈
5、int search(Object o)

I Map接口
Map接口中的元素是按照keyvalue的形式保存，也称为二元偶对象。

K,V可以使任意类型，key、value可以使任意类型的对象，但是任意一个类的对象，如果要想作为key且实现查找的功能，则类必须实现equals()和hashCode()方法。

一、Map<K,V>接口的定义
public interface Map<K,V>

二、Map接口的操作方法
1、void clear()
2、boolean containsKey(Object key)
3、boolean containsValue(Object value)
4、Set<Map.Entry<K,V>> entrySet()
5、boolean equals(Object o)
6、V get(Object key)
7、int hashCode()
8、boolean isEmpty()
9、Set<K> keySet()
10、V put(K key, V value)
11、void putAll(Map<? extends K,? extends V> m)
12、V remove(Object key)
13、int size()
14、Collection<V> values()

四、Map接口的内部接口Map.Entry<K,V>
1、Map.Entry<K,V>接口的定义：public static interface Map.Entry<K,V>
2、Map.Entry<K,V>接口的操作方法：
(1)boolean equals(Object o)
(2)K getKey()   
(3)V getValue()
(4)int hashCode()
(5)V setValue(V value)

五、Map接口的子接口
1、Map接口的直接子接口SortedMap<K,V>
SortedMap<K,V>接口的定义：public interface SortedMap<K,V>extends Map<K,V>

2、Map接口的间接子接口NavigableMap<K,V>
NavigableMap<K,V>接口的定义：public interface NavigableMap<K,V>extends SortedMap<K,V>

六、Map接口的子类
Map接口的子类：AbstractMap、HashMap、Hashtable、Properties

1、AbstractMap<K,V>类的定义：public abstract class AbstractMap<K,V>extends Object implements Map<K,V>
2、HashMap<K,V>类的定义：public class HashMap<K,V>extends AbstractMap<K,V>implements Map<K,V>, Cloneable, Serializable
3、Hashtable<K,V>类的定义：public class Hashtable<K,V>extends Dictionary<K,V>implements Map<K,V>, Cloneable, Serializable
其中Dictionary<K,V>类的定义如下：public abstract class Dictionary<K,V>extends Object
4、Properties类的定义：public class Properties   extends Hashtable<Object,Object>

J HashMap类
一、HashMap<K,V>的定义
public class HashMap<K,V>extends AbstractMap<K,V>implements Map<K,V>, Cloneable, Serializable

二、HashMap<K,V>类的操作方法（详见文档，应用时主要以Map接口的方法为准）

K TreeMap类
一、TreeMap<K,V>的定义
public class TreeMap<K,V>extends AbstractMap<K,V>implements NavigableMap<K,V>, Cloneable, Serializable

二、TreeMap<K,V>类的操作方法（详见文档，应用时主要以Map接口的方法为准）

三、TreeMap<K,V>类的特点
TreeMap子类是允许key进行排序的操作子类，其本身在操作的时候将按照key进行排序，另外，key中的内容可以为任意的对象，但是要求对象所在的类必须实现Comparable接口。


L HashTable类
一、Hashtable <K,V>的定义
public class Hashtable<K,V>extends Dictionary<K,V>implements Map<K,V>, Cloneable, Serializable
其中Dictionary<K,V>类的定义如下：public abstract class Dictionary<K,V>extends Object

二、Hashtable <K,V>类的操作方法（详见文档，应用时主要以Map接口的方法为准）

M Hashtable<K,V>类和HashMap<K,V>类的区别
No. 区别点 HashMap Hastable
1 推出时间 JDK 1.2之后推出的，新的操作类 JDK 1.0时推出的，旧的操作类
2 性能 异步处理，性能较高 同步处理，性能较低
3 null 允许设置为null 不允许设置，否则将出现空指向异常

N Map集合的输出
步骤：
1、 使用Map接口中的entrySet()方法将Map接口的全部内容变为Set集合
2、 可以使用Set接口中定义的iterator()方法为Iterator接口进行实例化
实例化方法：用Set<E>（继承Collection接口）的public Iterator<E> iterator()方法
3、 之后使用Iterator接口对象的方法进行迭代输出，每一次的迭代都可以取得一个Map.Entry的实例
1、boolean hasNext()
2、E next()

4、 通过Map.Entry进行key和value的分离
Map.Entry接口的分离方法：
(1)K getKey()   
(2)V getValue()

O Properties类
一、Properties类的定义
public class Properties extends Hashtable<Object,Object>
特点：擦除泛型

二、Properties类的操作方法
1、String getProperty(String key)
2、String getProperty(String key, String defaultValue)
3、void list(PrintStream out)
4、void list(PrintWriter out)
5、void load(InputStream inStream)
6、void load(Reader reader)
7、void loadFromXML(InputStream in)
8、Enumeration<?> propertyNames()
9、void save(OutputStream out, String comments)
10、Object setProperty(String key, String value)
11、void store(OutputStream out, String comments)
12、void store(Writer writer, String comments)
13、void storeToXML(OutputStream os, String comment)
14、void storeToXML(OutputStream os, String comment, String encoding)
15、Set<String> stringPropertyNames()

P Collections类
一、Collections类的定义
public class Collections extends Object
从定义上此类和Collection接口无关

二、Collections类的特点
此类的所有方法都是静态方法



项目案例

A 现在要求实现对一个超市商品的统一管理，可以进行商品的上架、下架、查询的功能，问类该如何设计？
个人收获：
宠物商店的类和接口的设计模式是一个典型的设计思路
能定义成接口和抽象类的就定义成接口

案例名称：

A
解决方法：
画结构图

问题描述：
类集各个接口和类的继承、实现关系混乱？
备注：
A 1、观察AbstractList (class)类实现List<E>接口的方式
2、观察ArrayList<E>(class)类等继承AbstractList (class)类并实现List<E>接口的方式
得出结论：
1、抽象类在实现接口的时候，可以不实现其全部的抽象方法，但是如果其子类是具体的类，那么在实现方法的时候，还是需要将其父接口的在此抽象类中未实现的方法一一实现


今天换了一种复习方式，把所讲的类和接口的继承和实现关系整理了一下，这样知识之间的关系就清晰了很多，而且区别和联系也明朗了许多。
下面是Collection接口的子接口或子类
[img]image002.jpg [/img]
[img]image003.png [/img]

评论

1 楼 Javakeith 2010-10-18  

想是在读API，还是很好的！