集合Collection接口:
 Collection c1=new ArrayList();    -->创建一个可变数组
 List和set都属于Collection接口里面的 *Map属于另一个接口
 Collection有一个工具类叫Collections 比他多一个s 里面有提供很多方法如吧线程改成安全的

集合:ArrayList可变数组:
  List  list1=new ArrayList(); -->底层数组 查询快
  List li=new LinkedList();   -->底层链表 插入删除快 无序
   -->Arraylist 初始化长度为10,后面长度不够<默认为扩容1.5倍> 同时将数组复制到新的数组中 条件允许开发中使用带参的构造器确认数组长度
   -->8.0版本之后刚刚创建开始是 空{}  在add操作之后才开始创建 长度为10的操作 这样子可以节约内存
   -->LinkedList无序可变数组 -->底层采用的是双向链表结构 频繁的插入和删除调用它最好  因为下面需要频繁的操作指针所以只需要添加不需要频繁修改 的话使用ArrayList比较快

 添加插入：
   list1.add(a);       -->添加
   list.add(1,"我好"); -->在指定下标插入
   list.addAll(list1);-->吧另一个可变数组添加到此数组后面
 删除：
  list1.remove(2);       -->移除指定下标
  list1.remove("你好");  -->移除指定元素
  list1.removeAll(coll);-->查找2个重复的如果相同就不输入相同的
 修改：
  list1.set(1, "你好"); -->修改  指定坐标的值
 查询：
   list1.get(1)                    -->查询下标为1对应的东西
   int a= list1.indexOf("你好")    -->查找"你好"对于的下标->如果不存在返回-1
   int a=list.lastIndexOf("123"); -->查找"123"最后一次出现的位置->如果不存在返回-1
   List l1=list.subList(0,3);     -->获取下标0到3位置下的值
   list1.retainAll(c2);           -->查找相同的,输出出来并且修改完成之后list1就为相同的了
   list1.removeAll(c1);           -->查找2个重复的如果相同就不输入相同的[你好, 4] 并且修改完成之后list1就里面就存储2个相同的
 转换：
   Object[] objects = list1.toArray();    -->集合转换成数组
   List list= Arrays.asList(new Integer[]{123,123}); -->吧数组转换成集合

遍历1：
iterator()-->遍历操作 每次调他都会返回迭代器开头  -> Iterator 迭代器，再次调用他将会吧指针返回到初始化位置0
{
  -> Iterator iterator = list.iterator(); -->集合的遍历迭代器为0
        while(iterator.hasNext()) -->判断hasNext元素指针下一个是否有元素
        {
            iterator = list1.iterator(); -->返回到指针开始
            System.out.println(iterator.next()); -->输出元素   next 是指针下移
            iterator.remove();-->删除元素
        }
}
遍历2：
list1.forEach(System.out::println); -->新的遍历方法java8新特性
遍历3：
for(Object O:list1)
{
  System.out.println(O);
}

集合:LinkedList
 List list=new LinkedList();
for (Object e:list)  -->增强for循环 前面是类型后面是需要循环的值

Set接口:
Set s1=new HashSet();   -->按照类型来排序
Set s1=new LinkedHashSet(); -->按照输入顺序排序
Set s1=new TreeSet(); -->按照输入顺序排序 ,根据第一个类型判别后面所有类型

< map = new HashMap<>()>底层调用了此
-->
-->1.不可重复:是指地址值不可重复  如果有重复只输出一次,
-->2.无序性不等于随机性  存储的数据在地址也中并非按照索引顺序添加的.
-->3.底层采用链表加数组 通过哈希表  先通过计算哈希值判断位置然后找到数组位置 位置上如果没有值就直接放进去,
-->如果有值哈希值相同就比较equas值， 如果值也相同就残忍抛弃，如果不相同就添加上用链表连接，下一个值进来的时候有会判断上一个和本值是否不一样如果不一样也放进来

Map接口：实现类
  Map map1=new HashMap();  -->1
  Map map2=new LinkedHashMap();-->2
  Map map3=new TreeMap();  -->3
  Map map3=new Hashtable();-->4  --废弃方法,古老实现类线程不安全  不可以存储null的key和value

  <1>主要实现类,线程不安全,效率高,可以存储null的key和value ->底层采用数组加链表(java7)  (java8)之后采用数组+链表+红黑树
  <2>保证遍历map元素时key,按照顺序执行遍历,底层有(双向链表) ->对于频繁的遍历操作 效率高于HashMap
  <3>保证按照添加发的key——value 对于进行排序,实现排序遍历,底层使用(红黑树)
  <4>Properties 子类  常用来处理配置文件 底层key value都是string类型的

    -->HashMap 是一个散列表，它存储的内容是键值对(key-value)映射。
    -->HashMap 实现了 Map 接口，根据键的 HashCode 值存储数据，具有很快的访问速度，最多允许一条记录的键为 null，不支持线程同步。
    -->HashMap 是无序的，即不会记录插入的顺序。
    -->HashMap 继承于AbstractMap，实现了 Map、Cloneable、java.io.Serializable 接口。

Map接口：方法
添加:
map1.put("AA",111);-->添加
删除：
map1.remove("AA");  -->移除所对应的key和value
修改：
map1.put("AA",444); -->如果key一样那么修改后面对于的值为444
查询：
Object var=map1.remove("BB");  -->接收到BB所对应的value, 不存在放回null <删除>
Object var=map1.get("AA");    -->返回key“AA”所对应的value,不存在返回null
Object var=map1.size();      -->返回key“AA”所对应的长度

bool b=containsKey() 方法检查 hashMap 中是否存在指定的 key 对应的映射关系。
如果 hashMap 中是否存在指定的 key 对应的映射关系返回 true，否则返回 false。

-->遍历
Set set = map1.keySet(); -->对于的所有key值
Collection values = map1.values(); -->对应所有的value值
Set set2 = map1.entrySet();-->对应的所有的set和对应的vlue值

容器:Collections工具类
    Collections.reverse(li);     -->反转数组
    Collections.sort(li);       -->对集合进行自然排序
    Object obj=Collections.max(li);  -->返回元素中最大的值
    Object obj=Collections.frequency(li,21); -->返回元素中21出现的次数

    Collections.synchronizedXXXX(li)               -->返回一个线程安全的对象;
    List list = Collections.synchronizedList(li); -->返回一个List安全对象
    Set set=Collections.synchronizedSet(l2);     -->返回一个Set安全对象
    Map map=Collections.synchronizedMap(l3);    -->返回一个Map安全对象