黑马程序员——集合框架Collection

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------
Collection

概述：

在Java2出现以后，Java提供了一套了由接口和类组成了Java集合框架Collection。Collection下提供一系列子接口，例如Map、Set、List等。

这些不同的子接口操作不同数据结构的数据，使程序员对成批数据或元素极为方便。

Collection框架图：



需要注意的是：Colleciton、List、Set和Map都是接口，不是类的实现，具体的实现类例如：ArrayList、HashSet等。

常用的集合类的继承结构：

Collection<--List<--Vector

Collection<--List<--ArrayList

Collection<--List<--LinkedList

Collection<--Set<--HashSet

Collection<--Set<--HashSet<--LinkedHashSet

Collection<--Set<--SortedSet<--TreeSet

Map<--SortedMap<--TreeMap

Map<--HashMap

List接口：此接口通过数组下标存放有序的元素，用户也可以通过数组下标准确的来访问List的元素，List中元素可以重复。

List接口的常用实现类：

1.Vector：基于数组的链表，由于使用了synchronized线程安全，性能差，被ArrayList取代。

示例代码：

import java.util.*;
public class Collection
{
public static void main(String[] args)
{
Vector<Integer> vec = new Vector<Integer>(); //创建Vector对象。
vec.add(1); //add（E e）方法添加元素。
vec.add(2);
vec.add(3);
Vector<Integer> vec1 = new Vector<Integer>();
Boolean isCompare = vec1.equals(vec); //比较两个Vector对象是否相等。
Boolean isContain = vec.contains(5); //判断vec中是否有2这个元素，有就返回true，没有就返回false。
Boolean isNull = vec.isEmpty(); //判断vec是否为空。
vec.remove(2); //删除指定位置的元素。
vec.clear(); //清空vec中所有的元素。
Iterator it = vec.iterator(); //创建vec的迭代器。可以遍历vec容器中所有的元素。
while(it.hasNext())
{
it.next();
}
int length = vec.size(); //获取vec的大小。
Integer[] arr = vec.toArray(new Integer[0]);  //讲vec中的元素返回到指定Integer的类型的数组中。
}
}

2.ArrayList：基于数组的链表，不同步，适合用于查询元素，不适合于用于增加、删除元素。

示例代码：

import java.util.*;
public class Collection
{
public static void main(String[] args)
{
ArrayList<Integer> list = new ArrayList<Integer>(); //创建ArrayList对象。
list.add(1); //list容器添加元素。
list.add(2);
list.add(3);
Boolean isNull = list.isEmpty(); //判断容器是否为空。
Boolean isContain = list.contains(4); //判断容器里面有没有指定的元素，有就返回true，没有就返回false。
list.indexOf(2); //根据指定的元素，返回容器中首次出现指定元素的索引，如果容器中没此元素就返回-1.
list.remove(2); //移除指定位置的上的元素。
list.set(1, 5); //替换指定位置的元素。
list.size(); //返回容器list的元素个数。
int i= list.get(2); //根据指定位置，获取指定位置上的元素。
list.clear(); //清除list中所有的元素。
int length = list.size(); //获取vec的大小。
Integer[] arr = list.toArray(new Integer[0]);  //讲list中的元素返回到指定Integer的类型的数组中。
Iterator<Integer> it = list.iterator();  //创建list的迭代器，用于循环遍历list的所有元素。
while(it.hasNext())
{
it.next();
}
}
}

3.LinkedList：基于数组的双向链表，不同步，适合用于增加、删除元素，不适合用于查询元素。

示例代码：

import java.util.*;
public class Collection
{
public static void main(String[] args)
{
LinkedList<Integer> list = new LinkedList<Integer>(); //创建LinkedList对象。
list.add(1); //lsit容器添加元素。
list.add(2);
list.add(3);
Boolean isNull = list.isEmpty(); //判断容器是否为空。
Boolean isContain = list.contains(4); //判断容器里面有没有指定的元素，有就返回true，没有就返回false。
list.indexOf(2); //根据指定的元素，返回容器中首次出现指定元素的索引，如果容器中没此元素就返回-1.
list.remove(2); //移除指定位置的上的元素。
list.set(1, 5); //替换指定位置的元素。
list.size(); //返回容器list的元素个数。
int i= list.get(2); //根据指定位置，获取指定位置上的元素。
list.clear(); //清除list中所有的元素。
int length = list.size(); //获取list的大小。
list.offerFirst(1); //将指定的元素插入列表的头。
list.offerLast(2); //将指定的元素插入列表的尾。
list.peekFirst(); //获取并移除此列表的第一个元素；如果此列表为空，则返回 null。
list.peekLast(); //获取并移除此列表的最后一个元素；如果此列表为空，则返回 null。
list.pollFirst(); //获取并移除此列表的第一个元素；如果此列表为空，则返回 null。
list.peekLast(); //获取并移除此列表的最后一个元素；如果此列表为空，则返回 null。
Integer[] arr = list.toArray(new Integer[0]);  //讲list中的元素返回到指定Integer的类型的数组中。
Iterator<Integer> it = list.iterator();  //创建list的迭代器，用于循环遍历list的所有元素。
while(it.hasNext())
{
it.next();
}
}
}

Set接口：此接口不可以存放重复的元素，判断是否元素重复由equals方法判断。

Set接口的常用实现类：

1.HashSet：基于hash值的散列法的机制存储，存放的元素在容器中无序。

示例代码：

import java.util.*;
public class Collection
{
public static void main(String[] args)
{
HashSet<Integer> set = new HashSet<Integer>(); //创建HashSet对象。
set.add(1); //添加指定元素到set中。
set.add(2);
set.add(3);
Boolean isContain = set.contains(5); //如果此 set容器包含指定元素，则返回 true，否则返回false。
set.isEmpty(); //判断set容器是否为空。
set.size(); //返回set容器的元素个数。
System.out.println(isContain);
set.clear(); //清除set容器中所有的元素。
set.remove(2); //移除set容器中的指定的元素。
Iterator<Integer> it = set.iterator();  //创建set的迭代器，用于循环遍历list的所有元素。
while(it.hasNext())
{
it.next();
}
}
}

2.TreeSet：基于树型结构存储元素，对元素以升序顺序存储，访问和遍历时间都很快。。

代码：

import java.util.*;
public class Collection
{
public static void main(String[] args)
{
TreeSet<Integer> set = new TreeSet<Integer>();  //创建TreeSet对象。
set.add(1); //添加指定元素到set中。
set.add(2);
set.add(3);
set.clear();
Boolean isContain = set.contains(5); //如果此 set容器包含指定元素，则返回 true，否则返回false。
set.isEmpty(); //判断set容器是否为空。
set.size(); //返回set容器的元素个数。
set.comparator(); //返回对此 set 中的元素进行排序的比较器；如果此 set 使用其元素的自然顺序，则返回 null。
set.clear(); //清除set容器中所有的元素。
set.remove(2); //移除set容器中的指定的元素。
set.pollFirst(); // 获取并移除第一个（最低）元素；如果此 set 为空，则返回 null。
set.pollLast(); // 获取并移除最后一个（最高）元素；如果此 set 为空，则返回 null。
set.first(); //返回此 set 中当前第一个（最低）元素。
set.last(); //返回此 set 中当前最后一个（最高）元素
set.floor(2); //返回此 set 中小于等于给定元素的最大元素；如果不存在这样的元素，则返回 null。
set.lower(2); //返回此 set 中严格小于给定元素的最大元素；如果不存在这样的元素，则返回 null。
set.ceiling(2); //返回此 set 中大于等于给定元素的最小元素；如果不存在这样的元素，则返回 null。
Iterator<Integer> it = set.iterator();  //创建set的迭代器，用于循环遍历list的所有元素。
while(it.hasNext())
{
it.next();
}
}
}

3：LinkedHashSet：基于以元素插入的顺序来维护集合的链接表，允许以插入的顺序在集合中迭代。

此类继承了HashSet的方法。

不过此类的构造方法特殊：

LinkedHashSet(Collection<? extends E> c)  ：构造一个与指定 collection 中的元素相同的新链接哈希 set。

LinkedHashSet(int initialCapacity)  ：构造一个带指定初始容量和默认加载因子 (0.75) 的新空链接哈希 set。

LinkedHashSet(int initialCapacity, float loadFactor)  ：构造一个带有指定初始容量和加载因子的新空链接哈希 set。

Map接口：此接口是把键和值进行关联再存储，不允许有同值的key存在，value可以重复。

Map接口的常用实现类：

1.HashMap：基于将键的哈希值作为内存索引依据，内部实现是一个适当长度的链式数组，由Key的Hash值对应数组下标，再间接对应内存，是一种比较高效的存取方式。Key的hashCode相同的情况下，放在同一个单项链表结构中。

示例代码：

import jav
af57
a.util.*;
public class Collection
{
public static void main(String[] args)
{
HashMap<Integer, String> map = new HashMap<Integer, String>();
map.put(1, "zhansan"); //向map中添加元素。
map.put(2, "lisi");
map.put(3, "wangwu");
map.isEmpty(); //判断map容器中是否为空。
map.get(2); //返回指定键所映射的值；如果对于该键来说，此映射不包含任何映射关系，则返回 null。
Boolean isContain = map.containsKey(1); //如果此映射包含对于指定键的映射关系，则返回 true 否则false。
Boolean isValue = map.containsValue("zhangsan"); //如果此映射将一个或多个键映射到指定值，则返回 true,否则返回false。
map.size(); //返回map容器中的元素数量。
Set set = map.keySet(); //返回此映射中所包含的键的 Set 视图。
Collection coll = (Collection)map.values(); //返回此映射所包含的值的 Collection 视图。
map.remove(1); //从此映射中移除指定键的映射关系（如果存在）。
Set<Map.Entry<Integer,String>> setMap = map.entrySet(); //返回此映射所包含的映射关系的 Set 视图，可以使map可以间接的遍历。
Iterator<Map.Entry<Integer,String>> it = setMap.iterator(); //创建Set迭代器进行遍历。
while(it.hasNext())
{
it.next();
}
}
}

2.TreeMap：基于采用树型存储结构存放。

迭代器：

import java.util.*;
public class Collection
{
public static void main(String[] args)
{
TreeMap<Integer, String> map = new TreeMap<Integer, String>();
map.comparator(); //返回对此映射中的键进行排序的比较器；如果此映射使用键的自然顺序，则返回 null。
map.put(1, "zhansan"); //向map中添加元素。
map.put(2, "lisi");
map.put(3, "wangwu");
map.remove(1); //如果此 TreeMap 中存在该键的映射关系，则将其删除。
map.isEmpty(); //判断map容器中是否为空。
map.get(2); //返回指定键所映射的值；如果对于该键来说，此映射不包含任何映射关系，则返回 null。
Boolean isContain = map.containsKey(1); //如果此映射包含对于指定键的映射关系，则返回 true 否则false。
Boolean isValue = map.containsValue("zhangsan"); //如果此映射将一个或多个键映射到指定值，则返回 true,否则返回false。
map.size(); //返回map容器中的元素数量。
map.firstEntry(); //返回一个与此映射中的最小键关联的键-值映射关系；如果映射为空，则返回 null。
map.firstKey(); //返回此映射中当前第一个（最低）键。
map.floorKey(1); //返回小于等于给定键的最大键；如果不存在这样的键，则返回 null
map.floorEntry(1); //返回一个键-值映射关系，它与小于等于给定键的最大键关联；如果不存在这样的键，则返回 null。
map.get(1); // 返回指定键所映射的值，如果对于该键而言，此映射不包含任何映射关系，则返回 null。
Set<Integer> set = map.keySet(); //返回此映射包含的键的 Set 视图。
Map.Entry<Integer, String> entry = map.lastEntry(); //返回与此映射中的最大键关联的键-值映射关系；如果映射为空，则返回 null。
map.lastKey(); //返回映射中当前最后一个（最高）键。
map.lowerKey(1); //返回严格小于给定键的最大键；如果不存在这样的键，则返回 null。
map.higherKey(1); //返回严格大于给定键的最小键；如果不存在这样的键，则返回 null。
map.ceilingEntry(1); // 返回大于等于给定键的最小键；如果不存在这样的键，则返回 null。
Map.Entry<Integer, String> entry1 = map.lowerEntry(1); //返回一个键-值映射关系，它与严格小于给定键的最大键关联；如果不存在这样的键，则返回 null。
Map.Entry<Integer, String> entry2 = map.pollFirstEntry(); //移除并返回与此映射中的最小键关联的键-值映射关系；如果映射为空，则返回 null。
Map.Entry<Integer, String> entry3 = map.ceilingEntry(1); //返回一个键-值映射关系，它与大于等于给定键的最小键关联；如果不存在这样的键，则返回 null。
Map.Entry<Integer, String> entry4 = map.pollLastEntry(); //移除并返回与此映射中的最大键关联的键-值映射关系；如果映射为空，则返回 null。
Collection coll = (Collection)map.values(); //返回此映射所包含的值的 Collection 视图。
Set<Map.Entry<Integer,String>> setMap = map.entrySet(); //返回此映射所包含的映射关系的 Set 视图，可以使map可以间接的遍历。
Iterator<Map.Entry<Integer,String>> it = setMap.iterator(); //创建Set迭代器进行遍历。
while(it.hasNext())
{
it.next();
}
}
}

Iterator接口：提供一种方法访问一个容器对象各个元素，而又不需暴露改对象的内部细节，对于要遍历一个容器中所有的元素，Iterator模式是首选。

Iterator接口以实现的类：

1.Collection定义了Iterator<E> iterator()方法，子类都各自实现了该方法，我们直接调用即可。

2.Map中虽没有定义，我们可以利用map.entrySet()的iterator()方法。