java 集合总结

106 阅读 0 评论 70 点赞

我是靠谱客的博主无奈小蜜蜂，这篇文章主要介绍java 集合总结，现在分享给大家，希望可以做个参考。

1.综述

在java 1.2 之前，java中提供了四种类型的“集合类”：Vector（矢量），BitSet(位集)，Stack(堆栈)以及HashTable（散列表）。

在java 1.2时，推出新的集合，即现在我们常用的一些集合。包括Collections，Lists,Sets,Maps。下面是其关系脑图。

图 1

首先看到源码中public interface Collection<E> extends Iterable<E> {}；所以简单的介绍一下Iterable，

public interface Iterable<T> {

Iterator<T> iterator(); // 返回一个T类型元素的迭代器

/**

对可迭代的每个元素执行给定的操作(action)，直到所有元素都被处理或操作抛出异常为止。除非实现类另有规定，否则操作将按照迭代顺序执行(如果指定了迭代顺序)。由动作抛出的异常被转发给调用者，accept（）属于Consumer接口中的函数。
*/

default void forEach(Consumer<? super T> action) {
Objects.requireNonNull(action);
for (T t : this) {
action.accept(t);
}
}

// since 1.8 在这个可迭代的元素上创建一个Spliterator，关于Spliterator可查看博客https://blog.csdn.net/lh513828570/article/details/56673804

default Spliterator<T> spliterator() {
return Spliterators.spliteratorUnknownSize(iterator(), 0);
}

} 可以简单的认为：extends Iterator就是使collections拥有迭代器功能（Iterator<E> iterator();）。

2. 详解collection接口

collection本身拥有众多方法，包括：

图 2

retainAll(Collection<?> c)功能是保留执行retainAll的原始集合中重叠部分，改变了原集合的数据。

collection中主要有List和Set两个集合下面将详细介绍：

List集合：部分函数及描述

方法	描述
boolean contains(Object o)	如果此列表包含指定的元素，则返回true。更正式地说，如果且仅当此列表包含至少一个元素e (o= null ?)e = = null:o.equals(e))。
ListIterator<E> listIterator()	返回一个列表迭代器，遍历列表中的元素(按适当的顺序)。
int indexOf(Object o)	返回指定对象的索引位置，当存在多个时，返回第一个索引的位置，当不存在时，返回-1
int lastIndexOf(Object o)	返回指定对象的索引位置，当存在多个时，返回最后一个的索引位置，当不存在时，返回-1
List<E> subList(int fromIndex, int toIndex)	截取从起始索引fromIndex(包含)到终止索引位置ToIndex(不包含)的对象，重新生成一个List集合并返回

list主要有2个子类：list 有序，而且元素可以重复。

Arraylist:底层实现是数组结构，数组长度可变，特点查询效率高，增删较慢，而且线程不同步

LinkedList：底层实现是链表结构，特点查询效率低，增删较快。

set主要有2个类和1个接口。set 存储无序（存入和取出的顺序不一定相同），值不能重复。

HashSet:HashSet存储元素的顺序并不是按照存入时的顺序是按照hash值存储，取也是按照hash值取，所以hashset存取速度快，set通过hashcode()和equals方法进行判断元素是否重复，只能去重，不能排序。

TreeSet:只能存放引用类型，不能用于基本数据类型，去重并排序。TreeSet支持两种排序方法：自然排序和定制排序，默认采用自然排序。TreeSet是非同步的，线程不安全。

自然排序：TreeSet调用compare To比较元素之间的大小关系，然后按照升序排序。下面是源码部分

复制代码

public class TreeSet<E> extends AbstractSet<E>
implements NavigableSet<E>, Cloneable, java.io.Serializable {
//存放元素的map对象
private transient NavigableMap<E,Object> m;
//key-value ,不同的键都会对象相同的value, value = PRESENT
private static final Object PRESENT = new Object();
//指定的map对象
TreeSet(NavigableMap<E,Object> m) {
this.m = m;
}
//无参构造方法，初始化一个TreeMap对象
public TreeSet() {
this(new TreeMap<E,Object>());
}
//构造方法，指定比较器
public TreeSet(Comparator<? super E> comparator) {
this(new TreeMap<>(comparator));
}
//将集合中的元素转化为TreeSet存储
public TreeSet(Collection<? extends E> c) {
this();
addAll(c);
}
//构造方法，SortedSet转化为TreeSet存储，并使用SortedSet的比较器
public TreeSet(SortedSet<E> s) {
this(s.comparator());
addAll(s);
}
//遍历方法，返回m.keyset集合
public Iterator<E> iterator() {
return m.navigableKeySet().iterator();
}
//逆序排序的迭代器
public Iterator<E> descendingIterator() {
return m.descendingKeySet().iterator();
}
/**
* @since 1.6
*/
public NavigableSet<E> descendingSet() {
return new TreeSet<>(m.descendingMap());
}
//返回 m 包含的键值对的数量
public int size() {
return m.size();
}
//是否为空
public boolean isEmpty() {
return m.isEmpty();
}
//是否包含指定的key
public boolean contains(Object o) {
return m.containsKey(o);
}
//添加元素，调用m.put方法实现
public boolean add(E e) {
return m.put(e, PRESENT)==null;
}
//删除方法，调用m.remove()方法实现
public boolean remove(Object o) {
return m.remove(o)==PRESENT;
}
//清除集合
public void clear() {
m.clear();
}
//将一个集合中的所有元素添加到TreeSet中
public
boolean addAll(Collection<? extends E> c) {
// Use linear-time version if applicable
if (m.size()==0 && c.size() > 0 &&
c instanceof SortedSet &&
m instanceof TreeMap) {
SortedSet<? extends E> set = (SortedSet<? extends E>) c;
TreeMap<E,Object> map = (TreeMap<E, Object>) m;
Comparator<? super E> cc = (Comparator<? super E>) set.comparator();
Comparator<? super E> mc = map.comparator();
if (cc==mc || (cc != null && cc.equals(mc))) {
map.addAllForTreeSet(set, PRESENT);
return true;
}
}
return super.addAll(c);
}
//返回子集合，通过 m.subMap()方法实现
public NavigableSet<E> subSet(E fromElement, boolean fromInclusive,
E toElement,
boolean toInclusive) {
return new TreeSet<>(m.subMap(fromElement, fromInclusive,
toElement,
toInclusive));
}
//返回set的头部
public NavigableSet<E> headSet(E toElement, boolean inclusive) {
return new TreeSet<>(m.headMap(toElement, inclusive));
}
//返回尾部
public NavigableSet<E> tailSet(E fromElement, boolean inclusive) {
return new TreeSet<>(m.tailMap(fromElement, inclusive));
}
//返回子Set
public SortedSet<E> subSet(E fromElement, E toElement) {
return subSet(fromElement, true, toElement, false);
}
//返回set的头部
public SortedSet<E> headSet(E toElement) {
return headSet(toElement, false);
}
//返回set的尾部
public SortedSet<E> tailSet(E fromElement) {
return tailSet(fromElement, true);
}
//返回m使用的比较器
public Comparator<? super E> comparator() {
return m.comparator();
}
//返回第一个元素
public E first() {
return m.firstKey();
}
//返回最后一个元素
public E last() {
return m.lastKey();
}
//返回set中小于e的最大的元素
public E lower(E e) {
return m.lowerKey(e);
}
//返回set中小于/等于e的最大元素
public E floor(E e) {
return m.floorKey(e);
}
//返回set中大于/等于e的最大元素
public E ceiling(E e) {
return m.ceilingKey(e);
}
//返回set中大于e的最小元素
public E higher(E e) {
return m.higherKey(e);
}
//获取TreeSet中第一个元素，并从Set中删除该元素
public E pollFirst() {
Map.Entry<E,?> e = m.pollFirstEntry();
return (e == null) ? null : e.getKey();
}
//获取TreeSet中最后一个元素，并从Set中删除该元素
public E pollLast() {
Map.Entry<E,?> e = m.pollLastEntry();
return (e == null) ? null : e.getKey();
}
//克隆方法
public Object clone() {
TreeSet<E> clone = null;
try {
clone = (TreeSet<E>) super.clone();
} catch (CloneNotSupportedException e) {
throw new InternalError();
}
clone.m = new TreeMap<>(m);
return clone;
}
//将对象写入到输出流中。
private void writeObject(java.io.ObjectOutputStream s)
throws java.io.IOException {
// Write out any hidden stuff
s.defaultWriteObject();
// Write out Comparator
s.writeObject(m.comparator());
// Write out size
s.writeInt(m.size());
// Write out all elements in the proper order.
for (E e : m.keySet())
s.writeObject(e);
}
//从输入流中读取对象的信息
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
// Read in any hidden stuff
s.defaultReadObject();
// Read in Comparator
Comparator<? super E> c = (Comparator<? super E>) s.readObject();
// Create backing TreeMap
TreeMap<E,Object> tm;
if (c==null)
tm = new TreeMap<>();
else
tm = new TreeMap<>(c);
m = tm;
// Read in size
int size = s.readInt();
tm.readTreeSet(size, s, PRESENT);
}
//序列化版本号
private static final long serialVersionUID = -2479143000061671589L;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
public class TreeSet<E> extends AbstractSet<E>
implements NavigableSet<E>, Cloneable, java.io.Serializable {
//存放元素的map对象
private transient NavigableMap<E,Object> m;
//key-value ,不同的键都会对象相同的value, value = PRESENT
private static final Object PRESENT = new Object();
//指定的map对象
TreeSet(NavigableMap<E,Object> m) {
this.m = m;
}
//无参构造方法，初始化一个TreeMap对象
public TreeSet() {
this(new TreeMap<E,Object>());
}
//构造方法，指定比较器
public TreeSet(Comparator<? super E> comparator) {
this(new TreeMap<>(comparator));
}
//将集合中的元素转化为TreeSet存储
public TreeSet(Collection<? extends E> c) {
this();
addAll(c);
}
//构造方法，SortedSet转化为TreeSet存储，并使用SortedSet的比较器
public TreeSet(SortedSet<E> s) {
this(s.comparator());
addAll(s);
}
//遍历方法，返回m.keyset集合
public Iterator<E> iterator() {
return m.navigableKeySet().iterator();
}
//逆序排序的迭代器
public Iterator<E> descendingIterator() {
return m.descendingKeySet().iterator();
}
/**
* @since 1.6
*/
public NavigableSet<E> descendingSet() {
return new TreeSet<>(m.descendingMap());
}
//返回 m 包含的键值对的数量
public int size() {
return m.size();
}
//是否为空
public boolean isEmpty() {
return m.isEmpty();
}
//是否包含指定的key
public boolean contains(Object o) {
return m.containsKey(o);
}
//添加元素，调用m.put方法实现
public boolean add(E e) {
return m.put(e, PRESENT)==null;
}
//删除方法，调用m.remove()方法实现
public boolean remove(Object o) {
return m.remove(o)==PRESENT;
}
//清除集合
public void clear() {
m.clear();
}
//将一个集合中的所有元素添加到TreeSet中
public
boolean addAll(Collection<? extends E> c) {
// Use linear-time version if applicable
if (m.size()==0 && c.size() > 0 &&
c instanceof SortedSet &&
m instanceof TreeMap) {
SortedSet<? extends E> set = (SortedSet<? extends E>) c;
TreeMap<E,Object> map = (TreeMap<E, Object>) m;
Comparator<? super E> cc = (Comparator<? super E>) set.comparator();
Comparator<? super E> mc = map.comparator();
if (cc==mc || (cc != null && cc.equals(mc))) {
map.addAllForTreeSet(set, PRESENT);
return true;
}
}
return super.addAll(c);
}
//返回子集合，通过 m.subMap()方法实现
public NavigableSet<E> subSet(E fromElement, boolean fromInclusive,
E toElement,
boolean toInclusive) {
return new TreeSet<>(m.subMap(fromElement, fromInclusive,
toElement,
toInclusive));
}
//返回set的头部
public NavigableSet<E> headSet(E toElement, boolean inclusive) {
return new TreeSet<>(m.headMap(toElement, inclusive));
}
//返回尾部
public NavigableSet<E> tailSet(E fromElement, boolean inclusive) {
return new TreeSet<>(m.tailMap(fromElement, inclusive));
}
//返回子Set
public SortedSet<E> subSet(E fromElement, E toElement) {
return subSet(fromElement, true, toElement, false);
}
//返回set的头部
public SortedSet<E> headSet(E toElement) {
return headSet(toElement, false);
}
//返回set的尾部
public SortedSet<E> tailSet(E fromElement) {
return tailSet(fromElement, true);
}
//返回m使用的比较器
public Comparator<? super E> comparator() {
return m.comparator();
}
//返回第一个元素
public E first() {
return m.firstKey();
}
//返回最后一个元素
public E last() {
return m.lastKey();
}
//返回set中小于e的最大的元素
public E lower(E e) {
return m.lowerKey(e);
}
//返回set中小于/等于e的最大元素
public E floor(E e) {
return m.floorKey(e);
}
//返回set中大于/等于e的最大元素
public E ceiling(E e) {
return m.ceilingKey(e);
}
//返回set中大于e的最小元素
public E higher(E e) {
return m.higherKey(e);
}
//获取TreeSet中第一个元素，并从Set中删除该元素
public E pollFirst() {
Map.Entry<E,?> e = m.pollFirstEntry();
return (e == null) ? null : e.getKey();
}
//获取TreeSet中最后一个元素，并从Set中删除该元素
public E pollLast() {
Map.Entry<E,?> e = m.pollLastEntry();
return (e == null) ? null : e.getKey();
}
//克隆方法
public Object clone() {
TreeSet<E> clone = null;
try {
clone = (TreeSet<E>) super.clone();
} catch (CloneNotSupportedException e) {
throw new InternalError();
}
clone.m = new TreeMap<>(m);
return clone;
}
//将对象写入到输出流中。
private void writeObject(java.io.ObjectOutputStream s)
throws java.io.IOException {
// Write out any hidden stuff
s.defaultWriteObject();
// Write out Comparator
s.writeObject(m.comparator());
// Write out size
s.writeInt(m.size());
// Write out all elements in the proper order.
for (E e : m.keySet())
s.writeObject(e);
}
//从输入流中读取对象的信息
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
// Read in any hidden stuff
s.defaultReadObject();
// Read in Comparator
Comparator<? super E> c = (Comparator<? super E>) s.readObject();
// Create backing TreeMap
TreeMap<E,Object> tm;
if (c==null)
tm = new TreeMap<>();
else
tm = new TreeMap<>(c);
m = tm;
// Read in size
int size = s.readInt();
tm.readTreeSet(size, s, PRESENT);
}
//序列化版本号
private static final long serialVersionUID = -2479143000061671589L;
}