java 集合框架

最新推荐文章于 2023-12-18 16:22:47 发布

weixin_30725315

最新推荐文章于 2023-12-18 16:22:47 发布

阅读量179

点赞数

原文链接：http://www.cnblogs.com/lifan1998/p/10388540.html

版权

java集合框架

java集合框架¹

目录图

框架图

List

Queue 方法	等效 Deque 方法
add(e)	addLast(e)
offer(e)	offerLast(e)
remove()	removeFirst()
poll()	pollFirst()
element()	getFirst()
peek()	peekFirst()

堆栈方法	等效 Deque 方法
push(e)	addFirst(e)
pop()	removeFirst()
peek()	peekFirst()

ArrayList

Serializable, Cloneable, Iterable<E>, Collection<E>, List<E>, RandomAccess
List list = Collections.synchronizedList(new ArrayList(...));

LinkedList

实现的接口：

Serializable, Cloneable, Iterable<E>, Collection<E>, Deque<E>, List<E>, Queue<E>

LinkedList 类还为在列表的开头及结尾 get、remove 和 insert 元素提供了统一的命名方法。这些操作允许将链接列表用作堆栈、队列或双端队列。

此类实现 Deque 接口，为 add、poll 提供先进先出队列操作，以及其他堆栈和双端队列操作。

IteratordescendingIterator() 返回以逆向顺序在此双端队列的元素上进行迭代的迭代器。

Vector

Serializable, Cloneable, Iterable<E>, Collection<E>, List<E>, RandomAccess

同步的

Vector() 构造一个空向量，使其内部数据数组的大小为 10，其标准容量增量为零。
Vector(int initialCapacity) 使用指定的初始容量和等于零的容量增量构造一个空向量。
Vector(int initialCapacity, int capacityIncrement) 使用指定的初始容量和容量增量构造一个空的向量。
void trimToSize() 对此向量的容量进行微调，使其等于向量的当前大小。

Stack

extends Vector<E>

Deque 接口及其实现提供了 LIFO 堆栈操作的更完整和更一致的 set，应该优先使用此 set，而非此类。例如：

Deque<Integer> stack = new ArrayDeque<Integer>();

特有方法

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

Map

HashMap

实现原理是数组+链表

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。

LinkedHashMap

extends HashMap<K,V>

返回的顺序与插入的顺序相同，你也可以这样使用

void foo(Map m) {
     Map copy = new LinkedHashMap(m);
     ...
 }

同步：

Map m = Collections.synchronizedMap(new LinkedHashMap(...));

Hashtable

extends Dictionary<K,V> implements Map<K,V>

它是同步的

protected void rehash()
增加此哈希表的容量并在内部对其进行重组，以便更有效地容纳和访问其元素。

Properties

extends Hashtable<Object,Object>

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

常用方法：

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 stringPropertyNames()
返回此属性列表中的键集，其中该键及其对应值是字符串，如果在主属性列表中未找到同名的键，则还包括默认属性列表中不同的键。

TreeMap

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

此实现为 containsKey、get、put 和 remove 操作提供受保证的 log(n) 时间开销。

TreeMap()
使用键的自然顺序构造一个新的、空的树映射。
TreeMap(Comparator<? super K> comparator)
构造一个新的、空的树映射，该映射根据给定比较器进行排序。
Map.Entry<K,V> ceilingEntry(K key)
返回一个键-值映射关系，它与大于等于给定键的最小键关联；如果不存在这样的键，则返回 null。
Comparator<? super K> comparator()
返回对此映射中的键进行排序的比较器；如果此映射使用键的自然顺序，则返回 null。
Set<Map.Entry<K,V>> entrySet()
返回此映射中包含的映射关系的 Set 视图。
Map.Entry<K,V> firstEntry()
返回一个与此映射中的最小键关联的键-值映射关系；如果映射为空，则返回 null。
Map.Entry<K,V> floorEntry(K key)
返回一个键-值映射关系，它与小于等于给定键的最大键关联；如果不存在这样的键，则返回 null
Map.Entry<K,V> lastEntry()
返回与此映射中的最大键关联的键-值映射关系；如果映射为空，则返回 null
V put(K key, V value)
将指定值与此映射中的指定键进行关联。

Set

HashSet

extends AbstractSet<E>implements Set<E>, Cloneable, Serializable

HashSet()
构造一个新的空 set，其底层 HashMap 实例的默认初始容量是 16，加载因子是 0.75。

LinkedHashSet

extends HashSetimplements Set, Cloneable, Serializable
具有可预知迭代顺序的 Set 接口的哈希表和链接列表实现。

void foo(Set s) {
Set copy = new LinkedHashSet(s);
...
}
LinkedHashSet()
构造一个带默认初始容量 (16) 和加载因子 (0.75) 的新空链接哈希 set。
LinkedHashSet(Collection<? extends E> c)
构造一个与指定 collection 中的元素相同的新链接哈希 set。
LinkedHashSet(int initialCapacity)
构造一个带指定初始容量和默认加载因子 (0.75) 的新空链接哈希 set。
LinkedHashSet(int initialCapacity, float loadFactor)
构造一个带有指定初始容量和加载因子的新空链接哈希 set。

TreeSet

extends AbstractSet<E>implements NavigableSet<E>, Cloneable, Serializable

基于 TreeMap 的 NavigableSet 实现。使用元素的自然顺序对元素进行排序，或者根据创建 set 时提供的 Comparator 进行排序，具体取决于使用的构造方法。

此实现为基本操作（add、remove 和 contains）提供受保证的 log(n) 时间开销。

常用方法：

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

boolean add(E e)
将指定的元素添加到此 set（如果该元素尚未存在于 set 中）。

E ceiling(E e)
返回此 set 中大于等于给定元素的最小元素；如果不存在这样的元素，则返回 null。
E floor(E e)
返回此 set 中小于等于给定元素的最大元素；如果不存在这样的元素，则返回 null。
E first()
返回此 set 中当前第一个（最低）元素。
E last()
返回此 set 中当前最后一个（最高）元素。
E lower(E e)
返回此 set 中严格小于给定元素的最大元素；如果不存在这样的元素，则返回 null。
E higher(E e)
返回此 set 中严格大于给定元素的最小元素；如果不存在这样的元素，则返回 null
E pollFirst()
获取并移除第一个（最低）元素；如果此 set 为空，则返回 null。
E pollLast()
获取并移除最后一个（最高）元素；如果此 set 为空，则返回 null。
IteratordescendingIterator()
返回在此 set 元素上按降序进行迭代的迭代器。
Iterator iterator()
返回在此 set 中的元素上按升序进行迭代的迭代器。

其它

Iterator和ListIterator区别

ListIterator有add()方法，可以向List中添加对象，而Iterator不能
ListIterator和Iterator都有hasNext()和next()方法，可以实现顺序向后遍历，但是ListIterator有hasPrevious()和previous()方法，可以实现逆向（顺序向前）遍历。Iterator就不可以。
ListIterator可以定位当前的索引位置，nextIndex()和previousIndex()可以实现。Iterator没有此功能。
都可实现删除对象，但是ListIterator可以实现对象的修改，set()方法可以实现。Iierator仅能遍历，不能修改。

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 返回的最后一个元素（可选操作）。

快速失败(fail-fast)和安全失败(fail-safe)的区别

快速失败（fail—fast）：
在用迭代器遍历一个集合对象时，如果遍历过程中对集合对象的内容进行了修改（增加、删除、修改），则会抛出Concurrent Modification Exception。

java.util包下的集合类都是快速失败的，不能在多线程下发生并发修改（迭代过程中被修改）
安全失败（fail—safe）:
采用安全失败机制的集合容器，在遍历时不是直接在集合内容上访问的，而是先复制原有集合内容，在拷贝的集合上进行遍历。

原理：由于迭代时是对原集合的拷贝进行遍历，所以在遍历过程中对原集合所作的修改并不能被迭代器检测到，所以不会触发Concurrent Modification Exception。

缺点：基于拷贝内容的优点是避免了Concurrent Modification Exception，但同样地，迭代器并不能访问到修改后的内容，即：迭代器遍历的是开始遍历那一刻拿到的集合拷贝，在遍历期间原集合发生的修改迭代器是不知道的。

场景：java.util.concurrent包下的容器都是安全失败，可以在多线程下并发使用，并发修改。

map空值问题

集合类	key	value	Super	说明
Hashtable	not null	not null	Dictionary	线程安全
ConcurrentHashMap	not null	not null	AbstractMap	锁分段技术（JDK8:CAS）
TreeMap	not null	null	AbstractMap	线程不安全
HashMap	null	null	AbstractMap	线程不安全

ArrayList的subList不可强转成ArrayList

ArrayList的subList不可强转成ArrayList,否则会抛出ClassCastException异常。

说明：

subList返回的是ArrayList的内部类SubList，并不是ArrayList而是ArrayList的一个视图，对SubList子列表的所有操作最终都会反映到原列表中

在subList场景中，高度注意对原集合的增加或删除，均会导致子列表的遍历，增加，删除产生的ConcurrentModificationExcetion异常。

比较器的使用

new Comparator<Student>(){
    @Override
    public int compare(Student o1,Student o2){
       if(o1.getScore() > o2.getScore()){
            return 1;
        }else if(o1.getScore() < o2.getScore()){
            return -1;
        }else{
            return 0;
        }
    }
}

Arrays.class

static int
binarySearch(T[] a, T key, Comparator<? super T> c)

    使用二分搜索法来搜索指定数组，以获得指定对象。

static void
sort(T[] a, Comparator<? super T> c)

    根据指定比较器产生的顺序对指定对象数组进行排序。

Collections.class

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

    使用二分搜索法搜索指定列表，以获得指定对象。

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

static T
min(Collection<? extends T> coll, Comparator<? super T> comp)

    根据指定比较器产生的顺序，返回给定 collection 的最小元素。

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

    根据指定比较器产生的顺序，返回给定 collection 的最大元素。

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

    根据指定比较器产生的顺序对指定列表进行排序。

Collections同步方法

static Collection
synchronizedCollection(Collection c)

    返回指定 collection 支持的同步（线程安全的）collection。

static List
synchronizedList(List list)

    返回指定列表支持的同步（线程安全的）列表。

static <K,V> Map<K,V>
synchronizedMap(Map<K,V> m)

    返回由指定映射支持的同步（线程安全的）映射。

static Set
synchronizedSet(Set s)

    返回指定 set 支持的同步（线程安全的）set。

static <K,V> SortedMap<K,V>
synchronizedSortedMap(SortedMap<K,V> m)

    返回指定有序映射支持的同步（线程安全的）有序映射。

static SortedSet
synchronizedSortedSet(SortedSet s)

    返回指定有序 set 支持的同步（线程安全的）有序 set。

Arrays.asList() 数组转集合

工具类Arrays.asList()把数组转集合时，不能使用其修改集合相关的方法，它的add/remove/clear方法会抛出异常。

说明：

asList的返回对象是一个Arrays内部类，并没有实现集合的修改方法。它体现的是适配器模式，只是转换接口，后台数据仍是数组。

另外数组转集合还可以用这个方法

static boolean
addAll(Collection<? super T> c, T... elements)

    将所有指定元素添加到指定 collection 中。

例：

List<String> resultList = new ArrayList<>(array.length);
Collections.addAll(resultList,array);

list 转数组

利用集合的toArray(T[] array)方法

String[] array = new String[list.size()];
array = list.toArray(array);

转载于:https://www.cnblogs.com/lifan1998/p/10388540.html

weixin_30725315

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java 集合框架

目录 java集合框架框架图 List Map Set 其它 java集合框架1目录图框架图List相关接口接口中出现的方法其实现类中必然都有且含义相同，所以先介绍接口，再看具体实现类实现的接口与相...
复制链接

扫一扫