七、黑马程序员—集合框架（1）
第七篇 集合框架（1）
1、集合类 & 容器
为什么出现集合类？
面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，就要
对对象进行存储，集合就是存储对象最常用的一种方式。
数组和集合类同是容器，有何不同？
数组虽然也可以存储对象，但长度是固定的；集合长度是可变的。数组中可以存储任意
数据类型，集合只能存储对象。
集合类的特点
集合只用于存储对象，集合长度是可变的，集合可以存储不同类型的对象。
我的总结：集合类比数组强大，类似于包装类与基本数据类型！
集合框架的构成及分类
两大接口
Java 集合类主要由两个接口派生出来：
Collection
Set ：不能存放重复对象
List ：可存放重复对象，有序
Queue ：队列
SortedSet：可对集合数据排序
Map
SortedMap ：可对集合数据排序
2、Collection 接口
方法：
boolean add(Object o):该方法用于向集合里面添加一个元素，若集合对象被添加操作改变了，
返回 true.
boolean addAll(Collection c):把集合 c 里面的所有元素添加到指定集合里面去，如果集合对象
被添加操作改变了返回 true.
void clear():清除集合里面的所有元素，将集合长度变为 0。
boolean contains(Object o):返回集合里是否包含指定的元素。
boolean containsAll(Collection c):返回集合里是否包含集合 c 内所有的元素。
boolean isEmpty()：返回集合是否为空（长度是否为 0）。
Iterator iterator():返回一个 Iterator 对象，用于遍历集合里的元素。
boolean remove(Object o)：删除集合中指定元素 o。
boolean removeAll(Collection c):从集合中删除集合 c 里面的元素。若删除一个或以上返回
true。
boolean retainAll(Collection c):从集合中删除集合 c 里不包含的元素。
int size()：得到集合元素的个数。
Object[] toArray():把集合转成一个数组，所有集合元素编程数组元素。
Eg：
public class Demo10 {
public static void main(String[] args) {
Collection<String> c = new ArrayList<String>();
c.add("A");
c.add("A");
c.add("A");
c.add("A");
//c.add(new Date());上面写了泛型，这个语句就是错误的了，因为泛型规定
了加进来的类型！
System.out.println(c);
}
}
3、Iterator 接口
Iterator 主要遍历 Collection 集合中的元素，也有称为迭代器或迭代精灵。
boolean hasNext()：若被迭代的集合元素还没有被遍历，返回 true.
Object next():返回集合的下一个元素.
void remove():删除集合上一次 next()方法返回的元素。(若集合中有多个相同的元素，都可以
删掉)
iterator 对于集合才能用，for 不同，只要是循环都可用。
迭代是取出集合中元素的一种方式。
因为 Collection 中有 iterator 方法，所以每一个子类集合对象都具备迭代器。
迭代器在 Collcection 接口中是通用的，它替代了 Vector 类中的 Enumeration(枚举)。迭代器
的 next 方法是自动向下取元素，要避免出现 NoSuchElementException。
迭代器的 next 方法返回值类型是 Object，所以要记得类型转换。（学到泛型就可以消除强转！）
Eg：Iterator iter = l.iterator();
while(iter.hasNext()){
System.out.println(iter.next());
}
4、集合遍历输出方式
Iterator：迭代输出
一旦操作集合的遍历输出，首选 Iterator 接口;
ListIterator:Iterator 子接口，专门输出 List 中的元素;
Enumeration:古老的输出方式，迭代 Vector 元素，被 Iterator 取代;
foreach:可输出数组和 Iterable 对象;
我的总结：
集合遍历输出方式：
1. Iterable 接口（迭代遍历） 注：优先选择 Iterator 接口，遍历 Collection 里所有元素，
也称为迭代器和迭代精灵；迭代是取出集合中元素的一种推荐方式。
2. Foreach 循环 注：可以直接用，使用场合：数组和 Iterable 对象！
3. For 循环 注：在（）内实例化 Iterable 对象，进行遍历！
4. 先用 toArray 方法输出成为数组，再用 Foreach 循环！
第一个和第三个很类似，第二个和第四个很类似！
很好
Eg：
package july7;
//遍历输出的四种方式
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class Demo11 {
public static void main(String[] args) {
List<String> l = new ArrayList();
l.add("1");
l.add("2");
l.add("3");
l.add("4");
System.out.println(l);
/**
* 遍历输出：四种方式
*/
// 1、推荐使用的Iterator对象，迭代输出！
Iterator it = l.iterator();
while (it.hasNext()) {
System.out.println("迭代输出：" + it.next());
}
// 2、对集合进行fore循环！
for (String str : l) {
System.out.println("fore集合迭代输出：" + str);
}
// 3、for循环迭代，在for方法体内部实例化Iterator对象！
int i = 0;// for方法体内定义项不能出现多种不同类型
for (Iterator iter = l.iterator(); i < l.size(); i++) {
System.out.println("for循环迭代实例化输出：" + iter.next());
}
// 4、先将集合转换为数组，再利用数组的遍历输出；
Object[] o = l.toArray();
for (Object object : o) {
System.out.println("转换数组迭代输出：" + object);
}
}
}
5、Set 接口（元素不可以重复）
Set 是 Collection 子接口；
Set 和 Collection 基本上一样，一点除外：
Set 无法记住添加的顺序，不允许包含重复的元素。
当试图添加两个相同元素进 Set 集合，添加操作失败，add()方法返回 false。
Set 判断两个对象是否相等用 equals,而不是使用==。
也就是说两个对象 equals 比较返回 true，Set 集合是不会接受这个两个对象的。
常用子类：
HashSet:散列存放
TreeSet:有序存放
hashCode 方法对于 HashSet 的作用
HashSet 类是 Set 接口最常用的实现类,采用 hash 算法存储数据,具有良好的存储和查找功能。
散列存储:不记录添加顺序;排列顺序时，顺序有可能发生变化;
线程不安全的，多个线程访问一个 HashSet 要使用同步代码;
HashSet 集合元素值允许是 null,但是最多只能有一个;//因为 Set 集合就不可以装重复的对象！
hash(翻译为哈希,或散列)算法的功能:
保证通过一个对象快速找到另一个对象;
其算法价值体现在速度,可以保证查询快速执行;
当从 HashSet 中访问元素时,HashSet 先计算该元素的 hashCode(也就是该对象的 hashCode 方
法返回值),然后直接到该 HashCode 对应的位置取出该元素;
在这里对象的 hashCode 就好比是数组里的索引,但是不是索引;
HashSet 元素添加
当向 HashSet 集合中存入一个元素时，HashSet 会调用该对象的 hashCode()方法来得到该对
象的 hashCode 值,判断已经存储在集合中的对象的 hashCode 值是否与添加的对象的
hashCode 值一致:若不一致:直接添加进去;若一致,再进行 equals 方法比较,equals 方法如果返
回 true,表明对象已经添加进去了,就不会再添加新的对象了,否则添加进去;
如果我们重写了 equals 方法,也要重写 hashCode 方法,反之亦然;。
HashSet 集合判断两个元素相等的标准是两个对象通过 equals 方法比较相等，并且两个对象
的 hashCode 方法返回值也相等。
如果需要某个类的对象保存到 HashSet 集合中，覆写该类的 equals()和 hashCode()方法，应
该尽量保证两个对象通过 equals 比较返回 true 时,他们的 hashCode 返回也相等。
我的总结：
很重要的一点：理解！往 HashSet 集合里面存入数据，要先后调用两个方法：hashCode
方法和 equals 方法！！！
备注：使用 eclipse 添加这两个方法。
Eg：
package july7;
//hashset方法和equals方法判断输入的对象是否重复！
import java.util.HashSet;
import java.util.Set;
class PersonDemo{
private String name;
public PersonDemo(String name) {
super();
this.name = name;
}
@Override
public String toString() {
return "name= " + name ;
}
//没有覆写hashcode和equals方法前，显示三次（一样的）。覆写后，只剩下一个
了！说明覆写后方法起作用了，重复的输入不进去！
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
PersonDemo other = (PersonDemo) obj;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
}
public class Demo12 {
public static void main(String[] args) {
Set s = new HashSet();
s.add(new PersonDemo("章泽天"));
s.add(new PersonDemo("章泽天"));
s.add(new PersonDemo("章泽天"));
System.out.println(s);
}
}
6、TreeSet
TreeSet 是 SortedSet 接口唯一的实现，与 HashSet 相比额外的方法有：
Comparator comparator():返回当前 Set 使用的 Comparator,若返回 null,表示以自然顺序排序。
Object first() 返回此 set 中当前第一个(最低)元素。
Object last() 返回此 set 中当前最后一个(最高)元素。
SortedSet subSet(Object fromElement, E toElement) 返回此 set 的部子集，其元素从
fromElement（包括）到 toElement（不包括）。
SortedSet headSet(Object toElement)返回此 set 的部分子集，其元素严格小于 toElement。
SortedSet tailSet(Object fromElement) 返 回 此 set 的 部 分 子 集 ， 其 元 素 大 于 等 于
fromElement。
TreeSet 的排序之自然排序
TreeSet 会调用元素的 compareTo(Object o)方法来比较元素之间的大小关系,然后将集合里的
元素按升序排列 .此时需要排序元素的类 必须实现 Compareble 接口,并覆写其 int
compareTo(Object o)方法;
该方法用于比较对象,若:obj1,compareTo(obj2),返回 0,表示两个对象相等,若返回一个正整数,
表示 obj1 大于 obj2,若返回一个负整数,表示 obj1 小于 obj2;
对于 TreeSet 集合而言,判断两个对象相等的标准是:
compareTo()方法比较返回 0;
package july7;
//TreeSet可以自动进行排序！最简单的情况
import java.util.Set;
import java.util.TreeSet;
public class Demo13 {
public static void main(String[] args) {
Set<Integer> s = new TreeSet<Integer>();
s.add(1);
s.add(192);
s.add(123);
s.add(56);
s.add(13);
s.add(96);
System.out.println(s);//[1, 13, 56, 96, 123, 192]
}
}
稍复杂点的
package july7;
//TreeSet的自然排序，升序
import java.util.Set;
import java.util.TreeSet;
class Student implements Comparable{//必须实现接口
private Integer age;
public Student(Integer age) {
super();
this.age = age;
}
@Override
public int compareTo(Object o) {//比较的规则，运用泛型可以消除强转！
if(o instanceof Student){
Student s = (Student)o;
return this.age.compareTo(s.age);
}
return 0;
}
@Override
public String toString() {
return age+"" ;
}
}
public class Demo14 {
public static void main(String[] args) {
Set<Student> s = new TreeSet();
s.add(new Student(140));
s.add(new Student(15));
s.add(new Student(11));
s.add(new Student(63));
s.add(new Student(96));
System.out.println(s);//[11, 15, 63, 96, 140]
}
}
TreeSet 的排序之定制排序
TreeSet 的自然排序是根据元素的大小进行升序排序的,若想自己定制排序,比如降序排序,就
可以使用 Comparator 接口了:
该接口包含 int compare(Object o1,Object o2)方法,用于比较两个对象的大小,比较结果和
compareTo 方法一致;
要实现定制排序,需要在创建 TreeSet 集合对象时,提供一个一个 Comparator 对象,该对象里
负责集合元素的排序逻辑;
TreeSet(Comparator comparator)
Eg：
package july7;
//定制排序的话，必须在创建TreeSet集合对象的时候提供一个Comparator方法
import java.util.Comparator;
import java.util.Set;
import java.util.TreeSet;
class Student1{
private Integer age;
public Student1(Integer age) {
super();
this.age = age;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
@Override
public String toString() {
return age + "";
}
}
class MyComparator implements Comparator{
@Override
public int compare(Object o1, Object o2) {
if(o1 instanceof Student1 & o2 instanceof Student1){
Student1 s1 = (Student1)o1;
Student1 s2 = (Student1)o2;
if(s1.getAge() > s2.getAge()){
return -1;
}else if(s1.getAge() < s2.getAge()){
return 1;
}
}
return 0;
}
}
public class Demo15 {
public static void main(String[] args) {
Set<Student1> s = new TreeSet(new MyComparator());
/**
* 要 实 现 定 制 排序 , 需 要 在 创 建 TreeSet 集 合 对 象 时 , 提 供 一 个 一 个
Comparator对象,
* 该对象里负责集合元素的排序逻辑;
*/
s.add(new Student1(140));
s.add(new Student1(15));
s.add(new Student1(11));
s.add(new Student1(63));
s.add(new Student1(96));
System.out.println(s);
}
}
7、List 接口
Collection 子接口；
List 是有序的集合，集合中每个元素都有对应的顺序序列。List 集合可使用重复元素，可以
通过索引来访问指定位置的集合元素（顺序索引从 0 开始）,List 集合默认按元素的添加顺
序设置元素的索引,比如第一个元素的索引就是 0,好似数组。
List 作为 Collection 子接口当然拥有其所有方法，同时也有自己的方法：
void add(int index,Object e):将元素 e 添加到 List 集合中的 index 处；
boolean addAll(int index,Collection c):将集合 c 所包含的所有元素都插入在 List 集合的 index
处；
Object get(int index):返回集合 index 索引处的元素；
int indexOf(Object o):返回对象 o 在 List 集合中第一次出现位置的索引；
int lastIndexOf(object o):返回对象 o 在 List 集合中最后一次出现的位置索引；
Object remove(int index)：删除并返回 index 索引处的元素；
Object set(int index,Object e):把集合 index 处的元素替换为 e 对象，返回以前在指定位置的元
素；
List subList(int fromIndex,int toIndex):返回从所有 fromIndex(包括)到 toIndex(不包括)处所有
集合元素的子集合。
ListIterator
Iterator 的子接口，专门用于操作 List 集合的输出；
List 自己还有一个 listIterator()方法，该方法返回 ListIterator 对象，ListIterator 继承了 Iterator
接口，提供了专门操作 List 的方法。在 Iterator 上额外增加的方法：
支持双向输出：
boolean hasPrevious():返回该迭代器关联集合是否还有上一个元素；
Object previous():返回该迭代器的上一个元素；
我的总结：这是相对更加特殊的一个接口，只用于 List 集合，可以完成逆序输出！
Eg：
package july7;
import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;
public class Demo16 {
public static void main(String[] args) {
List<Integer> l = new ArrayList<Integer>();
l.add(12);
l.add(24);
l.add(36);
l.add(23);
l.add(37);
System.out.println(l);
ListIterator<Integer> it = l.listIterator();
while(it.hasNext()){
System.out.println("正序："+it.next());
}
System.out.println("==================================");
//使用向前迭代前必须将游标（指针）移动到后边！
while(it.hasPrevious()){
System.out.println("逆序："+it.previous());
}
}
}
输出：
[12, 24, 36, 23, 37]
正序：12
正序：24
正序：36
正序：23
正序：37
==================================
逆序：37
逆序：23
逆序：36
逆序：24
逆序：12
8、List 接口中常用类
Vector：线程安全，但速度慢，已被 ArrayList 替代。
ArrayList：线程不安全，查询速度快。
LinkedList：链表结构，增删速度快。取出 List 集合中元素的方式：
get(int index)：通过脚标获取元素。
iterator()：通过迭代方法获取迭代器对象。
ArrayList 和 Vector 类都是基于数组实现的 List 类,Vector 比较古老,被 ArrayList 取代了;
ArrayList 是线程不安全的,而 Vector 是线程安全的,但是即使这样,也不推荐使用 Vector,因为
Collections 有方法可以得到线程安全的 ArrayList 对象;
Collections 类: static List synchronizedList(List list) 返回指定列表支持的同步（线程安全的）
列表。
Queue 接口
继承 Collection 接口
模拟队列：先进先出(FIFO);
void add(Object e):将 e 插入到队列尾部；
Object element():获取队列头部的元素；
boolean offer(Object e):将 e 插入到队列的尾部，当使用有容量限制的队列时，此方法比
add(Object e)方法更好。
Object peek():获取队列头部的元素。如果此双端队列为空，则返回 null。
Object poll():获取并删除队列头部的元素。如果此双端队列为空，则返回 null。
Object remove():获取并删除队列头部的元素。
Eg：练习：List 的使用
设计 Department 和 Employee 对象类(按照开发的样式没有写在一个文件里面)
//一个员工只可以有一个部门，所以按照普通的写法
//一个部门可以有许多员工，所以按照集合的写法；
//员工
package re538.Department;
public class Emp {
private Dept dept;//一个员工只可以有一个部门，所以按照普通的写法
private String name;
public Dept getDept() {
return dept;
}
public void setDept(Dept dept) {
this.dept = dept;
}
public Emp(String name) {
super();
this.name = name;
}
public String toString(){//覆写toString方法
return this.name+"";
}
}
//部门
package re538.Department;
import java.util.List;
public class Dept {
private String name;
private List emp;//一个部门可以有许多员工，所以按照集合的写法；部门里的
属性，员工！
public Dept(String name) {
super();
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public List getEmp() {
return emp;
}
public void setEmp(List emp) {
this.emp = emp;
}
private Dept parent;//一个部门只有一个直接主管部门，所以普通写法
private List children;//但是一个部门可以管理很多部门，充当很多部门的直
接主管部门，所以使用集合
public Dept getParent() {
return parent;
}
public void setParent(Dept parent) {
this.parent = parent;
}
public List getChildren() {
return children;
}
public void setChildren(List children) {
this.children = children;
}
public String toString(){
return this.name.toString();
}
}
//测试类，主方法！
package re538.Department;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class TestDemo {
public static void main(String[] args) {
Emp e1 = new Emp("刘亦菲");
Emp e2 = new Emp("章泽天");
Emp e3 = new Emp("张月娟");
Emp e4 = new Emp("王二五");
Emp e5 = new Emp("刘昭");
List list = new ArrayList();//把员工丢尽集合去
list.add(e1);
list.add(e2);
list.add(e3);
list.add(e4);
list.add(e5);
for (Object object : list) {//把员工给遍历出来，使用的是直接的
foreach（四种方法之一）
System.out.println("----->"+object);
}
System.out.println("-------------------");
Dept d = new Dept("部门");//定义出一个部门来接收员工
d.setEmp(list);//把员工这个集合丢到部门去。
Dept d1 = new Dept("itcast");
Dept cditcast = new Dept("成都传智播客");
Dept gzitcast = new Dept("广州传智播客");
Dept d4 = new Dept("CSDN");
System.out.println(d4);
List children = new ArrayList();
children.add(cditcast);
children.add(gzitcast);
d1.setChildren(children);//定义直接被主管部门（集合）
d1.setParent(d4);//定义直接主管部门
Iterator it = children.iterator();//运用到了迭代遍历，四种之一！
while(it.hasNext()){
System.out.println(it.next());
}
}
}
9、Map 接口
映射关系,也有人称为字典,Map 集合里存在两组值，一组是 key,一组是 value。Map 里的 key
不允许重复。通过 key 总能找到唯一的 value 与之对应。
Map 里的 key 集存储方式和对应的 Set 集合中的元素存储方式一致;
学生都有一个学号，我们能点学号就能找到某个学生，好比这个学号就是 key，学生就是
value。
Map.Entry 是 Map 接口的内部接口，专门用来保存 key-value 内容：
Map 常用方法
void clear():删除该 Map 对象中所有的 key-value 对。也就是清理该集合；
boolean containsKey(Object key):查询 Map 中是否包含指定的 key；
boolean containsValue(Object value):查询 Map 中是否包含至少一个 value;
Set entrySet():返回Map所包含的key-value对所组成的Set集合，每个集合元素都是Map.Entry
对象(Entry 是 Map 内部类)；
Object get(Object key):返回指定 key 所对应的 value,若此 Map 中不包含该 key,返回 null;
boolean isEmpty():判断 Map 集合是否为空；
Set keySet():返回该 Map 中所有 key 所组成的 Set 集合；
Object put(Object key,Object value):添加一个 key-value 对，若 Map 中已有与 key 相等的
key-value 对，则新的 key-value 对覆盖原来的 key-value 对；
void putAll(Map m):将 m 中的 key-value 赋值到调用该方法的 Map 对象中；
Object remove(Object key):删除指定 key 所对应的 key-value 对，返回本删除 key 所关联的
value,若 key 不存在，返回 null;
int size():返回该 Map 里面 key-value 对的个数；
Collection values():返回 Map 里所有 value 组成的 Collection。
Eg：package july7;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class Demo17 {
public static void main(String[] args) {
Map m = new HashMap();
m.put(1, "jack");
m.put(2, "rose");
m.put(3, "lucy");
System.out.println(m);//{1=jack, 2=rose, 3=lucy}
Set s = m.entrySet();
System.out.println(s);//[1=jack, 2=rose, 3=lucy]
s = m.keySet();
System.out.println(s);//[1, 2, 3]
for (Object key : s) {
System.out.println(key);//Key
System.out.println(m.get(key));//Value
}
Collection c = m.values();
System.out.println(c);
}
}
Map.Entry
Entry 是 Map 接口里面的一个内部接口.
该接口用于封装 key- value,有 3 个方法:
Object getKey();返回 Entry 里包含的 key 值
Object getValue();返回 Entry 里包含的 value 值
Object setValue(Object value):设置 Entry 里包含的 value 值,并返回新设置的 value 值;
Map 集合的输出
按照最正统的做法，所有的 Map 集合的内容都要依靠 Iterator 输出，以上虽然是完成了输出，
但是完成的不标准，Map 集合本身并不能直接为 Iterator 实例化，如果此时非要使用 Iterator
输出 Map 集合中内容的话，则要采用如下的步骤：
方法一：
1.通过 entrySet 方法变成 Set 对象
2.调用 Set 的 Iterator 方法，此时每个 Iterator 对象是 Map.Entry 对象
3.对 Map.Entry 分离出 key - value
方法二：
1.通过 keySet 得到 Map 集合多有 key 的 Set 集合
2.调用 Set 的 Iterator 方法，此时每个 Iterator 对象是 key 值
3.通过 Map 的 getValue(key)得到 value 值
Eg：
package july7;
//把Map中的元素取出来
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
public class Demo18 {
public static void main(String[] args) {
Map<Integer, String> m = new HashMap<Integer, String>();
m.put(1, "jack");
m.put(2, "rose");
m.put(3, "lucy");
//第一种方法
Set s = m.entrySet();
Iterator it = s.iterator();
while(it.hasNext()){
Map.Entry me = (Entry) it.next();
System.out.println(me.getKey()+" "+me.getValue());
}
//第二种方法
s = m.keySet();//得到的是key的集合
it = s.iterator();//然后将key迭代出来
while(it.hasNext()){
int i = (int)it.next();
System.out.println(i+" "+m.get(i));
}
}
}