表ADT
Java语言包含有一些普通数据结构的实现，这一部分通常被叫做Collections API。表ADT是在Collections API中实现的数据结构之一。
Collection接口
Collections API位于java.util包中，集合（collection）的概念在Collection接口中得到抽象，它存储一组类型相同的对象。
public interface Collection<E> extends Iterable<E> {
int size();
boolean isEmpty();
boolean contains(Object var1);
Iterator<E> iterator();
Object[] toArray();
<T> T[] toArray(T[] var1);
default <T> T[] toArray(IntFunction<T[]> generator) {
return this.toArray((Object[])generator.apply(0));
}
boolean add(E var1);
boolean remove(Object var1);
boolean containsAll(Collection<?> var1);
boolean addAll(Collection<? extends E> var1);
boolean removeAll(Collection<?> var1);
default boolean removeIf(Predicate<? super E> filter) {
Objects.requireNonNull(filter);
boolean removed = false;
Iterator each = this.iterator();
while(each.hasNext()) {
if (filter.test(each.next())) {
each.remove();
removed = true;
}
}
return removed;
}
boolean retainAll(Collection<?> var1);
void clear();
boolean equals(Object var1);
int hashCode();
default Spliterator<E> spliterator() {
return Spliterators.spliterator(this, 0);
}
default Stream<E> stream() {
return StreamSupport.stream(this.spliterator(), false);
}
default Stream<E> parallelStream() {
return StreamSupport.stream(this.spliterator(), true);
}
}源码告诉我们Collection接口扩展了Iterable接口，而实现了Iterable接口的那些类可以拥有增强for循环。
Iterator接口
Iterator是一个在java.util包中定义的接口。
实现Iterable接口的集合必须提供一个称为iterator的方法，该方法返回一个Iterator类型的对象。
public interface Iterator<E> {
boolean hasNext();
E next();
default void remove() {
throw new UnsupportedOperationException("remove");
}
default void forEachRemaining(Consumer<? super E> action) {
Objects.requireNonNull(action);
while (hasNext())
action.accept(next());
}
}Iterator的就是每个集合都可以通过iterator方法来创建并返回给用户一个Iterator接口的对象，并将当前位置的概念在对象内部存储下来。
当编译器看到一个增强for循环作用于Iterable的对象时，它用对iterator方法的那些调用代替增强的for循环得到一个Iterator对象，然后调用next和hasNext。
每次调用next都会给出集合的下一项。第一次调用next是给出集合的第一项。
remove可以删除由next最新返回的项，此后，直到再一次调用next方法之前都不能在调用remove。
至此我们会发现，Collection接口和Iterator接口都有一个remove方法，那么我们该如何选择呢？
当要探究这个问题之前，我们还需要记住一个重要的基本法则：当直接使用Iterator时，不能对正在被迭代的集合进行结构上的改变（如add，remove，clear方法），否则将会抛出异常（ConcurrentModificationException）。这也就意味着，只有在需要立即使用迭代器的时候我们才能进行获取操作。
接下来我们再看：
Collection接口的remove方法必须首先找出要被删除的项，如果事先知道所要删除的项的准确位置，那么此remove的开销就会很小。
举一个例子来看：在集合中每隔一项删除一项，这时我们用iterator迭代器的效率就会比Collection中remove的效率更高。而且Iterator中的remove方法对于迭代器来说是合法的。
List接口
public interface List<E> extends Collection<E> {
int size();
boolean isEmpty();
boolean contains(Object o);
Iterator<E> iterator();
Object[] toArray();
<T> T[] toArray(T[] a);
boolean add(E e);
boolean remove(Object o);
boolean containsAll(Collection<?> c);
boolean addAll(Collection<? extends E> c);
boolean addAll(int index, Collection<? extends E> c);
boolean removeAll(Collection<?> c);
boolean retainAll(Collection<?> c);
default void replaceAll(UnaryOperator<E> operator) {
Objects.requireNonNull(operator);
final ListIterator<E> li = this.listIterator();
while (li.hasNext()) {
li.set(operator.apply(li.next()));
}
}
@SuppressWarnings({"unchecked", "rawtypes"})
default void sort(Comparator<? super E> c) {
Object[] a = this.toArray();
Arrays.sort(a, (Comparator) c);
ListIterator<E> i = this.listIterator();
for (Object e : a) {
i.next();
i.set((E) e);
}
}
void clear();
boolean equals(Object o);
int hashCode();
E get(int index);
E set(int index, E element);
void add(int index, E element);
E remove(int index);
int indexOf(Object o);
int lastIndexOf(Object o);
ListIterator<E> listIterator();
ListIterator<E> listIterator(int index);
List<E> subList(int fromIndex, int toIndex);
@Override
default Spliterator<E> spliterator() {
return Spliterators.spliterator(this, Spliterator.ORDERED);
}
}呜呜呜，书上骗人，书上的List源代码只有五行，哭辽
源代码中有个listIterator方法，这个会产生比通常认为的还要复杂的迭代器。
ArrayList类、LinkedList类
ArrayList类的优点是get和set方法花费常数时间，缺点是删除和插入操作时间代价昂贵（除非是在表的末端进行）。
LinkedList类在明确欲操作项位置时，插入和删除的开销很小，但是get代价很大。其也提供了对两端的add、remove和get等操作。
在看源码的时候发现了：ArrayList的ensureCapacity()方法，书上的实现代码只用了六行……我是不是该换书了
public void ensureCapacity(int minCapacity) {
int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
// any size if not default element table
? 0
// larger than default for default empty table. It's already
// supposed to be at default size.
: DEFAULT_CAPACITY;
if (minCapacity > minExpand) {
ensureExplicitCapacity(minCapacity);
}
}
private void ensureCapacityInternal(int minCapacity) {
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}
ensureExplicitCapacity(minCapacity);
}
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
// overflow-conscious code
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
/**
* The maximum size of array to allocate.
* Some VMs reserve some header words in an array.
* Attempts to allocate larger arrays may result in
* OutOfMemoryError: Requested array size exceeds VM limit
*/
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
/**
* Increases the capacity to ensure that it can hold at least the
* number of elements specified by the minimum capacity argument.
*
* @param minCapacity the desired minimum capacity
*/
private void grow(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length;
int newCapacity = oldCapacity + (oldCapacity >> 1);
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
// minCapacity is usually close to size, so this is a win:
elementData = Arrays.copyOf(elementData, newCapacity);
}
private static int hugeCapacity(int minCapacity) {
if (minCapacity < 0) // overflow
throw new OutOfMemoryError();
return (minCapacity > MAX_ARRAY_SIZE) ?
Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
}ListIterator接口
ListIterator接口扩展了List的Iterator的功能。
previous和hasPrevious使得对表从后向前的遍历得以完成
栈和队列
记得刚学的时候，数据结构书上没有给出怎么用，然后就是：学到了，可是不知道怎么用……
后来是一次力扣做题看题解的时候跟着题解照猫画虎对照着写的……
Deque和Queue（此部分来自于）
1.Queue接口（单向队列）
Queue接口，是集合框架Collection的子接口，是一种常见的数据结构，遵循先进先出的原则。
是基于链表来进行实现，的单向队列。
LinkedList接口，实现了Queue，所以LinkedList，在插入和删除操作，效率会比较高。
poll（）：将队首的元素删除，并返回该元素。
peek（）：返回队首的元素，但不进行删除操作。
offer（）：将元素添加到队尾，如果成功，则返回true。2.Deque接口（双向队列）
Deque接口，是Queue接口的子接口，是指队列两端的元素，既能入队（offer）也能出队。
如果将Deque限制为只能从一端进行入队，和出队，就是栈的数据结构的实现。对于栈而言，有入栈（push）和出栈（pop），遵循先进后出的规则。
双端队列：
add(（e）/offer（e）：将元素增加到队列的末尾，如果成功，返回true。
remove（）/poll（）:将元素从队列的末尾删除。
element（）/peek（）：返回队首的元素，但不进行删除。
栈：
push（e）:入栈
pop（e）:出栈
peek（）:返回栈首元素，但不进行删除
Stack
public
class Stack<E> extends Vector<E> {
public Stack() {
}
public E push(E item) {
addElement(item);
return item;
}
public synchronized E pop() {
E obj;
int len = size();
obj = peek();
removeElementAt(len - 1);
return obj;
}
public synchronized E peek() {
int len = size();
if (len == 0)
throw new EmptyStackException();
return elementAt(len - 1);
}
public boolean empty() {
return size() == 0;
}
public synchronized int search(Object o) {
int i = lastIndexOf(o);
if (i >= 0) {
return size() - i;
}
return -1;
}
private static final long serialVersionUID = 1224463164541339165L;
}
444
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
