黑马程序员_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：当实现一个由泛型修饰的接口时，实现者的泛型一定不能和接口的泛型一致。实现者的泛型可以包含接口的泛型，也可以是接口泛型的子类。实现者也可以没有泛型。

❻泛型的使用原则

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

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

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

❼静态方法的泛型设定

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

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

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

❾泛型的限定

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

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

public interface Collection<E>

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

❶成员方法：

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

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

public boolean addAll(Collection<? extends E> 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<E> 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> T[] toArray(T[] a)

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

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

❷Collection的两个子接口

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

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

④Iterable<T>接口

public interface Iterable<T>

成员方法：

public Iterator<T> iterator()

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

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

public interface Iterator<E>

❶成员方法：

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<E>/*[list]列表[itə'reitə]迭代器*/

public interface ListIterator<E>

extends Iterator<E>

成员方法(特有)：

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<E>/*[list]列表*/接口

public interface List<E>

extends Collection<E>

❶成员方法(特有)：

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

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

public void addAll(int index,Collection<? extendsE> c)

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

public E get(int index)

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

public int indexOf(Object o)

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

public int lastIndexOf(Object o)

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

public ListIterator<E> listIterator()

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

public ListIterator<E> listIterator(int index)

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

public E remove(int index)

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

public E set(int index,E element)

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

public List<E> subList(int fromIndex,int toIndex)

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

❷List中三个常见的实现

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

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

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

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

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

public class Vector<E>

extends AbstractList<E>

implementsList<E>,RandomAccess,Cloneable,Serializable

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

❶成员方法(特有)：

public Enumeration<E> elements()

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

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

public interface Enumeration<E>

成员方法：

public boolean hasMoreElements()

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

public E nextElement()

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

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

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

public class LinkedList<E>

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

implements List<E>,Deque<E>,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<E>类

public class ArrayList<E>

extends AbstractList<E>

implementsList<E>,RandomAccess,Cloneable,Serializable

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

❶构造方法

public ArrayList()

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

public ArrayList(Collection<? extends E> 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<E>/*[set]集合*/接口

public interface Set<E>

extends Collection<E>

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

public boolean add(E e)

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

public boolean addAll(Collection<? extends E> 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<E> 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> 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<T>/*['kʌmprəbl]可比较的*/接口

public interface Comparable<T>

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

成员方法：

public int compareTo(T o)

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

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

public interface Comparator<T>

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

成员方法：

public int compare(T o1,T o2)

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

public boolean equals(Object obj)

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

⑭HashSet<E>类

public class HashSet<E>

implements Set<E>,Cloneable,Serializable

❶构造方法

public HashSet()

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

public HashSet(Collection<? extends E> 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<E>类

public class TreeSet<E>

extends AbstractSet<E>

implements NavigableSet<E>,Cloneable,Serializable

❶构造方法

public TreeSet()

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

public TreeSet(Collection<? extends E> c)

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

public TreeSet(Comparator<? super E> comparator)

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

public TreeSet(SortedSet<E> s)

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

❷成员方法(特有)

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

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

public Object clone()

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

public Comparator<? super E> comparator()

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

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

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

public NavigableSet<E> descendingSet()

返回此集合的逆序视图。

public E first()

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

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

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

public SortedSet<E> headSet(E toElement)

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

public NavigableSet<E> headSet(E toElement,booleaninclusive)

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

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

public E higher(E e)

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

public Iterator<E> iterator()

返回此集合的迭代器。

public E last()

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

public E lower(E e)

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

public E pollFirst()

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

public E pollLast()

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

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

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

public SortedSet<E> subSet(E fromElement,EtoElement)

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

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

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

public NavigableSet<E> tailSet(EfromElement,boolean inclusive)

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

⑯Map<K,V>/*[mæp]映射*/接口

public interface Map<K,V>

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

❶内部接口

Map.Entry<K,V>/*['entri]条目*/接口

public static interface Map.Entry<K,V>

映射项(键-值对)。获取映射项的唯一方法是，通过此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<Map.Entry<K,V>> entrySet()

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

public boolean equals(Object o)

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

public V get(Object key)

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

public int hashCode()

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

public boolean isEmpty()

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

public Set<K> keySet()

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

public V put(K key,V value)

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

public void putAll(Map<? extends K,? extends V> m)

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

public V remove(Object key)

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

public int size()

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

public Collection<V> 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<K,V>类

public class HashMap<K,V>

extends AbstractMap<K,V>

implements Map<K,V>,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<? extends K,? extends V> m)

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

❹成员方法(特有)

public Object clone()

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

❺HashMap与Hashtable的区别

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

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

(18)Hashtable<K,V>类

public class Hashtable<K,V>

extends Dictionary<K,V>/*['dikʃənəri]字典*/

implements Map<K,V>,Cloneable,Serializable

❶成员方法(特有)

public Enumeration<V> elements()

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

public Enumeration<K> keys()

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

public String toString()

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

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

(19)TreeMap<K,V>类

public class TreeMap<K,V>

extends AbstractMap<K,V>

implements NavigableMap<K,V>,Cloneable,Serializable

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

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

❶构造方法

public TreeMap()

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

public TreeMap(Comparator<? super K> comparator)

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

public TreeMap(Map<? extends K,? extends V> m)

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

public TreeMap(SortedMap<? extends V> m)/*['sɔ:tid]分类的*/

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

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

❷成员方法(特有)

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

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

public K ceilingKey(K key)

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

public Comparator<? super K> comparator()

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

public NavigableSet<K> descendingKeySet()

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

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

public NavigableMap<K,V> descendingMap()

返回此映射的逆序视图。

public Map.Entry<K,V> firstEntry()

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

public K firstKey()

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

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

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

public K floorKey(K key)

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

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

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

public NavigableMap<K,V> headMap(K toKey,booleaninclusive)

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

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

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

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

public K higherKey(K key)

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

public Map.Entry<K,V> lastEntry()

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

public K lastKey()

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

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

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

public K lowerKey()

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

public NavigableSet<K> navigableKeySet()

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

public Map.Entry<K,V> pollFirstEntry()/*[pəul]剪短*/

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

public Map.Entry<K,V> pollLastEntry()

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

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

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

public SortedMap<K,V> subMap(K fromKey,K toKey)

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

public SortedMap<K,V> tailMap(K fromKey)/*[teil]尾巴*/

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

public NavigableMap<K,V> 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 <T> boolean addAll(Collection<?Super T> c,T... e)

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

public static <T> Queue<T>asLifoQueue(Deque<T> deque)

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

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

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

public static <T> int binarySearch(List<?extends Comparable<? super T>> list,T key)

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

public static <T> int binarySearch(List<?extends T> list,T key,Comparator<? super T> c)

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

public static <T> void fill(List<? super T>list,T obj)/*[fil]填满*/

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

public static <T extends Comparable<? superT>> T max(Collection<? extends T> coll)

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

public static <T> T max(Collection<? extendsT> coll,Comparator<? super T> comp)

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

public static <T> boolean replaceAll(List<T>list,T oldV,T newV)

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

public static void reverse(List<?> list)

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

public static <T> Comparator<T>reverseOrder()/*['ɔ:də]顺序*/

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

public static <T> Comparator<T>reverseOrder(Comparator<T> comp)

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

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

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

public static void shuffle(List<?> list,Random rnd)

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

public static <T extends Comparable<? superT>> void sort(List<T> list)

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

public static <T> void sort(List<T>list,Comparator<? Super T> c)

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

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

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

public static <T> X<T>synchronizedX(X<T> obj)

X：Collection,List,Set,SortedSet

public static <K,V> Y<K,V>synchronizedY(Y<K,V> obj)

Y：Map,SortedMap

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

public static <T> X<T> unmodifiableX(X<?extends T> obj)

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

public static <K,V> X<K,V>unmodifiableX(X<? extends K,? extends V> obj)

Y：Map,SortedMap

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

(21)Arrays类

public class Arrays

extends Object

❶成员方法(部分)

public static <T> List<T> 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 <T> int binarySearch(T[] a,Tkey,Comparator<? super T> c)

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

public static <T> int binarySearch(T[] a,intfromIndex,int toIndex,T key,Comparator<? super T> 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> 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> 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 <T> void sort(T[] a,Comparator<?super T> c)

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

public static <T> void sort(T[] a,int fromIndex,inttoIndex,Comparator<? super T> 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> 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+云物联、期待与您交流！---------------------------------------------