java集合

List特点：
1. 允许有重复的元素
2. 可以精确控制元素放置的顺序

List主要方法：
add(Object o)
add(int index, Object o)
get(int index)
set(int index, Object o)

Set特点：
1. 元素不能重复
2. 没有顺序

常见Set实现类：
HashSet: 使用对象的hashCode作为对象的存放位置
TreeSet: 实现SortedSet接口，可以对插入的对象进行排序，底层是树结构
LinkedHashSet: 内部使用链表维护其元素，特点是遍历它的元素顺序与存储时候的顺序一致，遍历较快

为确保具有等价关系的两个对象不被保存到HashSet中，必须重新equals()和hashCode方法
Set set = new Set()
set.add(new Animal("Cat"));
set.add(new Animal("Cat"));
set.size();   // 2

Map主要方法：
Set keySet()
Collection values()
Set entrySet()

Iterator接口：Collection的iterator()方法返回对象

循环中删除Collection元素：
List list = new ArrayList();
list.add("c");
list.add("a");
list.add("f");
list.add("d");

for (int i = 0; i < list.size(); i++) {
	String s = list.gte(i)
	if (s.equals("a") || s.equals("f")) {
		list.remove(s);
	}
}

list.size(); // 3

// 在循环中删除元素，通过Iterator中的remove()方法可以正确删除
for (Iterator it = list.iteraror(); it.hasNext();) {
	String s = it.next();
	if (s.equals("a") || s.equals("f")) {
		it.remove();
	}
}

// 下面的做法也是错误的，不允许对原始数据进行修改
for (Iterator it = list.iteraror(); it.hasNext();) {
	String s = it.next();
	if (s.equals("a") || s.equals("f")) {
		list.remove(s); // ConcurrentModificationException
	}
}

排序:
Collections.sort(List<T> list)
Collections.sort(List<T> list, Comparator<? super T> c)

Arrays.sort(T[] a)
Arrays.void sort(T[] a, Comparator<? super T> c)

1. Comparable接口：
   实现public int comparaTo(Object o)
   集合内部重写comparaTo方法排序
   一个类实现Comparable接口，则之间调用Collections或Arrays的sort方法，类的实例之间可以进行排序操作

public class Student implements Comparable<Object> {

	private int id;

	private String name;

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}
	
	@Override
	public int compareTo(Object obj) {
		return this.id - ((Student)obj).getId();
	}

	@Override
	public boolean equals(Object obj) {
		return this.id == ((Student)obj).getId();
	}
	
	public static void main(String[] args) {
		Student stu1 = new Student();
		stu1.setId(3);
		stu1.setName("c");
		
		Student stu2 = new Student();
		stu2.setId(1);
		stu2.setName("c++");
		
		Student stu3 = new Student();
		stu3.setId(2);
		stu3.setName("java");
		
		List<Student> stus = new ArrayList<Student>();
		stus.add(stu1);
		stus.add(stu2);
		stus.add(stu3);
		
		System.out.println("Before sort: ");
		for (Student stu : stus) {
			System.out.println(stu.getId() + ", " + stu.getName());
		}
		
		Collections.sort(stus);
		
		System.out.println("\nAfter sort: ");
		for (Student stu : stus) {
			System.out.println(stu.getId() + ", " + stu.getName());
		}
	}
}

2. Comparator接口
   1. 独立的排序算法接口
   2. 类的设计师未考虑到排序，未实现Comparable接口，可实现Comparator进行排序

public class Student2 {
	
	private int id;

	private String name;

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}
	
	public static void main(String[] args) {
		Student2 stu1 = new Student2();
		stu1.setId(3);
		stu1.setName("c");
		
		Student2 stu2 = new Student2();
		stu2.setId(1);
		stu2.setName("c++");
		
		Student2 stu3 = new Student2();
		stu3.setId(2);
		stu3.setName("java");
		
		List<Student2> stus = new ArrayList<Student2>();
		stus.add(stu1);
		stus.add(stu2);
		stus.add(stu3);
		
		System.out.println("Before sort: ");
		for (Student2 stu : stus) {
			System.out.println(stu.getId() + ", " + stu.getName());
		}
		
		Collections.sort(stus, new Comparator<Object>() {
			public int compare(Object o1, Object o2) {
				return ((Student2)o1).getId() -  ((Student2)o2).getId();
			}
		});
		
		System.out.println("\nAfter sort: ");
		for (Student2 stu : stus) {
			System.out.println(stu.getId() + ", " + stu.getName());
		}
	}
}

HashSet和HashMap:
1. 数据存入规则
   a. 都使用数组来存放数据
   b. HashSet根据存入对象的hashCode来确定对象存放到数组的那个位置
   c. HashMap根据存入key的hashCode来确定key-value(Entry)存储到数组那个位置
   d. 如果hashCode经过一定运算得到一个存储位置后，在该位置上已经有对象存在，则判断两个对象是否等价(equals)，如果等价则替换，否则将新对象链接到旧对象之后
2. 对象读取规则
   a. 根据要取出的对象(key)的hashCode来获取对象存储在数组中的具体位置
   b. 根据存入规则可知，在这个位置上可能存在一个或多个对象，所以会依次判断这个位置的若干个对象。判断规则：第一，这个对象的hashCode要与取出的对象的hashCode相等；第二，这个对象要等价(equals)要取出的对象;

选择集合：
1. ArrayXXX, 访问速度快，末端添加快
2. LinkedXXX, 中间插入、删除数据块
3. HashXXX， 读取数据极快，变量比较慢
4. TreeXXX， 需要排序时使用，遍历较快