集合框架结构
Collection接口
集合层次结构中的根界面
public interface Collection<E> extends Iterable<E> {
//约定：所有实现Collection接口的类都分别提供一个无参构造函数和传入Collection参数的构造函数
//仅保留此集合中包含在指定集合中的元素
boolean retainAll(Collection<?> c);
boolean isEmpty();
boolean contains(Object o);
//返回当前集合的数组
Object[] toArray();
//返回指定类型元素数组，如果a长度小于集合则创建新的，否则直接传入a,且a中剩余空间为null
<T> T[] toArray(T[] a);
boolean add(E e);
boolean remove(Object o);
void clear();
//返回以此集合作为源的顺序 Stream
default Stream<E> stream()
default Stream<E> parallelStream()
}
AbstractCollection抽象类
提供了Collection接口的骨架实现，add，iterator，size未实现
public abstract class AbstractCollection<E> implements Collection<E> {
//集合的最大长度
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
public boolean isEmpty() {
return size() == 0;
}
public boolean contains(Object o) {
Iterator<E> it = iterator();
//遍历迭代器，如果o为空只要迭代器中存在空就返回true
//不为空则使用equals判断
if (o==null) {
while (it.hasNext())
if (it.next()==null)
return true;
} else {
while (it.hasNext())
if (o.equals(it.next()))
return true;
}
return false;
}
public <T> T[] toArray(T[] a) {
int size = size();
//三目运算如果a长度大于size则直接为a
//否则调用Array类创建一个size大小的新数组
T[] r = a.length >= size ? a :
(T[])java.lang.reflect.Array
.newInstance(a.getClass().getComponentType(), size);
//省略遍历迭代器赋值
}
public boolean remove(Object o) {
/**
*遍历迭代器Iterator.remove
*/
}
//遍历迭代器删除next(),remove()
public void clear()
//遍历当前集合元素，如果元素不存在c中则remove
public boolean retainAll(Collection<?> c)
//[e,e]
toString()
}
List接口
有序集合
public interface List<E> extends Collection<E> {
//将指定集合中的所有元素插入到此列表中的指定位置
boolean addAll(int index, Collection<? extends E> c);
//将该列表的每个元素替换为将该运算符应用于该元素的结果。调用ListIterator.set(operator结果)
default void replaceAll(UnaryOperator<E> operator)
//使用附带的 Comparator排序此列表来比较元素。
//将当前集合toArray转化为数组，然后调用Arrays.sort([],c),最后遍历集合ListIterator迭代器将当前数组的值set(迭代器中方法)入集合
default void sort(Comparator<? super E> c)
//返回此列表中指定位置的元素。
E get(int index);
//用指定的元素（可选操作）替换此列表中指定位置的元素。
E set(int index, E element);
//返回此列表中指定元素的第一次出现的索引，如果此列表不包含元素，则返回-1。
int indexOf(Object o);
//返回此列表中指定元素的最后一次出现的索引，如果此列表不包含元素，则返回-1。
int lastIndexOf(Object o);
//返回列表中指定的fromIndex和toIndex之间的部分视图(前闭后开)。
List<E> subList(int fromIndex, int toIndex);
//返回列表迭代器
ListIterator<E> listIterator();
//Collection集合中remove方法返回Boolean，这里返回被删除的元素
E remove(int index);
}
Queue接口
队列集合，设计用于在处理之前保留元素的集合。
public interface Queue<E> extends Collection<E> {
//将指定的元素插入到此队列中。如果队列已满返回false，add方法慢抛出异常
boolean offer(E e);
//检索并删除此队列的头。 为null抛出异常
E remove();
//检索并删除此队列的头，如果此队列为空，则返回 null 。
E poll();
//检索，但不删除，这个队列的头。为null抛出异常
E element();
//检索但不删除此队列的头，如果此队列为空，则返回 null 。
E peek();
}
Set接口
不包含重复元素的集合。集合不包含一对元素e1和e2 ，使得e1.equals(e2) ，并且最多一个空元素
public interface Set<E> extends Collection<E> {
//方法同Collection接口
}
SortedSet接口
提供不重复集合中元素的排序,插入到排序集中的所有元素必须实现Comparable接口
public interface SortedSet<E> extends Set<E> {
//返回用于对该集合中的元素进行排序的比较器，或null
Comparator<? super E> comparator();
//返回该集合的部分的视图，其元素的范围为[fromElement,toElement)
SortedSet<E> subSet(E fromElement, E toElement);
//返回该集合的部分的视图，其元素严格小于 toElement 。
SortedSet<E> headSet(E toElement);
//返回此组件的元素大于或等于 fromElement的部分的视图。
SortedSet<E> tailSet(E fromElement);
//返回此集合中当前的第一个（最低）元素。
E first();
//返回此集合中当前的最后（最高）元素。
E last();
}
AbstractList抽象类
public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E> {
//此列表已被结构修改的次数 对集合的修改都会导致该值改变
protected transient int modCount = 0;
//继承自Collection的add方法默认调用add(int,e)添加到集合末尾
public boolean add(E e) {
add(size(), e);
return true;
}
//遍历ListIterator，equals判断 ListIterator<E> it = listIterator();
public int indexOf(Object o)
//从最后一个元素开始遍历ListIterator ListIterator<E> it = listIterator(size());
public int lastIndexOf(Object o)
//调用ListIterator，删除0至size的元素
public void clear() {
removeRange(0, size());
}
//遍历集合中的元素生成hashCode
public int hashCode() {
int hashCode = 1;
for (E e : this)
hashCode = 31*hashCode + (e==null ? 0 : e.hashCode());
return hashCode;
}
//无论是生成SubList还是RandomAccessSubList，子集的操作实质都是对当前集合操作，所以删除、插入等也会改变当前集合。
public List<E> subList(int fromIndex, int toIndex) {
return (this instanceof RandomAccess ?
new RandomAccessSubList<>(this, fromIndex, toIndex) :
new SubList<>(this, fromIndex, toIndex));
}
//内部类，Iterator()返回的迭代器
private class Itr implements Iterator<E> {
//cursor表示当前迭代器中元素所在位置，lastRet表示调用next()之前的位置(如果remove，则为-1)
//expectedModCount用来检测并发修改抛出异常
int cursor = 0;
int lastRet = -1;
int expectedModCount = modCount;
//主要方法，next实际返回是调用集合的get方法
public E next() {
checkForComodification();
try {
int i = cursor;
E next = get(i);
lastRet = i;
cursor = i + 1;
return next;
} catch (IndexOutOfBoundsException e) {
checkForComodification();
throw new NoSuchElementException();
}
}
//调用集合的remove方法，最后修改expectedModCount为最新的modCount
public void remove() {
if (lastRet < 0)
throw new IllegalStateException();
checkForComodification();
try {
AbstractList.this.remove(lastRet);
if (lastRet < cursor)
cursor--;
lastRet = -1;
expectedModCount = modCount;
} catch (IndexOutOfBoundsException e) {
throw new ConcurrentModificationException();
}
}
}
//内部类，ListIterator()返回的迭代器
private class ListItr extends Itr implements ListIterator<E> {
//在当前迭代器位置添加元素
public void add(E e) {
checkForComodification();
try {
int i = cursor;
AbstractList.this.add(i, e);
lastRet = -1;
cursor = i + 1;
expectedModCount = modCount;
} catch (IndexOutOfBoundsException ex) {
throw new ConcurrentModificationException();
}
}
}
}
AbstractSet抽象类
此类提供的骨干实现Set界面最小化以实现此接口所需的工作。
public abstract class AbstractSet<E> extends AbstractCollection<E> implements Set<E> {
//将集合中所有元素的hashCode相加返回
public int hashCode() {
int h = 0;
Iterator<E> i = iterator();
while (i.hasNext()) {
E obj = i.next();
if (obj != null)
h += obj.hashCode();
}
return h;
}
//判断引用，判断是否为Set集合，返回containsAll
public boolean equals(Object o) {
if (o == this)
return true;
if (!(o instanceof Set))
return false;
Collection<?> c = (Collection<?>) o;
if (c.size() != size())
return false;
try {
return containsAll(c);
} catch (ClassCastException unused) {
return false;
} catch (NullPointerException unused) {
return false;
}
}
}
Map接口
将键映射到值的对象。不包含重复键
public interface Map<K,V> {
//内部接口,与内部类相似需要Map.Entry来实现,是对类逻辑的进一步细分
//内部接口总被static修饰
interface Entry<K,V> {
K getKey();
V getValue();
//用指定的值替换与该条目相对应的值
V setValue(V value);
//返回一个比较器 ，按键自然顺序比较Map.Entry 。
public static <K extends Comparable<? super K>, V> Comparator<Map.Entry<K,V>> comparingByKey() {
return (Comparator<Map.Entry<K, V>> & Serializable)
(c1, c2) -> c1.getKey().compareTo(c2.getKey());
}
//返回一个比较器，比较Map.Entry按键使用给定的Comparator 。
public static <K, V> Comparator<Map.Entry<K, V>> comparingByKey(Comparator<? super K> cmp) {
Objects.requireNonNull(cmp);
return (Comparator<Map.Entry<K, V>> & Serializable)
(c1, c2) -> cmp.compare(c1.getKey(), c2.getKey());
}
}
int size();
boolean isEmpty();
void clear();
//当前键值对是否包含键
boolean containsKey(Object key);
//当前键值对是否有一个或多个键映射到指定的值
boolean containsValue(Object value);
//给定key获得value
V get(Object key);
//返回此地图中包含的键的Set视图
Set<K> keySet();
//返回此地图中包含的映射的Set视图。
Set<Map.Entry<K, V>> entrySet();
//返回此地图中包含的值的Collection视图。
Collection<V> values();
//将指定的值与该映射中的指定键相关联
V put(K key, V value);
//将指定地图的所有映射复制到此映射
void putAll(Map<? extends K, ? extends V> m);
//移除当前键
V remove(Object key);
//仅当指定的密钥当前映射到指定的值时删除该条目。
default boolean remove(Object key, Object value) {
Object curValue = get(key);
if (!Objects.equals(curValue, value) ||
(curValue == null && !containsKey(key))) {
return false;
}
remove(key);
return true;
}
//返回到指定键所映射的值，否则返回默认值defaultValue。
default V getOrDefault(Object key, V defaultValue) {
V v;
return (((v = get(key)) != null) || containsKey(key))
? v
: defaultValue;
}
//用给定值替换键对应的值
default V replace(K key, V value) {
V curValue;
if (((curValue = get(key)) != null) || containsKey(key)) {
curValue = put(key, value);
}
return curValue;
}
//如果指定的键尚未与某个值相关联（或映射到null）将其与给定值相关联并返回 null，否则返回当前值。
default V putIfAbsent(K key, V value) {
V v = get(key);
if (v == null) {
v = put(key, value);
}
return v;
}
}
SortedMap接口
在map的基础上进一步提供其键上的总排序
public interface SortedMap<K,V> extends Map<K,V> {
//返回map的比较器
Comparator<? super K> comparator();
//返回此地图部分的视图，[fromKey,toKey)
SortedMap<K,V> subMap(K fromKey, K toKey);
//返回该地图的部分密钥严格小于toKey的视图
SortedMap<K,V> headMap(K toKey);
//返回此地图部分的视图，其键大于或等于 fromKey 。
SortedMap<K,V> tailMap(K fromKey);
//返回此地图中当前的第一个（最低）键。
K firstKey();
//返回当前在此地图中的最后（最高）键。
K lastKey();
}
AbstractMap抽象类
此类提供了Map接口的骨架实现，以尽量减少实现此接口所需的工作量。put
//成员变量
transient Set<K> keySet;//存放key的set集合
transient Collection<V> values;//存放value的Collection集合
public abstract class AbstractMap<K,V> implements Map<K,V> {
//内部SimpleEntry类
public static class SimpleEntry<K,V> implements Entry<K,V>, java.io.Serializable{
private final K key;
private V value;
//判断是否为Map.Entry接口，key与value是否相同
public boolean equals(Object o) {
if (!(o instanceof Map.Entry))
return false;
Map.Entry<?,?> e = (Map.Entry<?,?>)o;
return eq(key, e.getKey()) && eq(value, e.getValue());
}
//返回key和value hashCode的异或
public int hashCode() {
return (key == null ? 0 : key.hashCode()) ^
(value == null ? 0 : value.hashCode());
}
}
//map大小获取,从Set<Entry>集合获取
public int size() {
return entrySet().size();
}
//判断size()是否为0
public boolean isEmpty() {
return size() == 0;
}
public void clear() {
entrySet().clear();
}
//调用Set<Entry>集合的迭代器搜索key和value，如果为null值则返回第一个搜索到的null
public boolean containsValue(Object value)
public boolean containsKey(Object key)
public V get(Object key)
public V remove(Object key)//返回最后一个为null的
//遍历entrySet()
public void putAll(Map<? extends K, ? extends V> m) {
for (Map.Entry<? extends K, ? extends V> e : m.entrySet())
put(e.getKey(), e.getValue());
}
//成员变量keySet不为空则返回，否则创建一个新的AbstractSet包含entrySet().iterator()的迭代器
public Set<K> keySet()
//成员变量values不为空则返回,否则创建一个新的AbstractCollection包含entrySet().iterator()的迭代器
public Collection<V> values()
//遍历Set<Entry>对其中每个entry的hashcode相加,key^value
public int hashCode()
}
集合工具类
Array
存在于java.lang.reflect包中
提供静态方法来动态创建和访问Java数组
// 类不可继承、实例化
public final class Array {
private Array() {}
//主要方法如下
/**
*创建具有指定组件类型和长度的新数组。
*其中componentType传入创建的数组类型，可以通过Class.getComponentType方法获取,也可直接传入
*getComponentType数组类型调用返回对应数组组件类型,非数组调用返回null
*底层调用private static native Object newArray(Class<?> componentType, int length)
*例：newInstance(int.class,10) = new int[10]
*/
public static Object newInstance(Class<?> componentType, int length)
/**
*创建具有指定组件类型和维度的新数组。
*其中维度由可变参数dimensions.length决定，上限为255
*底层调用private static native Object multiNewArray(Class<?> componentType,
int[] dimensions)
*例：newInstance(int.class,3,3,3) = new int[3][3][3]
*/
public static Object newInstance(Class<?> componentType, int... dimensions)
/**
*返回指定数组对象中的索引组件的值。
*/
public static native Object get(Object array, int index)
/**
*将指定数组对象的索引组件的值设置为指定的新值。
*/
public static native void set(Object array, int index, Object value)
/**
*返回指定数组对象的长度，底层是jvm通过arraylength指令获取array对象对象头中存放的数组长度
*/
public static native int getLength(Object array)
}
集合常见接口
Iterator接口
表示一个集合的迭代器
package java.util;
public interface Iterator<E> {
boolean hasNext();
E next();
//从迭代器指向的 collection 中移除迭代器返回的最后一个元素
default void remove() {
throw new UnsupportedOperationException("remove");
}
//对每个剩余元素执行给定的操作，直到所有元素都被处理或动作引发异常。
default void forEachRemaining(Consumer<? super E> action) {
Objects.requireNonNull(action);
while (hasNext())
action.accept(next());
}
}
Iterable接口
实现此接口允许对象成为“for-each loop”语句的目标。
package java.lang;
public interface Iterable<T> {
//返回一个迭代器
Iterator<T> iterator();
default void forEach(Consumer<? super T> action)
default Spliterator<T> spliterator()
}
ListIterator接口
用于允许程序员沿任一方向遍历列表的列表的迭代器
public interface ListIterator<E> extends Iterator<E> {
//反向遍历判断
boolean hasPrevious();
//返回列表上一个元素
E previous();
//用指定的元素替换由 next()或 previous()返回的最后一个元素
void set(E e);
//将指定的元素插入列表
void add(E e);
//返回随后调用 next()返回的元素的索引。
int nextIndex();
//返回由后续调用 previous()返回的元素的索引。
int previousIndex();
}
Comparable接口
自然排序接口，实现自定义排序，使自身具有比较性
public interface Comparable<T> {
//当前元素与o比较，返回负，0，正
public int compareTo(T o);
}
Comparator接口
比较功能，对一些对象的集合施加了一个整体排序，标记为函数式接口，只能有一个抽象方法，能够使用Lambda表达式
@FunctionalInterface
public interface Comparator<T> {
//比较集合两个参数的顺序。
int compare(T o1, T o2);
boolean equals(Object obj);
}
RandomAccess接口
标记接口，表示实现该接口的类支持快速（通常为恒定时间）随机访问
public interface RandomAccess {
}
扫一扫
2158
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
