Java基础3（集合）

Java中集合类分为两类：Collection和Map
Collection又分为：List和Set两类
Collection中的一些方法有：add(Object o),addAll(Collection c),clear(),contains(Object o),collectionAll(Collection c),isEmpty(),
iterator(),remove(Object o),removeAll(Collection c),retainAll(Collection c),size(),toArray()
Iterator接口遍历集合对象：
hasNext(),next(),remove()
一、List
列表型集合类型，常用的有两个——ArrayList和LinkedList
ArrayList使用数组结构，相当于动态数组，所以按位置的随机访问快，插入删除操作慢。
LinkedList使用链表数据结构，所以随机访问慢，按需访问比较合适，插入删除操作快。其中提供了多种方法，不论是作为堆栈、队列等都

很方便。
          方法原型                                                        功能
void add(int index, Object element) 向当前列表的指定索引位置插入对象，索引起始为0
boolean addAll(int index,Collection c) 向当前列表的指定索引位置插入参数集合的所有对象
Object get(int index)               获取当前列表中指定索引位置的对象
int indexOf(Object o)               获取指定对象在列表中首次出现的索引位置，没有返回-1
int lastIndexOf(Object o)               获取指定对象在列表中最后出现的索引位置，没有返回-1
Object remove(int index)               从当前列表中移出指定索引位置插入对象并返回
Object set(int index, Object element) 替换当前列表中指定索引位置的对象并返回原位置的对象
List subList(int from, int to)               产生子列表，from=起点，to=终点（不包含）

1、ArrayList类的使用方法
如下示例创建一个ArrayList对象用于存放Employee不定数量的Employee对象，然后示意遍历输出的形式：
List<Employee> list=new ArrayList<Employee>(); //创建一空的列表
list.add(new Employee("张")); //索引位置0，实际数量=1
list.add(new Employee("王")); //索引位置1，实际数量=2
list.add(1,new Employee("赵")); //索引位置1，实际数量=3
for (int i=0; i<list.size(); ++i) {System.out.println(list.get(i));}
//输出次序为：张、赵、王

2、LinkedList类的使用方法
因为使用链表结构，所以LinkedList类中增加了几个必须的特定方法如：addFirst、addLast、getFirst、getLast、removeFirst、

removeLast。如下的示意代码相当于以堆栈方式访问一个链表：
List<Employee> list=new LinkedList<Employee>(); //创建一空的列表
list. addFirst (new Employee("张")); //实际数量=1
list. addFirst (new Employee("王")); //实际数量=2
Employee e1= new Employee("赵");
list. addFirst (e1); //实际数量=3
list. addFirst (e1); //实际数量=4，即使引用相同也不限制
for (int i=0; i<list.size(); ++i) {System.out.println(list. removeFirst ());}
//输出次序为：赵、赵、王、张
二、Set
从数据结构的角度看，集合是简单地把对象集中起来，其中存放的对象不按特定方式排序，因此Set是三种聚集类中的最简单的集合类型，

没有加入更多进一步的处理逻辑，主要使用的还是Collection接口的方法。
在实现了Set接口的类中，常用的有两个——HashSet和TreeSet。
Set类型强调集合中对象的唯一性，因而关于“相同”一词有很多逻辑值得探讨，具体涉及equals()、hashCode()两个方法的重写。
例如，Employee可以如下重写两个方法：
    public boolean equals (Object obj) //相等识别
    {
        boolean temp=name.equalsIgnoreCase(((Employee)obj).name);
        return temp;
    }
    public int hashCode()  //哈希码生成
    {
        return name.hashCode();
    }
1.HashSet类的使用方法
HashSet类根据对象的哈希码决定对象的存储位置，因而具有较好的存取和查找性能。
虽然逻辑上集合成员本身并无特定的顺序，但实际上相当于按照哈希码排序，所以进行集合元素遍历时候的顺序是哈希码增量顺序而不是

加入的顺序。
Set<Employee> hashSet=new HashSet<Employee>(); //创建一空的集合
hashSet. add (new Employee("张")); //实际数量=1
hashSet. add (new Employee("王")); //实际数量=2
Employee e1= new Employee("赵");
hashSet. add (e1); //实际数量=3
hashSet. add (e1); //实际数量=3，引用相同不行
hashSet. add (new Employee("赵")); //实际数量=3，equals()判断相同也不行
Iterator<Employee> it=hashSet.iterator();
while (it.hasNext())
{
    Employee ex=it.next();
    System.out.println(ex);
}//输出次序为：王、赵、张
如果需要使用加入的次序，HashSet类的子类LinkedHashSet保证遍历时候的次序和加入次序一致。

2.TreeSet类的使用方法
如果期望集合的元素能按照特定的顺序（与HashSet和LinkedHashSet类提供的次序不同）进行遍历，那么可以使用TreeSet类。
TreeSet通过实现java.util.SortedSet接口，能保证在遍历集合时自动按照某种递增的顺序获得对象。
决定对象次序的途径有两种，一种是集合元素类本身实现下面的比较接口Comparable，通过其中的比较方法的实现支持对象的比较，另一

种是单独建立一个实现下面的比较器接口Comparator的类并创建该类的一个对象（比较器），作为new TreeSet(c)时候的参数。
实现java.util.SortedSet接口为TreeSet类增加的方法如下表所示：
方法原型 功能
Comparator comparator() 返回比较器对象
Object first() 获取第一个对象（最小的）
Object last() 获取最后一个对象
SortedSet headSet(Object toElement) 获取小于集合元素toElement的子集
SortedSet subSet(Object from, Object to) 获取大于或等于集合元素from小于to的子集
SortedSet tailSet(Object fromElement) 获取大于或等于集合元素fromElement的子集

三、Map
Map集合为映射类型，其中存放的每个元素作为值（value）对象都要求配有一个相应的键（key）对象，即影射关系，因而对象的存放是成对的，这就是映射与Set和List的区别是。
映射模拟的是一种适合按照内容（关键字）进行检索的一种集合——“属性——值”集合，例如类似环境变量这样的配置信息，总是按照名字检索值，并且每条信息（每个值对象）的使用者或所属者相对不固定，相当于动态的公共对象。
就Map集合本身而言，存取对象时必须通过相应的键对象来进行，因而要求键对象必须是唯一的，唯一性的依据是使用键对象默认的equals()方法进行判定。
在加入对象操作方面与Set相比较，Set不允许重复（相等）对象出现，Map对于值对象不作区分，但是对于键对象相等的时候依然可以进行加入操作，相当于更改值对象。同时，值对象可以为null。
Map接口定义的功能如下：
方法原型     功能
void clear()   移除集合中所有的映射关系
boolean isEmpty()   判断集合是否为空
int size()    返回集合中映射关系的个数
Object get(Object key) 
Object put(Object key, Object value) 向集合中添加指定的键—值映射关系（返回被替换的对象）
void putAll(Map t)   将指定集合中的所有键—值映射关系添加到该集合中
Object remove(Object key)  通过指定键获取并移出对应的值对象（没有为nul）
boolean containsKey(Object key) 通过指定键判断是否存在相应的映射关系（基于键对象的equals()方法覆盖）
boolean containsValue(Object value) 通过指定值判断是否存在相应的映射关系（基于值对象的equals()方法覆盖）
Set keySet()   返回键对象集合
Collection values()   返回值对象集合

在实现了Map接口的类中，常用的有两个——HashMap和TreeMap
1.HashMap类
HashMap是最常用的Map类，除了上面描述的特性，其一特殊的（与后面TreeMap不同的）地方就是允许最多一个键值为null。具体使用示例如下：
Map<String,Employee> hashMap=new HashMap<String,Employee>(); //创建一空的Map
hashMap.put ("01",new Employee("张")); //实际数量=1
hashMap.put ("01",new Employee("王")); //实际数量=1
Employee e1= new Employee("赵");
hashMap.put ("02",e1); //实际数量=2
hashMap.put ("03",e1); //实际数量=3
Iterator<Employee> it=hashMap.values().iterator();
while (it.hasNext())
{
   Employee ex=it.next();
   System.out.println(ex);
   }//输出次序为：王、赵、赵
2.TreeMap类
同TreeSet相似，TreeMap是支持有序遍历的Map类，所以应用场合相似，即需要特定顺序的时候再使用它。