黑马程序员——java基础拾遗之集合框架（一） List 和 Set

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

java的集合框架是重点需要掌握的内容，是java基础中的基础，所以下面对集合框架的知识点进行详细的总结；

java中的集合类的出现方便了对多个对象进行操作，存储等。

集合和数组的区别：

数组的长度固定，集合的长度可变，数组可以存储基本数据类型，集合只能存对象；

数组存内容的类型必须相同，集合类可以存储不同类型的对象。

集合类的特点：

集合的长度可变，集合只能存对象，集合类可以存储不同类型的对象。

集合框架的体系结构

集合框架的顶级接口有Collection和Map两个，这篇先对Collection接口及其子类对象进行总结

Collection接口的共性方法：

add(E e) 添加一个元素

addAll(Collection c) 添加一组元素

clear()清空所有元素

contains(Object o) 检测是否包含指定元素

remove(Object o) 删除一个元素

removeAll(Collection c)删除c中的元素

isEmpty() 判断集合中是否有元素

size() 返回元素数

toArray() 集合变数组

retainAll(Collection<?> c) 求交集

iterator() 迭代器负责取出

一.Collection 常用子接口

1 . List接口：元素是有序的，元素之间可以重复，因为有索引从0开始凡是可以操作角标的方法都是这个类的特有方法。

（1）ArrayList类:

常用方法演示

增

add(E e) 添加元素，在最后追加

add(int index, E element) 方法，添加元素

addAll(Collection<? extends E> c) 添加一组元素，追加到最后

addAll(int index, Collection<? extends E> c) 添加一组元素到指定位置

add(E e)方法演示

<span style="font-size:14px;"><span style="white-space:pre">	</span>public static void main(String[] args){
<span style="white-space:pre">	</span>ArrayList<String> al = new ArrayList<String>();
al.add("zhangsan");
al.add("lisi");
al.add("wangwu");
al.add("zhaoliu");
System.out.println(al);
}</span>

执行结果

[zhangsan, lisi, wangwu, zhaoliu]

add(int index, E element) 方法演示

<span style="font-size:14px;"><span style="white-space:pre">		</span>ArrayList<String> al = new ArrayList<String>();
//添加元素
al.add("zhangsan");
al.add("lisi");
al.add("wangwu");
al.add("zhaoliu");
System.out.println(al);
//在指定位置添加元素
al.add(0, "chenqi");
System.out.println(al);</span>

执行结果

[zhangsan, lisi, wangwu, zhaoliu]

[chenqi, zhangsan, lisi, wangwu, zhaoliu]

可以看到chenqi被插入到了最开始的位置

addAll(Collection<? extends E> c)方法演示

<span style="font-size:14px;">	ArrayList<String> al1 = new ArrayList<String>();
ArrayList<String> al2 = new ArrayList<String>();
al1.add("zhangsan");
al1.add("lisi");
System.out.println(al1);
al2.add("wangwu");
al2.add("zhaoliu");
al1.addAll(al2);
System.out.println(al1);</span>

执行结果

[zhangsan, lisi]

[zhangsan, lisi, wangwu, zhaoliu]

可以看到wangwu, zhaoliu一起被添加到了最后

addAll(int index, Collection<? extends E> c)方法演示

<span style="font-size:14px;">	ArrayList<String> al1 = new ArrayList<String>();
ArrayList<String> al2 = new ArrayList<String>();
al1.add("zhangsan");
al1.add("lisi");
System.out.println(al1);
al2.add("wangwu");
al2.add("zhaoliu");
al1.addAll(0, al2);
System.out.println(al1);</span>

执行结果

[zhangsan, lisi]

[wangwu, zhaoliu, zhangsan, lisi]

可以看到wangwu, zhaoliu一起被添加到了开始

删

remove(int index) 删除指定位置元素的索引

remove(Object o) 删除该list中首次出现的该元素的索引

remove(int index) 方法演示，根据位置删除

<span style="font-size:14px;">	ArrayList<String> al = new ArrayList<String>();
al.add("zhangsan");
al.add("lisi");
al.add("wangwu");
al.add("zhaoliu");
System.out.println(al);
al.remove(0);
System.out.println(al);</span>

执行结果

[zhangsan, lisi, wangwu, zhaoliu]

[lisi, wangwu, zhaoliu]

可以看到第一个元素zhangsan被删除了

remove(Object o) 方法演示，根据元素删除

<span style="font-size:14px;">	ArrayList<String> al = new ArrayList<String>();
al.add("zhangsan");
al.add("lisi");
al.add("wangwu");
al.add("zhaoliu");
System.out.println(al);
//删除元素
al.remove("lisi");
System.out.println(al);</span>

执行结果

[zhangsan, lisi, wangwu, zhaoliu]

[zhangsan, wangwu, zhaoliu]

可以看出lisi已经被删除

改

set(int index, E element) 指定元素来替代特定位置上的元素

set(int index, E element) 方法演示

<span style="font-size:14px;">	ArrayList<String> al3 = new ArrayList<String>();
//添加元素
al3.add("zhangsan");
al3.add("lisi");
al3.add("wangwu");
al3.add("zhaoliu");
System.out.println(al3);
al3.set(0, "chengqi");
System.out.println(al3);</span>

执行结果

[zhangsan, lisi, wangwu, zhaoliu]

[chengqi, lisi, wangwu, zhaoliu]

可以看到第一个元素zhangsan被改成了chengqi

查

get(int index) 返回此列表中指定位置上的元素

subList(int fromIndex, int toIndex) 返回指定头尾位置的子序列，包含头不包含尾

iterator() 返回迭代器

indexOf(Object o) 返回指定元素的位置

get(int index) 方法演示，获取指定位置元素

<span style="font-size:14px;">	ArrayList<String> al = new ArrayList<String>();
//添加元素
al.add("zhangsan");
al.add("lisi");
al.add("wangwu");
al.add("zhaoliu");
System.out.println(al.get(1));</span>

执行结果

lisi

可以看到第二个元素被获取到了



subList(int fromIndex, int toIndex) 方法演示

<span style="font-size:14px;">	ArrayList<String> al = new ArrayList<String>();
//添加元素
al.add("zhangsan");
al.add("lisi");
al.add("wangwu");
al.add("zhaoliu");
System.out.println(al);
System.out.println(al.subList(1, 3));</span>

执行结果

[zhangsan, lisi, wangwu, zhaoliu]

[lisi, wangwu]

可以看到列表中的第二和第三个元素被获取到了，包含头不包含尾

iterator() 迭代器演示，迭代器用来遍历Collection中所有元素时常用

<span style="font-size:14px;">	ArrayList<String> al4 = new ArrayList<String>();
al4.add("zhangsan");
al4.add("lisi");
al4.add("wangwu");
al4.add("zhaoliu");
Iterator<String> it = al4.iterator();
while(it.hasNext()){
System.out.println(it.next());
}</span>

输出结果

zhangsan

lisi

wangwu

zhaoliu

可以看到list中的每个元素都被遍历了，其中hasNext()判断list中是否还有元素可以迭代，next()返回迭代的下一个元素。

注意，在使用迭代器来操作集合的时候，如果同时使用集合除迭代器外的方法操作集合，会产生ConcurrentModificationException异常，该异常的产生是因为迭代器在获取的时候已经有集合中所有元素的引用，一旦迭代器已经获取，再修改集合中的元素，这时集合中的元素引用和迭代器中的元素引用会发生不一致。通常在这些情况下，迭代的结果是不确定的。为了在这种情况下还能操作集合，迭代器定义了很多自己的操作集合的方法，来在迭代过程中操作集合中的元素。比如ListIterator接口中的remove() ，set(E
e) ，和add(E e) 方法。这里一起演示下这几个方法

<span style="font-size:14px;"><span style="white-space:pre">	</span>ArrayList<String> al4 = new ArrayList<String>();
ArrayList<String> al5 = new ArrayList<String>();
al4.add("zhangsan");
al4.add("lisi");
al4.add("wangwu");
al4.add("zhaoliu");
System.out.println(al4);
ListIterator<String> it = al4.listIterator();
//使用迭代器增加chenqi元素
it.add("chenqi");
System.out.println(al4);
while(it.hasNext()){
if("wangwu".equals(it.next())){
//遍历到wangwu时删除整个元素
it.remove();
System.out.println(al4);
}
if("zhaoliu".equals(it.next())){
//遍历到zhaoliu时修改值为zhaoliu_haha
it.set("zhaoliu_haha");
System.out.println(al4);
}
</span>

执行结果

[zhangsan, lisi, wangwu, zhaoliu]

[chenqi, zhangsan, lisi, wangwu, zhaoliu]

[chenqi, zhangsan, lisi, zhaoliu]

[chenqi, zhangsan, lisi, zhaoliu_haha]

可以看到先用迭代器加入了一个元素chenqi，后来遍历到元素wangwu是进行了删除，最后遍历到zhaoliu时，将它的值改为了zhaoliu_haha。

indexOf(Object o)方法演示

<span style="font-size:14px;">	ArrayList<String> al4 = new ArrayList<String>();
al4.add("zhangsan");
al4.add("lisi");
al4.add("wangwu");
al4.add("zhaoliu");
System.out.println(al4.indexOf("wangwu"));</span>

输出结果

2

表示wangwu是list中的第三个元素

判断

contains(Object o) 方法 检查集合中是否包含指定元素

isEmpty() 判断该list是否为空false表示不为空，true表示为空

contains(Object o) 方法演示

<span style="font-size:14px;">	ArrayList<String> al4 = new ArrayList<String>();
al4.add("zhangsan");
al4.add("lisi");
al4.add("wangwu");
al4.add("zhaoliu");
System.out.println(al4.contains("wangwu"));
System.out.println(al4.contains("chenqi"));</span>

输出结果

true

false

说明该list中包含wangwu，不包含chenqi



isEmpty()方法演示

<span style="font-size:14px;">	ArrayList<String> al4 = new ArrayList<String>();
ArrayList<String> al5 = new ArrayList<String>();
al4.add("zhangsan");
al4.add("lisi");
al4.add("wangwu");
al4.add("zhaoliu");
System.out.println(al4.isEmpty());
System.out.println(al5.isEmpty());</span>

执行结果

false

true

表示al4不为空，al5为空

上面以ArrayList为例，说明了List接口的常用方法，List接口还有两个其他常用子类，它们是LinkedList和Vector。它们三者的区别是：

ArrayList:底层的数据结构是数组结构。特点：查询速度快，但那时增删稍慢。线程不同步

LinkedList:底层使用链表数据结构。特点：增删速度快，查询稍慢。

Vector:底层是数组数据结构。线程同步。被ArrayList替代

查看Vector在rt.jar中的源码，可以发现里面的方法都加上了synchronized关键字，而ArrayList和LinkedList都没有，造成了Vector线程同步而前两者线程不同步。

（2）LinkedList类简介

特有方法

addFirst(E e)在开头添加元素

addLast(E e) 在结尾添加元素

getFirst() 获取开头的元素

getLast() 获取结尾的元素

removeFirst() 移除开头的元素，并返回该元素

removeLast() 移除结尾的元素，并返回该元素

addFirst(E e)方法演示

<span style="font-size:14px;">	LinkedList<String> link = new LinkedList<String>();
link.addFirst("01");
link.addFirst("02");
link.addFirst("03");
link.addFirst("04");
System.out.println(link);</span>

输出结果

[04, 03, 02, 01]

addLast(E e) 方法演示

<span style="font-size:14px;">	LinkedList<String> link = new LinkedList<String>();
link.addLast("01");
link.addLast("02");
link.addLast("03");
link.addLast("04");
System.out.println(link);</span>

输出结果

[01, 02, 03, 04]

getFirst() 和 getLast() 方法演示

<span style="font-size:14px;">   	 LinkedList<String> link = new LinkedList<String>();
link.addLast("01");
link.addLast("02");
link.addLast("03");
link.addLast("04");
System.out.println(link.getFirst());
System.out.println(link.getLast());</span>

输出结果

01

04

removeFirst()和removeLast()方法演示

<span style="font-size:14px;">	 LinkedList<String> link = new LinkedList<String>();
link.addLast("01");
link.addLast("02");
link.addLast("03");
link.addLast("04");
System.out.println(link.removeFirst());
System.out.println(link.removeLast());
System.out.println(link);</span>

输出结果

01

04

[02, 03]

可以看出01和04元素已经被删除，并且删除的时候被返回

注意：当列表为空的时候getFirst()、getLast()、 removeFirst()、removeLast() 四个方法会抛出NoSuchElementException异常，因此JDK1.6以后有新的方法替代它们，分别是peekFirst()、peekLast() 、pollFirst() 、pollLast() ，当列表为空的时候，这些方法会返回null

（3）Vector类

Vector类中有一个特殊的方法elements() ，会返回枚举类型的数据，而枚举类型在JAVA的IO知识的合并流SequenceInputStream中有用到，因此有可能会用到这个类。

<span style="font-size:14px;">	 Vector<String> v = new Vector<String>();
v.add("01");
v.add("02");
v.add("03");
v.add("04");
Enumeration en = v.elements();
while(en.hasMoreElements()){
System.out.println(en.nextElement());
}</span>

执行结果

01

02

03

04

2.Set接口

Set的特点：元素无序（存入取出顺序不一定一致），元素不可以重复。

Set接口常用实现类

（1）HashSet:底层数据结构是哈希表;线程非同步

HashSet常用方法：

add(E e) 添加元素成功则返回true，前提是之前未包含此元素，否则返回false。

contains(Object o) 判断是否包含元素。

isEmpty() 判断是否为空，是返回true，否则返回false

iterator() 迭代器，用来遍历元素，是HashSet类唯一的获取元素的方法

size() 返回元素数量

HashSet特性演示

<span style="font-size:14px;">	 HashSet<String> hs = new HashSet<String>();
hs.add("01");
hs.add("02");
hs.add("03");
hs.add("04");
System.out.println(hs.add("01"));
Iterator hsit = hs.iterator();
while(hsit.hasNext()){
System.out.println(hsit.next());
}</span>

输出结果

false

04

01

02

03

由此可见HashSet是无序的，而且相同的元素不会存储两遍。

HashSet为了保证存储的元素不会重复，底层都会在每个元素进行存储时和之前的元素进行比较，至于什么样的两个元素算是重复的元素，就必须要说equals()和hashCode()两个方法。

当往HashSet中增加元素的时候，HashSet的add方法会调用被添加对象的equals()和hashCode()两个方法，先调用hashCode()方法，看两个对象的哈希值是否相同，一旦相同，会继续调用equals()方法，判断两个对象的内容是否相同。一旦两个方法返回的都是相等，则HashSet判断两个对象是同一个对象。

这一点在用HashSet存储自定义对象的时候格外的重要，需要在自定义类中复写equals()和hashCode()方法，说明什么样的情况下，两个对象是相同的，不然HashSet中可能会违背意愿的存入相同的对象。

示例代码

没有复写equals()和hashCode()之前

<span style="font-size:14px;"><span style="white-space:pre">	</span>class Person
{
private String name;
private int age;
Person(String name, int age){
this.name = name;
this.age = age;
}
public String toString(){
return name + "..." + age;
}
}
public class CollectionTest {
public static void main(String[] args){
HashSet<Person> hsp = new HashSet<Person>();
hsp.add(new Person("zhangsan",10));
hsp.add(new Person("zhangsan",10));
hsp.add(new Person("zhangsan",10));
hsp.add(new Person("zhangsan",10));
System.out.println(hsp);
}
}</span>

执行结果

[zhangsan...10, zhangsan...10, zhangsan...10, zhangsan...10]

很显然，"zhangsan",10被存储了4遍，对Person类来讲，一旦name和age属性都相同，应该是同一个对象，不应该被存储4遍，这里出现问题的原因就是没有复写equals()和hashCode()方法。

复写equals()和hashCode()以后，看看结果是什么样的：

<span style="font-size:14px;">class Person
{
private String name;
private int age;
Person(String name, int age)
{
this.name = name;
this.age = age;
}

public int hashCode(){
System.out.println(name+"......判断hashCode值");
return name.hashCode() + age;
}

public boolean equals(Object o){
System.out.println(name+"判断equals.......");
if(!(o instanceof Person)){
return false;
}
Person p = (Person)o;
return this.name.equals(p.name) && this.age == p.age;
}

public String toString() {
return name + "..." + age;
}
}

public class CollectionTest
{
public static void main(String[] args) {
HashSet<Person> hsp = new HashSet<Person>();
hsp.add(new Person("zhangsan", 10));
hsp.add(new Person("zhangsan1", 10));
hsp.add(new Person("zhangsan", 10));
System.out.println(hsp);
}
}</span>

执行结果

zhangsan......判断hashCode值

zhangsan1......判断hashCode值

zhangsan......判断hashCode值

zhangsan判断equals.......

[zhangsan...10, zhangsan1...10]

可以看出，当前两次存储"zhangsan", 10和"zhangsan1", 10时，先判断hashCode值，发现不相同，所以判断是两个不同对象，因此不再判断equals，而第三次存储"zhangsan", 10时，因为hashCode值相同（name.hashCode() + age算出的结果一致），因此转而去判断equals方法，发现equals方法返回的也是相同，一次判定两个对象是同一个对象，不再存储。

（这里必须保证equals方法如果返回相同，hashCode()方法必须返回相同，hashCode()方法是equals方法的前提）

同理，在HashSet中，判断是否包含一个元素，和删除的元素在集合中是否存在，也会调用equals()和hashCode()方法。

示例代码

<span style="font-size:14px;"> 	HashSet<Person> hsp = new HashSet<Person>();
hsp.add(new Person("zhangsan", 10));
hsp.add(new Person("zhangsan1", 10));
hsp.add(new Person("zhangsan", 10));
System.out.println();
hsp.contains(new Person("zhangsan", 10));
hsp.remove(new Person("zhangsan", 10));</span>

执行结果

zhangsan......判断hashCode值

zhangsan1......判断hashCode值

zhangsan......判断hashCode值

zhangsan判断equals.......

zhangsan......判断hashCode值

zhangsan判断equals.......

zhangsan......判断hashCode值

zhangsan判断equals.......

contains方法和remove方法都同时判断了equals()和hashCode()两个方法，最后才确定要操作的对象是不是和集合中的一致。

（2）TreeSet:可以对Set集合中的元素进行排序

示例代码

<span style="font-size:14px;">	TreeSet<String> ts = new TreeSet<String>();
ts.add("c");
ts.add("b");
ts.add("d");
ts.add("a");
Iterator it = ts.iterator();
while(it.hasNext()){
System.out.println(it.next());
}</span>

输出结果

a

b

c

d

可见，无论添加元素的顺序，TreeSet都将元素进行了排序

TreeSet对元素的排序肯定是有特定的规则，这个规则是如何制定的？当TreeSet存储自定义对象时，怎么判断元素之间的顺序，下面就来分析这个问题

先定义一个自定义的类student，之后在TreeSet中添加这个类的对象，看看什么结果

<span style="font-size:14px;">class Student
{
private String name;
private int age;

Student(String name, int age){
this.name = name;
this.age = age;
}

@Override
public String toString(){
return name + "......" + age;
}
}

<span style="white-space:pre">	</span>//main函数中打印一下
<span style="white-space:pre">	</span>TreeSet<Student> ts = new TreeSet<student>();
<span style="white-space:pre">	</span>ts.add(new Student("c",5));
<span style="white-space:pre">	</span>ts.add(new Student("c",3));
<span style="white-space:pre">	</span>ts.add(new Student("c",2));
<span style="white-space:pre">	</span>ts.add(new Student("c",1));
<span style="white-space:pre">	</span>Iterator it = ts.iterator();
<span style="white-space:pre">	</span>while(it.hasNext()){
<span style="white-space:pre">		</span>System.out.println(it.next());
<span style="white-space:pre">	</span>}</span>

输出结果

Exception in thread "main" java.lang.ClassCastException: student cannot be cast to java.lang.Comparable

at java.util.TreeMap.put(Unknown Source)

at java.util.TreeSet.add(Unknown Source)

at com.baobao.CollectionTest1.main(CollectionTest1.java:79)

这里报出了ClassCastException异常，说是student没有实现Comparable接口。来看看这个接口是干什么的？

查API发现，此接口强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的 compareTo 方法被称为它的自然比较方法。

看来要实现TreeSet的自然比较还要实现这个接口，并且重写这个compareTo方法才行，看看这个方法的要求：比较此对象与指定对象的顺序。如果该对象小于、等于或大于指定对象，则分别返回负整数、零或正整数。

按照要求重新写下student类，现在看看打印结果

<span style="font-size:14px;">class Student implements Comparable
{
private String name;
private int age;

Student(String name, int age){
this.name = name;
this.age = age;
}

@Override
public int compareTo(Object o) {
if(!(o instanceof Student)){
throw new RuntimeException("不是学生");
}
Student s = (Student) o;
if(this.age > s.age){
return 1;
}
if(this.age < s.age){
return -1;
}
return 0;
}

@Override
public String toString(){
return name + "......" + age;
}
}</span>

输出结果

c......1

c......2

c......3

c......5

排序成功，TreeSet根据compareTo方法的定义，用年龄将Student类的对象进行了排序。