---------------------------------------- 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集合的功能。
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+云物联、期待与您交流!---------------------------------------------