集合

集合的由来：
         我们学习的是面向对象语言，而面向对象语言对事物的描述是通过对象体现的，为了方便对多个对象进行操作，我们就必须把这多个对象进行存储。
         而要想存储多个对象，就不能是一个基本的变量，而应该是一个容器类型的变量，在我们目前所学过的知识里面，有哪些是容器类型的呢?
         数组和StringBuffer。但是呢?StringBuffer的结果是一个字符串，不一定满足我们的要求，所以我们只能选择数组，这就是对象数组。
         而对象数组又不能适应变化的需求，因为数组的长度是固定的，这个时候，为了适应变化的需求，Java就提供了集合类供我们使用。
　　

集合和数组的区别：

　　数组---长度固定 存储的是同一类型元素     可以存储几百本数据类型也可以存储引用数据类型

　　集合---长度可变 可以存储不同类型的元素  只能存储引用类型

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():元素的个数

   6:交集功能
          boolean retainAll(Collection c):两个集合都有的元素?思考元素去哪了，返回的boolean又是什么意思呢?
  7：把集合转换为数组
          Object[] toArray()

迭代器-----专门遍历结合的方式

　　Iterator it = c.iterator();
        while (it.hasNext()) {
            Student s = (Student) it.next();
            System.out.println(s.getName() + "---" + s.getAge());}

Collection

　　　List：有序(存储顺序和取出顺序一致),可重复

　　　　　ArrayList      Vector     LinkedList　　　　

　　　Set： 无序(存储顺序和取出顺序不一致),唯一

　　　　　HashSet   TreeSet

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()方法结合使用

　　　for (int x = 0; x < list.size(); x++) {
            String s = (String) list.get(x);
            System.out.println(s);  }

泛型：是一种把类型明确的工作推迟到创建对象或者调用方法的时候才去明确的特殊的类型。参数　　　化类型，把类型当作参数一样的传递。
　　 　ArrayList<String> array = new ArrayList<String>();  <E>

public class ArrayListDemo2 {
    public static void main(String[] args) {
        // 创建集合对象
        // JDK7的新特性：泛型推断。
        // ArrayList<Student> array = new ArrayList<>();
        ArrayList<Student> array = new ArrayList<Student>();

        // 创建元素对象
        Student s1 = new Student("曹操", 40); // 后知后觉
        Student s2 = new Student("蒋干", 30); // 不知不觉
        Student s3 = new Student("诸葛亮", 26);// 先知先觉

        // 添加元素
        array.add(s1);
        array.add(s2);
        array.add(s3);

        // 方式1迭代器遍历
        Iterator<Student> it = array.iterator();
        while (it.hasNext()) {
            Student s = it.next();
            System.out.println(s.getName() + "---" + s.getAge());
        }
        System.out.println("------------------");
　　　　　//方式2 size()+get()遍历
        for (int x = 0; x < array.size(); x++) {
            Student s = array.get(x);
            System.out.println(s.getName() + "---" + s.getAge());
        }
    }
}

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()

(2)HashSet集合(掌握)
        A:底层数据结构是哈希表(是一个元素为链表的数组)
        B:哈希表底层依赖两个方法：hashCode()和equals()
          执行顺序：
            首先比较哈希值是否相同
                相同：继续执行equals()方法
                    返回true：元素重复了，不添加
                    返回false：直接把元素添加到集合
                不同：就直接把元素添加到集合
        C:如何保证元素唯一性的呢?
            由hashCode()和equals()保证的
        D:开发的时候，代码非常的简单，自动生成即可。
        E:HashSet存储字符串并遍历
        F:HashSet存储自定义对象并遍历(对象的成员变量值相同即为同一个元素)
    (3)TreeSet集合
        A:底层数据结构是红黑树(是一个自平衡的二叉树)
        B:保证元素的排序方式
            a:自然排序(元素具备比较性)
                让元素所属的类实现Comparable接口
            b:比较器排序(集合具备比较性)
                让集合构造方法接收Comparator的实现类对象
        C:把我们讲过的代码看一遍即可

Collection
          List    有序,可重复
            　　　ArrayList
              　　　　　　  底层数据结构是数组，查询快，增删慢。
              　　　　　　  线程不安全，效率高
            　　　Vector
               　　　　　　 底层数据结构是数组，查询快，增删慢。
               　　　　　　 线程安全，效率低
            　　  LinkedList
               　　　　 　　 底层数据结构是链表，查询慢，增删快。
               　　　　　　  线程不安全，效率高
           Set    无序,唯一
            　　   HashSet
                　　　　　　 底层数据结构是哈希表。
                　　　　　　 如何保证元素唯一性的呢?
                    　　　　　依赖两个方法：hashCode()和equals()
                    　　　　　开发中自动生成这两个方法即可
                 　LinkedHashSet
                    　　　　　　底层数据结构是链表和哈希表
                    　　　　　　由链表保证元素有序
                    　　　　　　由哈希表保证元素唯一
            　     TreeSet
               　　　　　　　 底层数据结构是红黑树。
                　　　　　　　如何保证元素排序的呢?
                   　　　　　　 自然排序
                  　　　　　　  比较器排序
                　　　　　　    如何保证元素唯一性的呢?
                    　　　　　　根据比较的返回值是否是0来决定

　　ArrayXxx:　　底层数据结构是数组，查询快，增删慢
   　LinkedXxx:　  底层数据结构是链表，查询慢，增删快
       HashXxx:       底层数据结构是哈希表。依赖两个方法：hashCode()和equals()
       TreeXxx:        底层数据结构是二叉树。两种方式排序：自然排序和比较器排序

Collection和Collections的区别?

　　Collections:是针对集合进行操作的工具类，都是静态方法。
 　   Collection:是单列集合的顶层接口，有子接口List和Set。
       Collections:是针对集合操作的工具类，有对集合进行排序和二分查找的方法

Map集合

Map集合的一个最大的特点，就是它可以存储键值对的元素

Map集合和Collection集合的区别?
          Map集合存储元素是成对出现的，Map集合的键是唯一的，值是可重复的。可以把这个理解为：夫妻对
          Collection集合存储元素是单独出现的，Collection的儿子Set是唯一的，List是可重复的。可以把这个理解为：光棍(11.11)
 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()：返回集合中的键值对的对数

public class MapDemo3 {
    public static void main(String[] args) {
        // 创建集合对象
        Map<String, String> map = new HashMap<String, String>();

        // 创建元素并添加到集合
        map.put("杨过", "小龙女");
        map.put("郭靖", "黄蓉");
        map.put("杨康", "穆念慈");
        map.put("陈玄风", "梅超风");

        // 遍历
        // 获取所有的键
        Set<String> set = map.keySet();
        // 遍历键的集合，获取得到每一个键
        for (String key : set) {
            // 根据键去找值
            String value = map.get(key);
            System.out.println(key + "---" + value);
        }
    }
}

HashMap:是基于哈希表的Map接口实现。
 哈希表的作用是用来保证键的唯一性的。

TreeMap:是基于红黑树的Map接口的实现

Hashtable和HashMap的区别?
 * Hashtable:线程安全，效率低。不允许null键和null值
 * HashMap:线程不安全，效率高。允许null键和null值