黑马程序员——集合篇

------- android培训、java培训、期待与您交流！ ----------

集合概述

1.集合的由来

        集合有时又称为容方法。Java集合是多个对象的容方法，容方法里放了N多对象。集合被用于存储、获取、操纵和传输聚合的数据。简单来说，集合就是对象的容器。

        其实，数组也可以存储引用类型，称之为对象数组。但是数组的长度固定，不适合做变化的需求，所以Java就提供了集合供我们使用。

2.集合和数组的区别

        ①:长度区别

            数组固定

            集合可变

        ②:内容区别

            数组可以是基本类型，也可以是引用类型

            集合只能是引用类型

        ③:元素内容

            数组只能存储同一种类型

            集合可以存储不同类型(其实集合一般存储的也是同一种类型)

集合框架

        由于需求不同，Java就提供了不同的集合类。这多个集合类的数据结构不同，但是，它们肯定有共性的内容（存储、获取、判断等）。

        通过不断的向上提取，最终就形成了集合的继承体系结构图。

        

Collection接口

1.Collection接口概述

        Collection接口是Java集合框架的最顶层接口，它提供了大量的通用的集合操纵方法。

        Collection接口是List接口和set接口的父接口。

2.Collection接口的基本操作

        Collection接口的基本操作有六个。

        ①.int size()返回此 collection 中的元素数

        ②.boolean isEmpty()如果此 collection 不包含元素，则返回 true

        ③.boolean contains(Object o)如果此 collection 包含指定的元素，则返回 true

        ④.boolean add(E o)确保此 collection 包含指定的元素(可选操作)

        ⑤.boolean remove(Object o)从此 collection 中移除指定元素的单个实例，如果存在的话（可选操作）

        ⑥. Iterator<E> iterator()返回在此 collection 的元素上进行迭代的迭代器

3.Collection接口的批量操作

        批量操作是指在整个集合上的操作，下面是批量操作的一些方法。

        ①.boolean addAll(Collection<? extends E> c)将指定 collection 中的所有元素都添加到此 collection 中（可选操作）。

        ②.void clear()移除此 collection 中的所有元素（可选操作）。

        ③.boolean containsAll(Collection<?> c)如果此 collection 包含指定 collection 中的所有元素，则返回 true。 

        ④.boolean removeAll(Collection<?> c)移除此 collection 中那些也包含在指定 collection 中的所有元素（可选操作）。 

        ⑤.boolean retainAll(Collection<?> c)仅保留此 collection 中那些也包含在指定 collection 的元素（可选操作）。

4.Collection接口的数组操作

        数组操作允许Collection中的内容被转换到一个数组中去。

        ①.Object[] toArray()返回包含此 collection 中所有元素的数组。 

        ②.<T> T[] toArray(T[] a)返回包含此 collection 中所有元素的数组；返回数组的运行时类型与指定数组的运行时类型相同。

5.Collection集合的遍历

        要遍历Collection集合中的元素，有三种方法：把集合转数组进行遍历，使用for-each结构，或者通过Iterator()迭代方法。

        ①.把集合转数组进行遍历。通过集合的toArray()方法 ，可以把集合转成数组，然后使用普通for循环进行遍历。  

// 遍历// Object[] toArray():把集合转成数组，可以实现集合的遍历Object[] objs = c.toArray();for (int x = 0; x < objs.length; x++) {// System.out.println(objs[x]);// 我知道元素是字符串，我在获取到元素的的同时，还想知道元素的长度。// System.out.println(objs[x] + "---" + objs[x].length());// 上面的实现不了，原因是Object中没有length()方法// 我们要想使用字符串的方法，就必须把元素还原成字符串// 向下转型String s = (String) objs[x];System.out.println(s + "---" + s.length());}

        ②.使用for-each结构。for-each结构允许使用for循环简洁地遍历一个集合或数组。

//遍历for(Object o : c){System.out.println(o);}

        ③.通过Iterator()迭代方法。通过调用集合的Iterator()方法来获得集合的迭代方法，迭代方法是一个对象，通过它可以遍历一个集合并从集合中有选择的移除元素。

             需要注意的是，在迭代期间，Itreator.remove是修改集合的唯一安全方法。

while (it.hasNext()) {// System.out.println(it.next());String s = (String) it.next();System.out.println(s);}

List接口

1.List接口概述

        List是一个有序的集合（有时被称为序列）。List存储顺序和取出顺序一致，可以包含重复的元素。

2.List接口的操作

        除了从Collection继承过来的的操作之外，List接口还包括一下操作。

        ①.void add(int index, E element)在列表的指定位置插入指定元素（可选操作）。 

        ②.E get(int index) 返回列表中指定位置的元素。

        ③.int indexOf(Object o)返回列表中首次出现指定元素的索引，如果列表不包含此元素，则返回 -1。

        ④.int lastIndexOf(Object o)返回列表中最后出现指定元素的索引，如果列表不包含此元素，则返回 -1。

        ⑤.E remove(int index)移除列表中指定位置的元素（可选操作）。

        ⑥.E set(int index, E element)用指定元素替换列表中指定位置的元素（可选操作）。 

        ⑦.ListIterator<E> listIterator()返回列表中元素的列表迭代器（以正确的顺序）。

        ⑧.ListIterator<E> listIterator(int index)返回列表中元素的列表迭代器（以正确的顺序），从列表的指定位置开始。 

3.List集合的遍历

        遍历Collection集合中元素的三种方法，同样可以用来遍历List集合中的元素。

        除此之外，List集合还有两种特有遍历方法：通过 listIterator()迭代方法，或者由size()和get()结合。

        ①.通过 listIterator()迭代方法。它允许从前到后地遍历List对象，也可以从后到前的遍历，在迭代期间修改List对象，以及获得 迭代方法的当前位置。

        ②.由size()和get()结合。size()方法可以获取集合中元素的个数，get()方法可以获取指定位置的元素。通过普通for循环对List集合经行遍历。

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

4.List集合的子类

        (1).ArrayList

            ①.特点：底层数据结构是数组，查询快，增删慢。线程不安全，效率高。

            ②.没有特殊功能需要学习。

        (2).Vector

             ①.特点：底层数据结构是数组，查询快，增删慢。线程安全，效率低。

             ②.特殊功能：

                        void addElement(E obj) 将指定的组件添加到此向量的末尾，将其大小增加 1。

                        E elementAt(int index) 返回指定索引处的组件。

                        Enumeration<E> elements() 返回此向量的组件的枚举。

        (3).LinkedList

            ①.特点：底层数据结构是链表，查询慢，增删快。线程不安全，效率高。

            ②.特殊功能：

                        void addFirst(E o) 将给定元素插入此列表的开头。 

                        void addLast(E o) 将给定元素追加到此列表的结尾。

                        E getFirst()返回此列表的第一个元素。 

                        E getLast()返回此列表的最后一个元素。

                        E removeFirst()移除并返回此列表的第一个元素。 

                        E removeLast()移除并返回此列表的最后一个元素。

Set接口

1.Set接口概述

        Set是一个不能包含重复元素的接口，它是数学集合的抽象模型。

2.Set接口的操作

        Set接口是Collection的子接口，只包含从Collection继承过来的方法，包括基本操作和批量操作，只对以下两项经行了修改。

        ①.增加了对add()方法使用的限制，不允许有重复的元素。

        ②.修改了equals()和hashCode()方法的实现，允许对Set实例进行内容上的比较，即使它们的实现类型不同。如果两个Set包含相同的元素，那么它们就是相等的。

3.Set集合的遍历

        Set集合的遍历与Collection集合的遍历方式相同，同样具有三种遍历方式。分别为：把集合转数组进行遍历，使用for-each结构，或者通过Iterator()迭代方法。

4.Set集合的子类

        (1).HashSet

             ①.特点：将元素存储在一个哈希表中，它具有较好的性能实现，然而它不保证迭代的顺序。底层数据结构是哈希表。

             ②.哈希表底层依赖两个方法来确保元素的唯一性：hashCode()和equals()。

                  首先比较哈希值是否相同，如果不同直接把元素添加到集合；如果相同就继续执行equals()，如果不同就添加，相同就不添加。

                  开发中直接生产两个方法即可。

        (2).TreeSet

             ①.特点：将元素存储在一个红黑树中，按元素的值顺序排列，本质上它比HashSet要慢。底层数据结构是红黑树。

             ②.保证元素的排序方式有两种，分别为：自然排序和比较器排序。

                  自然排序让元素所属的类实现Comparable接口。

                  比较器排序让集合构造方法接收Comparator的实现类对象。

        (3).LinkedHashSet

            ①.特点：作为一个哈希表实现的，用链表连接这些元素，按元素的插入顺序排列。底层数据结构是链表和哈希表。

            ②.由链表保证元素有序，由哈希表保证元素唯一。

Map接口

1.Map接口概述

        Map是一种包含键值对的元素的集合。Map不能包含重复的键，每个键最多可映射到一个值。它是数学函数的抽象模型。

2.Map和Collection的区别

        ①.Map存储的是键值对形式的元素，键唯一，值可以重复。可以比喻成夫妻对。

        ②.Collection存储的是单独出现的元素，子接口List元素可重复，子接口Set元素唯一。可以比喻成光棍。

3.Map接口的基本操作

        Map接口的基本操作有七个。

        ①.V put(K key, V value)将指定的值与此映射中的指定键相关联（可选操作）。  

        ②.V get(Object key)返回此映射中映射到指定键的值。

        ③.boolean containsKey(Object key)如果此映射包含指定键的映射关系，则返回 true。

        ④.boolean containsValue(Object value)如果此映射为指定值映射一个或多个键，则返回 true。

        ⑤.int size()返回此映射中的键-值映射关系数。

        ⑥.boolean isEmpty()如果此映射未包含键-值映射关系，则返回 true。 

        ⑦.V remove(Object key)如果存在此键的映射关系，则将其从映射中移除（可选操作）。

4.Map接口的批量操作

        Map接口的批量操作有主要有两个。

        ①.void clear()从此映射中移除所有映射关系（可选操作）。

        ②.void putAll(Map<? extends K,? extends V> t)从指定映射中将所有映射关系复制到此映射中（可选操作）。

5.Map接口的视图操作

        Map接口的视图操作主要有三个。

        ①.Set<K> keySet()返回此映射中包含的键的 set 视图。 

        ②.Collection<V> values()返回此映射中包含的值的 collection视图。

        ③.Set<Map.Entry<K,V>> entrySet()返回此映射中包含的映射关系的 set 视图。 

6.Map集合的遍历

        要遍历Map集合中的元素，有两种方法：键找值，或者键值对对象找键和值。

        ①.键找值。首先获取所有键的集合，然后遍历键的集合得到每一个键，最后根据键到集合中去找值。

Set<Student> set = tm.keySet();for (Student key : set) {String value = tm.get(key);System.out.println(key.getName() + "---" + key.getAge() + "---"+ value);}

        ②.键值对对象找键和值。首先获取所有键值对对象的集合，然后遍历键值对对象的集合，获取每一个键值对对象，根据键值对对象去获取键和值。

for (HashMap<String, String> hm : array) {Set<String> set = hm.keySet();for (String key : set) {String value = hm.get(key);System.out.println(key + "---" + value);}}

7.Map集合的子类

        Java平台包含三种通用的Map实现：HashMap、TreeMap、LinkedHashMap。它们的行为和执行性能正好与HashSet、TreeSet和LinkedHashSet类似。

        (1).HashMap

         ①.特点：基于哈希表的Map接口实现，用来保证键的唯一性。

        (2).TreeMap

         ①.特点：基于红黑树的Map接口。

Collections类

1.Collections定义及注意事项

        ①.此类是针对集合进行操作的工具类，可以对集合进行排序和查找等。

        ②.此类完全由在 collection 上进行操作或返回 collection 的静态方法组成。

        ③.如果为此类的方法所提供的 collection 或类对象为 null，则这些方法都会抛出 NullPointerException。

2.常见方法

        ①.void  sort(List<T> list)根据元素的自然顺序 对指定列表按升序进行排序。 

        ②.void  sort(List<T> list, Comparator<? super T> c)根据指定比较器产生的顺序对指定列表进行排序。

        ③.int  binarySearch(List<?> list,T key)使用二进制搜索算法来搜索指定列表，以获得指定对象。

        ④.T  max(Collection<?> coll)根据元素的自然顺序，返回给定 collection 的最大元素。

        ⑤.static void reverse(List<?> list)反转指定列表中元素的顺序。

        ⑥.static void shuffle(List<?> list)使用默认随机源随机更改指定列表的序列。

扩展知识

        在TreeSet中，保证元素的排序方式有两种，分别为：自然排序和比较器排序。

        ①. 自然排序让元素所属的类实现Comparable接口。

        ②.比较器排序让集合构造方法接收Comparator的实现类对象。

        接下来就分析一下Comparable接口和Comparator接口。

1.Comparable接口

        ①.此接口强行对实现它的每个类的对象进行整体排序。此排序被称为该类的自然排序，类的 compareTo 方法被称为它的自然比较方法。

        ②.实现此接口的对象列表（和数组）可以通过Collections.sort(和Arrays.sort)进行自动排序。

        ③.定义在类的内部，重写compareTo()方法。

        ④.方法调用Collections.sort(List<T> list) 或Arrays.sort(int[] a)

public class Student implements Comparable<Student> {private String name;private int age;@Overridepublic int compareTo(Student s) {int num = this.age - s.age;int num2 = num == 0 ? this.name.compareTo(s.name) : num;return num2;}

2.Comparator接口

        ①.比较函数强行对某些对象 collection 进行整体排序。可以将 Comparator 传递给 sort 方法（如 Collections.sort），从而允许在排序顺序上实现精确控制。

        ②.还可以使用 Comparator 来控制某些数据结构（如 TreeSet 或 TreeMap）的顺序。

        ③.定义在类的外部，重写compare()方法和equals()方法。

        ④.方法调用Collections.sort(List<T> list, Comparator<? super T>c) 

Collections.sort(list, new Comparator<Student>() {@Overridepublic int compare(Student s1, Student s2) {int num = s2.getAge() - s1.getAge();int num2 = num == 0 ? s1.getName().compareTo(s2.getName()): num;return num2;}});