迭代器Iterator
迭代器是实现集合遍历的一种方法。集合遍历的常用方法有三种：for循环、Iterator迭代器和增强for循环（或称高级迭代）。Collection接口提供了相应的方法Iterator()来获取接口的实现类对象（所有Collection的子类都有这个方法）。
Iterator类的常用API：
boolean hasNext() //询问集合中有没有下一个元素
E next() //取出下一个元素
void remove() //删除取出的元素（使用迭代器期间，不能通过调用集合的增删改查方法进行操作）
具体实现：
for(Iterator it = 集合对象.iterator();it.hasNext();){
集合对象的类 a = (集合对象的类）it.next();
//it.remove() 移除获取的元素则调用这个方法
System.out.println(a);
}
增强for循环的具体实现（底层实现是迭代器，使用形式：元素的类型 随便一个变量：要遍历的集合啥的）：
List<Integer> list = new List<Integer>();
for(int i=0;i<3;i++)
list.add(i);
for(Integer a : list)
System.out.println(a);
泛型
在JDK1.5之后添加的新特性，作用是对集合进行“参数化类型”，防止使用向下造型产生错误。集合可以规定元素的类型，编译器会在集合进行增删操作时，检查元素类型是否匹配，避免错误。
同样，集合框架中的所有类型都添加了泛型机制。
定义泛型： 在类名后面加<E> （加别的字母也可以但是习惯用E或者T）
具体实现：
public class MyArrayList<E> {
Object arr[];
public MyArrayList(){
arr = new Object[8];
}
public void add(Object o) {
}
}
public class Person<K,V> {
K k;
V v;
public Person(K k,V v){
this.k=k;
this.v=v;
}
}
public class TestFanxing {
public static void main(String[] args) {
MyArrayList<Person> person = new MyArrayList<Person>();
Person<String,Integer> p1 = new Person<String,Integer>("张三",93);
Person<String,Integer> p2 = new Person<String,Integer>("李四",91);
person.add(p1);
person.add(p2);
}
}
Comparable接口
集合存在一个工具类Collections，提供了很多方法，其中有对集合排序的sort()方法。
sort(List<T> list)方法的底层实现是元素调用compareTo（E e)方法和另外一个元素比较
sort(List<T> list,Comparator<? super T> c)方法底层是两个元素调用compare(Object o1,Object o2)方法进行比较
先不关心具体的实现sort方法，如果我们想实现集合的排序，需要实现Comparable或者Comparator接口，我认为实现他们俩谁都是一样的，是两种不同的方法。
（1） 实现Comparable接口：
package com.Collection;
public class Circle implements Comparable<Circle> {
private double r;
private int x;
private int y;
public Circle(double r, int x, int y) {
super();
this.r = r;
this.x = x;
this.y = y;
}
public double getR() {
return r;
}
public void setR(double r) {
this.r = r;
}
public int getX() {
return x;
}
public void setX(int x) {
this.x = x;
}
public int getY() {
return y;
}
public void setY(int y) {
this.y = y;
}
@Override
public String toString() {
return "[" + r + "," + x + "," + y + "]";
}
@Override
public int compareTo(Circle o) { //重写compareTo方法
int a = this.getX()*this.getX()+this.getY()*this.getY();
int b = o.getX()*o.getX()+o.getY()*o.getY();
return a-b; //实现升序
}
}
package com.Collection;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class TestCircle {
public static void main(String[] args) {
Circle c1 = new Circle(1,1,1);
Circle c2 = new Circle(1,6,7);
Circle c3 = new Circle(1,2,3);
List<Circle> list = new ArrayList<Circle>();
list.add(c1);
list.add(c2);
list.add(c3);
Collections.sort(list); //继承接口后直接调用方法即可
System.out.println(list);
}
}
（2） 实现Comparator接口
Circle类与上相同，但是不需要实现接口了，自然也不需要重写方法了，Test类有改变
package com.Collection;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class TestCircle {
public static void main(String[] args) {
Circle c1 = new Circle(1,1,1);
Circle c2 = new Circle(1,6,7);
Circle c3 = new Circle(1,2,3);
List<Circle> list = new ArrayList<Circle>();
list.add(c1);
list.add(c2);
list.add(c3);
Collections.sort(l,new Comparator<Circle>() { //通过匿名内部类实现接口，重写compare方法
@Override
public int compare(Circle o1,Circle o2) {
return o1.getY()-o2.getY();
}
});
System.out.println(list);
}
}
对于重写compare方法时，将第二个参数和第一个参数比较，则是降序（也就是说返回的是true或者第二个数大于第一个数时）
反之升序。