Iterator（迭代器）
所有实现了Collection接口的容器都有一个iterator方法, 用来返回一个实现了Iterator接口的对象
Iterator对象称作迭代器, 用来方便的实现对容器内的元素的遍历
迭代器是一种设计模式，它是一个对象，它可以遍历并选择序列中的对象，而开发人员不需要了解该序列的底层结构。迭代器通常被称为“轻量级”对象，因为创建它的代价小。
Java中的Iterator功能比较简单，并且只能单向移动：
(1) 使用方法iterator()要求容器返回一个Iterator。第一次调用Iterator的next()方法时，它返回序列的第一个元素。注意：iterator()方法是java.lang.Iterable接口,被Collection继承。
(2) 使用next()获得序列中的下一个元素。
(3) 使用hasNext()检查序列中是否还有元素，如果迭代具有更多的元素，则返回true 。换句话说，如果next()返回一个元素而不是抛出一个异常，则返回true ）
(4) 使用remove()将迭代器新返回的元素删除。
Iterator是Java迭代器最简单的实现，为List设计的ListIterator具有更多的功能，它可以从两个方向遍历List，也可以从List中插入和删除元素。
for循环与迭代器比较 例子 ：
package collectionTest;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
public class test {
public static void main(String[] args) {
List list=new ArrayList();
list.add("aaa");
list.add("ccc");
list.add("vvv");
list.add("bbb");
list.add("nnn");
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
//foreach循环遍历，没有下标，需要的话可以自己定义
for(Object s:list){
System.out.println(s);
}
Iterator iter=list.iterator();
while(iter.hasNext()){//判断有没有下一个
System.out.println(iter.next());
}
Map map=new HashMap();
map.put("aa", 1);
map.put("bb", 2);
map.put("cc", 3);
map.put("dd", 4);
Set set=map.keySet();//返回Set集合，存放map的键的值
for(Object o:set){
System.out.println(o);//输出对象的键
System.out.println(map.get(o));//输出对象的值，无序
}
Iterator iter2=set.iterator();
while(iter2.hasNext()){//遍历
System.out.println(map.get(iter2.next()));
}
Collection c=map.values();//返回Collection
Iterator iter3=c.iterator();
while(iter3.hasNext()){
System.out.println(iter3.next());
}
}
}
collections
是一个包装类。它包含有各种有关集合操作的静态多态方法。直接调用，简单实用。此类不能实例化，就像一个工具类，服务于Java的Collection框架。
如果提供给它们的集合或类对象为null，则此类的方法都抛出一个NullPointerException 。
该类中包含的多态算法的文档通常包括实现的简要说明 。 这些描述应被视为实施说明 ，而不是说明书的一部分 。 只要规范本身得到遵守，实现者就可以随意替代其他算法。 （例如，sort使用的算法不一定是一个mergeesort，但它必须是稳定的 。）
package collectionTest;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class test1 {
public static void main(String[] args) {
List list=new ArrayList();
list.add("aaa");
list.add("ccc");
list.add("vvv");
list.add("bbb");
list.add("nnn");
Collections.sort(list);//排序，如果是字母按照字母表排序
System.out.println(list);
Collections.shuffle(list);//随机乱序
System.out.println(list);
Collections.reverse(list);//逆序
System.out.println(list);
List list2=new ArrayList();
//Collections.copy(list2, list);//复制集合，前提是size相同
Collections.fill(list, new Person());
System.out.println(list);
Collections.binarySearch(list, 2);//二分搜索法，使用要先排序
}
}
class Person{
}
自动打包/解包（装箱拆箱）
这里的装箱应该理解为 封装对象 ，即把基础数据类型（如 int）转换成基础类型封装类的对象（如 new Integer()）
拆箱就是装箱的反过程，即把基础类型封装类的对象（如 new Integer()）转换为基础数据类型（如 int）。
Integer a = new Integer() ;//装箱
a = 100 ;
int b = new Integer(100) ; //拆箱
自动装箱拆箱
//自动装箱拆箱
Integer i = 100;
执行上面那句代码的时候，系统执行了：Integer i = new Integer(100);
这就是基本数据类型的自动装箱功能。
泛型(Generic)(1.5之后才有泛型)
泛型，即“参数化类型”。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢？顾名思义，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。
1, 装入集合的类型都被当作Object对待, 从而失去了自己的实际类型
2, 集合中取出来的时候需要转型, 效率低, 易出错
好处: 增强程序的可读性和稳定性
package collectionTest;
import java.util.ArrayList;
import java.util.List;
public class Test3 {
public static void main(String[] args) {
// TODO Auto-generated method stub
List<String> list=new ArrayList<String>();
List<Person2> list2=new ArrayList<Person2>();
list2.add(new Student());//父类的引用指向子类的对象
}
}
class Person2{
}
class Student extends Person2{
}
注意：泛型里不能写基础数据类型，因为 基础数据类型不能为 null，引用类型可以
comparable接口
Collections.sort（和Arrays.sort）可以自动对实现此接口的对象进行列表（和数组）排序。 实现该接口的对象，可以使用如在键sorted map或作为在元件sorted set ，而不需要指定一个comparator 。一类C的自然顺序被说成是与equals一致当且仅当e1.compareTo(e2) == 0对每一个e1和C类e2相同的布尔值e1.equals(e2)。 请注意， null不是任何类的实例， e.compareTo(null)应该抛出一个NullPointerException即使e.equals(null)返回false 。
强烈建议（尽管不需要）自然排序与等于一致。 这是因为，当没有显式比较器的排序集（和排序映射）与其自然排序与equals不一致的元素（或键）一起使用时会“奇怪地”。 特别地，这种排序集合（或排序映射）违反了根据equals方法定义的集合（或映射）的一般合同。
只有一个方法
package com.hanqi;
public class Student implements Comparable<Student>{//实现接口时也要泛型
private String name;
private Integer age;
public Student() {
super();
}
public Student(String name, Integer age) {
super();
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
@Override
public String toString() {
return "Student ["+ name + ","+age+"]";
}
@Override
//通过年龄来比较，从大到小排列
public int compareTo(Student o) {
// TODO Auto-generated method stub
if(this.age<o.age){
return 1;
}else if(this.age>o.age){
return -1;
}else{
return this.age.compareTo(o.age);
}
}
}
总结:
集合是数组的一种延伸, 与数组相比有很多好处和优点,
1, 可以存放不同的类型
2, 长度可变
3, 随时存放和获取
六个接口和一个类:
List
Map
Set
Iterator
Collection
Comparable
Collections类
选择一种集合类型是一件非常痛苦的事
在以后的编程中要考虑读取和修改的效率问题, 数据的存取在以后的使用过程中, Collection是主要的载体,
Array: 读快改慢
Linked: 读慢改快
Hash: 介于两者之间的