集合框架（一）
一、概述
1.集合出现的原因
Java中，数据被封装成对象；对象完成了对数据的存储。而集合的出现，完成了对对象的存储，方便对对象进行操作。
2.集合与数组的区别
1）数组虽然可以存储对象，但是长度固定，不利于后期扩展；只能存储同一类型对象；
2）集合的长度是可变的；并且能存储不同类型对象
3.集合的特点
1）长度可变；
2）可以存储不同类型的对象；
3）集合只用于存储对象，不能存储基本数据类型
二、Collection
1.定义Collection是集合框架层次结构中的根接口。Collection提供了具体的自接口（如Set和List）实现。这个根接口用来传递collection，并提供共性方法，操作这些collection。
2.共性方法
1）添加操作
-boolean add(E e)：添加指定元素到集合中
-boolean addAll(Collection<？ extends E> c)：添加指定集合中的所有元素到当前集合中
2）判断操作
-boolean contains(Object o)：判断当前集合中是否包含指定元素
-booean isEmpty()：判断当前集合是否为空
3）删除操作
-void clear()：清空当前集合
-boolean remove(Object o)：移除指定元素
-boolean removeAll(Collection<？> c)：指定一个集合，将该集合中的元素从当前集合中移除
4）获取操作
-int size()：获取当前集合长度
-booean retianAll(Collection<？> c)：取当前集合与指定集合的交集
-Iterator iterator()：迭代器，用于取出集合中元素
3.共性方法演示
演示Collection中的共性方法。
示例代码：
package com.heisejiuhuche.Collection;
import java.util.ArrayList;
public class CollectionDemo {
public static void main(String[] args) {
method1();
method2();
}
private static void method2() {
ArrayList al = new ArrayList();
al.add("java01");
al.add("java02");
al.add("java03");
al.add("java04");
ArrayList a2 = new ArrayList();
a2.add("java03");
a2.add("java04");
a2.add("java05");
a2.add("java06");
//取交集
al.retainAll(a2);
print(al);
}
private static void method1() {
ArrayList al = new ArrayList();
//添加操作
al.add("java01");
al.add("java02");
al.add("java03");
al.add("java04");
//打印集合，结果为[java01, java02, java03, java04]
print(al);
//删除
al.remove("java03");
print(al);
//是否包含指定对象
print(al.contains("java-2"));
//是否为空
print(al.isEmpty());
//清楚所有对象
al.clear();
print(al);
print(al.size());
}
private static void print(Object obj) {
System.out.println(obj);
}
}注意：
-add()方法的参数类型是Object，以便于接受任意类型对象；
-集合中存放的不是对象实体，存储的是对象内存地址
三、迭代器
1.定义
迭代器是对Iterator接口的实现，用于取出集合中的对象，以便于对对象进行操作。
容器的取出操作，不足以用一个方法描述。每个容器的取出操作过程，都有所不同。因此，容器将取出操作封装成一个对象，对象中提供了多个功能以实现容器对象的取出操作。 每个容器类的内部，都定义了做取出操作的内部类（便于直接访问容器内部的元素），用于取出各容器不同数据结构中的对象。这个取出操作被称为迭代器。无论是什么容器，其迭代器的操作都会有判断和取出的操作，将这些操作提取之后形成了Iterator接口。每个容器通过调用iterator()方法，获得自身的迭代器。
2.迭代器的使用
iterator()方法返回的是一个Iterator接口的子类对象
1）获取iterator迭代器：Iterator it = arraylist.iterator();
2）调用next()方法获取第一个元素并打印：System.out.println(it.next());
3）调用hasNext()方法，循环取出所有元素
for(Iterator it = arraylist.iterator();it.hasNext();) {
System.out.println(it.next());
}四、List
1.List集合的特点List集合中的元素是有序的，并可以重复。该集合体系有索引。
2.List集合特有方法
凡是操作索引的方法都是该体系特有的方法。
1）添加操作
-void add(int index, E element)：添加指定元素
-boolean addAll(int index, Collection<？ extends E> c)：在指定位置插入指定collection中的元素
2）获取操作
-get(int index)：返回集合中指定位置元素
-int indexOf(Object o)：获取元素的索引，不存在返回-1
-int lastIndexOf(Object o)：反向索引
-ListIterator listIterator()：List集合特有迭代器
-List subList(int fromIndex, int toIndex)：返回子集合
3）删除操作
-remove(int index)：按索引移除元素
4）修改操作
-set(int index, E element)：用指定元素替换指定位置的元素
3.特有方法演示
示例代码：
package com.heisejiuhuche.Collection;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class ListDemo {
public static void main(String[] args) {
ArrayList arr = new ArrayList();
arr.add("java01");
arr.add("java02");
arr.add("java03");
arr.add(1, "java04");
ArrayList arr2 = new ArrayList();
arr2.add("java05");
arr2.add("java06");
arr2.add("java07");
arr.addAll(3, arr2);
arr.remove(0);
arr.set(1, "java10");
System.out.println(arr.get(0));
System.out.println(arr.indexOf("java07"));
System.out.println(arr.lastIndexOf("java01"));
for(Iterator it = arr.iterator(); it.hasNext(); ) {
System.out.println(it.next());
}
List list = arr.subList(1, 5);
for(Iterator it = list.iterator(); it.hasNext();) {
System.out.println("---" + it.next());
}
}
}3.ListIterator列表迭代器
1）定义
List集合特有迭代器，ListIterator，是Iterator的子接口。迭代器和集合不能对同一组元素进行两种不同的操作（取和增），会发生ConcurrentModificationException异常；因此，在迭代时，只能用迭代器的方法操作元素。但是Iterator的方法是有限的，只有判断，取出和删除操作。如果需要添加或者修改的操作，就需要使用ListIterator。该接口只能通过List集合的listIterator()方法获取。
2）列表迭代器特有方法
-void add(E e)：添加指定元素
-set(E e)：修改指定元素
-boolean hasPrevious()：指针位之前有没有元素
五、List子类对象
1.List子类对象组成
- List
- ArrayList
- LinkedList
- Vector
List子类对象包括ArrayList，LinkedList和Vector。
2.List子类对象的特点
1）ArrayListArrayList底层数据结构使用的是数组结构；特点在于查询速度块，但是增加删除操作速度较慢
2）LinkedListLinkedList底层数据结构使用的是链表结构；特点在于增加删除操作较快，查询速度较慢
3）VectorVector底层数据结构使用的是数组结构；Vector是最早的容器，其特点在与，Vector是线程同步的
3.Vector中的枚举
枚举（Enumeration）是Vector的迭代器，是其特有的取出元素方式。枚举和迭代是一样的，选用迭代的原因是，枚举的代码过长。
示例代码：
package com.heisejiuhuche.Collection;
import java.util.Enumeration;
import java.util.Vector;
public class VectorDemo {
public static void main(String[] args) {
//创建Vector对象
Vector v = new Vector();
//添加元素
v.add("java01");
v.add("java02");
v.add("java03");
v.add("java04");
//使用枚举遍历元素
for(Enumeration e = v.elements();e.hasMoreElements();) {
System.out.println(e.nextElement());
}
}
}程度输出结果：
java01
java02
java03
java044.LinkedList
1）LinkedList中的特有方法
JDK6.0之前方法：
-void addFirst(E e)：将指定元素插入链表开头
-void addLast(E e)：将指定元素插入链表结尾
-getFirst()：获取第一个元素
-getLast()：获取最后一个元素
-removeFirst()：移除第一个元素，并获取该元素，如果元素不存在，抛出NoSuchElementException
-removeLast()：移除最后一个元素，并获取该元素，如果元素不存在，抛出NoSuchElementException
JDK6.0之后新方法：
-E pollFirst():移除第一个元素，并获取该元素，如果元素不存在，返回null
-E pollLast():移除最后一个元素，并获取该元素，如果元素不存在，返回null
-offerFirst():将指定元素插入链表开头
-offerLast():将指定元素插入链表结尾
2）LinkedList练习
使用LinkedList模拟堆栈或队列数据结构
堆栈数据结构：先进后出；如同一个桶
队列数据结构：先进先出（FIFO）如果水管
队列数据结构示例代码：
package com.heisejiuhuche.Collection;
import java.util.LinkedList;
public class LinkedListTest {
public static void main(String[] args) {
MyList ml = new MyList();
ml.myAdd("java01");
ml.myAdd("java02");
ml.myAdd("java03");
ml.myAdd("java04");
for(;!ml.myEmpty();) {
System.out.println(ml.myGet());
}
}
}
class MyList {
private LinkedList list;
/*
* 初始化MyList
*/
MyList() {
list = new LinkedList();
}
/*
* 声明MyList添加方法，添加到MyList头部
*/
public void myAdd(Object obj) {
list.offerFirst(obj);
}
/*
* 声明MyList获取方法，获取MyList尾部元素
*/
public Object myGet() {
return list.pollLast();
}
/*
* 声明判断MyList是否为空的方法
*/
public boolean myEmpty() {
return list.isEmpty();
}
}程序输出结果：
java01
java02
java03
java04堆栈数据结构，只需修改如下代码：
/*
* 声明MyList获取方法，获取MyList头部元素
*/
public Object myGet() {
return list.pollFirst();
}程序运行结果：
java04
java03
java02
java015.ArrayList练习
1）练习1
去除ArrayList中的重复元素
示例代码：
package com.heisejiuhuche.Collection;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class ArrayListTest {
public static void main(String[] args) {
ArrayList arrList = new ArrayList();
arrList.add("java01");
arrList.add("java01");
arrList.add("java02");
arrList.add("java02");
arrList.add("java03");
arrList.add("java01");
arrList.add("java03");
arrList.add("java04");
System.out.println("原列表： " + arrList);
arrList = singleElement(arrList);
System.out.println("新列表： " + arrList);
}
private static ArrayList singleElement(ArrayList list) {
ArrayList arrList = new ArrayList();
/* 遍历ArrayList，如果新的容器中没有旧容器中的元素，就将这个元素添加到新容器 */
for(Iterator it = list.iterator(); it.hasNext(); ) {
Object obj = it.next();
if(!arrList.contains(obj)) {
arrList.add(obj);
}
}
/* 返回新容器 */
return arrList;
}
}程序输出结果：
原列表： [java01, java01, java02, java02, java03, java01, java03, java04]
新列表： [java01, java02, java03, java04]2）练习2
将自定义元素添加到ArrayList集合中，并去除重复元素。例如，存人对象；同姓名同年龄，视为重复元素。
示例代码：
package com.heisejiuhuche.Collection;
import java.util.ArrayList;
import java.util.Iterator;
public class ArrayListTest2 {
public static void main(String[] args) {
ArrayList arrayList = new ArrayList();
arrayList.add(new Person("lisi01", 30));
arrayList.add(new Person("lisi02", 31));
arrayList.add(new Person("lisi01", 30));
arrayList.add(new Person("lisi03", 36));
arrayList.add(new Person("lisi03", 36));
arrayList.add(new Person("lisi02", 31));
arrayList.add(new Person("lisi04", 31));
arrayList = singleElement(arrayList);
for(Iterator it = arrayList.iterator(); it.hasNext(); ) {
/*
* 将obj向下转型成Person类型
*/
Person p = (Person)it.next();
System.out.println(p.getName() + "..." + p.getAge());
}
}
private static ArrayList singleElement(ArrayList list) {
ArrayList arrList = new ArrayList();
for(Iterator it = list.iterator(); it.hasNext(); ) {
Object obj = it.next();
if(!arrList.contains(obj)) {
arrList.add(obj);
}
}
return arrList;
}
}
/*
* 声明Person类，以加入ArrayList
*/
class Person {
private String name;
private int age;
Person(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return this.name;
}
public int getAge() {
return this.age;
}
/* 复写Object类中的equals方法，判断年龄和姓名相等，就是同一对象 */
/* 列表的contains方法会调用equals()方法进行比较 */
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);
}
}程序输出结果：
lisi01...30
lisi02...31
lisi03...36
lisi04...31结论：
-List集合判断元素是否相同，依据的是元素的equals()方法；
-List集合删除元素的时候，依据的是原色的equals()方法判断List中是否有该元素
六、HashSet
1.Set集合的特点Set集合的元素是无序的，指的是存入和取出的顺序不一定以致，并且元素不可以重复。
2.Set集合常见子类对象特点
- Set
- HashSet
- TreeSet
1）HashSet
HashSet底层数据结构是哈希表
2）TreeSet
TreeSet底层数据结构是二叉树
3.HashSet使用
示例代码：
package com.heisejiuhuche.Collection;
import java.util.HashSet;
import java.util.Iterator;
public class HashSetDemo {
public static void main(String[] args) {
/*
* 创建HashSet对象
*/
HashSet hs = new HashSet();
/*
* 添加元素
*/
hs.add("java01");
hs.add("java02");
hs.add("java02");
hs.add("java03");
hs.add("java04");
hs.add("java04");
hs.add("java05");
/*
* 打印所有元素
*/
for(Iterator it = hs.iterator(); it.hasNext(); ) {
System.out.println(it.next());
}
}
}程序运行结果：
java05
java04
java03
java02
java01高能：
-HashSet集合在存储对象的时候，为保证元素的唯一性，是以对象的哈希值为标准进行判断；如果哈希值不同，则直接进行存储；如果哈希值相同，HashSet集合则启动第二套比较机制，用两个对象equals()方法，对两个对象的属性进行比较，如果此时比较结果不同，则进行存储，相同，则不存储；
-开发时，如果要讲对象存入HashSet，一定要复写hashCode()和equals()方法，以确保对象唯一性以存储Person类为例，要确保存储的Person对象的唯一性，要复写hashCode()和equals()方法；Person类代码如下：
class Person {
private String name;
private int age;
Person(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return this.name;
}
public int getAge() {
return this.age;
}
/*
* 复写hashCode()方法，以姓名和年龄为依据，计算Person对象的哈希值，并确保唯一
*/
public int hashCode() {
return name.hashCode() + age * 37;
}
/* 复写Object类中的equals方法，判断年龄和姓名相等，就是同一对象 */
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);
}
}程序输出结果：
lisi01....20
lisi03....21
lisi02....22注意：
HashSet在进行判断元素是否存在和删除元素操作的时候，同样依据的是hashCode()方法和equals()方法来保证元素的唯一性
