这类集合都实现了Collection接口,因此也大部分方法都相同,以ArrayList为例,列出相同的部分
package collection;
import java.util.ArrayList;
import java.util.Iterator;
import com.sun.org.apache.commons.collections.iterators.IteratorChain;
/**
* 1.方法的参数是object,以便于接收任意类型的对象
* 2.集合中存储的都是对象的引用(地址)
* @author asus
* Collection
* |--List:元素是有序的,元素可以重复,因为该集合体系有索引
* |--ArrayList 数组式结构,查询更改速度快(根据角标查询),但是添加和删除速度慢(数据越多越明显),线程不同步
* |--LinkedList 链表式结构,查询速度慢,但是添加删除元素速度快
* |--Vector 数组式结构(最早出现的容器),功能同ArrayList,线程同步(但是多线程时,仍然会使用加锁的ArrayList代替),与ArrayList不同的是当添加新数据需要扩大空间时,会翻倍扩大空间,而不是根据需要
* |--Set: 元素无序(存入和取出的顺序不一定一致),元素不可重复,没有索引
* |--HashSet 使用哈希表作为存储方式,通过先判断哈希值(HashCode),然后再判断元素值,保证元素的唯一性,线程不同步
* 如果存入自定义对象,需要重写equals(obj)方法和hashCode()方法
* |--TreeSet 二叉树结构,默认进行先序遍历排序,通过compareTo()方法return 0;,来判断元素是否唯一
* 如果存入自定义对象,需要重写compareTo(obj)方法
*/
public class CollectionDemo {
public static void main(String[] args) {
testArrayList();
}
//创建一个集合容器,使用Collection接口的子类,ArrayList
public static void testArrayList(){
ArrayList<String> al = new ArrayList<String>();
/*
* 1.添加元素
* add()方法的参数是object,以便于接收任意类型的对象
*/
al.add("java01");
al.add("java02");
al.add("java03");
al.add("java04");
System.out.println(al.toString());
/*
* 2.获取集合长度
*/
System.out.println("当前集合长度为"+al.size());
/*
* 3.删除元素
*/
//删除指定元素
al.remove("java02");
System.out.println(al.toString());
//清空集合,删除所有元素
// al.clear();
// System.out.println(al.toString());
//两集合取交集
ArrayList<String> al2 = new ArrayList<String>();
al2.add("java01");
al2.add("java02");
al2.add("java05");
al2.add("java06");
System.out.println(al2);
al.retainAll(al2);
System.out.println(al);
//迭代器
Iterator<String> it = al2.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
for(Iterator<String> it2 = al2.iterator();it.hasNext();){
System.out.println(it2.next());
}
}
}
接着说说各自的区别,Collection有两个分支,一个是List(元素有序且可重复),一个是Set(元素无序且不能重复)
List中以常用的ArrayList、LinkedList、Vector为例
ArrayList,最常见的集合,数组式结构,有利于查找数据(可以通过角标进行查找),但是一个长的ArrayList在添加删除数据时速度会变慢,线程不同步
package collection.list;
import java.util.ArrayList;
import java.util.ListIterator;
import java.util.Iterator;
/**
* List:元素是有序的,元素可以重复,因为该集合体系有索引
* |--ArrayList 数组式结构,查询更改速度快(根据角标查询),但是添加和删除速度慢(数据越多越明显),线程不同步
* @author asus
*
*/
public class ListDemo {
public static void main(String[] args) {
//这里以ArrayList为例
arrayList();
}
private static void arrayList(){
ArrayList<String> al = new ArrayList<String>();
al.add("java01");
al.add("java02");
al.add("java03");
System.out.println(al);
//添加
al.add(2, "java09");
System.out.println(al);
//移除
al.remove(0);
System.out.println(al);
//修改
al.set(1, "09java");
System.out.println(al);
//剪切
System.out.println(al.subList(0,2));
//迭代
for(Iterator<String> it = al.iterator();it.hasNext();){
System.out.println(it.next());
}
//迭代中修改
System.out.println(al);
for(ListIterator<String> lit = al.listIterator();lit.hasNext();){
String s = lit.next();
if(s.equals("java02")){
lit.add("java04");
}
}
System.out.println(al);
}
}
LinkedList,链式结构,插入或删除数据只需要改变前后数据的指针(链的连接)即可,因此插入和删除数据很快,但是查找需要通过一个一个节点的进行,因此查找比较慢
package collection.list;
import java.util.LinkedList;
/**
* LinkedList有自己特有的方法 ,
* addFirst() addLast(),
* getFirst() getLast(),
* removeFirst() removeLast(),
* pollFirst() pollLast()
* @author asus
*
*/
public class LinkedListDemo {
public static void main(String[] args) {
linkedList();
}
private static void linkedList() {
LinkedList<String> link = new LinkedList<String>();
link.add("java01");
link.add("java02");
link.add("java03");
link.add("java04");
link.addFirst("java05");// 向头部添加
link.addLast("java06");// 向尾部添加
link.add("java07");// 默认也会向尾部添加
System.out.println(link);
System.out.println(link.getFirst());// 获取第一个
System.out.println(link.getLast());// 获取最后一个
System.out.println(link.removeFirst());// 获取第一个,之后删除第一个
System.out.println(link);
System.out.println(link.remove());// 默认也是获取第一个,之后删除第一个
System.out.println(link);
System.out.println(link.removeLast());// 获取最后一个,之后删除第一个
System.out.println(link);
// 使用remove()代替迭代器
while (!link.isEmpty()) {
System.out.println(link.remove());
}
link.add("java01");
link.add("java02");
link.add("java03");
link.add("java04");
// JDK1.6中出现 pollFirst() pollLast(),取代removeFirst() removeLast(),
// 在遇到空的LinkedList时返回null取代返回NoSuchElementsException异常
String s = null;
while ((s = link.pollFirst()) != null) {
System.out.println(s);
}
}
}
Vector,最早出现的集合,同样是数组结构,但是线程安全,进行操作时都有判断锁的过程,也因此效率比ArrayList要慢
package collection.list;
import java.util.Enumeration;
import java.util.Vector;
/**
* 枚举是Vector特有的取出方式 枚举和迭代方式是一样的 因为枚举的名称和方法名称都过长,所以被迭代器所取代,以至于枚举基本不再使用
*/
public class VectorDemo {
public static void main(String[] args) {
vector();
}
private static void vector() {
Vector<String> v = new Vector<String>();
v.add("java01");
v.add("java02");
v.add("java03");
v.add("java04");
Enumeration<String> e = v.elements();
while (e.hasMoreElements()) {
System.out.println(e.nextElement());
}
}
}
Set集合中,常见的是HashSet和TreeSet
Hashset,哈希表结构,也是根据哈希表来判断数据是否相同
package collection.set;
import java.util.HashSet;
import java.util.Iterator;
/**
* HashSet中没有自己的方法,和Collection中的完全一样,通过hashCode值存储数据
* 在判断数据的唯一性时,先判断哈希值是否相同,如果相同继续判断数据是否相同
* @author asus
*
*/
public class HashSetDemo {
public static void main(String[] args) {
HashSet hs = new HashSet();
hs.add(new Person("java01",11));
hs.add(new Person("java02",12));
hs.add(new Person("java03",13));
hs.add(new Person("java02",12));
Iterator<Person> it = hs.iterator();
while(it.hasNext()){
Person p = it.next();
System.out.print("["+p.getName()+","+p.getAge()+"] ");
}
}
}
class Person{
private String name;
private int age;
public Person(String name,int age){
this.name = name;
this.age = age;
}
public String getName(){
return name;
}
public int getAge(){
return age;
}
public int hashCode(){
return name.hashCode()+age*7;
}
public boolean equals(Object obj){
if(obj instanceof Person){
Person p = (Person)obj;
return p.getName().equals(name)&&(p.getAge()==age);
}
return false;
}
}
TreeSet,二叉树结构,而且会对数据以先序遍历的方式排序和读取
package collection.set;
import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;
/**
* TreeSet: 二叉树结构,会对数据进行比较排序,因此在存放时需要进行比较,若果是自定义对象则需要重新实现比较接口(即compareTo()方法,通过覆盖这个方法也可以改变排序方式),
* 通过比较保证元素的惟一性(compareTo()方法return 0,表示元素重复)。
*
* TreeSet当元素不具有比较性或者排序方式不适用时,需要为集合添加比较方法,然后通过集合来比较(比如示例中,要按着姓名排序,就需要使用集合比较方法)
* @author asus
*
*/
public class TreeSetDemo {
public static void main(String[] args) {
TreeSet ts = new TreeSet(new MyTreeSet());
ts.add(new Student("java01",11));
ts.add(new Student("java02",12));
ts.add(new Student("java03",13));
ts.add(new Student("java02",14));
ts.add(new Student("java03",13));
Iterator<Student> it = ts.iterator();
while(it.hasNext()){
Student s = it.next();
System.out.print("["+s.getName()+","+s.getAge()+"] ");
}
}
}
//重写compareTo()方法,让元素自身具备比较性
class Student implements Comparable{
private String name;
private int age;
Student(String name,int age){
this.name=name;
this.age=age;
}
public String getName(){
return name;
}
public int getAge(){
return age;
}
public int compareTo(Object obj){
if(!(obj instanceof Student)){
System.out.println("不是Student类型");
throw new RuntimeException("不是Student类型");
}
Student s = (Student)obj;
if(this.age>s.age){
return 1;
}
if(this.age==s.age){
return this.name.compareTo(s.getName());
}
return -1;
}
}
//实现comparator接口,重写compare()方法
class MyTreeSet implements Comparator{
public int compare(Object obj1,Object obj2){
int n = 0;
if(!(obj1 instanceof Student)||!(obj2 instanceof Student)){
throw new RuntimeException("不是Student类型");
}
Student s1 = (Student)obj1;
Student s2 = (Student)obj2;
n = s1.getName().compareTo(s2.getName());
if(n==0){
return String.valueOf(s1.getAge()).compareTo(String.valueOf(s2.getAge()));
}
return n;
}
}