黑马程序员_Java基础_前期准备01_3.2

---------------------------------------- JavaEE+云物联、期待与您交流！---------------------------------------------

 

前期准备01-3.2

 

五、集合框架

一个集合的体系。集合就是一个容器，用于操作对象。而每一个集合对数据的存储方式(数据结构)又是不同的，将所有集合的特性不断向上抽取，就形成了集合的体系，即集合框架。

①集合框架概述

❶集合出现的原因

在面向对象的语言中，为了简化对数据的操作，将数据封装进了对象里面，通过操作对象来实现对数据的操作。当对象有很多个的时候，为了简化对对象的操作，就将对象封装进了集合里面，通过操作集合来实现对对象的操作。这里也表现出了面向对象编程封装的特性。

❷集合与数组的区别

两者都可以实现对对象的操作。

数组的特点：容量是固定的，在被定义之后就只能存储一种数据类型。

集合的特点：容量是可变的，能够同时存储多种引用数据类型。集合中只能存储引用数据类型。当集合中添加了基本数据类型时，基本数据类型的值会被自动装箱，存入集合的依然只是一个引用(即地址)。

在集合中，同时存储多种数据类型会有操作风险，可以由泛型来限定。

❸集合框架的使用原则

对于集合的使用，一般的原则是：参阅顶层，创建底层。参阅顶层的原因是，顶层中包含了该体系最基本的功能。创建底层的原因有两个，一是顶层是被不断抽取出来的，有可能不能够创建对象；二是创建底层的对象，可以使用更多的功能。

❹迭代器

集合中元素的取出，使用的是迭代器。类似于对数组的遍历。

凡是实现了Iterable接口的集合，都会具有迭代的功能。

❺集合框架的结构

 

❻集合中的两个分支

Collection：单列集合，其泛型只接受一个参数。

Map：双列集合，其泛型要接受两个参数，是一个键-值对。此集合更常用。

❼创建对象时的注意事项

当需要将对象存入集合中时，必须要一实现，三覆盖。实现Comparable接口，让对象具备比较性(用于二叉树结构)；覆盖hashCode方法和equals方法，让对象具备适合实际需要的哈希值(用于哈希表结构)；覆盖toString方法，让对象具备更容易被理解的字符串表示形式。

❽集合框架的工具类

Collections：其方法全部为静态方法，用于对集合进行操作。

Arrays：其方法全部为静态方法，用于对数组进行操作。

❾泛型/*generic[dʒi'nerik]泛型*/

泛型是JDK1.5版本以后出现的新特性，用于解决安全问题，是一个有关于类型的安全机制。

②泛型概述

❶泛型的格式

<参数>，由参数来定义要操作的引用数据类型。

在自定义泛型时，如果要操作的数据类型不确定，就可以用一个参数来代替。在操作具体数据时，要明确参数的取值，这样可以减少强转的操作。

❷泛型的好处

一是将运行时期出现的问题ClassCastException，提前到了编译时期，方便于将问题解决在编译时期，减少了运行时期出现问题的几率。

二是减少了对类型的强制转换操作。

❸泛型的缺点

泛型一旦被明确了之后，将会像数组一样，只能够操作一种数据类型。在泛型未被确定时，不可以使用特有方法。

❹泛型的应用

对于集合、接口和类的定义，放在其名称的后面；对于方法的定义，放在其返回值类型之前，修饰符之后。泛型方法可以嵌套在泛型类中，被单独定义。

泛型定义在类上，更方便；泛型定义在方法上，更灵活。

❺泛型在继承和实现时的区别

extends：当继承一个由泛型修饰的类时，子类的泛型必须是父类的泛型或者是父类泛型的子类。

implements：当实现一个由泛型修饰的接口时，实现者的泛型一定不能和接口的泛型一致。实现者的泛型可以包含接口的泛型，也可以是接口泛型的子类。实现者也可以没有泛型。

❻泛型的使用原则

当能够明确要操作的具体数据类型时，就可以定义为指定参数类型的泛型。通常用于减少程序运行时的安全隐患。

当只能明确要操作的数据属于某一范围时，也可以定义为泛型。这时要使用泛型的限定。通常用于对程序的扩展。

当不能明确要操作的具体数据类型时，可以使用参数来定义泛型。通常用于提高代码的复用性。在实现具体操作时，要明确具体的参数类型，可以减少强制转换的操作。

❼静态方法的泛型设定

静态方法不可以访问在类上定义的泛型。因为类上的泛型是由对象来确定的，但是静态方法却优先于对象而存在。如果静态方法操作的数据类型不确定，就只能够将泛型定义在方法上。

❽泛型中的通配符(占位符)

通常用于对泛型不确定的时候。

❾泛型的限定

当对泛型的使用有确定的区间时，可以使用泛型的限定。泛型限定分为向上限定和向下限定。向上限定用，只能接受父类及其子类的对象(多态的应用，父类引用可以接收子类对象)，这时泛型强调的是对象；向下限定用，只能接受自身及其父类的引用(多态的应用，子类对象的类型被向上转型)，这时泛型强调的是引用。

③Collection/*[kə'lekʃn]集合*/接口

public interface Collection

extends Iterable/*['itərəbl]可迭代的*/

❶成员方法：

public boolean add(E e)/*[æd]添加*/

添加此collection所指定类型的元素。如果此集合被成功添加内容，则返回true。(如果此集合不允许有重复元素，并且已经包含了指定的元素，依然返回false)

public boolean addAll(Collection c)

将传入集合中的所有元素都添加到此collection中。规则同上。

public void clear()/*[kliə]清除*/

清除此collection中的所有元素。

public boolean contains(Object o)

如果此collection中包含指定的元素，则返回true。更确切的讲，当且仅当此collection至少包含一个(o==null ? e==null:o.equals(e))的元素e时，返回true。Contains方法底层调用的是equals方法。

public boolean containsAll(Collection c)

如果此collection中包含指定的collection中的所有元素，则返回true。

public boolean equals(Object o)

比较此collection与指定对象是否相等。

public int hashCode()

返回此collection的哈希码值。

public boolean isEmpty()/*['empti]空的*/

如果此collection中不包含任何元素，则返回true。

public Iterator iterator()/*[itə'reitə]迭代器*/

返回在此collection的元素上进行迭代的迭代器。

public boolean remove(Object o)/*[ri'mu:v]移除*/

从此collection中移除指定元素的单个实例引用，并且只是移除一个。如果该集合中允许出现重复元素，则只是移除第一个符合条件的元素。更确切的讲，如果此collection中包含元素e(o==null ? e==null:o.equals(e))，则移除第一个符合条件的元素。remove底层调用的是equals方法。

public boolean removeAll(Collection c)

移除此collection中那些也包含在指定collection中的所有元素。此调用返回后，此collection中将不包含任何与指定的collection所相同的元素。

public boolean retainAll(Collection c)/*[ri'tein]保留*/

仅保留此collection中那些同时也包含在指定collection中的元素。即此集合中只保留两个集合的交集。

public int size()

返回此collection中的元素的个数。

public Object[] toArray()

返回包含此collection中所有元素的数组。如果collection对其迭代器返回元素的顺序做出了某些保证，那么此方法必须以相同的顺序返回这些元素。调用者可以任意修改返回的数组，数组是独立的。

public T[] toArray(T[] a)

返回包含此collection中所有元素的数组。如果指定的数组能容纳该collection中的元素，则返回指定数组。否则，将分配一个具有与指定数组相同类型，并且与此collection的size相同大小的新数组。当指定数组的容量大于collection.size()时，第collection.size()位将被置为null。

此处的数组的长度应定义为collection.size()，是最合适的。

❷Collection的两个子接口

对于List集合，其中的元素是有序的(存入和取出的顺序是一致的)，并且元素可以重复，因为该集合体系有索引。

对于Set集合，其中的元素是无序的(存入和取出的顺序不一定一致)，并且元素不可以重复。

④Iterable接口

public interface Iterable

成员方法：

public Iterator iterator()

返回一个在一组T类型的元素上进行迭代的迭代器。T的类型由调用者来确定。

⑤Iterator/*[itə'reitə]迭代器*/接口

public interface Iterator

❶成员方法：

public boolean hasNext()/*[hæz]有[nekst]下一个*/

如果仍有元素可以迭代，则返回true。

public E next()

返回被迭代的下一个元素。在迭代时，必须取一次就要判断一次。

public void remove()

从迭代器指向的collection中,移除迭代器返回的最后一个元素。每次调用next方法后，只能调用此方法一次。

❷迭代器是以内部类的方式，被定义在集合内部的，这样会更方便其对集合中各个元素的访问。集合对外提供了调用其自身迭代器的方法iterator()，当需要取出集合中的元素时，直接调用该方法即可。

❸对于迭代器的使用，用for循环更能优化内存，用while循环更直观。

当用迭代器对当前集合中的元素进行迭代操作时，就不可以再用集合的方法操作被迭代的元素，否则将会发生并发修改异常。在迭代时只能用迭代器的方法操作被迭代的元素。

❹迭代过程中的比较：如果在迭代过程中需要进行对象间的比较，此时调用的是Object中的equals方法，比较的是对象的地址。若想重新设定比较的方式，对于ArrayList集合来说，只需要覆盖Object中的equals(Object obj)方法即可。对于HashSet集合来说，除了要覆盖equals方法之外，还要覆盖hashCode方法。因为HashSet集合的比较是以hashCode为主，equals为辅。

Set集合为了保证集合中元素的唯一性，在添加元素的时候，也是需要进行比较的。

⑥ListIterator/*[list]列表[itə'reitə]迭代器*/

public interface ListIterator

extends Iterator

成员方法(特有)：

public void add(E e)

将指定的元素插入此列表。该元素直接插入到调用next后返回的元素之前，或者调用previous后返回的元素之后；如果列表中没有元素，那么新元素就成为此列表中的唯一元素，其被插入到隐式光标的前面：并不影响对next的后续调用，但对previous的后续调用会返回此新添加的元素。此调用会把调用nextIndex或previousIndex所返回的值增加1。

public boolean hasPrevious()/*['pri:viəs]前面的*/

如果以逆向遍历列表，列表迭代器有多个元素，则返回true。

public int nextIndex()

返回调用next后，所返回元素的索引。如果列表迭代器在此列表的结尾，则返回该列表的大小。

public E previous()

返回列表中的前一个元素。可以重复调用此方法来迭代列表，与next类似，只是迭代方向相反。也可以和next搭配使用，实现迭代中的前后移动，在交替使用next和previous时，将重复返回相同的元素。

public int previousIndex()

返回调用previous后，所返回元素的索引。如果列表迭代器在列表的开始，则返回-1。

public void set(E e)

用指定的元素替换，调用next或previous后所返回的元素。只有在调用next或previous后，既没有调用迭代器的remove方法，也没有调用迭代器的add方法时，才可以调用此方法。

⑦List/*[list]列表*/接口

public interface List

extends Collection

❶成员方法(特有)：

public void add(int index,E element)/*['elimnt]元素*/

在列表的指定位置插入指定的元素。将当前出于该位置的元素(如果有的话)，以及后续的所有元素都向右移动1位(即其索引加1)。

public void addAll(int index,Collection c)

将指定的collection中的所有元素，都插入此列表中的指定位置。新元素将按照它们，通过指定的collection的迭代器所返回的顺序，出现在此列表中。原列表中的后续元素都顺位后移。

public E get(int index)

返回此列表中指定位置处的元素。

public int indexOf(Object o)

返回此列表中第一次出现指定元素的索引。如果，该列表中没有指定的元素，则返回-1。

public int lastIndexOf(Object o)

返回此列表中最后出现的指定元素的索引。如果，该列表中没有指定的元素，则返回-1。

public ListIterator listIterator()

返回此列表中所有元素的列表迭代器。

public ListIterator listIterator(int index)

返回此列表中部分元素的列表迭代器，从指定的所引处开始。指定的索引表示next的初始调用所返回的第一个元素。

public E remove(int index)

移除列表中指定位置的元素。其后续的所有元素都向左移动(即其索引-1)。

public E set(int index,E element)

用指定的元素替换此列表中指定位置上的元素，并返回被替换的元素。

public List subList(int fromIndex,int toIndex)

返回此列表的子列表视图，在fromIndex(包括)和toIndex(不包括)之间。如果两个索引相等，则返回的列表为空。返回的列表由原列表支持，对子列表的非结构性更改将反映在原列表中，反之亦然。

❷List中三个常见的实现

ArrayList：底层的数据结构是数组结构。其特点是查询和修改很快，增加和删除较慢。线程不同步。开发时建议使用此方法。

LinkedList：底层的数据结构是链式结构。其特点是增加和删除很快，查询和修改较慢。线程不同步。

Vector：底层的数据结构是数组结构。线程同步。

❸对于数据结构为数组的集合而言，其数组长度的不断扩展，是通过不断的新建数组来实现的。首先创建一个比原数组更大的数组，再将原数组中的内容复制的新数组中，然后在后面添加新的元素。对于ArrayList，初始容量是10个空列表，扩容时以50%的容量增加长度，比较节约内存空间；对于Vector，初始容量也是10个空列表，但扩容时以100%的容量增加长度，比较浪费内存空间。

⑧Vector/*['vektə]向量*/类

public class Vector

extends AbstractList

implementsList,RandomAccess,Cloneable,Serializable

/*['rændəm]随机['ækses]存取['kləuniəbl]可克隆的['siriəlaizəbl]可序列化的*/

❶成员方法(特有)：

public Enumeration elements()

返回此向量组件的枚举。返回的Enumeration对象将包含此向量中的所有元素。

❷Enumeration/*[ɪˌnju:mə'reiʃn]枚举*/接口

public interface Enumeration

成员方法：

public boolean hasMoreElements()

测试此枚举是否包含更多的元素。参考Iterator，同hasNext方法。

public E nextElement()

如果此枚举对象至少还有一个可以提供的元素，则返回此枚举的下一个元素。参考Iterator，同next方法。

❸枚举就是Vector特有的取出方式。枚举和迭代的功能是一样的，已经被迭代取代了。

⑨LinkedList/*[liŋkt]链接的*/类

public class LinkedList

extends AbstractSequentialList/*[si'kwenʃl]有顺序的*/

implements List,Deque,Cloneable,Serializable

/*[dek]双端队列['kləuniəbl]可克隆的['siriəlaizəbl]可序列化的*/

❶成员方法(特有)：

public void addFirst(E e)

将指定的元素添加到此列表的开头。

public void addLast(E e)

将指定的元素添加到此列表的结尾。

public E getFirst()

返回此列表的第一个元素。链表为空，则抛NoSuchElementException异常。/*[sʌtʃ]这样的*/

public E getLast()

返回此列表的最后一个元素。链表为空，则抛NoSuchElementException异常。

public E removeFirst()

移除并返回此列表的第一个元素。如果此链表为空，则抛出NoSuchElementException异常。

public E removeLast()

移除并返回此列表的最后一个元素。如果此链表为空，则抛处NoSuchElementException异常。

public boolean offerFirst(E e)/*['ɔfə]提供*/

将指定的元素添加到此列表的开头。

public boolean offerLast(E e)

将指定的元素添加到此列表的结尾。

public E peekFirst()/*[pi:k]窥视*/

获取此列表的第一个元素。如果此链表为空，则返回null。

public E peekLast()

获取此列表的最后一个元素。如果此链表为空，则返回null。

public E pollFirst()/*[pəul]剪短*/

获取并移除此列表的第一个元素。如果此链表为空，则返回null。

public E pollLast()

获取并移除此列表的最后一个元素。如果此链表为空，则返回null。

❷链式数据结构的两个实例

堆栈：先进后出，类似于水杯。

队列：先进先出，类似于水管。

⑩ArrayList类

public class ArrayList

extends AbstractList

implementsList,RandomAccess,Cloneable,Serializable

/*['rædəm]随机的['ækses]存取*/

❶构造方法

public ArrayList()

构造一个初始容量为10的空列表。

public ArrayList(Collection c)

构造一个包含指定的collection的元素的列表。这些元素是按照，指定集合的迭代器，返回它们的顺序排列的。

public ArrayList(int initialCapacity)/*[i'niʃəl]初始[kə'pæsiti]容量*/

构造一个具有指定初始容量的空列表。

❷成员方法(特有)

public Object clone()

返回此列表的浅表副本(视图)。并不会复制这些元素本身。

public void ensureCapacity(int minCapacity)/*[in'ʃuə]确保*/

如有必要，增加此列表的容量，以确保它至少能够容纳，最小容量参数所指定的元素数。

public void removeRange(int fromIndex,int toIndex)

/*[reindʒ]范围*/

移除列表中，索引在fromIndex(包括)和toIndex(不包括)之间的所有元素。后续元素顺位左移。如果两个索引相等，则此操作无效。

public void trimToSize()/*[trim]修剪*/

将此列表的容量调整为列表的当前大小。此操作可以用来最小化该列表的存储容量。

⑪Set/*[set]集合*/接口

public interface Set

extends Collection

❶成员方法(与Collection集合相同)

public boolean add(E e)

如果此set中尚未存在指定的元素，则添加此元素。不可以添加重复的元素。底层调用了equals方法。

public boolean addAll(Collection c)

如果此set中没有指定的collection中的元素，则将其添加到此set中。不可以添加重复的元素。底层调用了equals方法。

public void clear()

移除此set中的所有元素。

public boolean contains(Object o)

如果此set中包含指定的元素，则返回true。底层调用了equals方法。

public boolean containsAll(Collection c)

如果此set中包含指定的collection中的所有元素，则返回true。底层调用了equals方法。

public boolean equals(Object o)

比较此set与指定对象的相等性。必是集合类型相同，并且元素内容相同。

public int hashCode()

返回此set的哈希码值。一个set的哈希码值是其所包含的，所有元素的哈希码值的和。

public boolean isEmpty()

如果此set不包含任何元素，则返回true。

public Iterator iterator()

返回在此set中的元素上进行迭代的迭代器。

public boolean remove(Object o)

如果set中存在指定的元素，则将其移除。底层调用了equals方法。

public boolean removeAll(Collection c)

移除此set中那些包含在指定collection中的元素。底层调用了equals方法。

public boolean retainAll(Collection c)

仅保留set中那些包含在指定的collection中的元素，即保留其交集。

public int size()

返回此set中的元素数，即其容量。

public Object[] toArray()

返回一个包含此set中所有元素的数组，按其迭代的顺序存放。返回的数组是独立的，可以任意操作。

public T[] toArray(T[] a)

返回一个包含此set中所有元素的数组。如果指定的数组能够容纳此set中的所有元素，则返回原数组。否则，将分配一个新的数组，该数组的长度与此set的容量相同。当返回指定数组时，指定数组中原来的元素，将按正向遍历的顺序被覆盖，并且第set.size位(如果有)将被置为null。

❷Set中两个常见的实现

HashSet：底层的数据结构是哈希表。此集合的特点是，所有的判断都是通过先调用hashCode方法，再调用equals方法来实现的。开发时，只要涉及到HashSet集合的应用，都必需要覆盖hashCode方法和equals方法。一个优良的hashCode算法可以避免再次调用equals方法，能够提升效率。

TreeSet：底层的数据结构是二叉树(红黑树)。此集合的特点是，可以对Set集合中的元素进行排序。其排序的方法有两种，一是让对象具有比较性，二是让集合拥有一个比较器，使集合自身具备比较的功能。当两种比较方式同时存在时，以比较器为首选方式。二叉树结构默认的取出顺序是从小到大。

❸TreeSet集合的两种比较方式：一是让对象必须具备比较性，需要让对象所在的类实现Comparable接口，并覆盖其中的compareTo方法。二是让集合具备比较的功能，使其拥有一个比较器。构造一个比较器就是让一个类实现Comparator接口，并覆盖其中的Compare方法。然后将比较器作为参数传递给该集合的构造函数，从而让该集合的对象具备比较的功能。所有的排序，若是主要条件相等，就还要再比较次要条件。

❹对于TreeSet集合的第一种排序方式，让对象具备比较性。当存储的数据有很多之后，集合会自动取折中值作为第一次比较的基数，从而减少判断的次数。

❺对于TreeSet集合的第二种排序方式，让集合具备比较的功能，也可以通过定义匿名内部类的方式来完成。

⑫Comparable/*['kʌmprəbl]可比较的*/接口

public interface Comparable

此接口强制对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，或者叫做默认顺序。

成员方法：

public int compareTo(T o)

比较此对象与指定对象的自然排列顺序。如果该对象小于、等于或大于指定对象，则分别返回负整数、零或正整数。如果指定对象的类型不允许与此对象进行比较，则抛出ClassCastException/*[ka:st]转换*/。实现此接口的类必须覆盖此方法。

⑬Comparator/*[kəm'pærətə]比较器*/接口

public interface Comparator

用于构造比较器。将比较器作为参数，传递给TreeSet集合的构造函数后，能够让该集合的对象，具备可以对其所操作的元素进行比较的功能。

成员方法：

public int compare(T o1,T o2)

比较需要进行排序的两个参数。根据第一个参数小于、等于或大于第二个参数，分别返回负整数、零或者正整数。如果指定的对象的类型，不允许Comparator对它们进行比较，则抛出ClassCastException。实现此接口的类必须覆盖此方法。

public boolean equals(Object obj)

用于比较两个比较器是否相同。两个相同的比较器的功能是完全一样的。

⑭HashSet类

public class HashSet

implements Set,Cloneable,Serializable

❶构造方法

public HashSet()

构造一个HashSet集合，该集合具有默认的初始容量(16)和默认加载因子(0.75)。

public HashSet(Collection c)

构造一个包含指定collection中的元素的新的HashSet集合。该集合具有默认的加载因子，和足以包含指定集合中所有元素的初始容量。

public HashSet(int initialCapacity)/*[i'niʃəl]初始[kə'pæsiti]容量*/

构造一个HashSet集合，该集合具有指定的初始容量和默认的加载因子。

public HashSet(int initialCapacity,float loadFactor)

/*[i'niʃəl]初始[kə'pæsiti]容量[ləud]负载['fæktə]因子*/

构造一个HashSet集合，该集合具有指定的初始容量和加载因子。

❷成员方法(特有)

public Object clone()

返回此集合的浅表副本(视图)。其并没有复制这些元素本身。

⑮TreeSet类

public class TreeSet

extends AbstractSet

implements NavigableSet,Cloneable,Serializable

❶构造方法

public TreeSet()

构造一个TreeSet集合，该集合可以根据元素的自然顺序进行排序。存入的元素必须具备比较性。

public TreeSet(Collection c)

构造一个TreeSet集合，该集合包含指定集合中的所有元素，并按照其元素的自然顺序进行排序。存入的元素必须具备比较性。

public TreeSet(Comparator comparator)

构造一个TreeSet集合，该集合根据指定的比较器，对其存入的元素进行排序。

public TreeSet(SortedSet s)

构造一个TreeSet集合，该集合与指定的集合具有相同的元素和相同的排序方式。

❷成员方法(特有)

public E ceiling(E e)/*['si:liŋ]上限*/

返回此集合中的一个最小的元素，该元素要等于或大于指定的元素。如果没有这样的元素，则返回null。

public Object clone()

返回该集合的浅表副本(视图)。这些元素本身并不会被复制。

public Comparator comparator()

返回此集合的比较器。如果没有则返回null。

public Iterator descendingIterator()/*[di'sendiŋ]递减*/

返回在此集合上，对其元素按降序进行迭代的迭代器。

public NavigableSet descendingSet()

返回此集合的逆序视图。

public E first()

返回此集合中的第一个元素。

public E floor(E e)/*[flɔ:]基底*/

返回此集合中的一个最大的元素，该元素要等于或小于指定的元素。如果没有这样的元素，则返回null。

public SortedSet headSet(E toElement)

返回此集合的部分视图。其中的元素要小于toElement。

public NavigableSet headSet(E toElement,booleaninclusive)

/*['nævigəbl]可导航的[hed]前端['elimnt]元素[in'klu:siv]包含的*/

返回此集合的部分视图。其中的元素要小于(或等于，当inclusive为true时)toElement。

public E higher(E e)

返回此集合中的最小的元素，该元素要大于指定的元素。如果没有这样的元素，则返回null。

public Iterator iterator()

返回此集合的迭代器。

public E last()

返回此集合的最后一个元素。

public E lower(E e)

返回此集合中的最大的元素，该元素要小于指定的元素。如果没有这样的元素，则返回null。

public E pollFirst()

移除并返回此集合中的第一个元素。如果此集合为空，则返回null。

public E pollLast()

移除并返回此集合中的最后一个元素。如果此集合为空，则返回null。

public NavigableSet subSet(E fromElement,booleanfromInclusive,E toElement,boolean toInclusive)

返回此集合的部分视图。如果boolean型的参数为true，则包含指定的参数。

public SortedSet subSet(E fromElement,EtoElement)

返回此集合的部分视图。其元素从fromElement(包括)到toElement(不包括)。如果两个参数相同，则返回一个空集合。

public SortedSet tailSet(E fromElement)/*[teil]尾巴*/

返回此集合的部分视图。其中的元素要大于或等于指定的元素。

public NavigableSet tailSet(EfromElement,boolean inclusive)

返回此集合的部分视图。其中的元素要大于(或等于，当inclusive为true时)指定的元素。

⑯Map/*[mæp]映射*/接口

public interface Map

键-值对中的键是唯一的，并且一个键只能映射一个值。但是，一个值可以对应多个键。

❶内部接口

Map.Entry/*['entri]条目*/接口

public static interface Map.Entry

映射项(键-值对)。获取映射项的唯一方法是，通过此Map集合所有映射项的collection视图的迭代器来实现。可以通过Map.entrySet方法获得此Map集合的Set视图。

成员方法：

public boolean equals(Object o)

比较此映射项与指定对象的相等性。若要两个映射项相等，必须同时满足其中的键和值分别相等。键和值可以均为null。

public K getKey()

返回此映射项的键。

public V getValue()

返回此映射项的值。

public V setValue(V value)

用指定的值替换此映射项的值，并返回原值。

public int hashCode()

返回此映射项的哈希码值。映射项e的哈希码值定义如下：

(e.getKey()==null ? 0：e.getKey().hashCode())^

(e.getValue()==null ? 0：e.getValue().hashCode())

❷成员方法

public void clear()

将此映射中的所有映射项都清空。

public boolean containsKey(Object key)

判断此映射中是否包含指定键的映射关系。底层调用了equals方法。

public boolean containsValue(Object value)

判断此映射中是否包含指定值的映射关系。底层调用了equals方法。

public Set> entrySet()

返回此映射的所有映射项的Set视图。该Set视图受此映射的支持，通过Set视图对所有映射项的修改，将会反映在此映射中，反之亦然。此Set视图只支持修改和移除操作，不支持添加操作。

public boolean equals(Object o)

比较此映射与指定的对象是否相等。两个相等的映射表示相同的映射关系，即其映射项一一对应并且相等。

public V get(Object key)

返回此映射中指定键所映射的值。不包含则返回null。

public int hashCode()

返回此映射的哈希码值。该值为此映射的所有映射项的哈希码值之和。

public boolean isEmpty()

判断此映射中是否包含映射项。

public Set keySet()

返回此映射中包含的所有键的Set视图。该Set视图受此映射的支持，规则同entrySet方法。

public V put(K key,V value)

将指定的键和指定的值作为一个映射项，添加到此映射中。如果此映射中包含了指定键的映射关系，则用新值换旧值，同时返回旧值。如果此映射中没有包含该键的映射项，则返回null。

public void putAll(Map m)

将指定的映射中的所有映射项复制到此映射中。相当于调用多次put方法。

public V remove(Object key)

如果此映射中存在指定键的映射项，则将此项移除，并返回此映射项中的值。若不包含此映射项则返回null。

public int size()

返回此映射中的映射项的数量。

public Collection values()

返回此映射中所有的值的Collection视图。该Collection视图受此映射的支持，规则同entrySet方法。

❸Map集合的三个常见的实现

Hashtable：底层是哈希表数据结构，不可以存入null键和null值。线程同步，执行效率较低。

HashMap：底层是哈希表数据结构，可以使用null键和null值。线程不同步，执行效率较高。

TreeMap：底层是二叉树数据结构。线程不同步。可以给Map集合中的键进行排序。

❹Map集合的取出方式

第一种：将该集合中的所有键，以Set集合视图的形式取出。然后用Set集合的迭代器，将Map集合的键的视图一一取出。之后再通过键取出其所对应的值。

第二种：将该集合的映射项(映射关系)，以Set集合视图的形式取出。然后用Set集合的迭代器，以及Map.Entry的方法，将Map集合的键和值一一取出。

Set集合的底层调用的就是Map集合的功能。

(17)HashMap类

public class HashMap

extends AbstractMap

implements Map,Cloneable,Serializable

❶基于哈希表的Map接口实现。此实现允许使用null键和null值。线程不同步。作为键的对象必须覆盖hashCode方法和equals方法。

❷影响HashMap实例的性能的两个参数

初始容量：哈希表在创建时的容量。容量是哈希表中散列桶的数量。

加载因子：哈希表在其容量自动增加之前，可以达到多满的一种尺度。

当哈希表中的条目数，超出了加载因子与当前容量的乘积时，就要对哈希表进行rehash/*[ri:'hæʃ]重新处理*/(即重建内部数据结构)操作，从而使新的哈希表具有大约两倍的桶数。

❸构造函数

public HashMap()

构造一个HashMap，具有默认的初始容量(16)和默认的加载因子(0.75)。

public HashMap(int initialCapacity)/*[i'niʃəl]初始[kə'pæsiti]容量*/

构造一个HashMap，具有指定的初始容量和默认加载因子。

public HashMap(int initialCapacity,float loadFactor)

/*[i'niʃəl]初始[kə'pæsiti]容量[ləud]负载['fæktə]因子*/

构造一个HashMap，具有指定的容量和加载因子。

public HashMap(Map m)

构造一个映射关系与指定的Map集合相同的HashMap。所创建的HashMap具有默认的加载因子，和足以容纳指定Map中映射关系的初始容量。

❹成员方法(特有)

public Object clone()

返回此HashMap实例的浅表副本(即视图)，并不会复制键和值本身。

❺HashMap与Hashtable的区别

HashMap：可以使用null作为键和值。线程不同步。

Hashtable：不可以使用null作为键和值。线程同步。

(18)Hashtable类

public class Hashtable

extends Dictionary/*['dikʃənəri]字典*/

implements Map,Cloneable,Serializable

❶成员方法(特有)

public Enumeration elements()

返回此哈希表中的值的枚举。对返回的对象使用Enumeration中的方法，可以按顺序取出其中的元素。

public Enumeration keys()

返回此哈希表中键的枚举。

public String toString()

返回此Hashtable对象的字符串表示形式。其形式为ASCII字符“， ”(逗号加空格)分隔开的，括在括号中的一组条目。每个条目即一个键-值对，键和值用“=”相连。

❷其它同HashMap，包括构造函数和成员函数。

(19)TreeMap类

public class TreeMap

extends AbstractMap

implements NavigableMap,Cloneable,Serializable

/*['nævigəbl]可导航的*/

可以按键的顺序，给集合中的元素进行排序。线程不同步。

❶构造方法

public TreeMap()

构造一个树映射。所有的键必须具备比较性。

public TreeMap(Comparator comparator)

构造一个树映射，该映射根据给定的比较器对存入的键进行排序。

public TreeMap(Map m)

构造一个与指定的映射，具有相同映射关系的树映射。该映射根据其键的自然顺序进行排序。

public TreeMap(SortedMap m)/*['sɔ:tid]分类的*/

构造一个与指定的有序映射，具有相同映射关系和相同排序方式的树映射。

对于SortedMap集合，要么其所包含的键是具备比较性的，要么该集合拥有一个比较器。树映射将按照指定集合的排序方式，对键进行排序。

❷成员方法(特有)

public Map.Entry ceilingEntry(K key)/*['si:liŋ]上限*/

返回一个最小映射项(键-值对)，其中的键要等于或大于指定的键；如果没有这样的映射项，则返回null。

public K ceilingKey(K key)

返回一个最小键，该键要等于或大于指定的键；如果没有这样的键，则返回null。

public Comparator comparator()

返回此映射中对键进行排序的比较器，如果没有则返回null。

public NavigableSet descendingKeySet()

/*['nævigəbl]可导航的[di'sendiŋ]递减*/

返回此映射中所有键的逆序NavigableSet视图。该视图的迭代器将按降序返回其中的键。

public NavigableMap descendingMap()

返回此映射的逆序视图。

public Map.Entry firstEntry()

返回此映射中包含最小键的映射项，如果此映射为空，则返回null。

public K firstKey()

返回此映射中的最小键。如果此映射为空，则抛出无此元素异常。

public Map.Entry floorEntry(K key)/*[flɔ:]基底*/

返回一个最大映射项，该映射项的键要等于或小于指定的键；如果不存在这样的映射项，则返回null。

public K floorKey(K key)

返回一个最大键，该键要等于或小于指定的键；如果没有这样的键，则返回null。

public SortedMap headMap(K toKey)/*['sɔ:tid]分类的*/

返回此映射的部分视图，其中的键要小于指定的键。

public NavigableMap headMap(K toKey,booleaninclusive)

/*['nævigəbl]可导航的*/

返回此映射的部分视图，其中的键要小于(或等于，当inclusive为true时)指定的键。

public Map.Entry higherEntry(K key)/*['haiə]更高的*/

返回一个最小映射项，该映射项的键要大于指定的键。没有则返回null。

public K higherKey(K key)

返回一个最小键，该键要大于指定的键。没有则返回null。

public Map.Entry lastEntry()

返回该映射中，包含其最大键的映射项。如果此映射为空，则返回null。

public K lastKey()

返回此映射中的最大键。如果此映射为空，则抛出无此元素异常。

public Map.Entry lowerEntry(K key)/*['ləuə]下游的*/

返回一个最大映射项，该映射项的键要小于指定的键。没有则返回null。

public K lowerKey()

返回一个最大键，该键要小于指定的键。没有则返回null。

public NavigableSet navigableKeySet()

返回此映射中的所有键的NavigableSet视图，该视图的迭代器按升序返回其中的键。

public Map.Entry pollFirstEntry()/*[pəul]剪短*/

移除并返回，此映射中的最小映射项。如果此映射为空，则返回null。

public Map.Entry pollLastEntry()

移除并返回，此映射中的最大映射项。如果此映射为空，则返回null。

public NavigableMap subMap(K fromKey,booleanfromInclusive,K toKey,boolean toInclusive)/*[in'klu:siv]包含的*/

返回此映射的部分视图。如果boolean型参数为true，则包含指定的键。

public SortedMap subMap(K fromKey,K toKey)

返回此映射的部分视图。含头不含尾。如果头尾相同，则返回null。

public SortedMap tailMap(K fromKey)/*[teil]尾巴*/

返回此映射的部分视图。所有映射项的键要大于或等于指定的键。

public NavigableMap tailMap(K fromeKey,booleaninclusive)

返回此映射的部分视图。所有映射项的键要大于(或等于，如果inclusive为true)指定的键。

(20)Collections类

public class Collections

extends Object

❶成员常量

public static final List EMPTY_LIST

空的列表(不可改变的)。此列表是可序列化的。

public static final Map EMPTY_MAP

空的映射(不可改变的)。此映射是可序列化的。

public static final Set EMPTY_SET

空的Set(不可改变的)。此Set是序列化的。

❷成员方法(部分)

public static boolean addAll(Collection c,T... e)

将指定的元素添加到指定的集合中。

public static QueueasLifoQueue(Deque deque)

/*[kju:]队列[æz]如同['laifəu]后进先出[dek]双端队列*/

以后进先出为顺序的queue形式，返回指定的deque视图。

Lifo：last in first out(后进先出，堆栈型链表结构)

public static int binarySearch(List> list,T key)

使用二分搜索法搜索指定的列表，以获得指定对象的索引。如果没有，则返回(-(插入点)-1)。查找之前要先排序。

public static int binarySearch(List list,T key,Comparator c)

使用二分搜索法搜索指定的列表，以获得指定对象的索引。如果没有，则返回(-(插入点)-1)。查找之前要先排序。并且，在查找时，要以传入的比较器的规则为准。也就是说，如果排序和查找的比较方式并不相同，则返回的结果是不确定的。

public static void fill(Listlist,T obj)/*[fil]填满*/

用指定的元素，替换被传入的列表中的所有元素。

public static > T max(Collection coll)

根据元素的自然顺序，返回指定集合的最大元素。集合中的元素必须具备比较性。将max换成min即返回最小的元素。

public static T max(Collection coll,Comparator comp)

根据指定的比较器，返回被传入的集合中的最大的元素。将max换成min即返回最小的元素。

public static boolean replaceAll(Listlist,T oldV,T newV)

用新值替换被传入列表中指定的旧值。

public static void reverse(List list)

反转指定列表中元素的顺序。

public static ComparatorreverseOrder()/*['ɔ:də]顺序*/

返回一个比较器，它可以反转该集合所有元素的自然顺序。

public static ComparatorreverseOrder(Comparator comp)

返回一个比较器，它可以反转指定比较器的比较顺序。

public static void shuffle(List list)/*['ʃʌfl]随机*/

使用默认随机源，对指定列表中的元素进行排序。

public static void shuffle(List list,Random rnd)

使用指定的随机源，对所传入的列表中的元素进行排序。

public static > void sort(List list)

根据元素的自然顺序，对指定列表中的元素进行排序。列表中的元素必须具备比较性。

public static void sort(Listlist,Comparator c)

根据指定的比较器，对所传入的列表中的元素进行排序。

public static void swap(List list,int i,int j)/*[swɔp]交换*/

将被传入的列表中，指定的两个索引位置的元素进行互换。

public static XsynchronizedX(X obj)

X：Collection,List,Set,SortedSet

public static YsynchronizedY(Y obj)

Y：Map,SortedMap

返回指定集合X(或Y)，支持线程同步的集合。

public static X unmodifiableX(X obj)

X：Collection,List,Set,SortedSet/*['ʌn'mɔdifaiəbl]无法改变的*/

public static XunmodifiableX(X obj)

Y：Map,SortedMap

返回指定集合X(或Y)，不可修改的视图，即只可以查询。

(21)Arrays类

public class Arrays

extends Object

❶成员方法(部分)

public static List asList(T... a)

返回一个受指定数组支持的，固定大小的列表视图。参数a可以是单个数组，也可以是多个相同类型的元素。

public static int binarySearch(X[] x,X x)

X：byte,char,double,float,int,long,Object,short

用折半查找法来搜素指定数组中的指定元素，返回该元素的索引。如果没有，则返回(-(插入点)-1)或者x.length。查找之前要先排序。

public static int binarySearch(X[] x,int fromIndex,inttoIndex,X x)

X：byte,char,double,float,int,long,Object,short

用折半查找法搜索，在传入数组的指定范围内(含头不含尾)，指定元素的索引。如果没有，则返回(-(插入点)-1)或者toIndex。查找之前要先排序。

public static int binarySearch(T[] a,Tkey,Comparator c)

用折半查找法来搜索指定数组中的指定元素，返回该元素的索引。如果没有，则返回(-(插入点)-1)或者x.length。查找之前要先排序。并且，在查找时，要以传入的比较器的规则为准。也就是说，如果排序和查找的比较方式并不相同，则返回的结果是不确定的。

public static int binarySearch(T[] a,intfromIndex,int toIndex,T key,Comparator c)

用折半查找法搜索，在被传入数组的指定范围内(含头不含尾)，指定元素的索引。如果没有，则返回(-(插入点)-1)或者toIndex。并且，在查找时，要以传入的比较器的规则为准。也就是说，如果排序和查找的比较方式并不相同，则返回的结果是不确定的。

public static X[] copyOf(X[] original,int newLength)/*[ə'ridʒinl]原来的*/

X：boolean,byte,char,double,float,int,long,short

复制指定的数组，正向截取或者填充该类型的默认初始化值，以使副本具有指定的长度。

public static T[] copyOf(T[] original,intnewLength)

复制指定的数组，正向截取或者填充null，以使副本具有指定的长度。

public static X[] copyOfRange(X[] original,intfromIndex,int to)

X：boolean,byte,char,double,float,int,long,short

将传入的数组的指定范围，复制到一个新的数组中(含头不含尾)。0<=fromIndex<=original.length，新数组的长度为to-from。没有元素的位置，填充该类型的默认初始化值。

public static T[] copyOfRange(T[] original,intfrom,int to)

将传入的数组的指定范围，复制到一个新的数组中(含头不含尾)。0<=fromIndex<=original.length，新数组的长度为to-from。没有元素的位置，填充null。

public static boolean deepEquals(Object[] a1,Object[]a2)/*[di:p]深度*/

如果两个指定的数组彼此深度相等，则返回true。对于深度比较，既比较引用，也比较指向的对象，一直到最底层。

public static int deepHashCode(Object[] a)

基于指定数组的最底层内容，返回其哈希码值。

public static String deepToString(Object[] a)

返回指定数组最底层内容的字符串表示形式。

public static boolean equals(X[] a1,X[] a2)

X：boolean,byte,char,double,float,int,long,Object,short

如果指定的两个数组彼此相等，则返回true。必须是以相同的顺序，包含相同的元素。

public static void fill(X[] a,X value)

X：boolean,byte,char,double,float,int,long,Object,short

用指定的值填充指定的数组。

public static void fill(X[] a,int fromIndex,int toIndex,Xvalue)

X：boolean,byte,char,double,float,int,long,Object,short

用指定的值，填充所传入的数组的指定的部分(含头不含尾)。

public static int hashCode(X[] a)

X：boolean,byte,char,double,float,int,long,Object,short

基于指定数组的内容返回其哈希码值。

public static void sort(X[] a)

X：byte,char,double,float,int,long,Object,short

对指定的数组按照自然顺序进行升序排序。

public static void sort(X[] a,int fromIndex,int toIndex)

X：byte,char,double,float,int,long,Object,short

对所传入的数组的指定范围，按照自然顺序进行升序排序(含头不含尾)。

public static void sort(T[] a,Comparator c)

根据指定的比较器，对传入的数组进行排序。

public static void sort(T[] a,int fromIndex,inttoIndex,Comparator c)

根据指定的比较器，对所传入数组的指定范围进行排序(含头不含尾)。

public static String toString(Object[] a)

X：boolean,byte,char,double,float,int,long,Object,short

返回指定数组内容的字符串表示形式。如果a为空，则返回null。

❷把数组变成集合的好处

可以使用集合的思想和方法，来操作数组中的元素。此时的转变，返回的只是原数组的一个视图，对该集合视图的操作都将反映在原数组中。对该视图的操作不可以使用增加和删除的方法，因为数组的长度是固定的。

❸数组转集合的注意事项

如果数组中的元素都是引用数据类型的数据，那么在转变时，数组中的对象都会直接变成集合中的对象。

如果数组中的元素都是基本数据类型的数据，那么在转变时，数组自身会作为一个元素被存入集合中。

❹将集合转变为数组(Collection)

public Object[] toArray()

public T[] toArray(T[] a)

将集合变成数组，可以限定对其中元素的增删操作。

(22)高级for循环

❶格式

for(数据类型 变量名：被遍历的集合(Collection)或者数组)

{循环语句}

❷高级for的局限性

只能取出集合中的元素，不能对集合做增删和修改的操作。

❸高级for与传统for的区别

高级for中必须有被遍历的目标。传统for中可以没有。

只要实现了Iterable接口，其对象就可以被高级for语句遍历。高级for就是Iterator的简化形式。

对数组进行遍历时，建议使用传统for。因为在传统for中可以定义角标，并通过对角标的判断，做一些其它的操作。

(23)JDK1.5版本之后的新特性：可变参数

❶格式

参数类型... 变量名

❷原理

其实可变参数，就是数组参数的另一种表现形式。其接收的数组的长度是可变的。如果接收的是一组相同类型的元素，则所接收的元素将被自动封装进一个数组里。

❸局限性

在使用可变参数的时候，一定要将可变参数定义在参数序列的最后面。因为可变参数会默认的，将后面没有被匹配的所有参数，都封装进一个数组里。如果其后面还定义了其它类型的参数，将会被忽略，由于传入的数据类型不一致，将会导致编译失败。

(24)JDK1.5版本之后的新特性：静态导入

❶格式

import static 包名.类名.*；

❷功能

静态导入，类似于类的导入。其导入的是该类的所有静态成员，包括静态变量和静态方法。

❸注意事项

对于静态导入，如果出现了同名的静态成员，需要使用具体的类名或对象名加以区分。

对于类的导入，如果出现了同名的类，需要使用具体的包名来加以区分。

---------------------------------------- JavaEE+云物联、期待与您交流！---------------------------------------------