集合collection

* 集合的由来：
 * 我们学习的是面向对象语言，而面向对象语言对事物的描述是通过对象体现的，为了方便对多个对象进行操作，我们就必须把这多个对象进行存储。
 * 而要想存储多个对象，就不能是一个基本的变量，而应该是一个容器类型的变量，在我们目前所学过的知识里面，有哪些是容器类型的呢?
 * 数组和StringBuffer。但是呢?StringBuffer的结果是一个字符串，不一定满足我们的要求，所以我们只能选择数组，这就是对象数组。
 * 而对象数组又不能适应变化的需求，因为数组的长度是固定的，这个时候，为了适应变化的需求，Java就提供了集合类供我们使用。
 * 
 * 数组和集合的区别?
 * A:长度区别
 * 数组的长度固定
 * 集合长度可变
 * B:内容不同
 * 数组存储的是同一种类型的元素
 * 而集合可以存储不同类型的元素
 * C:元素的数据类型问题
 * 数组可以存储基本数据类型，也可以存储引用数据类型
 * 集合只能存储引用类型
 * 
 * 刚说过集合是存储多个元的，但是呢，存储多个元素我们也是有不同需求的：比如说，我要这多个元素中不能有相同的元素，
 * 再比如说，我要这多个元素按照某种规则排序一下。针对不同的需求，Java就提供了不同的集合类，这样呢，Java就提供了很多个集合类。
 * 这多个集合类的数据结构不同,结构不同不重要的，重要的是你要能够存储东西，并且还要能够使用这些东西，比如说判断，获取等。
 * 既然这样，那么，这多个集合类是有共性的内容的，我们把这些集合类的共性内容不断的向上提取，最终就能形成集合的继承体系结构。
 * 
 * 数据结构：数据的存储方式。
 * 
 * Collection:是集合的顶层接口，它的子体系有重复的，有唯一的，有有序的，有无序的。(后面会慢慢的讲解)
 * 
 * Collection的功能概述：
 * 1：添加功能
 * boolean add(Object obj):添加一个元素
 * boolean addAll(Collection c):添加一个集合的元素
 * 2:删除功能
 * void clear():移除所有元素
 * boolean remove(Object o):移除一个元素
 * boolean removeAll(Collection c):移除一个集合的元素(是一个还是所有)
 * 3:判断功能
 * boolean contains(Object o)：判断集合中是否包含指定的元素
 * boolean containsAll(Collection c)：判断集合中是否包含指定的集合元素(是一个还是所有)
 * boolean isEmpty()：判断集合是否为空
 * 4:获取功能
 * Iterator<E> iterator()(重点)
 * 5:长度功能
 * int size():元素的个数
 * 面试题：数组有没有length()方法呢?字符串有没有length()方法呢?集合有没有length()方法呢?
 * 6:交集功能
 * boolean retainAll(Collection c):两个集合都有的元素，思考元素去了调用对象中，返回的boolean表示调用对象中的值发生改变就返回true，
 * 7：把集合转换为数组

 * Object[] toArray()

* 集合的遍历。其实就是依次获取集合中的每一个元素。

 Iterator iterator():迭代器，集合的专用遍历方式
 * Object next():获取元素,并移动到下一个位置。
 * NoSuchElementException：没有这样的元素，因为你已经找到最后了。
 * boolean hasNext():如果仍有元素可以迭代，则返回 true。

 * List集合的特点：
 * 有序(存储和取出的元素一致)，可重复的。

* List集合的特有功能：
 * A:添加功能
 * void add(int index,Object element):在指定位置添加元素
 * B:获取功能
 * Object get(int index):获取指定位置的元素
 * C:列表迭代器
 * ListIterator listIterator()：List集合特有的迭代器
 * D:删除功能
 * Object remove(int index)：根据索引删除元素,返回被删除的元素
 * E:修改功能
 * Object set(int index,Object element):根据索引修改元素，返回被修饰的元素

* List集合的特有遍历功能：
 * size()和get()方法结合使用

Object get(int index):获取指定位置的元素

* List集合特有的列表迭代器：
 * ListIterator listIterator()：List集合特有的迭代器
 * 该迭代器继承了Iterator迭代器，所以，就可以直接使用hasNext()和next()方法。
 * 
 * 特有功能：
 * Object previous():获取上一个元素
 * boolean hasPrevious():判断是否有元素
 * 
 * 注意：ListIterator可以实现逆向遍历，但是必须先正向遍历，才能逆向遍历，所以一般无意义，不使用。
 

 * List的子类特点：
 * ArrayList:
 * 底层数据结构是数组，查询快，增删慢
 * 线程不安全，效率高
 * Vector:
 * 底层数据结构是数组，查询快，增删慢
 * 线程安全，效率低
 * LinkedList:
 * 底层数据结构是链表，查询慢，增删快
 * 线程不安全，效率高

* Vector的特有功能：
 * 1：添加功能
 * public void addElement(Object obj)--add()
 * 2：获取功能
 * public Object elementAt(int index)--  get()
 * public Enumeration elements()--Iterator iterator()
 * boolean hasMoreElements()hasNext()
 * Object nextElement()next()
 * 
 * JDK升级的原因：
 * A:安全
 * B:效率
 * C:简化书写

 LinkedList的特有功能：
 * A:添加功能
 * public void addFirst(Object e)
 * public void addLast(Object e)
 * B:获取功能
 * public Object getFirst()
 * public Obejct getLast()//返回得到的值
 * C:删除功能
 * public Object removeFirst() //删除谁返回谁
 * public Object removeLast()

* 泛型：是一种把类型明确的工作推迟到创建对象或者调用方法的时候才去明确的特殊的类型。参数化类型，把类型当作参数一样的传递。
 * 格式：
 * <数据类型>
 * 此处的数据类型只能是引用类型。
 * 好处：
 * A:把运行时期的问题提前到了编译期间
 * B:避免了强制类型转换
 * C:优化了程序设计，解决了黄色警告线

* 泛型在哪些地方使用呢?
 * 看API，如果类，接口，抽象类后面跟的有<E>就说要使用泛型。一般来说就是在集合中使用。

* 早期的时候，我们使用Object来代表任意的类型。
 * 向上转型是没有任何问题的，但是在向下转型的时候其实隐含了类型转换的问题。
 * 也就是说这样的程序其实并不是安全的。所以Java在JDK5后引入了泛型，提高程序的安全性。

* 泛型高级(通配符)
 * ?:任意类型，如果没有明确，那么就是Object以及任意的Java类了
 * ? extends E:向下限定，E及其子类
 * ? super E:向上限定，E极其父类

 JDK5的新特性：自动拆装箱,泛型,增强for,静态导入,可变参数,枚举
 * 
 * 增强for:是for循环的一种。
 * 
 * 格式：
 * for(元素数据类型 变量 : 数组或者Collection集合) {
 * 使用变量即可，该变量就是元素
 *    }
 *   
 * 好处：简化了数组和集合的遍历。
 * 
 * 弊端： 增强for的目标不能为null。
 * 如何解决呢?对增强for的目标先进行不为null的判断，然后在使用。

* 静态导入：
 * 格式：import static 包名….类名.方法名;
 * 可以直接导入到方法的级别
 * 
 * 静态导入的注意事项：
 * A:方法必须是静态的
 * B:如果有多个同名的静态方法，容易不知道使用谁?这个时候要使用，必须加前缀。由此可见，意义不大，所以一般不用，但是要能看懂。

 * 可变参数：定义方法的时候不知道该定义多少个参数
 * 格式：
 * 修饰符 返回值类型 方法名(数据类型…  变量名){
 * 
 * }
 * 
 * 注意：
 * 这里的变量其实是一个数组
 * 如果一个方法有可变参数，并且有多个参数，那么，可变参数肯定是最后一个

* public static <T> List<T> asList(T... a):把数组转成集合
 * 
 * 注意事项：
 * 虽然可以把数组转成集合，但是集合的长度不能改变。

* Collection
 * |--List
 * 有序(存储顺序和取出顺序一致),可重复
 * |--Set
 * 无序(存储顺序和取出顺序不一致),唯一
 * 
 * HashSet：它不保证 set 的迭代顺序；特别是它不保证该顺序恒久不变。
 * 注意：虽然Set集合的元素无序，但是，作为集合来说，它肯定有它自己的存储顺序，
 * 而你的顺序恰好和它的存储顺序一致，这代表不了有序，你可以多存储一些数据，就能看到效果。

* HashSet:存储字符串并遍历
 * 问题：为什么存储字符串的时候，字符串内容相同的只存储了一个呢?
 * 通过查看add方法的源码，我们知道这个方法底层依赖 两个方法：hashCode()和equals()。
 * 步骤：
 * 首先比较哈希值
 * 如果相同，继续走，比较地址值或者走equals()
 * 如果不同,就直接添加到集合中
 * 按照方法的步骤来说：
 * 先看hashCode()值是否相同
 * 相同:继续走equals()方法
 * 返回true： 说明元素重复，就不添加
 * 返回false：说明元素不重复，就添加到集合
 * 不同：就直接把元素添加到集合
 * 如果类没有重写这两个方法，默认使用的Object()。一般来说不同相同。
 * 而String类重写了hashCode()和equals()方法，所以，它就可以把内容相同的字符串去掉。只留下一个。

你使用的是HashSet集合，这个集合的底层是哈希表结构。
 * 而哈希表结构底层依赖:hashCode()和equals()方法。
 * 如果你认为对象的成员变量值相同即为同一个对象的话，你就应该重写这两个方法。
 * 如何重写呢?不同担心，自动生成即可。

* LinkedHashSet:底层数据结构由哈希表和链表组成。
 * 哈希表保证元素的唯一性。
 * 链表保证元素有素。(存储和取出是一致)

* TreeSet：能够对元素按照某种规则进行排序。
 * 排序有两种方式
 * A:自然排序
 * B:比较器排序
 * 
 * TreeSet集合的特点：排序和唯一
 * 
 * 通过观察TreeSet的add()方法，我们知道最终要看TreeMap的put()方法。

* TreeSet存储自定义对象并保证排序和唯一。
 * 
 * A:你没有告诉我们怎么排序
 * 自然排序，按照年龄从小到大排序
 * B:元素什么情况算唯一你也没告诉我
 * 成员变量值都相同即为同一个元素

•使用元素的自然顺序对元素进行排序

•或者根据创建 set 时提供的 Comparator进行排序

•具体取决于使用的构造方法。 

* TreeSet集合保证元素排序和唯一性的原理
 * 唯一性：是根据比较的返回是否是0来决定。
 * 排序：
 * A:自然排序(元素具备比较性)
 * 让元素所属的类实现自然排序接口 Comparable
 * B:比较器排序(集合具备比较性)
 * 让集合的构造方法接收一个比较器接口的子类对象 Comparator

* Map集合的特点：
 * 将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。 
 * 
 * Map集合和Collection集合的区别?
 * Map集合存储元素是成对出现的，Map集合的键是唯一的，值是可重复的。可以把这个理解为：夫妻对
 * Collection集合存储元素是单独出现的，Collection的儿子Set是唯一的，List是可重复的。可以把这个理解为：光棍(11.11)
 * 
 * 注意：
 * Map集合的数据结构值针对键有效，跟值无关
 * HashMap，TreeMap等会讲。
 * Collection集合的数据结构是针对元素有效
 * 
 * Map集合的功能概述：
 * 1:添加功能
 * V put(K key,V value):添加元素。这个其实还有另一个功能?先不告诉你，等会讲
 * 如果键是第一次存储，就直接存储元素，返回null
 * 如果键不是第一次存在，就用值把以前的值替换掉，返回以前的值
 * 2:删除功能
 * void clear():移除所有的键值对元素
 * V remove(Object key)：根据键删除键值对元素，并把值返回
 * 3:判断功能
 * boolean containsKey(Object key)：判断集合是否包含指定的键
 * boolean containsValue(Object value):判断集合是否包含指定的值
 * boolean isEmpty()：判断集合是否为空
 * 4:获取功能
 * Set<Map.Entry<K,V>> entrySet():???
 * V get(Object key):根据键获取值
 * Set<K> keySet():获取集合中所有键的集合
 * Collection<V> values():获取集合中所有值的集合
 * 5：长度功能
 * int size()：返回集合中的键值对的对数

 * 获取功能：
 * V get(Object key):根据键获取值
 * Set<K> keySet():获取集合中所有键的集合
 * Collection<V> values():获取集合中所有值的集合

* Map集合的遍历。
 * Map -- 夫妻对
 * 转换：
 * A:获取所有的键
 * B:遍历键的集合，获取得到每一个键
 * C:根据键去找值

 * Set<Map.Entry<K,V>> entrySet()：返回的是键值对对象的集合

 * LinkedHashMap:是Map接口的哈希表和链接列表实现，具有可预知的迭代顺序。
 * 由哈希表保证键的唯一性
 * 由链表保证键盘的有序(存储和取出的顺序一致)

 * TreeMap:是基于红黑树的Map接口的实现。
 * 
 * HashMap<String,String>
 * 键：String
 * 值：String

* 1:Hashtable和HashMap的区别?
 * Hashtable:线程安全，效率低。不允许null键和null值
 * HashMap:线程不安全，效率高。允许null键和null值
 * 
 * 2:List,Set,Map等接口是否都继承子Map接口?
 * List，Set不是继承自Map接口，它们继承自Collection接口
 * Map接口本身就是一个顶层接口

 Collections:是针对集合进行操作的工具类，都是静态方法。
 * 
 * 面试题：
 * Collection和Collections的区别?
 * Collection:是单列集合的顶层接口，有子接口List和Set。
 * Collections:是针对集合操作的工具类，有对集合进行排序和二分查找的方法
 * 
 * 要知道的方法
 * public static <T> void sort(List<T> list)：排序 默认情况下是自然顺序。
 * public static <T> int binarySearch(List<?> list,T key):二分查找
 * public static <T> T max(Collection<?> coll):最大值
 * public static void reverse(List<?> list):反转
 * public static void shuffle(List<?> list):随机置换