------- android培训、java培训、期待与您交流！ ----------
一、集合概念
相信大家都知道，java是一门面向对象的编程语言，而对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，就对对象进行存储进行存储，集合就是存储对象最常用的一种方式，我们可以把集合看成是一个容器。
同样，数组也是一种容器，那么集合和它有什么不同？
1.数组虽然也可以存储对象，但是长度是固定的，而集合长度是可变的。
2.数组中可以存储基本数据类型数据，集合只能存储对象。
3.数组中储存的基本数据类型数据或对象要类型相同，而集合可以存储不同类型的对象。
所以，当事先不知道要存放数据的个数，或者需要一种比数组下标存取机制更灵活的方法时，就需要用到集合类。
二、集合的构成与分类
下面是一张网上找到的图片，对于集合中的类和接口有比较清晰的表现：
1.Collection接口:
Collection是最基本的集合接口，一个Collection代表一组对象，即Collection的元素（Elements）。一些 Collection允许相同的元素而另一些不行。一些能排序而另一些不行。Java JDK不提供直接继承自Collection的类，Java JDK提供的类都是继承自Collection的”子接口“如List和Set。
所有实现Collection接口的类都必须提供两个标准的构造函数：无参数的构造函数用于创建一个空的Collection，另一个 Collection参数的构造函数用于创建一个新的Collection，这个新的Collection与传入的Collection有相同的元素。其实后一个构造函数就是复制一个Collection。
那么如何取出Collection中的元素？无论Collection的实际类型如何，它都支持一个iterator()的方法，该方法返回一个迭代器，使用该迭代器即可逐一访问Collection中每一个元素。典型的用法如下：
Iterator it = collection.iterator(); // 获得一个迭代器。
while(it.hasNext()) { //通过迭代器判断集合中是否还有元素。
Object obj = it.next(); // 得到下一个元素，类型为Object。
}
Collection定义了集合框架的共性功能（方法）：
①添加：add(e); addAll(collection);
②删除：remove(e); removeAll(collection); clear();
③判断：contains(e); isEmpty();
④获取：iterator(); size();
⑤获取交集：retainAll();
⑥集合变数组：toArray();
Collection接口派生的两个接口是List和Set。
（1）List接口
List是有序的Collection，使用此接口能够精确的控制每个元素插入的位置。用户能够使用索引（元素在List中的位置，类似于数组下标）来访问List中的元素，这类似于Java的数组。List允许有相同的元素，List集合判断元素是否相同是通过对象的equals()方法。
除了具有Collection接口必备的iterator()方法外，List还提供一个listIterator()方法，返回一个 ListIterator接口，和标准的Iterator接口相比，ListIterator多了一些add()之类的方法，允许添加，删除，设定元素， 还能向前或向后遍历。
实现List接口的常用类有ArrayList，LinkedList，Vector。
ArrayList类：
ArrayList实现了可变大小的数组。它允许所有元素，包括null。
每个ArrayList实例都有一个容量（Capacity），即用于存储元素的数组（数组结构）的大小。这个容量可随着不断添加新元素而自动增加。当需要插入大量元素时，在插入前可以调用ensureCapacity方法来增加ArrayList的容量以提高插入效率。
注意ArrayListList是非同步的，如果多个线程同时访问一个ArrayList实例，而其中至少一个线程从结构上修改了该列表，则它必须保持外部同步。一种解决方法是在创建ArrayList时构造一个同步的List来包装它：
List list = Collections.synchronizedList(new ArrayList(...));
数组结构（每个元素都有角标）：
LinkedList类：
LinkedList实现了List接口，存储数据的方式是双链表，允许null元素。此外LinkedList 类还为在列表的开头及结尾 get、remove 和 insert 元素提供了统一的命名方法。这些操作使LinkedList可被用作堆栈（stack），队列（queue）或双向队列（deque）。
注意LinkedList是非同步的，如果多个线程同时访问一个链接列表，而其中至少一个线程从结构上修改了该列表，则它必须保持外部同步。一种解决方法是在创建LinkedList时构造一个同步的List来包装它：
List list = Collections.synchronizedList(new LinkedList(...));
双链表结构（每个元素只知道前后的元素）：
Arraylist和Linkedlist的不同处：
①ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。
②对于随机访问get和set，ArrayList优于LinkedList，因为LinkedList要移动指针。
③对于新增和删除操作add和remove，LinedList比较占优势，因为ArrayList要移动数据。
Vector类：
Vector非常类似ArrayList，也是数组结构存储数据，但是Vector是同步的。由Vector创建的Iterator，虽然和 ArrayList创建的Iterator是同一接口，但是，因为Vector是同步的，当一个Iterator被创建而且正在被使用，另一个线程改变了 Vector的状态（例如，添加或删除了一些元素），这时调用Iterator的方法时将抛出 ConcurrentModificationException，因此必须捕获该异常。同样，当需要插入大量元素时，在插入前可以调用ensureCapacity方法来增加ArrayList的容量以提高插入效率。另外，Vector还有特有的取出元素的方式，通过它的elements()获取Enumeration枚举来得到元素，实际上Enumeration和Iterator功能是一样的。
Vector与ArrayList不同之处是：
①Vector是线程同步的，所以它也是线程安全的，而Arraylist是线程异步的，是不安全的。如果不考虑到线程的安全因素，一般用arraylist效率比较高。
②如果集合中的元素的数目大于目前集合数组的长度时，vector增长率为目前数组长度的100%,而arraylist增长率为目前数组长度的50%.如过在集合中使用数据量比较大的数据，用vector有一定的优势。
③Vector还有特有的取出元素的方式，Enumeration枚举。
（2）Set接口
Set是一种不包含重复的元素的Collection，即任意的两个元素e1和e2都有e1.equals(e2)=false，Set最多有一个null元素。
另外要注意，必须小心操作可变对象（Mutable Object）。如果一个Set中的可变元素改变了自身状态导致Object1.equals(Object2)=true将导致一些问题。
实现Set接口的常用类有HashSet和TreeSet。
HashSet类：
Hashset存储数据的结构是哈希表，它不保证 set 的迭代顺序，特别是它不保证该顺序恒久不变。也就是说，HashSet中的元素是无序的。它是通过元素的hashCode()和equals()方法来保证元素的唯一性。如果元素的hashCode值不同，则不需调用equals()进行比较。如果元素的HashCode值相同，才会调用equals()判断两个元素是否相同。基于这种唯一性标准，HashSet中判断元素是否存在，以及删除等操作，依赖的方法也是元素的hashCode()和equals()方法。
注意HashSet是非同步的，如果多个线程同时访问一个HashSet，而其中至少一个线程修改了该 set，那么它必须 保持外部同步。一种解决方法是在创建HashSet时构造一个同步的Set来包装它：
Set s = Collections.synchronizedSet(new HashSet(...));
哈希表结构（当元素比较hashCode不同时，元素处于不同区域；当元素比较hashCode相同，equals比较不同时，元素会在同个区域）：
TreeSet类：
TreeSet存储数据的结果是二叉树（红黑树），基于实现NavigableSet接口，它是使用元素的自然顺序对元素进行排序（当元素自身具有比较性时），或者根据创建 set 时提供的 Comparator进行排序（当元素自身不具备比较性，或者比较性不合需求时），具体取决于使用的构造方法。也就是说，TreeSet中的元素是有序的。它是通过元素的compareTo()或者构造时使用的比较器Comparator中的compare()方法来保证元素的唯一性。
注意TreeSet是非同步的，如果多个线程同时访问一个TreeSet，而其中至少一个线程修改了该 set，那么它必须 外部同步。一种解决方法是在创建TreeSet时构造一个同步的Set来包装它：
SortedSet s = Collections.synchronizedSortedSet(new TreeSet(...));
二叉树结构（比较后，小的元素在左子树，大的元素在右子树）：
2.Map接口
Map没有继承Collection接口，Map提供key（键）到value（值）的映射。一个Map中不能包含相同的key，每个key只能映射一个 value。Map接口提供3种集合的视图，允许以键集、值集或键-值映射关系集的形式查看某个映射的内容。映射顺序定义为迭代器在映射的 collection 视图上返回其元素的顺序。某些映射实现可明确保证其顺序，如 TreeMap 类；另一些映射实现则不保证顺序，如 HashMap 类。Map集合没有直接取出元素的方法，想获取Map集合中的元素，需要先用entrySet()方法获取键-值映射关系的Set集合，或者使用keySet()方法获取键的Set集合。
Map集合的共性功能（方法）：
①添加：put(K key, V value); putAll(Map<? extends K,? extends V> m);
②删除: remove(Object key); clear();
③判断:containsValue(Object value); containsKey(Object key); isEmpty();
④获取：get(Object key); size(); values(); entrySet(); keySet();
实现Map接口的常用类有HashMap，TreeMap。
HashMap类：
基于哈希表的 Map 接口的实现。此实现提供所有可选的映射操作，并允许使用null键和null值（替代Hashtable）。其键集上的对象是通过元素的hashCode()和equals()方法来保证元素的唯一性。如果元素的hashCode值不同，则不需调用equals()进行比较。如果元素的HashCode值相同，才会调用equals()判断两个元素是否相同。此类不保证映射的顺序，特别是它不保证该顺序恒久不变。
注意HashMap是非同步的，如果多个线程同时访问一个哈希映射，而其中至少一个线程从结构上修改了该映射，则它必须保持外部同步。一种解决方法是在创建HashMap时构造一个同步的Map来包装它：
Map m = Collections.synchronizedMap(new HashMap(...));
TreeMap类：
基于二叉树的 Map 接口的实现。它所包含的映射关系是有序的（以键为标准），其键的排序方式和TreeSet中的元素相同。
注意TreeMap是非同步的，如果多个线程同时访问一个映射，并且其中至少一个线程从结构上修改了该映射，则其必须外部同步。一种解决方法是在创建TreeMap时构造一个同步的Map来包装它：
SortedMap m = Collections.synchronizedSortedMap(new TreeMap(...));
三、集合的应用
1.例子一（将自定义对象作为元素存到ArrayList集合中，并去除重复元素）：
import java.util.ArrayList;
import java.util.Iterator; /*
将自定义对象作为元素存到ArrayList集合中，并去除重复元素。
比如：存人对象。同姓名同年龄，视为同一个人。为重复元素。 思路：
1，对人描述，将数据封装进人对象。
2，定义容器，将人存入。
3，取出。 List集合判断元素是否相同，依据是元素的equals方法。
*/
class Person {
private String name;
private int age;
Person(String name,int age) {
this.name = name;
this.age = age;
} public boolean equals(Object obj) {
if(!(obj instanceof Person))
return false;
Person p = (Person)obj;
return this.name.equals(p.name) && this.age == p.age;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
} public class ArrayListTest {
public static void main(String[] args) {
ArrayList<Person> al = new ArrayList<Person>(); //使用泛型指定集合元素类型。 al.add(new Person("lisi01",30));
al.add(new Person("lisi02",32));
al.add(new Person("lisi02",32));
al.add(new Person("lisi04",35));
al.add(new Person("lisi03",33));
al.add(new Person("lisi04",35)); al = singleElement(al);
System.out.println("remove 03 :"+al.remove(new Person("lisi03",33)));//remove方法底层也是依赖于元素的equals方法。 Iterator<Person> it = al.iterator();
while(it.hasNext()) { //判断集合中是否还有元素。
Person p = it.next();
System.out.println(p.getName()+"::"+p.getAge());
}
} // 去掉重复元素。
public static ArrayList<Person> singleElement(ArrayList<Person> al) {
//定义一个临时容器。
ArrayList<Person> newAl = new ArrayList<Person>();
Iterator<Person> it = al.iterator();
while(it.hasNext()) {
Person p = it.next(); if(!newAl.contains(p))
newAl.add(p);
}
return newAl;
}
}
运行结果为：
remove 03 :true
lisi01::30
lisi02::32
lisi04::35
2.例子二（使用LinkList模拟一个堆栈或者队列数据结构）：
import java.util.LinkedList; /*
使用LinkList模拟一个堆栈或者队列数据结构。 堆栈：先进后出，如同一个杯子。
队列：先进先出，如同一个水管。
*/
class DuiLie {
private LinkedList link;
private LinkedList link_2; DuiLie() {
link = new LinkedList();
link_2 = new LinkedList();
} public void myAdd(Object obj) {
link.addFirst(obj);
link_2.addFirst(obj);
} public Object myGet() {
return link.removeFirst();
} public Object myGet_2() {
return link.removeLast();
} public boolean isNull() {
if (link.isEmpty()) {
try {
return link.isEmpty();
}
finally {
link.addAll(link_2);
}
}
return link.isEmpty();
}
} public class LinkedListTest {
public static void main(String[] args) {
DuiLie dl = new DuiLie(); dl.myAdd("java01");
dl.myAdd("java02");
dl.myAdd("java03");
dl.myAdd("java04"); //堆栈形式；先进后出
while (!dl.isNull())
System.out.println(dl.myGet());
System.out.println(); //队列形式：先进先出
while (!dl.isNull())
System.out.println(dl.myGet_2());
}
}
运行结果为：
java04
java03
java02
java01
java01
java02
java03
java04
3.例子三（Vector枚举）：
import java.util.Enumeration;
import java.util.Vector; /*
枚举就是Vector特有的取出方式。
发现枚举和迭代器很像。
其实枚举和迭代是一样的。 因为枚举的名称以及方法的名称都过长。
所以被迭代器取代了。
*/
public class VectorDemo {
public static void main(String[] args) {
Vector<String> v = new Vector<String>(); v.add("java01");
v.add("java02");
v.add("java03");
v.add("java04"); Enumeration<String> en = v.elements();
while(en.hasMoreElements()) { //判断集合中是否还有元素。
System.out.println(en.nextElement());
}
}
}
运行结果为：
java01
java02
java03
java04
4.例子四（往HashSet集合中存入自定义对象）：
import java.util.HashSet;
import java.util.Iterator; /*
往HashSet集合中存入自定义对象。
以人为例：
姓名和年龄相同视为同一个人，重复元素。
*/
public class HashSetTest {
public static void main(String[] args) {
HashSet<Person> hs = new HashSet<Person>(); hs.add(new Person("a1",11));
hs.add(new Person("a2",12));
hs.add(new Person("a3",13));
hs.add(new Person("a2",12));
// 查看是否包含指定元素。
System.out.println("a1:"+hs.contains(new Person("a2",12)));
// 删除一个元素。
System.out.println(hs.remove(new Person("a3",13))); Iterator<Person> it = hs.iterator();
while (it.hasNext()) {
Person p = it.next();
System.out.println(p.getName()+"..."+p.getAge());
}
}
} class Person {
private String name;
private int age; Person(String name,int age) {
this.name = name;
this.age = age;
} public String getName() {
return name;
} public int getAge() {
return age;
} public int hashCode() {
return name.hashCode()+age*39;
} public boolean equals(Object obj) {
if (!(obj instanceof Person))
return false;
Person p = (Person)obj;
return this.name.equals(p.name) && this.age == p.age;
}
}
运行结果为：
a1:true
true
a2...12
a1...11
5.例子五（使用TreeSet添加字符串，字符串按长度排序）：
import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet; /*
按照字符串长度排序。 字符串本身具备比较性，但是它的比较方式不是所需要的。
这时只能使用比较器。
*/
public class TreeSetTest {
public static void main(String[] args) {
// 元素本身的比较性不合需求，构造时加上比较器。
TreeSet<String> ts = new TreeSet<String>(new StrLenCompare()); ts.add("abcd");
ts.add("cc");
ts.add("cba");
ts.add("aaa");
ts.add("z");
ts.add("hahaha"); Iterator<String> it = ts.iterator();
while (it.hasNext())
{
String s = (String)it.next();
System.out.println(s+"...length..."+s.length());
}
}
} //比较器比较内容。
class StrLenCompare implements Comparator<String> {
public int compare(String s1,String s2) {
int num = new Integer(s1.length()).compareTo(new Integer(s2.length()));
if (num==0)
return s1.compareTo(s2);
return num;
}
}
运行结果为：
z...length...1
cc...length...2
aaa...length...3
cba...length...3
abcd...length...4
hahaha...length...6
6.例子六（使用HashMap添加不重复的元素（映射关系））：
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set; /*
每一个学生都与对应的归属地。
学生Student，地址String。
学生属性：姓名，年龄。
注意：姓名和年龄相同的视为同一个学生。
保证学生的唯一性。 思路：
1，描述学生。
2，因为学生和地址存在映射关系。定义Map容器，将学生作为键，地址作为值存入。
3，获取Map集合中的元素。
*/
class Student implements Comparable<Student> {
private String name;
private int age;
Student(String name,int age) {
this.name = name;
this.age = age;
} public int compareTo(Student s) {
int num = new Integer(this.age).compareTo(new Integer(s.age));
if (num==0) {
return this.name.compareTo(s.name);
}
return num;
} public int hashCode() {
return this.name.hashCode()+this.age*34;
} public boolean equals(Object obj) { //这里重写的是父类Object的equals方法，参数类型必须Object，否则重写失败。
if(!(obj instanceof Student))
throw new ClassCastException("类型不匹配");
Student s = (Student)obj;
return this.name.equals(s.name) && this.age==s.age;
} public String getName() {
return name;
} public int getAge() {
return age;
} public String toString() {
return name+":::"+age;
}
} public class HashMapTest {
public static void main(String[] args) {
HashMap<Student,String> hm = new HashMap<Student,String>(); hm.put(new Student("lisi1",21),"beijing");
hm.put(new Student("lisi1",21),"tianjin");
hm.put(new Student("lisi2",22),"shanghai");
hm.put(new Student("lisi3",23),"nanjing");
hm.put(new Student("lisi4",24),"wuhan"); //第一种取出方式：keySet
Set<Student> keySet = hm.keySet();
Iterator<Student> it = keySet.iterator(); while (it.hasNext()) {
Student s = it.next();
String addr = hm.get(s);
System.out.println(s+"..."+addr);
}
System.out.println(); /* //第二种取出方式：entrySet
Set<Map.Entry<Student,String>> entrySet = hm.entrySet();
Iterator<Map.Entry<Student,String>> iter = entrySet.iterator(); while (iter.hasNext()) {
Map.Entry<Student,String> me = iter.next();
Student s = me.getKey();
String addr = me.getValue();
System.out.println(s+"....."+addr);
}*/
}
}
运行结果为：
lisi3:::23...nanjing
lisi1:::21...tianjin
lisi2:::22...shanghai
lisi4:::24...wuhan
7.例子七（使用TreeMap添加有序的元素（映射关系））：
import java.util.Comparator;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap; /*
需求：每一个学生都与对应的归属地。
学生Student，地址String。
学生属性：姓名，年龄。
对学生对象的年龄进行升序排序。 因为数据是以键值对形式存在的。
所以要是哟昂可以排序的Map集合，TreeMap。
*/
class StuNameComparator implements Comparator<Student> {
public int compare(Student s1,Student s2) {
int num = s1.getName().compareTo(s2.getName());
if (num==0)
return new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));
return num;
}
} public class TreeMapTest {
public static void main(String[] args) {
//因为Student本身定义有比较性，可以直接满足需求。如果是按姓名排序，则需要加上StuNameComparator比较器。
TreeMap<Student,String> tm = new TreeMap<Student,String>(/*new StuNameComparator()*/); tm.put(new Student("blisi3",23),"nanjing");
tm.put(new Student("lisi1",21),"beijing");
tm.put(new Student("alisi14",24),"wuhan");
tm.put(new Student("lisi1",21),"tianjin");
tm.put(new Student("alisi11",21),"tianjin");
tm.put(new Student("alisi12",22),"shanghai"); Set<Map.Entry<Student,String>> entrySet = tm.entrySet();
Iterator<Map.Entry<Student,String>> it = entrySet.iterator();
while (it.hasNext()) {
Map.Entry<Student,String> me = it.next();
Student s = me.getKey();
String addr = me.getValue();
System.out.println(s+"..."+addr);
}
}
} class Student implements Comparable<Student> {
private String name;
private int age;
Student(String name,int age) {
this.name = name;
this.age = age;
} public int compareTo(Student s) {
int num = new Integer(this.age).compareTo(new Integer(s.age));
if (num == 0) {
return this.name.compareTo(s.name);
}
return num;
} public int hashCode() {
return this.name.hashCode()+this.age*34;
} public boolean equals(Object obj) {
if(!(obj instanceof Student))
throw new ClassCastException("类型错误");
Student s = (Student)obj;
return s.name.equals(this.name) && this.age == s.age;
} public String getName() {
return name;
} public int getAge() {
return age;
} public String toString() {
return name+":::"+age;
}
}
运行结果为：
alisi11:::21...tianjin
lisi1:::21...tianjin
alisi12:::22...shanghai
blisi3:::23...nanjing
alisi14:::24...wuhan
四、总结
如果涉及到堆栈，队列等操作，应该考虑用List，对于需要快速插入，删除元素，应该使用LinkedList，如果需要快速随机访问元素，应该使用ArrayList。
如果程序在单线程环境中，或者访问仅仅在一个线程中进行，考虑非同步的类，其效率较高，如果多个线程可能同时操作一个类，应该使用同步的类或者在类意外加上同步。
要特别注意对哈希表的操作，作为key的对象要正确复写equals和hashCode方法。
尽量返回接口而非实际的类型，如返回List而非ArrayList，这样如果以后需要将ArrayList换成LinkedList时，客户端代码不用改变。这就是针对抽象编程。