跟着老毕学Java-集合框架篇之Collection

------- android培训、java培训、期待与您交流！
----------

————————————————————————————————————————————

集合框架

概述

为什么要用集合？

对象是对数据的封装，而集合是对对象的封装。编程中除了对单个象的操作外，常常还需要对多个对象进行统一操作，这时就需用一个容器将这些对象存储起来，这样的容器就是集合。其实，String类也是一个特殊的容器，它存储的是char类型的元素。集合的共性操作就是CRUD。集合的应用比数组更广泛。

集合与数组的区别

他们都是容器，都可以存储对象，他们的区别是：数组的长度是固定的，而集合的长度的可变的；数组既能存储基本数据类型也能存储引用数据类型，而集合只能存储引用数据类型，如果给集合添加基本数据类型的元素，这些基本数据类型会自动装箱成对应的引用数据类型；数组存储的元素都是同一类型，而集合可以存储不同类型的元素。

集合的特点

集合只用于存储对象，它的长度可变，能够存储不同类型的对象。

集合框架体系

集合框架为什么有这么多的容器？

因为每一个容器对数据的存储方式都有不同，这个存储方式称之为：数据结构。

提示：学习javaAPI时，通常查阅父类接口，了解其体系的共性方法，而使用时选择具体的子类，以利用子类的特有方法。

Collection

共性方法

Collection是一个接口，它定义了一些共性的方法，包括添加、移除、清空元素，是否为空、是否包括某一元素，获取元素个数等操作。

注意：

1.它里边有一个Iterator方法，专门用于取出元素。

2.集合的add方法的参数类型是Object，以便于接受任意类型的对象。

3.集合中存放的都是对象的引用（地址）。

示例代码1

import java.util.*;

class  CollectionDemo
{
public static void main(String[] args)
{
method_get();
//method_1();

}
public static void method_get()
{
ArrayList al = new ArrayList();

//1.添加元素
al.add("java01");//add的参数是Object类型的。
al.add("java02");
al.add("java03");
al.add("java04");

Iterator it = al.iterator();//获取迭代器，用于取出集合中的元素。
sop(it.hasNext());
sop(it.next());
sop(it.hasNext());

while(it.hasNext())
{
sop(it.next());
}
/*
for(Itera tor it = al.iterator();it.hasNext();)
{
sop(it.next());
}
*/
}

//取交集
public static void method_1()
{
ArrayList al1 = new ArrayList();
al1.add("java01");
al1.add("java02");
al1.add("java03");
al1.add("java04");

ArrayList al2 = new ArrayList();
al2.add("java02");
al2.add("java05");
al2.add("java07");
al2.add("java08");

//al1.retainAll(al2);//取交集，al1中只会保留和al2中相同的元素。
al1.removeAll(al2);

sop("al1:"+al1);
sop("al2:"+al2);

}

public static void base_method()
{
//创建一个集合容器，使用Collection接口的子类，ArrayList
ArrayList al = new ArrayList();

//1.添加元素
al.add("java01");//add的参数是Object类型的。
al.add("java02");
al.add("java03");
al.add("java04");

//打印原集合
sop(al);

//3.删除元素
al.remove("java02");

//4.判断元素。
sop("java03是否存在："+al.contains("java03"));
sop("结合是否为零："+al.isEmpty());

//2，获取个数，集合长度
sop("size="+al.size());

//打印改变后的集合
sop(al);

}
public static void sop(Object obj)
{
System.out.println(obj);
}
}

Iterator（迭代器）

集合中的的元素取出动作，不足以用一个函数来描述（取出前要先判断有没有），同时不同的存储结构，其取出的方式也不同，所以定义了一个接口Iterator专门用来实现其取出操作。因为要访问集合内部的元素，所以迭代器的实现放在了具体集合的内部。

Collection体系结构

Collection按元素是否允许重复，分为List和Set两类。List是允许元素重复，每个元素都有索引。Set不允许重复，元素没有索引。Collection体系结构如下：
Collection
|--List:元素是有序的，元素可以重复。因为该集合体系有索引。
|--ArrarList：底层数据使用的是数据结构。JDK1.2才出现的。特点：查询修改速度很快，但添加删除很慢。线程不同步。
|--LinkedList：底层数据用的是链表数据结构。特点：增删速度很快，查询稍慢。
|--Vector:底层是数组数据结构。JDK1.0出现的，线程同步。被ArrayList替代了，增删查询都很慢。
|--Set：元素是无序的（存入和取出的顺序不一定一致），元素不可重复，没有索引。
|---HashSet：底层数据结构是哈希表。
|---TreeSet：底层数据是二叉树结构。

Set集合的功能和Collection是一致。

List

特有方法

List中凡是可以操作角标的方法都是该体系特有的方法。

通用方法

增：
add(index,element);
addAll(index,Collection);
删：
remove(index);
改：
set(index,element);

查：
get(index);
subList(from,to);
ListIterator();
注意：
1.
List判断包含、移除等操作都要调用equals方法。所以新建立一个Student类，将值存入集合时，要复写equals方法，以满足对对象相同的设定。
2.
List取出元素的方式有三种：for循环，Iterator，ListIterator。

List特有的迭代器：ListIterator

ListIterator是Iterator的子接口。在迭代时，不可以通过集合对象的方法操作集合中的元素，因为会发生ConcurrentModificationException异常。所以，在迭代时，只能用迭代器的方法操作元素，可是Iterator方法是有限的，只能对元素进行判读，取出，删除的操作。如果想要其他的操作如添加，修改等，就需要使用其子接口，ListIterator。
实现该接口的子类对象只能通过List集合的ListIterator方法获取。

示例代码2

class ListDemo
{
public static void main(String[] args)
{
//演示列表迭代器
ArrayList al = new ArrayList();

//1.添加元素
al.add("java01");//add的参数是Object类型的。
al.add("java02");
al.add("java03");

//在迭代过程中，准备添加或者删除元素。
ListIterator it = al.listIterator();

sop("hasPrevious:"+it.hasPrevious());
while(it.hasNext())
{
Object obj = it.next();
if(obj.equals("java02"))
it.set("java08");
sop(obj);
}
while(it.hasPrevious())
{
sop("hasPrevious:"+it.previous());
}
sop("hasNext:"+it.hasNext());
sop("hasPrevious:"+it.hasPrevious());
sop(al);
/*
for(Iterator it = al.iterator();it.hasNext();)
{
Object obj = it.next();
if(obj.equals("java02"))
//al.add("java07");//迭代器和集合同时操作元素，会出现ConcurrentModificationException异常。
it.remove();//将java02的引用从集合中删除了。
sop("obj="+obj);
}
sop(al);
*/

//method();

}
public static void method()
{
ArrayList al = new ArrayList();

//1.添加元素
al.add("java01");//add的参数是Object类型的。
al.add("java02");
al.add("java03");

sop("原集合："+al);
//在指定位置添加元素。
al.add(1,"java09");
sop(al);

//删除指定位置的元素。
//al.remove(2);

//修改元素
//al.set(2,"java07");

//通过角标获取元素
sop("a1.get(1):"+al.get(1));
sop(al);
//获取所有元素
for(int x = 0;x<al.size();x++)
{
sop("al("+x+"):"+al.get(x));
}

for(Iterator it = al.iterator();it.hasNext();)
{
sop("next:"+it.next());
}

//通过indexOf获取对象的位置
sop("index="+al.indexOf("java02"));

List sub = al.subList(1,3);
sop("sub:"+sub);

}
public static void sop(Object obj)
{
System.out.println(obj);
}
}

ArrayList

ArrayList底层是数组结构，线程不同步。

示例代码3

/*
练习：将自定义对象作为元素存到ArrayList集合中，并去除重复元素，比如：存入对象，同姓名同年龄，视为同一个人，为重复元素。

思路：
1.对人描述，将数据封装进人对象。
2.定义容器，将人存入。
3.取出。
List集合判断元素是否相同，依据的是元素的equals方法。
*/
import java.util.*;
class Person1
{
private String name;
private int age;
Person1(String name,int age)
{
this.name =name;
this.age = age;
}
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
//复写equals方法，其实是为集合做判（包含）断服务的。
public boolean equals(Object obj)
{
if(!(obj instanceof Person1))
return false;
Person1 p = (Person1)(obj);
return this.name.equals(p.name) && this.age==p.age;
}
}
class ArrayListTest2
{
public static void main(String[] args)
{
ArrayList al = new ArrayList();
Person1 p1=new Person1("mama",23);
al.add(new Person1("lisi",20));
al.add(new Person1("zhangsna",23));
al.add(new Person1("wangwu",40));
al.add(new Person1("wangwu",40));
al.add(new Person1("loosi",20));
al.add(p1);
al.add(p1);

al=singleList(al);
//		sop("remove 03:"+al.remove(new Person1("zhangsna",23)));

Iterator it = al.iterator();
while(it.hasNext())
{
Person1 p = (Person1)it.next();

sop(p.getName()+"::"+p.getAge());
}

}
//去除ArrayList中的重复的元素
public static ArrayList singleList(ArrayList al)
{
ArrayList newAl = new ArrayList();

Iterator it = al.iterator();
while(it.hasNext())
{
Object obj = it.next();
if(!(newAl.contains(obj)))
//contains判断是否相同，用的是equals方法，集合中的元素如果没有重写equals方法，那么传入引用没有问题，
//但如果传入的是匿名对象，那么就会出现重复元素，该函数的实现就出现了bug
newAl.add(obj);
}
return newAl;

}
public static void sop(Object obj)
{
System.out.println(obj);
}
}

Vector

Vector底层也是数组结构，它是线程同步的，但效率低，它有自己特有的枚举Enumeration，用来取出集合元素。后来ArrayList取代了Vector，Iterator取代了Enumeration。

示例代码4

mport java.util.*;

class VectorDemo
{
public static void main(String[] args)
{
Vector v = new Vector();
v.add("java01");
v.add("java02");
v.add("java03");
v.add("java04");

Enumeration en =v.elements();
while(en.hasMoreElements())
{
sop(en.nextElement());
}
}

public static void sop(Object obj)
{
System.out.println(obj);
}
}

LinkedList

LinkedList的特有方法：

addFirst(); addLast();

getFirst();getLast();

获取元素，但不删除元素.如果集合中没有元素，会出现NoSuchElementException

removeFirst();removeLast();

获取元素，同时删除元素。如果集合中没有元素，会出现NoSuchElementException

在JDK1.6出现了替代方法。

offerFirst();offerLast();

peekFirst();peekLast();

获取元素，但是元素不被删除。如果集合中没有元素，会返回null

poolFirst();poolLast();

获取元素，但是元素被删除。如果集合中没有元素，会返回null。

示例代码5

/*
需求：使用LinkedList模拟一个堆栈或者队列数据结构
为什么要模拟？
LinkedList名称是固定的，在现实开发中，我们希望制作一个跟项目有关的容器，针对特定的数据结构提供更为简便的方法。
堆栈：先进后出。如同一个杯子。
队列：先进先出。如同一个水管。First In First Out
*/
import java.util.*;
class DuiLie
{
private LinkedList link ;
DuiLie()
{
link = new LinkedList();
}
public void myAdd(Object obj)
{
link.addFirst(obj);
}
public Object myGet()
{
return link.removeLast();
}
public boolean isNull()
{
return link.isEmpty();
}
}
class LinkedListTest
{
public static void main(String[] args)
{
DuiLie dl = new DuiLie();
dl.myAdd("java01");
dl.myAdd("java02");
dl.myAdd("java03");
dl.myAdd("java04");

sop(dl.myGet());
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}

Set

与List不同，Set中的元素不允许重复，但这里的“不允许”是建立在你正确运用其实现原理的基础上，否则仍可能出现重复的情况。

Set常用的子类为HashSet和TreeSet，这两个子类实现元素唯一性的原理不同：HashSet是通过依次调用元素的hashCode和equals方法，而TreeSet是通过让元素或集合具备比较性（分别对应Comparable和Comparator两个接口）来实现的。

TreeSet还有一个特点，它是元素是有序的。这里的有序，跟其存入顺序无关，是指其自然顺序或比较器指定的顺序。

HashSet

HashSet是如何保证元素的唯一性？
是通过依次调用hashCode和equals来完成。如果元素的HashCode值相同，才会判断equals是否为true。如果元素的hashCode值不同，不会调用equals方法。（开发时，往集合存对象时，一般要重写对象所属类的hashCode和equals方法）
HashSet对于判断元素是否存在，已经删除等操作，依赖的方法也是元素的hashCode和equals方法。

示例代码6

package bxd.day14;
/*
往HashSet集合中存入自定义对象。
姓名和年龄相同为同一个人，重复元素。

*/
import java.util.*;
class Person
{
private String name;
private int age;
Person(String name,int age)
{
this.name =name;
this.age = age;
}
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
public int hashCode()
{
System.out.println(this.name+"之前的hashCode值："+super.hashCode());
return name.hashCode()+age*37;//所有的目的都是为了让HashSet判断的hashCode值只跟你要保证唯一的那些值有关，
//age*37,是为了尽量保证hashCode值的唯一。比如（40+20）和（20+40）的情况。

}
public boolean equals(Object obj)
{
if(!(obj instanceof Person))
return false;
Person p = (Person)(obj);
System.out.println(this.name+"...equals..."+p.name);//该句没有被打印说明没有调用equals()方法。
return this.name.equals(p.name) && this.age==p.age;
}
}

class HashSetTest
{
public static void main(String[] args)
{
HashSet hs = new HashSet();
hs.add(new Person("a1",11));
hs.add(new Person("a2",12));
hs.add(new Person("a3",13));
hs.add(new Person("a2",12));
// hs.add(new Person("a4",14));

//sop("a1存在:"+hs.contains(new Person("a1",11)));
sop("a4 exists?"+hs.remove(new Person("a4",14)));

Iterator it = hs.iterator();
while(it.hasNext())
{
Person p = (Person)it.next();
sop(p.getName()+"::"+p.getAge());
}
}

public static void sop(Object obj)
{
System.out.println(obj);
}
}

TreeSet

TreeSet中元素的取出顺序跟存入顺序无关，不可以有重复元素。

TreeSet实现排序的方式有两种：

一、让元素具备比较性（或自然顺序，实现Comparable接口）

TreeSet存入的元素，如果没有实现Comparable接口，往TreeSet中add第一个元素的时候，不会出问题，但add第二个元素时，会出现类型转换异常，因为TreeSet集合是通过Comparable接口的compareTo方法来完成排序的，它默认其中的元素都实现了Comparable接口。

同时，在compareTo方法中，当主要条件判断相等后，一定要再判断下次要条件。

TreeSet对于判断元素是否存在，已经删除等操作，依赖的方法也是元素的compareTo方法。
二、让集合具备比较器（集合传入Comparator）
当集合元素没有比较性或具备的比较性不是所需要的时，可以让集合自己具备比较性，即集合初始化时，把一个比较器Comparator作为参数传入集合的构造函数。
Comparator接口里边有个compare（obj，obj）方法。

示例代码7

import java.util.*;
class TreeSetDemo2
{
public static void main(String[] args)
{
TreeSet ts = new TreeSet(new MyCompare());

ts.add(new Student2("a1",15));
ts.add(new Student2("a2",12));
ts.add(new Student2("a2",13));
ts.add(new Student2("a4",16));
ts.add(new Student2("a4",17));

Iterator it = ts.iterator();
while(it.hasNext())
{
Student2 stu = (Student2)it.next();
System.out.println(stu.getName()+"::"+stu.getAge());
}
}
}
//第二种排序方式：实现比较器，现在姓名再按年龄排序。
class MyCompare implements Comparator
{
public int compare(Object o1,Object o2)
{
Student2 s1 = (Student2)o1;
Student2 s2 = (Student2)o2;

int num = s1.getName().compareTo(s2.getName());
if(num==0)
{
/*if(s1.getAge()>s2.getAge())
return 1;
if(s1.getAge()==s2.getAge())
return 0;
return -1;*/
num=new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));
}
return num;
}
}

//第一种排序方式：让集合元素具备比较性，先按年龄再按姓名比较。
class Student2 implements Comparable//该接口让学生具备比较性。
{
private String name;
private int age=100;
Student2(String name,int age)
{
this.name = name;
this.age = age;
}

public int compareTo(Object obj)
{
if(!(obj instanceof Student2))
throw new RuntimeException(obj.toString()+"不是学生对象");
Student2 s = (Student2)obj;
//System.out.println(this.name+"...compareTo..."+s.name);
if(this.age>s.age)
return 1;
if(this.age==s.age)
{
return this.name.compareTo(s.name);
}
return -1;

}
/*
public int compareTo(Object obj){

return 1;//这样做会导致按存入顺序取出元素；改为-1，则逆序；改为0，则永远只能存一个元素。
}*/
public String getName()
{
return name;
}
public int getAge()
{
return age;
}

}

————————————————————————————————————————————

------- android培训、java培训、期待与您交流！
----------