Java Collections Framework（Java集合基础）

最新推荐文章于 2024-05-25 09:20:25 发布

温柔流浪

最新推荐文章于 2024-05-25 09:20:25 发布

阅读量124

点赞数

文章标签： Java集合框架集合中的常见问题主要集合的特点重要集合的方法

本文链接：https://blog.csdn.net/weixin_45495923/article/details/100023467

版权

Java 专栏收录该内容

36 篇文章 0 订阅

订阅专栏

Java Collections Framework（Java集合框架基础）

1、`Java.lang.Iterable`(接口 Iterable< T >)

1.1、作用

实现这个接口允许对象成为“foreach”语句的目标
public interface Iterable< T >

1.2、方法

方法摘要	方法	方法描述
`Iterator< T>`	`iterator()`	返回一个在一组 T 类型的元素上进行迭代的迭代器。

iterator

Iterator<T> iterator()

返回一个在一组 T 类型的元素上进行迭代的迭代器。 

返回：		一个迭代器。

1.3、`foreach`

用法( Java 5 加入的特征之一)

for( 类型  变量名称 : 数组实例 或 Iterable 实例 ) {
    // 通过循环中声明的变量来访问元素
}

注意事项：

foreach不支持在循环中添加删除操作，因为在使用foreach循环的时候数组（集合）就已经被锁定不能被修改，否则会报出java.util.ConcurrentModificationException异常。

1.4、典型的子接口

1.4.1、`java.util.Collection`

public interface Collection<E> extends Iterable<E>
Collection 表示一组对象，这些对象也称为 collection 的元素。

1.4.1.1、典型的子接口

java.util.List
- public interface List<E> extends Collection<E>
- 有序的 collection（也称为序列）。此接口的用户可以对列表中每个元素的插入位置进行精确地控制。用户可以根据元素的整数索引（在列表中的位置）访问元素，并搜索列表中的元素。
java.util.Set
- public interface Set<E> extends Collection<E>
- 一个不包含重复元素的 collection。更确切地讲，set 不包含满足 e1.equals(e2) 的元素对 e1 和 e2，并且最多包含一个 null 元素。
java.util.Queue
- public interface Queue<E> extends Collection<E>
- 在处理元素前用于保存元素的 collection。

2、`java.util.Iterator`(接口 Iterator< E >)

2.1、作用

表示对集合进行迭代的迭代器
迭代器取代了以前的java.util.Enumeration
public interface Iterator< E >

2.2、方法

返回值类型	方法	方法概述
`boolean`	`hasNext()`	如果仍有元素可以迭代，则返回 `true`。
`E`	`next()`	返回迭代的下一个元素。
`void`	`remove()`	从迭代器指向的 collection 中移除迭代器返回的最后一个元素（可选操作）。

2.3、典型子接口

java.util.ListIterator
- 作用：系列表迭代器，允许程序员按任一方向遍历列表、迭代期间修改列表，并获得迭代器在列表中的当前位置。
- 方法

返回值类型	方法	方法概述
`void`	`add(E e)`	将指定的元素插入列表（可选操作）。
`boolean`	`hasNext()`	以正向遍历列表时，如果列表迭代器有多个元素，则返回 `true`（换句话说，如果 `next` 返回一个元素而不是抛出异常，则返回 `true`）。
`boolean`	`hasPrevious()`	如果以逆向遍历列表，列表迭代器有多个元素，则返回 `true`。
`E`	`next()`	返回列表中的下一个元素。
`int`	`nextIndex()`	返回对 `next` 的后续调用所返回元素的索引。
`E`	`previous()`	返回列表中的前一个元素。
`int`	`previousIndex()`	返回对 `previous` 的后续调用所返回元素的索引。
`void`	`remove()`	从列表中移除由 `next` 或 `previous` 返回的最后一个元素（可选操作）。
`void`	`set(E e)`	用指定元素替换 `next` 或 `previous` 返回的最后一个元素（可选操作）。

3、`java.utill.Collection`(接口 Collection< E >)

3.1、`java.util.List`

3.1.1、特点

有序
可重复
可排序

3.1.2、方法

返回值类型	方法	方法概述
`boolean`	`add(E e)`	向列表的尾部添加指定的元素（可选操作）。
`void`	`add(int index, E element)`	在列表的指定位置插入指定元素（可选操作）。
`boolean`	`addAll(Collection<? extends E> c)`	添加指定 collection 中的所有元素到此列表的结尾，顺序是指定 collection 的迭代器返回这些元素的顺序（可选操作）。
`boolean`	`addAll*int index, Collection<? extends E> c)`	将指定 collection 中的所有元素都插入到列表中的指定位置（可选操作）。
`void`	`clear()`	从列表中移除所有元素（可选操作）。
`boolean`	`contains(Object o)`	如果列表包含指定的元素，则返回 `true`。
`boolean`	`containsAll(Collection<?> c)`	如果列表包含指定 collection 的所有元素，则返回 `true`。
`boolean`	`equals(Object o)`	比较指定的对象与列表是否相等。
`E`	`get(int index)`	返回列表中指定位置的元素。
`int`	`hashCode()`	返回列表的哈希码值。
`int`	`indexOf(Object o)`	返回此列表中第一次出现的指定元素的索引；如果此列表不包含该元素，则返回 -1。
`boolean`	`isEmpty()`	如果列表不包含元素，则返回 `true`。
`Iterator<E>`	`iterator()`	返回按适当顺序在列表的元素上进行迭代的迭代器。
`int`	`lastIndexOf(Object o)`	返回此列表中最后出现的指定元素的索引；如果列表不包含此元素，则返回 -1。
`ListIterator<E>`	`listIterator()`	返回此列表元素的列表迭代器（按适当顺序）。
`ListIterator<E>`	`listIterator(int index)`	返回列表中元素的列表迭代器（按适当顺序），从列表的指定位置开始。
`E`	`remove(int index)`	移除列表中指定位置的元素（可选操作）。
`boolean`	`remove(Object o)`	从此列表中移除第一次出现的指定元素（如果存在）（可选操作）。
`boolean`	`removeAll(Collection<?> c)`	从列表中移除指定 collection 中包含的其所有元素（可选操作）。
`boolean`	`retainAll(Collection<?> c)`	仅在列表中保留指定 collection 中所包含的元素（可选操作）。
`E`	`set(int index, E element)`	用指定元素替换列表中指定位置的元素（可选操作）。
`int`	`size()`	返回列表中的元素数。
`List<E>`	`subList(int fromIndex, int toIndex)`	返回列表中指定的 `fromIndex`（包括）和 `toIndex`（不包括）之间的部分视图。
`Object[]`	`toArray()`	返回按适当顺序包含列表中的所有元素的数组（从第一个元素到最后一个元素）。
`<T> T[]`	`toArray(T[] a)`	返回按适当顺序（从第一个元素到最后一个元素）包含列表中所有元素的数组；返回数组的运行时类型是指定数组的运行时类型。

3.1.3、重要的实现类

3.1.3.1、`java.util.ArrayList`

List 接口的大小可变数组的实现。实现了所有可选列表操作，并允许包括在内的所有元素。除了实现接口外，此类还提供一些方法来操作内部用来存储列表的数组的大小。（此类大致上等同于Vector类，除了此类是不同步的。）

3.1.3.1.1、特点

内部采用数组来存储元素
线程不安全：线程不同步
扩容方式：ArrayList是支持根据需要而动态增长的数组。java中标准数组是定长的，在数组被创建之后，它们不能被加长或缩短。这就意味着在创建数组时需要知道数组的所需长度，但有时我们需要动态程序中获取数组长度。ArrayList就是为此而生的。

源码分析：

如果在添加的时候远数组是空的，就直接给一个10的长度，否则的话就加一

 if (minCapacity - elementData.length > 0)
            grow(minCapacity);

可以简单理解为扩容至原容量的1.5倍

     
   private void grow(int minCapacity) {
           // 获取到ArrayList中elementData数组的内存空间长度
           int oldCapacity = elementData.length;
          // 扩容至原来的1.5倍
          int newCapacity = oldCapacity + (oldCapacity >> 1);
          // 再判断一下新数组的容量够不够，够了就直接使用这个长度创建新数组，
           // 不够就将数组长度设置为需要的长度
          if (newCapacity - minCapacity < 0)
              newCapacity = minCapacity;
          //若预设值大于默认的最大值检查是否溢出
          if (newCapacity - MAX_ARRAY_SIZE > 0)
              newCapacity = hugeCapacity(minCapacity);
          // 调用Arrays.copyOf方法将elementData数组指向新的内存空间时newCapacity的连续空间
          // 并将elementData的数据复制到新的内存空间
          elementData = Arrays.copyOf(elementData, newCapacity);
      }

允许存在null元素

3.1.3.1.2、构造

方法	方法概述
`ArrayList()`	构造一个初始容量为 10 的空列表。
`ArrayList(Collection<? extends E> c)`	构造一个包含指定 collection 的元素的列表，这些元素是按照该 collection 的迭代器返回它们的顺序排列的。
`ArrayList(int initialCapacity)`	构造一个具有指定初始容量的空列表。

3.1.3.1.3、方法

返回值类型	方法	方法概述
`boolean`	`add(E e)`	将指定的元素添加到此列表的尾部。
`void`	`add(int index, E element)`	将指定的元素插入此列表中的指定位置。
`boolean`	`addAll(Collection<? extends E> c)`	按照指定 collection 的迭代器所返回的元素顺序，将该 collection 中的所有元素添加到此列表的尾部。
`boolean`	`addAll(int index, Collection<? extends E> c)`	从指定的位置开始，将指定 collection 中的所有元素插入到此列表中。
`void`	`clear()`	移除此列表中的所有元素。
`Object`	`clone()`	返回此 `ArrayList` 实例的浅表副本。
`boolean`	`contains(Object o)`	如果此列表中包含指定的元素，则返回 `true`。
`void`	`ensureCapacity(int minCapacity)`	如有必要，增加此 `ArrayList` 实例的容量，以确保它至少能够容纳最小容量参数所指定的元素数。
`E`	`get(int index)`	返回此列表中指定位置上的元素。
`int`	`indexOf(Object o)`	返回此列表中首次出现的指定元素的索引，或如果此列表不包含元素，则返回 -1。
`boolean`	`isEmpty()`	如果此列表中没有元素，则返回 `true`
`int`	`lastIndexOf(Object o)`	返回此列表中最后一次出现的指定元素的索引，或如果此列表不包含索引，则返回 -1。
`E`	`remove(int index)`	移除此列表中指定位置上的元素。
`boolean`	`remove(Object o)`	移除此列表中首次出现的指定元素（如果存在）。
`protected void`	`removeRange(int fromIndex, int toIndex)`	移除列表中索引在 `fromIndex`（包括）和 `toIndex`（不包括）之间的所有元素。
`E`	`set(int index, E element)`	用指定的元素替代此列表中指定位置上的元素。
`int`	`size()`	返回此列表中的元素数。
`Object[]`	`toArray()`	按适当顺序（从第一个到最后一个元素）返回包含此列表中所有元素的数组。
`<T> T[]`	`toArray(T[] a)`	按适当顺序（从第一个到最后一个元素）返回包含此列表中所有元素的数组；返回数组的运行时类型是指定数组的运行时类型。
`void`	`trimToSize()`	将此 `ArrayList` 实例的容量调整为列表的当前大小。

3.1.3.2、`java.util.Vector`

3.1.3.2.1、特点

内部采用数组来存储元素
线程安全的
扩容方式
允许存在 null 元素

3.1.3.2.2、子类

java.util.Stack
Stack 类表示后进先出（LIFO）的对象堆栈
- 栈的特点: LIFO , Last In First Out
- 构造:
```
public Stack(){
	//创建一个空堆栈。 
}
```
- 方法

返回值类型	方法	方法概述
`boolean`	`empty()`	测试堆栈是否为空。
`E`	`peek()`	查看堆栈顶部的对象，但不从堆栈中移除它。
`E`	`pop()`	移除堆栈顶部的对象，并作为此函数的值返回该对象。
`E`	`push(E item)`	把项压入堆栈顶部。
`int`	`search(Object o)`	返回对象在堆栈中的位置，以 1 为基数。

3.1.3.3、`java.util.LinkedList`

public class LinkedList<E>extendsAbstractSequentialList<E>implements List<E>, Deque<E>, Cloneable, Serializable
List 接口的链接列表实现

3.1.3.3.1、特点

内部采用链表来存储元素
线程不安全的
允许存在 null 元素

3.1.3.3.1、构造

构造方法	方法概要
`LinkedList()`	构造一个空列表。
`LinkedList(Collection<? extends E> c)`	构造一个包含指定 collection 中的元素的列表，这些元素按其 collection 的迭代器返回的顺序排列。

3.1.3.3.1、方法

返回值类型	方法	方法概述
`boolean`	`add(E e)`	将指定元素添加到此列表的结尾。
`void`	`add(int index, E element)`	在此列表中指定的位置插入指定的元素。
`boolean`	`addAll(Collection<? extends E> c)`	添加指定 collection 中的所有元素到此列表的结尾，顺序是指定 collection 的迭代器返回这些元素的顺序。
`boolean`	`addAll(int index, Collection<? extends E> c)`	将指定 collection 中的所有元素从指定位置开始插入此列表。
`void`	`addFirst(E e)`	将指定元素插入此列表的开头。
`void`	`addLast(E e)`	将指定元素添加到此列表的结尾。
`void`	`clear()`	从此列表中移除所有元素。
`Object`	`clone()`	返回此 `LinkedList` 的浅表副本。
`boolean`	`contains(Object o)`	如果此列表包含指定元素，则返回 `true`。
`Iterator<E>`	`descendingIterator()`	返回以逆向顺序在此双端队列的元素上进行迭代的迭代器。
`E`	`element()`	获取但不移除此列表的头（第一个元素）。
`E`	`get(int index)`	返回此列表中指定位置处的元素。
`E`	`getFirst()`	返回此列表的第一个元素。
`E`	`getLast()`	返回此列表的最后一个元素。
`int`	`indexOf(Object o)`	返回此列表中首次出现的指定元素的索引，如果此列表中不包含该元素，则返回 -1。
`int`	`lastIndexOf(Object o)`	返回此列表中最后出现的指定元素的索引，如果此列表中不包含该元素，则返回 -1。
`ListIterator<E>`	`listIterator(int index)`	返回此列表中的元素的列表迭代器（按适当顺序），从列表中指定位置开始。
`boolean`	`offer(E e)`	将指定元素添加到此列表的末尾（最后一个元素）。
`boolean`	`offerFirst(E e)`	在此列表的开头插入指定的元素。
`boolean`	`offerLast(E e)`	在此列表末尾插入指定的元素。
`E`	`peek()`	获取但不移除此列表的头（第一个元素）。
`E`	`peekFirst()`	获取但不移除此列表的第一个元素；如果此列表为空，则返回 `null`。
`E`	`peekLast()`	获取但不移除此列表的最后一个元素；如果此列表为空，则返回 `null`。
`E`	`poll()`	获取并移除此列表的头（第一个元素）
`E`	`pollFirst()`	获取并移除此列表的第一个元素；如果此列表为空，则返回 `null`。
`E`	`pollLast()`	获取并移除此列表的最后一个元素；如果此列表为空，则返回 `null`。
`E`	`pop()`	从此列表所表示的堆栈处弹出一个元素。
`void`	`push(E e)`	将元素推入此列表所表示的堆栈。
`E`	`remove()`	获取并移除此列表的头（第一个元素）。
`E`	`remove(int index)`	移除此列表中指定位置处的元素。
`boolean`	`remove(Object o)`	从此列表中移除首次出现的指定元素（如果存在）。
`E`	`removeFirst()`	移除并返回此列表的第一个元素。
`boolean`	`removeFirstOccurrence(Object o)`	从此列表中移除第一次出现的指定元素（从头部到尾部遍历列表时）。
`E`	`removeLast()`	移除并返回此列表的最后一个元素。
`boolean`	`removeLastOccurrence(Object o)`	从此列表中移除最后一次出现的指定元素（从头部到尾部遍历列表时）。
`E`	`set(int index, E element)`	将此列表中指定位置的元素替换为指定的元素。
`int`	`size()`	返回此列表的元素数。
`Object[]`	`toArray()`	返回以适当顺序（从第一个元素到最后一个元素）包含此列表中所有元素的数组。
`<T> T[]`	`toArray(T[] a)`	返回以适当顺序（从第一个元素到最后一个元素）包含此列表中所有元素的数组；返回数组的运行时类型为指定数组的类型。

3.2、`java.util.Queue`

3.2.1、队列的特点

FIFO , First In First Out ( 先进先出 )

3.2.2、单段队列

3.2.3、`java.util.Deque`

双端队列 ( double ended queue )

3.2.3.1、`java.util.LinkedList`

特点
- 内部采用链表来存储元素
- 线程不安全的
- 允许存在 null 元素

3.3、`java.util.Set`

3.3.1、特点

无序
不可重复

3.3.2、方法

返回值类型	方法	方法概述
`boolean`	`add(E e)`	如果 set 中尚未存在指定的元素，则添加此元素（可选操作）。
`boolean`	`addAll(Collection<? extends E> c)`	如果 set 中没有指定 collection 中的所有元素，则将其添加到此 set 中（可选操作）。
`void`	`clear()`	移除此 set 中的所有元素（可选操作）。
`boolean`	`contains(Object o)`	如果 set 包含指定的元素，则返回 `true`。
`boolean`	`containsAll(Collection<?> c)`	如果此 set 包含指定 collection 的所有元素，则返回 `true`。
`boolean`	`equals(Object o)`	比较指定对象与此 set 的相等性。
`int`	`hashCode()`	返回 set 的哈希码值。
`boolean`	`isEmpty()`	如果 set 不包含元素，则返回 `true`。
`Iterator<E>`	`iterator()`	返回在此 set 中的元素上进行迭代的迭代器。
`boolean`	`remove(Object o)`	如果 set 中存在指定的元素，则将其移除（可选操作）。
`boolean`	`removeAll(Collection<?> c)`	移除 set 中那些包含在指定 collection 中的元素（可选操作）。
`boolean`	`retainAll(Collection<?> c)`	仅保留 set 中那些包含在指定 collection 中的元素（可选操作）。
`int`	`size()`	返回 set 中的元素数（其容量）。
`Object[]`	`toArray()`	返回一个包含 set 中所有元素的数组。
`<T> T[]`	`toArray(T[] a)`	返回一个包含此 set 中所有元素的数组；返回数组的运行时类型是指定数组的类型。

3.3.3、实现类

java.util.HashSet
- 特点
  - 内部采用哈希表来存储元素
  - 非线程安全
  - 允许存在 null 元素
- 构造

构造方法	方法概要
`HashSet()`	构造一个新的空 set，其底层 `HashMap` 实例的默认初始容量是 16，加载因子是 0.75。
`HashSet(Collection<? extends E> c)`	构造一个包含指定 collection 中的元素的新 set。
`HashSet(int initialCapacity)`	构造一个新的空 set，其底层 `HashMap` 实例具有指定的初始容量和默认的加载因子（0.75）。
`HashSet(int initialCapacity, float loadFactor)`	构造一个新的空 set，其底层 `HashMap` 实例具有指定的初始容量和指定的加载因子。

3.3.4、子接口 SortedSet

子接口 NavigableSet
- 实现类 TreeSet
  - 特点
    - 内部基于红黑树来存放元素（本质上是借助于 TreeMap 来存储数据）
    - 非线程安全
    - 不允许存在 null 元素
  - 构造

构造方法	方法概要
`TreeSet()`	构造一个新的空 set，该 set 根据其元素的自然顺序进行排序。
`TreeSet(Collection<? extends E> c)`	构造一个包含指定 collection 元素的新 TreeSet，它按照其元素的自然顺序进行排序。
`TreeSet(Comparator<? super E> comparator)`	构造一个新的空 TreeSet，它根据指定比较器进行排序。
`TreeSet(SortedSet<E> s)`	构造一个与指定有序 set 具有相同映射关系和相同排序的新 TreeSet。

4、`java.util.Map`

java.util 接口 Map<K,V>

类型参数：

K - 此映射所维护的键的类型

V - 映射值的类型

4.1、作用

将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。此接口取代 Dictionary 类，后者完全是一个抽象类，而不是一个接口。

4.2、特点

内部存放 “键-值” 对
- 实际上键和值被封装在同一个 Entry 对象中
- 在 Map 接口内部声明了一个内部接口 Entry 用来表示 "键-值"对 ( 映射项 )
不能包含重复的键
- 同一个 Map 内部的多个 Entry 中，不能包含 key 相同的 Entry
可以包含重复的值
- 同一个 Map 内部的多个 Entry 中，它们的 value 是可以相同的

4.3、设计

4.3.1、Map接口

public interface Map<K,V>

4.3.2、内部接口

修饰符	类名	作用
`static interface`	`Map.Entry<K,V>`	映射项（键-值对）。

4.3.2.1、方法

返回值类型	方法	方法概述
`boolean`	`equals(Object o)`	比较指定对象与此项的相等性。
`K`	`getKey()`	返回与此项对应的键。
`V`	`getValue()`	返回与此项对应的值。
`int`	`hashCode()`	返回此映射项的哈希码值。
`V`	`setValue(V value)`	用指定的值替换与此项对应的值（可选操作）。

4.4、方法

返回值类型	方法	方法概要
`void`	`clear()`	从此映射中移除所有映射关系（可选操作）。
`boolean`	`containsKey(Object key)`	如果此映射包含指定键的映射关系，则返回 `true`。
`boolean`	`containsValue(Object value)`	如果此映射将一个或多个键映射到指定值，则返回 `true`。
`Set<Map.Entry<K,V>>`	`entrySet()`	返回此映射中包含的映射关系的 `Set`视图。
`boolean`	`equals(Object o)`	比较指定的对象与此映射是否相等。
`V`	`get(Object key)`	返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 `null`。
`int`	`hashCode()`	返回此映射的哈希码值。
`boolean`	`isEmpty()`	如果此映射未包含键-值映射关系，则返回 `true`。
`Set<K>`	`keySet()`	返回此映射中包含的键的 `Set` 视图。
`V`	`put(K key, V value)`	将指定的值与此映射中的指定键关联（可选操作）。
`void`	`putAll(Map<? extends K,? extends V> m)`	从指定映射中将所有映射关系复制到此映射中（可选操作）。
`V`	`remove(Object key)`	如果存在一个键的映射关系，则将其从此映射中移除（可选操作）。
`int`	`size()`	返回此映射中的键-值映射关系数。
`Collection<V>`	`values()`	返回此映射中包含的值的 `Collection`视图。

4.5、实现类

4.5.1、java.util.HashMap

4.5.1.1、特点

内部采用哈希表来存储 “键-值对” ( 映射项 )
无序
非线程安全（此实现不是同步的）
键和值都可以为 null

4.5.1.2、构造

方法	方法概要
`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`。

4.5.2、java.util.Hashtable

4.5.2.1、特点

内部采用哈希表（采用数组 + 链表）来存储 “键-值对” ( 映射项 )
无序
线程安全（Hashtable类中所有的公开方法都是 synchronized 修饰的）
键和值都不可以为 null

4.5.2.2、构造

构造方法	方法概要
`Hashtable()`	用默认的初始容量 (11) 和加载因子 (0.75) 构造一个新的空哈希表。
`Hashtable(int initialCapacity)`	用指定初始容量和默认的加载因子 (0.75) 构造一个新的空哈希表。
`Hashtable(int initialCapacity, float loadFactor)`	用指定初始容量和指定加载因子构造一个新的空哈希表。
`Hashtable(Map<? extends K,? extends V> t)`	构造一个与给定的 Map 具有相同映射关系的新哈希表。

4.5.2.3、子类

4.5.2.3.1、`java.util.Properties`

Properties 类表示了一个持久的属性集。可保存在流中或从流中加载。属性列表中每个键及其对应值都是一个字符串。Properties是线程安全的。
字段

修饰符	字段	作用
`protected Properties`	`defaults`	一个属性列表，包含属性列表中所有未找到值的键的默认值。

构造

构造方法	方法概要
`Properties()`	创建一个无默认值的空属性列表。
`Properties(Properties defaults)`	创建一个带有指定默认值的空属性列表。

方法

返回值类型	方法	方法概要
`String`	`getProperty(String key)`	用指定的键在此属性列表中搜索属性。
`String`	`getProperty(String key, String defaultValue)`	用指定的键在属性列表中搜索属性。
`void`	`list(PrintStream out)`	将属性列表输出到指定的输出流。
`void`	`list(PrintWriter out)`	将属性列表输出到指定的输出流。
`void`	`load(InputStream inStream)`	从输入流中读取属性列表（键和元素对）。
`void`	`load(Reader reader)`	按简单的面向行的格式从输入字符流中读取属性列表（键和元素对）。
`void`	`loadFromXML(InputStream in)`	将指定输入流中由 XML 文档所表示的所有属性加载到此属性表中。
`Enumeration<?>`	`propertyNames()`	返回属性列表中所有键的枚举，如果在主属性列表中未找到同名的键，则包括默认属性列表中不同的键。
`Object`	`setProperty(String key, String value)`	调用 `Hashtable` 的方法 `put`。
`void`	`store(OutputStream out, String comments)`	以适合使用 `load(InputStream)` 方法加载到 `Properties` 表中的格式，将此 `Properties` 表中的属性列表（键和元素对）写入输出流。
`void`	`store(Writer writer, String comments)`	以适合使用 `load(Reader)`方法的格式，将此 `Properties` 表中的属性列表（键和元素对）写入输出字符。
`void`	`storeToXML(OutputStream os, String comment)`	发出一个表示此表中包含的所有属性的 XML 文档。
`void`	`storeToXML(OutputStream os, String comment, String encoding)`	使用指定的编码发出一个表示此表中包含的所有属性的 XML 文档。
`Set<String>`	`stringPropertyNames()`	返回此属性列表中的键集，其中该键及其对应值是字符串，如果在主属性列表中未找到同名的键，则还包括默认属性列表中不同的键。

4.6、子接口SortedMap

4.6.1、特点

有序

4.6.2、方法

返回值类型	方法	方法概述
`Comparator<? super K>`	`comparator()`	返回对此映射中的键进行排序的比较器；如果此映射使用键的自然顺序，则返回 `null`。
`Set<Map.Entry<K,V>>`	`entrySet()`	返回在此映射中包含的映射关系的 `Set` 视图。
`K`	`firstKey()`	返回此映射中当前第一个（最低）键。
`SortedMap<K,V>`	`headMap(K toKey)`	返回此映射的部分视图，其键值严格小于 `toKey`。
`Set<K>`	`keySet()`	返回在此映射中所包含键的 `Set` 视图。
`K`	`lastKey()`	返回映射中当前最后一个（最高）键。
`SortedMap<K,V>`	`subMap(K fromKey, K toKey)`	返回此映射的部分视图，其键值的范围从 `fromKey`（包括）到 `toKey`（不包括）。
`SortedMap<K,V>`	`tailMap(K fromKey)`	返回此映射的部分视图，其键大于等于 `fromKey`。
`Collection<V>`	`values()`	返回在此映射中所包含值的 `Collection`视图。

4.6.3、子接口NavigableMap

4.6.3.1、特点

具有了针对给定搜索目标返回最接近匹配项的导航方法

4.6.3.2、方法

返回值类型	方法	方法概述
`Map.Entry<K,V>`	`ceilingEntry(K key)`	返回一个键-值映射关系，它与大于等于给定键的最小键关联；如果不存在这样的键，则返回 `null`。
`K`	`ceilingKey(K key)`	返回大于等于给定键的最小键；如果不存在这样的键，则返回 `null`。
`NavigableSet<K>`	`descendingKeySet()`	返回此映射中所包含键的逆序 `NavigableSet` 视图。
`NavigableMap<K,V>`	`descendingMap()`	返回此映射中所包含映射关系的逆序视图。
`Map.Entry<K,V>`	`firstEntry()`	返回一个与此映射中的最小键关联的键-值映射关系；如果映射为空，则返回 `null`。
`Map.Entry<K,V>`	`floorEntry(K key)`	返回一个键-值映射关系，它与小于等于给定键的最大键关联；如果不存在这样的键，则返回 `null`。
`K`	`floorKey(K key)`	返回小于等于给定键的最大键；如果不存在这样的键，则返回 `null`。
`SortedMap<K,V>`	`headMap(K toKey)`	返回此映射的部分视图，其键值严格小于 `toKey`。
`NavigableMap<K,V>`	`headMap(K toKey, boolean inclusive)`	返回此映射的部分视图，其键小于（或等于，如果 `inclusive` 为 true）`toKey`
`Map.Entry<K,V>`	`higherEntry(K key)`	返回一个键-值映射关系，它与严格大于给定键的最小键关联；如果不存在这样的键，则返回 `null`。
`K`	`higherKey(K key)`	返回严格大于给定键的最小键；如果不存在这样的键，则返回 `null`。
`Map.Entry<K,V>`	`lastEntry()`	返回与此映射中的最大键关联的键-值映射关系；如果映射为空，则返回 `null`。
`Map.Entry<K,V>`	`lowerEntry(K key)`	返回一个键-值映射关系，它与严格小于给定键的最大键关联；如果不存在这样的键，则返回 `null`。
`K`	`lowerKey(K key)`	返回严格小于给定键的最大键；如果不存在这样的键，则返回 `null`。
`NavigableSet<K>`	`navigableKeySet()`	返回此映射中所包含键的 `NavigableSet` 视图。
`Map.Entry<K,V>`	`pollFirstEntry()`	移除并返回与此映射中的最小键关联的键-值映射关系；如果映射为空，则返回 `null`。
`Map.Entry<K,V>`	`pollLastEntry()`	移除并返回与此映射中的最大键关联的键-值映射关系；如果映射为空，则返回 `null`。
`NavigableMap<K,V>`	`subMap(K fromKey, boolean fromInclusive, K toKey, boolean toInclusive)`	返回此映射的部分视图，其键的范围从 `fromKey` 到 `toKey`。
`SortedMap<K,V>`	`subMap(K fromKey, K toKey)`	返回此映射的部分视图，其键值的范围从 `fromKey`（包括）到 `toKey`（不包括）。
`SortedMap<K,V>`	`tailMap(K fromKey)`	返回此映射的部分视图，其键大于等于 `fromKey`。
`NavigableMap<K,V>`	`tailMap(K fromKey, boolean inclusive)`	返回此映射的部分视图，其键大于（或等于，如果 `inclusive` 为 true）`fromKey`。

4.6.3.3、实现类TreeMap

4.6.3.3.1、特点

基于红黑树（Red-Black tree）的 NavigableMap 实现
有序
非线程安全(线程不同步)
key 不允许为null ， value 可以为 null

4.6.3.3.2、构造

构造方法	方法概述
`TreeMap()`	使用键的自然顺序构造一个新的、空的树映射。
`TreeMap(Comparator<? super K> comparator)`	构造一个新的、空的树映射，该映射根据给定比较器进行排序。
`TreeMap(Map<? extends K,? extends V> m)`	构造一个与给定映射具有相同映射关系的新的树映射，该映射根据其键的自然顺序进行排序。
`TreeMap(SortedMap<K,? extends V> m)`	构造一个与指定有序映射具有相同映射关系和相同排序顺序的新的树映射。

5、`java.util.Comparator`

public interface Comparator<T>
- 类型参数：T - 此 Comparator 可以比较的对象类型
强行对某个对象 collection 进行整体排序 的比较函数。

6、`java.lang.Comparable`

public interface Comparable<T>
此接口强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的 compareTo 方法被称为它的自然比较方法。

7、常见问题

7.1、简述 ArrayList 、Vector 、LinkedList 的异同

相同点

都是 java.util.List 接口的实现类
都是有序、可排序、可重复的集合
都支持迭代器操作

不同点

实现接口不同
- ArrayList 和 Vector 未实现 Queue 接口、Deque 接口，不支持队列操作
- LinkedList 实现了 Queue 接口和 Deque 接口，支持队列操作，同时支持栈操作
  - 请翻看API查看 Queue 、Deque 接口中声明的方法
  - 请翻看API查看 LinkedList 中对栈操作的支持
内部实现不同
- ArrayList 内部采用数组来存储元素
- Vector 内部采用数组来存储元素
- LinkedList 内部采用链表来存储元素
线程安全
- ArrayList 非线程安全，适用于单线程环境
- Vector 线程安全，适用于多线程环境
- LinkedList 非线程安全，适用于单线程环境
扩容方式不同
- ArrayList 内部采用 倍数增长 的方式扩容
- Vector 内部采用 增加固定增量 的方式扩容
- LinkedList 内部采用链表实现，不需要扩容
增删效率不同
- ArrayList 和 Vector 内部采用数组实现，因此增删慢
- LinkedList 内部采用链表实现，因此增删快
是否支持随机访问
- ArrayList 和 Vector 内部采用数组实现，因此随机访问效率较高
- LinkedList 内部采用链表实现，因此随机访问效率较低

7.2、HashMap 和 Hashtable 的区别

相同点

两者都实现 Map 接口，用于存放 键-值对
内部都采用哈希表实现，都采用哈希算法计算键-值对的存放位置

不同点

是否支持线程安全
- HashMap 非线程安全，理论上效率较高
- Hashtable 线程安全，理论上效率较低
内部实现不同
- 从 JDK 1.8 ( Java 8 ) 开始，HashMap 内部采用数组 + 链表 + 红黑树方式存储
  - 当链表长度大于8时会自动转换成红黑树
  - 当链表长度小于6时，红黑树重新转换成链表
- 而 Hashtable 内部则采用数组 + 链表实现
对元素位置的计算方法不同
- HashMap 内部采用一个单独的方法根据 key.hashCode() 重新计算一个哈希值后再确定元素存放位置
- Hashtable 内部直接采用 key.hashCode() 来确定元素存放位置
两者所继承的类不同
- HashMap 类继承 AbstraceMap 类
- Hashtable 类继承 Dictionary 类
是否支持 null
- HashMap 支持 null 键和 null 值
- Hashtable 不支持 null 键和 null 值

7.3、iterator与iterable的区别

区别就是Iterable接口是专门创建新的迭代器的，Iterator接口是一个专门设计迭代器的。

7.4、List、Set、Map的区别

List：
- 1.可以允许重复的对象。
- 2.可以插入多个null元素。
- 3.是一个有序容器，保持了每个元素的插入顺序，输出的顺序就是插入的顺序。
- 4.常用的实现类有 ArrayList、LinkedList 和 Vector。ArrayList 最为流行，它提供了使用索引的随意访问，而 LinkedList 则对于经常需要从 List 中添加或删除元素的场合更为合适。
Set：
- 1.不允许重复对象
- 2.无序容器，你无法保证每个元素的存储顺序，TreeSet通过 Comparator 或者 Comparable 维护了一个排序顺序。
- 3.只允许一个 null 元素
- 4.Set 接口最流行的几个实现类是 HashSet、LinkedHashSet 以及 TreeSet。最流行的是基于 HashMap 实现的 HashSet；TreeSet 还实现了 SortedSet 接口，因此 TreeSet 是一个根据其 compare() 和 compareTo() 的定义进行排序的有序容器。
Map:
- 1.Map不是collection的子接口或者实现类。Map是一个接口。
2.Map 的每个 Entry 都持有两个对象，也就是一个键一个值，Map 可能会持有相同的值对象但键对象必须是唯一的。
- 3.TreeMap 也通过 Comparator 或者 Comparable 维护了一个排序顺序。
- 4.Map 里你可以拥有随意个 null 值但最多只能有一个 null 键。
- 5.Map 接口最流行的几个实现类是 HashMap、LinkedHashMap、Hashtable 和 TreeMap。（HashMap、TreeMap最常用）

7.5、什么场景下使用List，Set，Map(优缺点)呢？

如果你经常会使用索引来对容器中的元素进行访问，那么 List 是你的正确的选择。如果你已经知道索引了的话，那么 List 的实现类比如 ArrayList 可以提供更快速的访问,如果经常添加删除元素的，那么肯定要选择LinkedList。
如果你想容器中的元素能够按照它们插入的次序进行有序存储，那么还是 List，因为 List 是一个有序容器，它按照插入顺序进行存储。
如果你想保证插入元素的唯一性，也就是你不想有重复值的出现，那么可以选择一个 Set 的实现类，比如 HashSet、LinkedHashSet 或者 TreeSet。所有 Set 的实现类都遵循了统一约束比如唯一性，而且还提供了额外的特性比如 TreeSet 还是一个 SortedSet，所有存储于 TreeSet 中的元素可以使用 Java 里的 Comparator 或者 Comparable 进行排序。LinkedHashSet 也按照元素的插入顺序对它们进行存储。
如果你以键和值的形式进行数据存储那么 Map 是你正确的选择。你可以根据你的后续需要从 Hashtable、HashMap、TreeMap 中进行选择。

温柔流浪

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java Collections Framework（Java集合基础）

Java Collections Framework（Java集合框架基础）1、Java.lang.Iterable(接口 Iterable< T >)1.1、作用实现这个接口允许对象成为“foreach”语句的目标public interface Iterable< T >1.2、方法方法摘要方法方法描述Iterator< T&...
复制链接

扫一扫