Java集合详解（一）：Collection
1.集合简介
集合类的由来：
对象用于封装特有数据，对象多了需要存储，如果对象的个数不确定。就使用集合容器进行存储。
集合的特点：
- 用于存储对象的容器。
- 集合的长度是可变的。
- 集合中不可以存储基本数据类型值。
集合容器因为内部的数据结构不同，有多种具体容器。
不断的向上抽取，就形成了集合框架。
集合体系：
- 集合是对各个容器不断向上抽取产生的一个体系框架
- 集合的长度是可变的，集合可以存储多种类型的对象。
- 创建集合对象的时候要使用具体的子类。
- 抽取的过程中形成顶级父类是抽象，是接口；子类可以提供更加 丰富的方法。
Collection框架图：
Collection集合子类比较：
Collection
|--List: 可以存放有序的对象，并且对象可以重复
|--ArrayList: 底层实现是数组，查询效率要高（因为有索引下标），线程不安全，jdk1.2， 增长是50%（即如果越界，则底层数组增加原来的50%）
|--vector: 底层实现也是数组，线程安全，所以查询效率要比ArrayList要低，jdk1.0 出现
使用ArrayList来对我们的vector进行了升级，所以建议大家使用ArrayList； 100%增长（即如果越界，则底层数组增加原来的100%）
|--LinkedList: 底层实现是链表，查询效率要比ArrayList低
ArrayList： 查询快，增删慢
LinkedList： 查询慢，增删快
Vector： 两个都慢
|--Set: 存放的元素是没有顺序的，元素不能重复
2.Collection子类代码示例：
List:
- ArryList
- LinkedList
- Vector
ArrayList
代码示例：
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class MyArrayListDemo {
public static void main(String[] args) {
List list = new ArrayList(); //创建一个ArrayList对象list
list.add("zhangsan"); //往list内添加元素
list.add("lisi");
list.add("wangwu");
printList(list);
}
public static void printList(List list) {
Iterator itr = list.iterator(); //使用list的迭代器进行list内元素的遍历
while (itr.hasNext()) { //判断迭代器中是否还有元素
System.out.println(itr.next()); //如果迭代器有元素，则取出这个元素并打印
}
}
}
LinkedList
代码示例：
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
public class MyArrayListDemo {
public static void main(String[] args) {
LinkedList list = new LinkedList(); //创建一个LinkedList对象
list.add("zhangsan"); //往list内添加元素
list.add("lisi");
list.add("wangwu");
printList(list);
}
public static void printList(List list) {
Iterator itr = list.iterator(); //使用list的迭代器进行list内元素的遍历
while (itr.hasNext()) { //判断迭代器中是否还有元素
System.out.println(itr.next()); //如果迭代器有元素，则取出这个元素并打印
}
}
}Vector
代码示例:
import java.util.Enumeration;
import java.util.Vector;
public class MyArrayListDemo {
public static void main(String[] args) {
Vector vector = new Vector(); //创建Vector对象vector
vector.addElement("zhangsan"); //往vector中添加对象
vector.addElement("lisi");
vector.addElement("wangwu");
printVector(vector);
}
/**
* 这是Vector中特有的遍历方式。当然，也可以使用之前的迭代器方法遍历
* @param vector
*/
public static void printVector(Vector vector) {
Enumeration elems = vector.elements(); //获取vector中所有元素
while (elems.hasMoreElements()) { //判断vector中是否还有元素
System.out.println(elems.nextElement()); //如果有，则打印这个元素
}
}
}
Set:
- HashSet
- TreeSet
HashSet
代码示例：
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
public class MyArrayListDemo {
public static void main(String[] args) {
Set hashSet = new HashSet();//创建HashSet对象hashSet
hashSet.add("java01");//往hashSet中添加对象
hashSet.add("java02");
hashSet.add("java02");
hashSet.add("java03");
sop(hashSet);
}
/**
* set：set集合中的数据没有顺序（存入的顺序和取出后的顺序没有关系），没有重复的元素
* 只能使用Iterator的方式来遍历其中的元素
* |--HashSet：底层是有哈希表hash表来维护，
*/
public static void sop(Collection col) {
Iterator it = col.iterator(); //使用col的迭代器
while(it.hasNext()) { //判断是否还有元素
System.out.println(it.next()); //如果有元素则取出打印
}
}
}由于Set集合中数据没有顺序 ，所以打印结果不确定。
TreeSet
代码示例：
import java.util.Collection;
import java.util.Iterator;
import java.util.TreeSet;
public class MyArrayListDemo {
public static void main(String[] args) {
TreeSet treeset = new TreeSet(); //初始化一个TreeSet对象treeset
treeset.add("java03"); //往treeset中添加元素
treeset.add("java02");
treeset.add("java04");
treeset.add("java01");
sop(treeset);
}
/**
* |--TreeSet：可以对我们Set集合进行排序。
* 用String做例子，我们发现，这种排序是对字符串进行的自然排序
*/
public static void sop(Collection col) {
Iterator it = col.iterator(); //使用col的迭代器
while(it.hasNext()) {//判断是否还有元素
System.out.println(it.next());//如果有元素则取出打印
}
}
}打印结果为：
java01
java02
java03
java04
3.List中contains()和remove()方法原理
List比较两个元素相等，实际上比较的是元素的hashCode()和equals()方法。remove()/contains()都比较的是hashCode()和equals()方法。比较时程序会先比较hashCode()，若不同，则两个对象不同，若hashCode()相同，则继续比较equals()方法。
我们可以通过重写hashCode()和equals()方法，实现List判断是否存在相同的对象，例如Person(name,age)。
代码示例：
@Override
public int hashCode() {//hashCode值定义为相同的值
System.out.println(this.name + "---------");
return name.hashCode() + age * 31;
}
@Override
/**
* obj : 要比较的对象
*/
public boolean equals(Object obj) {
if (obj == null) {
return false;
}
if (!(obj instanceof Person)) {
return false;
}
Person p = (Person) obj;
return this.name.equalsIgnoreCase(p.name) && this.age == p.age;
}
4.TreeSet中的比较器
TreeSet中可以使用Comparable和Comparator来实现Set集合的排序。
Comparable和Comparator区别：
在jdk的位置：
- Comparable是在java.lang包下的一个接口
- Comparator是在java.util包下的一个接口
使用场景：
- 如果要让我们的对象（集合元素）具备一个比较性，这个时候就需要用到了Comparable接口
- 如果要让我们的集合能够比较集合中的元素，这时就需要使用Comparator
Comparable代码示例：
import java.util.Collection;
import java.util.Iterator;
import java.util.TreeSet;
public class MyArrayListDemo {
public static void main(String[] args) {
TreeSet tst = new TreeSet(); //初始化TreeSet对象tst
tst.add(new Employee("zs06", 18)); //往tst中添加元素
tst.add(new Employee("zs02", 17));
tst.add(new Employee("zs03", 48));
tst.add(new Employee("zs01", 18));
tst.add(new Employee("zs02", 28));
tst.add(new Employee("zs01", 28));
sop(tst);
}
//打印集合内的元素
public static void sop(Collection col) {
Iterator it = col.iterator();
while (it.hasNext()) {
Employee p = (Employee) it.next();
System.out.println(p.getAge() + "\t" + p.getName());
}
}
}
/**
* 创建一个实现了Comparable接口比较器方法的Employee类
*/
class Employee implements Comparable {
private String name;
private int age;
public Employee() {
}
public Employee(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override //重写Comparable接口中的ComparaTo方法，使得Employee对象能够相互比较
public int compareTo(Object obj) {
if (obj == null) {
throw new RuntimeException("没有对象");
}
if (!(obj instanceof Employee)) {
throw new RuntimeException("不是同一种类型");
}
Employee employee = (Employee) obj;
int num = this.age - employee.age;
//先按照年龄进行排序，如果相等，就再按照name的字典顺序排序
if (num == 0) {
num = this.name.compareTo(employee.name);
}
return num;
}
}
Comparator代码示例：
import java.util.Collection;
import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;
public class MyArrayListDemo {
public static void main(String[] args) {
TreeSet tst = new TreeSet(new MyComParator()); //初始化TreeSet对象tst
tst.add(new Employee("zs06", 18)); //往tst中添加元素
tst.add(new Employee("zs02", 17));
tst.add(new Employee("zs03", 48));
tst.add(new Employee("zs01", 18));
tst.add(new Employee("zs02", 28));
tst.add(new Employee("zs01", 28));
sop(tst);
}
public static void sop(Collection col) {
Iterator it = col.iterator(); //通过使用迭代器打印出集合中的元素
while (it.hasNext()) {
Employee employee = (Employee) it.next();
System.out.println(employee.getAge() + "\t" + employee.getName());
}
}
}
class Employee {
private String name;
private int age;
public Employee() {
}
public Employee(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
//通过实现Comparator接口构造一个比较器MyComparator
class MyComParator implements Comparator {
@Override
public int compare(Object o1, Object o2) {
Employee em1 = (Employee) o1;
Employee em2 = (Employee) o2;
int result = new Integer(em1.getAge()).compareTo(new Integer(em2.getAge()));
//先比较年龄，如果年龄相同，则比较姓名
if (result == 0) {
result = em1.getName().compareTo(em2.getName());
}
return result;
}
}
5.应用
使用LinkedList实现自己的堆栈：
/**
* 使用LinkedList实现堆栈
*/
class MyStack {
private LinkedList list;
//初始化堆栈
public MyStack() {
list = new LinkedList();
}
//存入数据
public void myPush(Object obj) {
list.addLast(obj);
}
//取出数据
public Object myPop() {
return list.removeLast(); //此处若改为list.removeFirst() ，则为队列结构
}
//判断堆栈是否为空
public boolean isNull() {
return list.isEmpty();
}
}
6.集合常见方法
框架的顶层Collection接口：
Collection的常见方法：
1，添加。
boolean add(Object obj):
boolean addAll(Collection coll):2，删除。
boolean remove(object obj):
boolean removeAll(Collection coll);
void clear();3，判断：
boolean contains(object obj):
boolean containsAll(Colllection coll);
boolean isEmpty(): //判断集合中是否有元素。 4，获取：
int size():
Iterator iterator(): //取出元素的方式：迭代器。该对象必须依赖于具体容器，因为每一个容器的数据结构都不同。
所以该迭代器对象是在容器中进行内部实现的。
对于使用容器者而言，具体的实现不重要，只要通过容器获取到该实现的迭代器的 对象即可，也就是iterator方法。
Iterator接口就是对所有的Collection容器进行元素取出的公共接口。
5，其他：
boolean retainAll(Collection coll);//取交集。
Object[] toArray(): //将集合转成数组。 Collection
|--List：有序(存入和取出的顺序一致),元素都有索引(角标)，元素可以重复。
|--Set：元素不能重复,无序。
List:特有的常见方法：
有一个共性特点就是都可以操作角标。
1，添加
void add(index,element);
void add(index,collection);2，删除；
Object remove(index):3，修改：
Object set(index,element);4，获取：
Object get(index);
int indexOf(object);
int lastIndexOf(object);
List subList(from,to);list 集合是可以完成对元素的增删改查。
LinkedList特有方法：
1，添加： jdk1.6以后
addFirst(); offerFirst();
addLast(); offerLast();2,获取： jdk1.6以后
getFirst(): peekFirst();
getLast(); peekLast();如果集合中没有元素，那么该方法会发生异常NoSuchElementException
如果集合元素没有，该方法不会抛出异常，而是返回null。
3，删除： jdk1.6以后
removeFirst(): pollFirst();
removeLast(); pollLast();如果集合中没有元素，那么该方法会发生异常NoSuchElementException
如果集合元素没有，该方法不会抛出异常，而是返回null。
List集合子类-Vector
Vector已经不常用了，我们就说里面的一个方法，Elements方法。这个方法的返回值是枚举接口，里面有两个方法，判断和获取。
Vector中提供了一个独特的取出方式，就是枚举Enumeration。此接口Enumeration的功能与 Iterator 接口的功能是重复的。
Enumeration的名称和方法的名称过程，书写很麻烦。所以被Iterator所取代。
7.总结
List:
- |--Vector: 内部是数组数据结构，是同步的。增删，查询都很慢！. 100%增长
- |--ArrayList: 内部是数组数据结构，是不同步的。替代了Vector。查询的速度快。50%增长
- |--LinkedList: 内部是链表数据结构，是不同步的。增删元素的速度很快。
2：数组和链表的区别
当向数组中插入一个元素的时候，插入位置后面的元素都要往后移一位。元素越多越慢。
如果是链表的话，插入一个新元素，只需要让插入的元素记住前一个元素的位置，后一个元素记住插入元素的位置即可，非常简单快速。
删除也特别简单，只需要让后一个元素记住前一个元素的位置即可。中间的元素就删掉了。
总结：
- 链表：增删快，查询慢
- 数组：增删慢，查询快
Set:
元素不可以重复，是无序。
Set接口中的方法和Collection一致。
注意：set集合取出元素的方法只有迭代器。
|--HashSet: 内部数据结构是哈希表 ，是不同步的。
如何保证该集合的元素唯一性：
- 是通过对象的hashCode和equals方法来完成对象唯一性的。
- 如果对象的hashCode值不同，那么不用判断equals方法，就直接存储到哈希表中。
- 如果对象的hashCode值相同，那么要再次判断对象的equals方法是否为true。
- 如果为true，视为相同元素，不存。如果为false，那么视为不同元素，就进行存 储。
记住：如果元素要存储到HashSet集合中，必须覆盖hashCode方法和equals方法。
一般情况下，如果定义的类会产生很多对象，比如人，学生，书，通常都需要覆盖 equals，hashCode方法。
建立对象判断是否相同的依据。
Set常用的子类是HashSet和TreeSet
应用场景：假设要存储的元素必须是唯一的，这个时候就可以使用set集合。
226
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
