（黑马程序员）学习笔记，Collection集合（ArrayList、LinkedList、Vector、HashSet、TreeSet）

这类集合都实现了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;
	}
}