容器
1、容器
容器的API都位于java.util中；
接口：Collection (定义了存取一组对象的方法)
有两个子接口：Set (数据对象无顺序不可以重复；没有提供额外的方法；与数学中
的集合相对应) ：接口实现的类：HashSet / LinkedList / ArrayList
List(有顺序可以重复；每个元素都对应一个整数型的序号记载位
置) : 接口实现的类：HashMap
提供 List 容器类的方法：object get(int inndex) object set(int index,object element)
Void add(int index,object element) object remove(int index)
Int indexOf(object o) int lastIndexof(object o)
类java.util.Collections 提供了一些静态方法实现了基于List容器的常用算法：
Void sort (List) 对List容器内的元素排列
Void shuffle (List) 对List容器内的对象随机排列
Void reverse (List) 逆序排列
Void fill (List , object) 用特定对象重写List容器
Void copy( List dest , List src) 将src里的内容拷贝到dest
Int binarySearch(List , object) 用二分法查找特定对象
List l1 = new LinkedLisr();
List l2 = new LinkedList();
For (int i = 0;i<=9;i++) { li .add(“a”+i);}
Collections.shuffle(l1);
Collections.reverse(l1);
Collection.binarySearch( li , “a5”);
容器类对象在调用remove、contains等方法时需要比较对象是否相等，这会涉及 对象类型的equals 和 hashCode方法，对于自定义的类型，需要重写equals 和 hashCode方法。重写equals方法时就要重写hashCode方法，两个对象相等时，其hashCode也相等。
Iterator : 实现了Collection接口的容器类都有一个iterator方法用以返回一个实
现了Iterator接口的对象，Iterator 对象称作迭代器，用以方便的实现对容器
元素的遍历操作。
Iterator实现的方法: boolen hasNext() 判断游标右边还有没有元素
Object next() 返回游标右边 的元素并将游标移动到 下一个位置
Void remove() 删除游标左边的元素(此方法是在迭代过程中删除元素的唯
一安全的方法）
Collection 接口定义的方法：
Int size() boolean isEmpty() void clear() boolean contains(object element)
Boolean add(object element) boolean remove(object element)
Boolean containsAll(Collection c) boolean addAll(Collection c)
boolean removeAll(Collection c) boolean retainAll(Colection c) object[] toArray()求交集
Collection 方法举例：
Import java.util.*
Public class Test {
Public static void main (String []args){
Collection c = new ArrayList ();// Collection c = new HashSet();
可以放入不同的数据 c.add(new Name(“f1”);
C.add(“hello”); c.add(new Name(“f2”）；
C.add(new Name(“f1”)); c.add(new Name(“f3”);
C.add(new Integer(100); Iterator i = c.iterator();
System.out.println(c.size()); while( i.hasNext){
System.out.println(c); Name n = (Name) i.next();
} System.out.println( )
}
Comparable 接口：可以排序的类都实现了java.lang.Comparable接口；只有一个方法 public int compareTo(object obj) 方法返回 0表示 this ==obj ; 正数 this > obj ;负数this<obj
实现Comparable接口的类通过实现comparaTo方法从而确定该类对象的排序方式；
如何选择数据结构：Array 读快改慢 ；Linked 改快读慢 ；Hash 两者之间；
实现Map接口的类用来存储键---值对；接口的实现类有HashMap 和TreeMap等
Map中存储的键---值对通过键来标识，所以键不能重复; 键和值都必须是对象
Object put (object key , object value);
Object get( object key);
Object remove(object key);
Boolean containsKey (object key);
Boolean containsValue(object value);
Int size() ; boolean isEmpty() ; void putAll(Map t); void clear();
Import java . Util .*;
public class Test{
Public static void main(String args [] ){
Map m1 = new HashMap (); Map m2 = new HashMap();
m1.put (“one”,”new Integer(1)”);
M1.put(“two”,”new Integer(2)”);
M2.put(“A”,”new Integer(3)”);
If(m1.containsKey(“two”){
Int i = ((Integer) m1.get(“two”)).intValue();
System.out println(i);
}
Map m3 = new HashMap ();
M3.putAll(m2);
}
Import java.util.*;
Public class TestArgsWords{
Private static final Integer ONE = new Integer(1);
Public static void main(String args []){
Map m = new HashMap ();
For(int i = 0;i <= args.length ; i++){
Integer freq = (Integer)m.get(args[i]);
M.put(args[i],freq == null? ONE : new Integer ( freq.intValue () + 1));统计各个输入参数的个数
}
}
}
泛型 Generic : JDK 1.4以前类型不明确，装入集合的类型都被当做object，失去自己的实际类型；取出时需要转型，效率低，易产生错误；
所以 可以在定义集合时同时定义集合中对象类型；
Import java.util.*;
Public class BasicGeneric{
Public static void main(String args []){
List <String> c = new ArrayList <String> ();
C.add(“aaa”); c.add(“bbb”); c.add(“ccc”);
For(int i = 0; i < c.size() ; i++){
String s = c.get(i); 应用泛型直接 得到String类型不需要强制转化，若不用泛型返
System.out println(s); 回的为object类，需转化为String类型
}
Collection <String> c2 = new HashSet <String>();
C2.add(“aaa”); c2.add(“ddd”);
For (Iterator <String> it = c2.iterator() ; it.hasNext(); ){
String s = it.next();
System.out.println(s);
}
}
}
LinkedList ：其数据结构采用的是链表，此种结构的优势是删除和添加的效率很高，但随机访问元素时效率较ArrayList类低。
ArrayList：其数据结构采用的是线性表，此种结构的优势是访问和查询十分方便，但添加和删除的时候效率很低。
HashSet: Set类不允许其中存在重复的元素（集），无法添加一个重复的元素（Set中已经存在）。HashSet利用Hash函数进行了查询效率上的优化，其contain（）方法经常被使用，以用于判断相关元素是否已经被添加过。
HashMap: 提供了key-value的键值对数据存储机制，可以十分方便的通过键值查找相应的元素，而且通过Hash散列机制，查找十分的方便。
