java的集合分为三大接口，分别是Collection,Map,Iterator，集合接口和类在java.util包中，此次主要介绍三大接口之一的Collection接口。

　　一些Collection允许有重复元素，而另一些则不允许，一些Collection是有序的，另一些则是无序的。Collection不提供接口的任何直接实现，它提供更加具体的子接口List和Set。

　　1.List接口

　　List是有序的集合，此接口的用户队列表的每一个元素的插入位置进行精确的控制，可以根据元素的整数索引访问元素,并搜索列表中的元素。

　　List接口实现类主要有：ArrayList,Vector,LinkedList

　　1)ArrayList

　　1.默认的ArrayList的大小为10

　　

　　2.ArrayList内部实现是使用动态数组

　　3.ArrayList是线程不安全的

　　4.如果数组满了，需要动态扩充，扩充长度为原来数组长度的一半左右，扩充时需要新建一个数组，再把原先数据复制过来。

　　

　　ArrayList使用示例：

　　Java代码

1. public static void main(String[] args){
2. String okString=null;
3. List<String>lists=new ArrayList<String>();
4. lists.add("aa");
5. lists.add("aa");
6. lists.add(1,"bb");//指定位置插入
7. lists.add("cc");
8. lists.add(okString);
9. //检查ArrayList是否为空
10. System.out.println(lists.isEmpty());
11. //查找指定元素的首次出现位置
12. System.out.println(lists.indexOf("aa"));
13. //查看是否含有该元素
14. System.out.println(lists.contains("cc"));
15. //输出list的长度
16. System.out.println(lists.size());
17. //输出
18. for(int i=0;i<lists.size();i++)
19. System.out.println(lists.get(i));
20. //清除list
21. lists.clear();
22. }

　　总结：Arra能直接通过下标获取数据，数据读取非常方便；然而ArrayList的插入和删除，会导致内部数据大量移位,会影响性能。如果我们已经知道需要的元素个数，我们可以初始化时指定ArrayList的容量，这样可以有效的避免数组多次扩充，从而提高效率；但也不能初始化太大，浪费内存。

　　2)Vector

　　Vector类可以实现增长的对象数组，与数组一样,可以使用下标直接进行数据访问。Vector的大小可以根据需要扩充或缩小。

　　1.Vector内部使用动态数组实现

　　2.默认构造大小为10，增量为0.可在构造方法指定大小和增量Vector(int size,int Increment)

　　

　　3.扩充方式：如果有指定增量，则是当前容量+增量；如果增量等于0，则是当前容量*2；

　　

　　4.Vector是线程安全的

　　Vector用法和ArrayList基本差不多，示例代码

　　Java代码

1. public static void main(String[] args){
2. String okString=null;
3. List<String>vectors=new Vector<String>();
4. vectors.add("aa");
5. vectors.add("aa");
6. vectors.add(1,"bb");//指定位置插入
7. vectors.add("cc");
8. vectors.add(okString);
9. //检查ArrayList是否为空
10. System.out.println(vectors.isEmpty());
11. //查找指定元素的首次出现位置
12. System.out.println(vectors.indexOf("aa"));
13. //查看是否含有该元素
14. System.out.println(vectors.contains("cc"));
15. //输出list的长度
16. System.out.println(vectors.size());
17. //删除元素;
18. vectors.remove(0);
19. //输出
20. for(int i=0;i<vectors.size();i++)
21. System.out.println(vectors.get(i));
22. //清除list
23. vectors.clear();
24. }

　　3）LinkedList

　　LInkedList是List接口的链表实现。实现所有可选的列表操作，并允许所有元素包括null。其基本用法与ArrayList差不多，如：

　　Java代码

1. public static void main(String[] args){
2. String okString=null;
3. List<String>link=new LinkedList<String>();
4. link.add("aa");
5. link.add("aa");
6. link.add(1,"bb");//指定位置插入
7. link.add("cc");
8. link.add(okString);
9. //检查ArrayList是否为空
10. System.out.println(link.isEmpty());
11. //查找指定元素的首次出现位置
12. System.out.println(link.indexOf("aa"));
13. //查看是否含有该元素
14. System.out.println(link.contains("cc"));
15. //输出list的长度
16. System.out.println(link.size());
17. //删除元素;
18. link.remove(0);
19. //输出
20. for(int i=0;i<link.size();i++)
21. System.out.println(link.get(i));
22. //清除list
23. link.clear();
24. }

　　ArrayList和Vector是使用动态数组实现的，Vector相比ArrayList可以指定增量，而LinkedList是用链表实现的。他们的区别主要体现在数组和链表的区别

　　2.Set接口

　　一个不包含重复元素的colletion。即Set不包含满足e1.equals(e2)的元素，Set最多包含一个null元素

　　Set的实现类主要有：HashSet，TreeSet，LinkedHashSet

　　1）HashSet

　　实现了Set接口，它不保证set的迭代顺序，特别是它不保证该顺序永恒不变，此类允许使用null元素。底层是使用HashMap实现的。

　　下面我们主要讲解不能包含重复元素。

　　如：

　　定义Person类：

　　Java代码

1. public class Person {
2. public String name;
3. public int age;
4. public Person(String name,int age){
5. this.name=name;
6. this.age=age;
7. }
8. @Override
9. public String toString() {
10. return "person [name=" + name + ", age=" + age + "]";
11. }
12. }

　　set添加Person元素

　　Java代码

1. public static void main(String[] args){
2. Set<Person>sets=new HashSet<Person>();
3. Person ok=new Person("小明", 18);
4. Person ok1=new Person("小红", 16);
5. Person ok2=new Person("小白", 15);
6. sets.add(ok);
7. sets.add(ok1);
8. sets.add(ok2);
9. //添加不进去
10. sets.add(ok1);
11. //能添加进去
12. sets.add(new Person("小明", 18));//与ok数据一样
13. System.out.println("size: "+sets.size());
14. }

　　发现同一个对象的ok1只能添加一次,然而与ok相同数据的被多次添加。Set使用e1.equals(e2)来判断的。

　　在java集合中，判断两个对象是否是同一个对象是：

　　1.先判断两个对象的hashCode值是否相等，如果不相等，就认为两个对象不相等；若相等；判断条件2

　　2.判断两个对象的equals运算是否相等，相等则认为两个对象相等。

　　所以我们需要重写Person的hashCode和equals方法

　　把Person类加上方法：

　　Java代码

1. @Override
2. public int hashCode() {
3. final int prime = 31;
4. int result = 1;
5. result = prime * result + age;
6. result = prime * result + ((name == null) ? 0 : name.hashCode());
7. return result;
8. }
9. @Override
10. public boolean equals(Object obj) {
11. if (this == obj)
12. return true;
13. if (obj == null)
14. return false;
15. if (getClass() != obj.getClass())
16. return false;
17. Person other = (Person) obj;
18. if (age != other.age)
19. return false;
20. if (name == null) {
21. if (other.name != null)
22. return false;
23. } else if (!name.equals(other.name))
24. return false;
25. return true;
26. }

　　此时后面与ok数据相同的对象也不能添加进集合里了。

　　2）TreeSet

　　TreeSet元素自然排序，底层是使用TreeMap实现的，自定义要显示Comparable接口

　　定义Person类

　　Java代码

1. public class Person implements Comparable<Person>{
2. public String name;
3. public int age;
4. public Person(String name,int age)
5. {
6. this.name=name;
7. this.age=age;
8. }
9. public int compareTo(Person o) {
10. if(o==null)
11. throw new NullPointerException();
12. if(this.age>o.age)
13. return 1;
14. if(this.age<o.age)
15. return -1;
16. return 0;
17. }
18. @Override
19. public String toString() {
20. return "Person [name=" + name + ", age=" + age + "]";
21. }
22. }

　　TreeSet使用：

　　Java代码

1. public static void main(String[] args){
2. Set<Person>sets=new TreeSet<Person>();
3. Person ok=new Person("小明", 18);
4. Person ok1=new Person("小红", 16);
5. Person ok2=new Person("小白", 15);
6. sets.add(ok);
7. sets.add(ok1);
8. sets.add(ok2);
9. //添加不进去
10. sets.add(ok1);
11. //输出
12. Iterator<Person> iterator=sets.iterator();
13. while(iterator.hasNext())
14. {
15. System.out.println(iterator.next());
16. }
17. }

　　运行结果：

　　

技术分享：www.kaige123.com