list集合
ArrayList
List 接口的大小可变数组的实现，即长度可变的数组
ArrayList集合对象的创建：
ArrayList list =new ArrayList ();
ArrayList方法
添加对象：
boolean add(E e) ----将指定的元素添加到此列表的尾部
void add(int index, E element) -----将指定的元素插入此列表中的指定位置
boolean addAll(Collection<? extends E> c) ---将该 collection 中的所有元素添加到此列表的尾部
boolean addAll(int index, Collection<? extends E> c) ----从指定的位置开始，将指定 collection 中的所有元素插入到此列表中
删除对象
void clear() -----移除此列表中的所有元素
E remove(int index) -----移除此列表中指定位置上的元素
boolean remove(Object o) -----移除此列表中首次出现的指定元素（如果存在）
protected void removeRange(int fromIndex, int toIndex) -----移除 fromIndex（包括）和 toIndex（不包括）之间的所有元素
public boolean removeAll(Collection<?> c)-----删除和指定集合中所有相同的元素
public boolean retainAll(Collection<?> c)-----删除和指定集合中所有不相同的元素
替换对象
E set(int index, E element) -----用指定的元素替代此列表中指定位置上的元素
返回ArrayList的一个副本
Object clone()
查集合长度
int size() -----返回此列表中的元素数
调整实例容量
void trimToSize() -----将此 ArrayList 实例的容量调整为列表的当前大小
判断是否包含元素
boolean contains(Object o)
public boolean containsAll(Collection<?> c)-----包含指定 collection 中的所有元素
根据下标查元素
E get(int index) -----返回此列表中指定位置上的元素
根据元素查下标
int indexOf(Object o) -----返回此列表中首次出现的指定元素的索引，或如果此列表不包含元素，则返回 -1
int lastIndexOf(Object o) -----返回此列表中最后一次出现的指定元素的索引，或如果此列表不包含索引，则返回 -1
判断集合是否为空
boolean isEmpty()
比较ArrayList
public boolean equals(Object o)-----仅当指定的对象也是一个列表,两列表大小相同，所有元素一样才为true
ArrayList------>数组
Object[] toArray()-----按适当顺序（从第一个到最后一个元素）返回包含此列表中所有元素的数组
<T> T[] toArray(T[] a)-----按适当顺序（从第一个到最后一个元素）返回数组的运行时类型所有元素
获取集合迭代器
public Iterator<E> iterator() -----返回以恰当顺序在此列表的元素上进行迭代的迭代器
public ListIterator<E> listIterator()-----返回此列表元素的列表迭代器（按适当顺序）
public ListIterator<E> listIterator(int index)-----返回从列表的指定位置开始next的列表迭代器
ArrayList集合的字符串表示
public String toString()
通过 String.valueOf(Object) 可以将元素转换成字符串
集合的反转
Collections.reverse(list);反转排序，先输出列表最后一个元素
集合(列表集合) / 数组的排序
方法一：
1、排序的元素类必须实现java.lang.Comparable接口：public interface Comparable<T>
此接口强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的 compareTo 方法被称为它的自然比较方法
2、对象列表（和数组）可以通过 Collections.sort（和 Arrays.sort）进行自动排序。实现此接口的对象可以用作有序映射中的键或有序集合中的元素，无需指定比较器。
例子：
public class User {
private String id;
private int age;
get\set方法略
}
实现 User集合的按年龄排序
public class User implements Comparable<User>{
private String id;
private int age;
get\set方法略
public int compareTo(Object o) { //实现Comparable 接口的排序方法
// return this.age - ((User) o).getAge(); //对int类型属性排序
return this.getName().compareTo(((User) o).getName());//对String属性排序
}
}
ArrayList<User> list=new ArrayList<User>();
list .add(user);
Collections.sort(list); //集合元素升序排序
Collections.sort(list, Collections.reverseOrder());//集合元素降序排列
User[] users = new User[] { new User("a", 30), new User("b", 20) };
Arrays.sort(users); //数组排序
方法二：
1、实现一个java.util.Comparator接口
2、
public class User implements Comparator<Person >{
public int compare(Person o1, Person o2) {
return o1.getAge() - o2.getAge();
}
}
ArrayList<User> list=new ArrayList<User>();
list .add(user);
Comparator<Person> ascComparator = new User(); //创建升序对象
Collections.sort(list, ascComparator);// 利用Collections类静态工具方法对集合List进行排序
Comparator<Person> descComparator = Collections .reverseOrder(ascComparator);// 从升序排序对象产生一个反转(降序)的排序对象
Collections.sort(list, descComparator);
常用方法：
集合复制，java默认的复制规则是浅层复制(即只复制了集合里的对象引用，并没有复制集合里对象的本身)
集合复制有2种方式：
1、clone()-----是Object定义的 //只能复制本类型
ArrayList<Foo> list = new ArrayList<Foo>();
ArrayList<Foo> list = (ArrayList<Foo>) list.clone();
2、复制构造器 //可在不同类型的集合间复制（继承自Map的集合同继承自Collection的集合不能相互复制，结构不同）
Map map = new HashMap(); --------Map map2 = new HashMap(map);
List list = new ArrayList();--------List list2 = new LinkedList(list);
--------LinkedList<Foo> list2 = new LinkedList<Foo>(list);
--------HashSet<Foo> set = new HashSet<Foo>(list);
集合增删改查操作：
ArrayList list = new ArrayList();
list.add("tom");
list.add(new Date());
list.remove("tom");//按对象删除，默认调用equals()比较 （remove()方法是有返回值的，返回被删除的元素）
list.remove(0); //按序号删除
list.set(0,"king");//将第一个对象修改为“king”
int i=list.indexOf("tom");//查询"tom"元素的下标
集合和集合之间的操作：（和、交、差）
list.addAll(list2); //将两集合合并
list.removeAll(list2); //将list中和list2相同的元素删除
list.retainAll(list2); //将list中和list2相同的元素保留
list.isEmpty(); //判断是否为空集 （空集和null不一样）
数组------〉List
String[] names = {"A","B","C"};
List list = Arrays.asList(names); //list是只读list，不能增删操作
list = new ArrayList(list); //复制为全功能list，可以增删读操作
Set set = new HashSet(list); //
集合-------〉数组
集合转为Object[]:
Object[] ary = list.toArray();
集合转为指定类型数组：
String[] ary = (String[])list.toArray(new String[]{});
集合迭代：
是一种遍历算法
1) java 使用 Iterator 接口描述了迭代模式操作Iterator 中的方法，与门为 while 循环设计
2) Iterator 的实例可以从集合对象获得，是这个集合的一个元素序列视图，默认包含一个操作游标（在第一个元素之前）
? hasNext()方法，可以检查游标是否有下一个元素
? next() 方法，移动游标到下一个元素，并丏返回这个元素引用使用 while 循环配合这个两个方法, 可以迭代处理集合的所有元素
3) 迭代时可以使用迭代器 remove() 方法删除刚刚迭代的元素在迭代过程中
? 迭代时不能使用集合方法(add, remove, set) 更改集合元素！
Collection<String> eggs = new HashSet<String>();
egg.add("鸡蛋");
egg.add("鸭蛋");
Iterator<String> it = eggs.iterator();//it是eggs的集合的视图（另一种外观）
it =["鸡蛋" ,"鸭蛋"] //it是顺序结构，含有一个游标，在第一个元素之前
while(it.hasNext()){ //检查当前游标是否有下一个
String egg = it.next(); //移动游标，返回下一个
}
hasNext()和 next()方法是模式化的，配合 while 循环使用
注意：每调用一次 next()，游标会向后移动一位
remove()方法一定要在 next()方法后执行，删除的是 next()返回的元素
集合的工具类 Collections **
同数组的工具类 Arrays 相同，集合的工具类为 Collections，其中提供了许多的方法，诸如排序、
二分查找、打乱、填充等操作。
排序：
Collections.sort(new ArrayList());
二分法查找：
int index = Collctions.binarySearch(new ArrayList(),要查找的对象);
乱序：
Collctions.shuffle(new ArrayList());
Comparable 和 Comparator *
Comparable
1、 表示可以比较的（用于类实现）
2、 实现这个接口表示：这个类的实例可以比较大小，可以进行自然排序
3、 conpareTo() 返回正数表示大, 返回负数表示小, 返回 0 表示相等
4、 Comparable 的实现必须不 equals() 的结果一致，就是相等的对象时候, 比较结果一定是 0！
Comparator
1、 比较工具
2、 用于临时定义比较规则，丌是默认比较规则
1)String 重写的compareTo()方法：
int a ="Tom".compateTo("Jerry");
2)按自定义比较规则排序：
class ByLength implements Comparator<String>{
public int compare(String o1 ,String o2){
return -(o1.length() - o2.length());
}
}
List<String> names = new ArrayList<String>();
names.add("Tom");
names.add("Toms");
ByLength byLength =new ByLength();
Collections.sort(names,byLength);
set集合
map集合
HashMap 还有一些常用方法，请参照 API 练习
? clear()
? containsKey(Object key)
? containsValue(Object value)
? get()
? isEmpty()
? keySet() 返回所有的 key（注意：返回值都放入 set 集合中）
? put(key , value) 向 Map 中加入元素
? remove(Object o)
? size()
Map迭代：
对 key 进行迭代 map.keySet();
对 value 进行迭代 map.values();
对 key:value 进行迭代 map.entrySet();
Set<Character> keys = map.keySet();
Collection<Integer> values = map.values();
Set<Entry<Character,Integer>> entrySet = map.entrySet();//返回键值对集合
ArrayList<Entry<Character,Integer>> list = new ArrayList<Entry<Character,Integer>>(entrySet);//复制为List集合（便于排序）
Collections.sort(list,new ByValue());//按指定规则排序
class ByValue implements Comparator<Entry>{
public int compare(Entry o1,Entry o2){
return (Integer) o2.getValue() - (Integer) o1.getValue();
}
}
Map.Entry 类型 Entry 就是键值对[key：value]，通过 map.entrySet()方法获得
class ByValue{}最好写为静态内部类