java集合框架

最新推荐文章于 2024-09-15 09:47:04 发布

xzz4632

最新推荐文章于 2024-09-15 09:47:04 发布

阅读量168

点赞数

分类专栏： java基础文章标签： java

本文链接：https://blog.csdn.net/xzz4632/article/details/78870153

版权

java基础专栏收录该内容

10 篇文章 0 订阅

订阅专栏

java集合框架支持两种类型:

一是存储一类元素, 即为集合; 二是存储键值对,即为map.

集合支持三种类型的集合:
- 规则集: Set 存储一组不重复的元素, 且无序.
- 线性表: List 存储一组可重复的元素, 且有序.
- 队列 : Queue 存储用先进先出方式处理的对象.
java集合框架设计
- 使用接口，抽象类，具体类。用接口定义框架，用抽象类提供这个接口的部分实现。且具体的数据结构实现接口。
- 例如AbstaractCollection抽象类实现了Collection接口的部分定义，具体类又直接或间接继承了AbstractCollection。
- 所有的具体实现都实现了java.lang.Cloneable和java.io.Serializable接口，所以集合实例都是可复制且可序列化的。
Collection接口，定义了集合的基本操作，继承了Iterable接口.**
- boolean add(E e)
  确保此 collection 包含指定的元素。
- boolean addAll(Collection <？ extends E> c)
  将指定 collection 中的所有元素都添加到此 collection 中。
- boolean contains(Object o)
  如果此 collection 包含指定的元素，则返回 true。
- boolean containsAll(Collection< ?> c)
  如果此 collection 包含指定 collection 中的所有元素，则返回 true。
- boolean equals(Object o)
  比较此 collection 与指定对象是否相等。
- int hashCode()
  返回此 collection 的哈希码值。
- Iterator iterator()
  返回在此 collection 的元素上进行迭代的迭代器。
- boolean isEmpty()
  如果此 collection 不包含元素，则返回 true。
- void clear()
  移除此 collection 中的所有元素。
- boolean remove(Object o)
  从此 collection 中移除指定元素的单个实例，如果存在的话。
- boolean removeAll(Collection< ?> c)
  移除此 collection 中那些也包含在指定 collection 中的所有元素。
- boolean retainAll(Collection< ?> c)
  仅保留此 collection 中那些也包含在指定 collection 的元素。
- int size()
  返回此 collection 中的元素数。
- Object[] toArray()
  返回包含此 collection 中所有元素的数组。
- T[] toArray(T[] a)
  返回包含此 collection 中所有元素的数组；返回数组的运行时类型与指定数组的运行时类型相同。

Collection接口有3个直接子接口, 分别为 List , Set ,Queue.

5.1 List接口, List接口常用实现类有两个:ArrayList和LinkedList. ArrayList是数组型的,LinkedList是链表型的. 它们都允许插入多个null值.

5.1.1 ArrayList
构造方法:
ArrayList()  构造一个初始容量为10 的空列表。
ArrayList(int initialCapacity) 构造一个具有指定初始容量的空列表。
ArrayList(Collection<? extends E> c)   构造一个包含指定 collection 的元素的列表
ArrayList是不同步的, Vector是同步 的.

5.1.2 LinkedList
构造方法:
LinkedList() 构造一个空列表。
LinkedList(Collection<? extends E> c) 构造一个包含指定 collection 中的元素的列表
LinkedList除了实现了List接口的方法外, 还提供了从线性表两端提取,删除,插入元素的方法.
ArrayList在获取元素时的效率比LinkedList高, LinkedList在随意的插入或删除的效率要高于ArrayList.

5.2 Set接口, 不能包含重复元素, 最多可以包含一个null值. Set集合常用的有3个实现类,
HashSet , LinkedHashSet , TreeSet .

5.2.1 HashSet
构造方法: 
HashSet() 构造一个新的空 set，默认初始容量是 16，加载因子是 0.75。
HashSet(Collection< ? extends E> c)  构造一个包含指定 collection 中的元素的新 set。
HashSet(int initialCapacity)  构造一个新的空 set，具有指定的初始容量和默认的加载因子（0.75）。
HashSet(int initialCapacity, float loadFactor)  构造一个新的空 set，具有指定的初始容量和指定的加载因子。
//当元素的个数超过了容量和加载因子的乘积, 容量会自动翻倍. HashSet是无序的.


5.2.2 LinkedHashSet
构造方法: 与HashSet相同.
//它是有序的. 它的迭代不受容量影响. 由于其内部要维护一个链表, 故其开销要大于HashSet. 但在迭代时会例外, 因为HashSet的迭代与其容量成正比, 而LinkedHashSet的迭代只与Set的大小成正比,而与其容量无关.

5.2.3 TreeSet 这是一个有序的Set集合,这个顺序不是插入序而是自然顺序或自定义的Comparator比较器.它实现了SortSet及 NavigableSet.
构造方法:
TreeSet()   构造一个新的空 set，该 set 根据其元素的自然顺序进行排序。
TreeSet(Collection< ? extends E> c)  构造一个包含指定 collection 元素的新 TreeSet，它按照其元素的自然顺序进行排序。
TreeSet(Comparator<? super E> comparator)  构造一个新的空 TreeSet，它根据指定比较器进行排序。
TreeSet(SortedSet<E> s)  构造一个与指定有序 set 具有相同映射关系和相同排序的新 TreeSet。

5.3 向量类Vector和栈类Stack

5.3.1 Vector 与ArrayList的区别 是Vector是同步的. 其它用法基本与ArrayList相同.
//Vector 的大小可以根据需要增大或缩小.
构造方法:
Vector() 构造一个空向量，使其内部数据数组的大小为 10，其标准容量增量为零。
Vector(Collection<? extends E> c) 构造一个包含指定 collection 中的元素的向量，这些元素按其 collection 的迭代器返回元素的顺序排列。
Vector(int initialCapacity)  使用指定的初始容量和等于零的容量增量构造一个空向量。
Vector(int initialCapacity, int capacityIncrement)  使用指定的初始容量和容量增量构造一个空的向量。

5.3.2 Stack类
继承自Vector类, Stack 类表示后进先出（LIFO）的对象堆栈。Deque 接口及其实现提供了 LIFO 堆栈操作的更完整和更一致的 set，应该优先使用此 set，而非此类。

5.4 队列

Queue接口
队列通常（但并非一定）以 FIFO（先进先出）的方式排序各个元素。不过优先级队列和 LIFO 队列（或堆栈）例外.
除了基本的 Collection 操作外，队列还提供其他的插入、提取和检查操作。每个方法都存在两种形式：一种抛出异常（操作失败时），另一种返回一个特殊值（null 或 false，具体取决于操作）。
boolean add(E e) 
  将指定的元素插入此队列（如果立即可行且不会违反容量限制），在成功时返回 true，如果当前没有可用的空间，则抛出 IllegalStateException。
boolean offer(E e) 
  将指定的元素插入此队列（如果立即可行且不会违反容量限制），当使用有容量限制的队列时，此方法通常要优于 add(E)，后者可能无法插入元素，而只是抛出一个异常。

E   element() 
  获取，但是不移除此队列的头。此方法与 peek 唯一的不同在于：此队列为空时将抛出一个异常。
E   peek() 
  获取 , 但不移除此队列的头；如果此队列为空，则返回 null。

E   poll() 
  获取并移除此队列的头，如果此队列为空，则返回 null。
E   remove() 
  获取并移除此队列的头。此方法与 poll 唯一的不同在于：此队列为空时将抛出一个异常。

 ---------------------------------------------------------------------------- 
Deque接口
名称 deque 是“double ended queue（双端队列）”的缩写，通常读为“deck”。支持在两端插入和移除元素。
此接口定义在双端队列两端访问元素的方法。提供插入、移除和检查元素的方法。每种方法都存在两种形式：一种形式在操作失败时抛出异常，另一种形式返回一个特殊值（null 或 false，具体取决于操作）.

5.5 Map
用于存储key-value类型的数据.

5.5.1 Map接口方法
 void   clear()  从此映射中移除所有映射关系（可选操作）。

 boolean    containsKey(Object key) 
  如果此映射包含指定键的映射关系，则返回 true。
 boolean    containsValue(Object value) 
  如果此映射将一个或多个键映射到指定值，则返回 true。

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

 V  get(Object key) 
  返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null。 
 V  put(K key, V value) 
  将指定的值与此映射中的指定键关联（可选操作）。
 void   putAll(Map<? extends K,? extends V> m) 
  从指定映射中将所有映射关系复制到此映射中（可选操作）。 

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

 Set<K> keySet() 
  返回此映射中包含的键的 Set 视图。
 Collection<V>  values() 
  返回此映射中包含的值的 Collection 视图。

 V  remove(Object key) 
  如果存在一个键的映射关系，则将其从此映射中移除（可选操作）。
 int    size() 
  返回此映射中的键-值映射关系数。

  ------------------------------------------------------------
 5.5.2 HashMap
 允许使用 null 值和 null 键。（除了非同步和允许使用 null 之外，HashMap 类与 Hashtable 大致相同。）
 不保证映射的顺序，特别是它不保证该顺序恒久不变。
 构造方法:
HashMap() 
  构造一个具有默认初始容量 (16) 和默认加载因子 (0.75) 的空 HashMap。
HashMap(int initialCapacity) 
  构造一个带指定初始容量和默认加载因子 (0.75) 的空 HashMap。
HashMap(int initialCapacity, float loadFactor) 
  构造一个带指定初始容量和加载因子的空 HashMap。
HashMap(Map<? extends K,? extends V> m) 
  构造一个映射关系与指定 Map 相同的新 HashMap。

  --------------------------------------------------------
5.5.3 Hashtable
key 和 value均不可为null值. 是同步的.其它同HashMap.

------------------------------------------------------------
5.5.4 LinkedHashMap
具有可预知的迭代顺序。此实现与 HashMap 的不同之处在于，它维护着一个运行于所有条目的双重链接列表。此链接列表定义了迭代顺序，该迭代顺序通常就是将键插入到映射中的顺序（插入顺序）。注意，如果在映射中重新插入 键，则插入顺序不受影响。

--------------------------------------------------------
5.5.5 TreeMap
基于红黑树（Red-Black tree）的 NavigableMap 实现。该映射根据其键的自然顺序进行排序，或者根据创建映射时提供的 Comparator 进行排序，具体取决于使用的构造方法。
注意，此实现不是同步的。

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

<T> boolean addAll(Collection< ? super T> c, T... elements) 
将多个指定元素添加到指定 collection 中。

<T> Queue<T>    asLifoQueue(Deque<T> deque) 
以后进先出 (Lifo) Queue 的形式返回某个 Deque 的视图。

<T> int binarySearch(List<? extends Comparable< ? super T>> list, T key) 
使用二分搜索法搜索指定列表，以获得指定对象。
<T> int binarySearch(List<? extends T> list, T key, Comparator<? super T> c) 
使用二分搜索法搜索指定列表，以获得指定对象。

<E> Collection<E>   checkedCollection(Collection<E> c, Class<E> type) 
返回指定 collection 的一个动态类型安全视图。
<E> List<E> checkedList(List<E> list, Class<E> type) 
返回指定列表的一个动态类型安全视图。
<K,V> Map<K,V> checkedMap(Map<K,V> m, Class<K> keyType, Class<V> valueType) 
返回指定映射的一个动态类型安全视图。
<E> Set<E>  checkedSet(Set<E> s, Class<E> type) 
返回指定 set 的一个动态类型安全视图。
<K,V> SortedMap<K,V>    checkedSortedMap(SortedMap<K,V> m, Class<K> keyType, Class<V> valueType)  
返回指定有序映射的一个动态类型安全视图。
<E> SortedSet<E> checkedSortedSet(SortedSet<E> s, Class<E> type) 
返回指定有序 set 的一个动态类型安全视图。

<T> void copy(List<? super T> dest, List<? extends T> src) 
将所有元素从一个列表复制到另一个列表。

boolean disjoint(Collection<?> c1, Collection<?> c2) 
如果两个指定 collection 中没有相同的元素，则返回 true。

<T> List<T> emptyList() 
返回空的列表（不可变的）。
<K,V> Map<K,V>  emptyMap() 
返回空的映射（不可变的）。
<T> Set<T>  emptySet() 
返回空的 set（不可变的）。

<T> Enumeration<T>  enumeration(Collection<T> c) 
返回一个指定 collection 上的枚举。

<T> void    fill(List< ? super T> list, T obj) 
使用指定元素替换指定列表中的所有元素。

static int  frequency(Collection<?> c, Object o) 
返回指定 collection 中等于指定对象的元素数。

static int  indexOfSubList(List< ?> source, List<?> target) 
返回指定源列表中第一次出现指定目标列表的起始位置；如果没有出现这样的列表，则返回 -1。
static int  lastIndexOfSubList(List< ?> source, List<?> target) 
返回指定源列表中最后一次出现指定目标列表的起始位置；如果没有出现这样的列表，则返回 -1。

<T> ArrayList<T>    list(Enumeration<T> e) 
返回一个数组列表，它按返回顺序包含指定枚举返回的元素。

T   max(Collection< ? extends T> coll) 
根据元素的自然顺序，返回给定 collection 的最大元素。
<T> T   max(Collection< ? extends T> coll, Comparator< ? super T> comp) 
 根据指定比较器产生的顺序，返回给定 collection 的最大元素。

T   min(Collection< ? extends T> coll) 
根据元素的自然顺序 返回给定 collection 的最小元素。
<T> T   min(Collection< ? extends T> coll, Comparator< ? super T> comp) 
根据指定比较器产生的顺序，返回给定 collection 的最小元素。

< T> List< T>   nCopies(int n, T o) 
返回由指定对象的 n 个副本组成的不可变列表。

<E> Set<E>  newSetFromMap(Map<E,Boolean> map) 
返回指定映射支持的 set。

<T> boolean replaceAll(List<T> list, T oldVal, T newVal) 
使用另一个值替换列表中出现的所有某一指定值。

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

<T> Comparator<T>   reverseOrder() 
返回一个比较器，它强行逆转实现了 Comparable 接口的对象 collection 的自然顺序。
<T> Comparator<T>   reverseOrder(Comparator<T> cmp) 
返回一个比较器，它强行逆转指定比较器的顺序。

static void rotate(List< ?> list, int distance) 
根据指定的距离轮换指定列表中的元素。

static void shuffle(List< ?> list) 
使用默认随机源对指定列表进行置换。
static void shuffle(List< ?> list, Random rnd) 
使用指定的随机源对指定列表进行置换。

<T> Set<T>  singleton(T o) 
返回一个只包含指定对象的不可变 set。
<T> List<T> singletonList(T o) 
返回一个只包含指定对象的不可变列表。
<K,V> Map<K,V>  singletonMap(K key, V value) 
返回一个不可变的映射，它只将指定键映射到指定值。

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

static void swap(List< ?> list, int i, int j) 
在指定列表的指定位置处交换元素。
<T> Collection<T>   synchronizedCollection(Collection<T> c) 
返回指定 collection 支持的同步（线程安全的）collection。
<T> List<T> synchronizedList(List<T> list) 
返回指定列表支持的同步（线程安全的）列表。
<K,V> Map<K,V>  synchronizedMap(Map<K,V> m) 
返回由指定映射支持的同步（线程安全的）映射。
<T> Set<T>  synchronizedSet(Set<T> s) 
返回指定 set 支持的同步（线程安全的）set。
<K,V> SortedMap<K,V>    synchronizedSortedMap(SortedMap<K,V> m) 
返回指定有序映射支持的同步（线程安全的）有序映射。
<T> SortedSet<T>    synchronizedSortedSet(SortedSet<T> s) 
返回指定有序 set 支持的同步（线程安全的）有序 set。

<T> Collection<T>   unmodifiableCollection(Collection< ? extends T> c) 
返回指定 collection 的不可修改视图。
<T> List<T> unmodifiableList(List< ? extends T> list) 
返回指定列表的不可修改视图。
<K,V> Map<K,V>  unmodifiableMap(Map< ? extends K,? extends V> m) 
返回指定映射的不可修改视图。
<T> Set<T>  unmodifiableSet(Set< ? extends T> s) 
返回指定 set 的不可修改视图。
<K,V> SortedMap<K,V>    unmodifiableSortedMap(SortedMap<K,? extends V> m) 
返回指定有序映射的不可修改视图。
<T> SortedSet<T>    unmodifiableSortedSet(SortedSet<T> s) 
返回指定有序 set 的不可修改视图。