一、collection集合
1，add(E o)添加
2，addAll(Collection<? extends E> c)添加集合
3，clear（）清除所有集合内容
4，contains比较集合中的元素，如果有则返回true（String字符串也存在这种方法，用来判断一个字符串）
5，containsAll比较集合中是否存在一个集合
6，isEmpty如果collection中不包含此元素，则返回true
7，iterator集合迭代器，用来取出集合中的元素Iterator it=list.iterator
8,romove,移除collection集合中的元素
9，removeAll移除collection集合元素中的一个集合
================================
（1）list为collection的子类接口，为有序集合，除了以上方法以外，list独有的方法有
1，get返回列表中的指定位置的元素
2，add(int index, E element)在指定位置插入元素
3，addAll(int index, Collection<? extends E> c）在指定位置插入一个collection的元素
4，set(int index, E element) 替换指定位置的元素（可选操作）。
5，subList(int fromIndex, int toIndex) 截取collection集合中的元素
6，contains(Object o) 用contains方法查找collection中的元素，若有，则返回 true。
7，切记：list为有序接口，若要用角标掉调元素，则可以选择list接口
********************************************
（a） ArrayList
方法基本不变
（b）LinkedList为list的子类方法，其特有方法如下：
1，addFirst(E o) 将给定元素插入此列表的开头
2，addLast(E o)将给定元素追加到此列表的结尾。
3，contains(Object o) 如果此列表包含指定元素，则返回 true。
4，element() 找到但不移除此列表的头（第一个元素）。
5，get(int index) 返回此列表中指定位置处的元素。
6，getFirst() 返回此列表的第一个元素。
7，getLast() 返回此列表的最后一个元素。
8，listIterator(int index)
返回此列表中的元素的列表迭代器（按适当顺序），从列表中指定位置开始
****************************************
（2）set为collection集合中的子类，为无序列表，但是，set的子类接口可以实现有序列表
1，hashCode() 利用哈希码值查找元素速度快，返回 set 的哈希码值
2，isEmpty() 查找collection集合中set列表的元素，切记：如果不包含元素，则返回 true。
3，iterator() collection集合的迭代器，在set方法中去元素只有一种方法就是迭代器方法
Iterator it=set.itrator 返回在此 set 中的元素上进行迭代的迭代器 .
4,包含子类HashSet子类和TreeSet子类
******************************************************
（a）TreeSet为set列表的子类其特有方法
TreeSet必须做 implements Comparable比较器继承
若要按其他比较则需要做其他的比较器
===============================================================
例：比较器：
public class Person implements Comparable<Person> {
public int compareTo(Person obj)
{
Person p=(Person)obj;
int temp=this.age-p.age;
return temp==0?this.name.compareTo(p.name):temp;
}
================================================================
例：比较器：
import java.util.Comparator;
import bean.Person;
public class ComparetorByName implements Comparator<Person> {
public int compare(Person o1, Person o2) {
int temp=o1.getName().compareTo(o2.getName());
return temp==0?o1.getAge()-o2.getAge():temp;
}
}
============================================================================
系统自动生成比较器：
姓名比较：
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + age;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
年龄比较：
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Person other = (Person) obj;
if (age != other.age)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
================================================================
构造一个新的空 set，该 set 按照元素的自然顺序排序。
TreeSet(Comparator<? super E> c) 构造一个新的空 set，该 set 根据指定的比较器进行排序。
此方法需要继承比较器
1，comparator() 返回用于确定已排序 set 顺序的比较器，
或者，如果此树 set 使用其元素的自然顺序，则返回 null。
2，last() 返回已排序 set 中当前的最后一个（最大）元素。
3， first()返回已排序 set 中当前的第一个（最小）元素。
4，根据使用的构造方法不同，可能会按照元素的自然顺序 进行排序
(b)HashSet方法基本与set方法相同
================================================================
map集合Map<K,V>
（1）map集合一次添加一对元素，collection集合一次添加一个元素
所以map集合为双列集合，collection为单列集合
map集合存储的的是键值对
map集合必须保证键的唯一性
常用方法：
1，添加
value put(key ,value);
key与value一一对应，value有值则返回旧值，没有则返回null
返回前一个与key关联的值，没有则返回null
2，删除
void clear（）；
value remove（key):根据指定的key返回键值对
3，判断
boolean containsKey(Key);
boolean containsValue(Value);
boolean isEmpty();
4，获取
value get（key）；通过键获取值，如果没有该键则返回null。
可以通过返回null，来判断是否包含此键（）
（存入k1,v1,通过k1查找v1，可以找到，通过k2查找v2返回null，则此集合中不包含k2）
int size（）获取键值对的个数。
一，keyset map的取出方法一；
原理是，通过keyset方法获取map的所有键所在的set集合，在通过set的迭代器获取每一个键
再对每一个键获取对应的值即可
keySet() 返回此映射中包含的 键 的 set 视图
二，entrySet map的取出方法二；
通过Map转成set就可以迭代
找到另一个方法。entrySet。
该方法将键值映射关系作为对象存储到set集合中，而这个映射关系的类型就是Map.Entry类型（结婚证）
entrySet() 返回此映射中包含的 映射关系 的 set 视图
Entry为 Map的成员接口
Entry规则依附于Map规则，只有Map实现以后才可以调用entry方法
Map.Entry为嵌套接口
三，map.values();可以不通过键而取到所有的值
Collection<String> values=map.values();//返回值为集合所以调用collection
Iterator<String> it= values.iterator();//跌倒得到的String类型的values
while(it.hasNext())
{
System.out.println(it.next());
}
Map的常用子类：（什么叫做同步。什么叫不同步）
Hashtable:内部结构是哈希表，为同步的；表中的键和值不可以为null
Properties ：用来存储键值对型的配置文件的信息可以和IO技术相结合；
HashMap:内部结构为哈希表，为非同步，表中的键和值都可以为null
TreeMap:内部结构是二叉树，可以对内部结构的键进行排序
====================================================================
泛型：（直接收引用数据类型，引用数据类型，不是类就是接口）
JDK1.5以后出现的安全特性
好处：
1.将运行时的问题ClassCastException转到了编译时期（黄色警告）
2.避免了强转的麻烦
<>当应用数据不确定是使用<>,将要操作的数据类型传入即可。
其实<>就是一个用来接收具体引用数据类型的参数范围
void show(int x)
class ArrayList<E>
void show(int x，int y)
class Map<K, V>
在程序中只要用到了带有<>的类或者接口，就要明确传入的具体应用数据类型。
泛型技术是给编译器用的技术，用于编译时期，确保数据类型安全。
************************************************************
运行时会将泛型去掉，生成的class文件不带泛型，叫泛型的擦除
为什么擦除
因为为了兼容运行时的类加载器
泛型的补偿
在运行时，通过获取元素的类型进行转换动作，不用使用者再强制装换了
*************************************************************
集合技巧：
需要唯一元素吗？
需要：set
需要指定顺序吗
需要：TreeSet
不需要：HashSet
但是要想一个和存储一致的顺序（有序）：LinkedSashSet
不需要：List
需要频繁增删吗
需要：LinkedList
不需要：ArrayList
如何记住每个容器的结构和体系：
List：
ArrayList
LinkedList
Set：
HashSet
TreeSet
后缀为集合体系
前缀名为集合的数据结构；
看到Array就要想到数组，查询快有角标
看到link就要想打链表，想到增删快，想到add get remove+first last的方法
看到hash就要想到哈希表，就要想到唯一性，就要想到元素需要覆盖hashcoed方法和equals方法
看到tree就像到二叉树，就要想到排序呢，就要想到两个接口comparable。comparator.
通常常用的集合都是不同步的
vector
========================================================================
List list = new ArrayList();//非同步的；
list= MyCollections.synList(list);//返回一个同步的list
给非同步集合加锁
class MyCollections{
public List synList(List list){
}
private class MyList implements List{
private List list;
private static final Object lock =new Object();
MyList(List list){
this.list=list
}
public boolean add(object obj)
{
return list.add(obj);
}
}
public boolean remove(object obj)
{
synchronized(lock)
{
return list.remove(obj);
}
}
}
}
Collections的方法中已有加锁的方法可以在集合框架的工具类中直接查找调用
synchronizedCollection(Collection<T> c)