Java集合框架是Java语言中处理集合数据的一套标准库,它提供了丰富的类和接口,帮助开发者高效地管理数据。以下是Java集合框架中包含的类和接口的详细介绍。
1. Collection接口
作为集合框架的根接口,Collection 声明了所有集合共有的方法,例如添加、删除、查找和迭代元素等。它是所有集合类实现的超类。
public interface Collection<E> extends Iterable<E> {
boolean add(E e);
boolean remove(Object o);
boolean contains(Object o);
boolean isEmpty();
int size();
Iterator<E> iterator();
Object[] toArray();
<T> T[] toArray(T[] a);
boolean addAll(Collection<? extends E> c);
boolean removeAll(Collection<?> c);
boolean retainAll(Collection<?> c);
void clear();
}
2. List接口
List 接口继承自 Collection 接口,表示有序集合,允许重复元素。它提供了按索引访问元素的能力。
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);
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);
List<E> subList(int fromIndex, int toIndex);
}
3. Set接口
Set 接口也继承自 Collection 接口,表示无序集合,不允许重复元素。它提供了查找元素是否存在的能力。
public interface Set<E> extends Collection<E> {
boolean add(E e);
boolean remove(Object o);
boolean contains(Object o);
boolean isEmpty();
int size();
Iterator<E> iterator();
Object[] toArray();
<T> T[] toArray(T[] a);
boolean addAll(Collection<? extends E> c);
boolean retainAll(Collection<?> c);
boolean removeIf(Predicate<? super E> filter);
void clear();
}
4. Queue接口
Queue 接口继承自 Collection 接口,表示元素先进先出(FIFO)的队列。它提供了插入、删除、检查和检索元素的方法。
public interface Queue<E> extends Collection<E> {
boolean offer(E e);
E poll();
E peek();
boolean contains(Object o);
int size();
Iterator<E> iterator();
Object[] toArray();
<T> T[] toArray(T[] a);
}
5. Deque接口
Deque 接口继承自 Queue 接口,表示双端队列,允许在两端进行插入和删除操作。它提供了在队列两端的插入、删除和检索元素的方法。
public interface Deque<E> extends Queue<E> {
void addFirst(E e);
void addLast(E e);
E removeFirst();
E removeLast();
E getFirst();
E getLast();
boolean offerFirst(E e);
boolean offerLast(E e);
E pollFirst();
E pollLast();
E peekFirst();
E peekLast();
}
6. List接口的实现类
6.1 ArrayList
ArrayList 是基于动态数组实现的列表,随机访问速度快,但插入和删除操作较慢。
public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
private static final long serialVersionUID = 8683452581122892189L;
private transient Object[] elementData;
private int size;
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ARRAY;
}
public ArrayList(int initialCapacity) {
if (initialCapacity >= 0) {
this.elementData = new Object[initialCapacity];
} else {
throw new IllegalArgumentException("Illegal Capacity: " + initialCapacity);
}
}
public ArrayList(Collection<? extends E> c) {
elementData = c.toArray();
if ((size = elementData.length) != 0) {
// c.toArray() might (incorrectly) return "null" (see 6260652)
if (elementData.getClass() != Object[].class)
elementData = Arrays.copyOf(elementData, size, Object[].class);
} else {
// Replace with empty array.
this.elementData = DEFAULTCAPACITY_EMPTY_ARRAY;
}
}
// ... (其他方法)
}
6.2 LinkedList
LinkedList 是基于双向链表实现的列表,插入和删除操作较快,但随机访问速度慢。
public class LinkedList<E> extends AbstractSequentialList<E> implements List<E>, Deque<E>, Cloneable, java.io.Serializable {
private static final long serialVersionUID = 8683452581122892189L;
private static class Node<E> {
E item;
Node<E> next;
Node<E> prev;
Node(E element, Node<E> prev, Node<E> next) {
item = element;
this.prev = prev;
this.next = next;
}
}
private transient (Node<E>) first;
private transient (Node<E>) last;
private int size;
public LinkedList() {
}
public LinkedList(Collection<? extends E> c) {
super(c);
}
// ... (其他方法)
}
7. Set接口的实现类
7.1 HashSet
HashSet 是基于哈希表实现的集合,具有良好的性能,但不保证元素的顺序。
public class HashSet<E> extends AbstractSet<E> implements Set<E>, Cloneable, java.io.Serializable {
private static final long serialVersionUID = 1332172237904160800L;
private transient HashMap<E, Object> map;
public HashSet() {
map = new HashMap<>();
}
public HashSet(int initialCapacity) {
map = new HashMap<>(initialCapacity);
}
public HashSet(int initialCapacity, float loadFactor) {
map = new HashMap<>(initialCapacity, loadFactor);
}
public HashSet(Collection<? extends E> c) {
map = new HashMap<>(c);
}
// ... (其他方法)
}
7.2 LinkedHashSet
LinkedHashSet 是基于哈希表和链表实现的集合,既保证了性能,又保证了元素的插入顺序。
public class LinkedHashSet<E> extends HashSet<E> implements Set<E>, Cloneable, java.io.Serializable {
private static final long serialVersionUID = 8683452581122892189L;
public LinkedHashSet() {
super();
}
public LinkedHashSet(int initialCapacity) {
super(initialCapacity);
}
public LinkedHashSet(int initialCapacity, float loadFactor) {
super(initialCapacity, loadFactor);
}
public LinkedHashSet(Collection<? extends E> c) {
super(c);
}
// ... (其他方法)
}
7.3 TreeSet
TreeSet 是基于红黑树实现的集合,可以保证元素的有序性。
public class TreeSet<E> extends AbstractSet<E> implements NavigableSet<E>, Cloneable, java.io.Serializable {
private static final long serialVersionUID = -3106999030343635040L;
private transient Comparator<? super E> comparator;
private transient Object[] tree;
public TreeSet() {
comparator = null;
}
public TreeSet(Comparator<? super E> comparator) {
this.comparator = comparator;
}
public TreeSet(NavigableSet<? extends E> c) {
comparator = c.comparator();
if (comparator == null) {
comparator = tieBreaker;
}
if (c instanceof TreeSet<?>) {
TreeSet<? extends E> t = (TreeSet<? extends E>) c;
tree = t.tree;
} else {
TreeSet<E> s = new TreeSet<>(c);
tree = s.tree;
}
}
// ... (其他方法)
}
8. Queue接口的实现类
8.1 PriorityQueue
PriorityQueue 是基于优先队列实现的队列,元素按照自然排序或自定义的 Comparator 排序。
public class PriorityQueue<E> extends AbstractQueue<E> implements Queue<E>, Serializable {
private static final long serialVersionUID = -3170361109233564390L;
private final Comparator<? super E> comparator;
private transient Object[] queue;
public PriorityQueue() {
this(new PriorityQueueComparator<>());
}
public PriorityQueue(int initialCapacity) {
this(initialCapacity, new PriorityQueueComparator<>());
}
public PriorityQueue(int initialCapacity, Comparator<? super E> comparator) {
if (initialCapacity < 1 || comparator == null)
throw new IllegalArgumentException();
this.comparator = comparator;
this.queue = new Object[initialCapacity];
}
public PriorityQueue(Collection<? extends E> c) {
this(c, null);
}
public PriorityQueue(Collection<? extends E> c, Comparator<? super E> comparator) {
this(comparator);
if (c == null)
throw new NullPointerException();
initQueue(c);
}
// ... (其他方法)
}
8.2 ArrayDeque
ArrayDeque 是基于动态数组实现的队列,支持FIFO和LIFO操作。
public class ArrayDeque<E> extends AbstractCollection<E> implements Deque<E>, Cloneable, java.io.Serializable {
private static final long serialVersionUID = 8683452581122892189L;
private transient E[] elements;
private transient int head;
private transient int tail;
private transient int size;
public ArrayDeque() {
elements = (E[]) new Object[8];
}
public ArrayDeque(int initialCapacity) {
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal Capacity: " + initialCapacity);
elements = (E[]) new Object[initialCapacity];
}
public ArrayDeque(Collection<? extends E> c) {
elements = (E[]) new Object[c.size()];
addAll(c);
}
// ... (其他方法)
}
9. Deque接口的实现类
9.1 ArrayDeque
ArrayDeque 是基于动态数组实现的队列,支持FIFO和LIFO操作。
public class ArrayDeque<E> extends AbstractCollection<E> implements Deque<E>, Cloneable, java.io.Serializable {
private static final long serialVersionUID = 8683452581122892189L;
private transient E[] elements;
private transient int head;
private transient int tail;
private transient int size;
public ArrayDeque() {
elements = (E[]) new Object[8];
}
public ArrayDeque(int initialCapacity) {
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal Capacity: " + initialCapacity);
elements = (E[]) new Object[initialCapacity];
}
public ArrayDeque(Collection<? extends E> c) {
elements = (E[]) new Object[c.size()];
addAll(c);
}
// ... (其他方法)
}
9.2 LinkedList
LinkedList 是基于双向链表实现的队列,支持FIFO和LIFO操作。
public class LinkedList<E> extends AbstractSequentialList<E> implements List<E>, Deque<E>, Cloneable, java.io.Serializable {
private static final long serialVersionUID = 8683452581122892189L;
private static class Node<E> {
E item;
Node<E> next;
Node<E> prev;
Node(E element, Node<E> prev, Node<E> next) {
item = element;
this.prev = prev;
this.next = next;
}
}
private transient (Node<E>) first;
private transient (Node<E>) last;
private int size;
public LinkedList() {
}
public LinkedList(Collection<? extends E> c) {
super(c);
}
// ... (其他方法)
}
这些类和接口共同构成了Java集合框架,为Java程序提供了丰富的数据结构。开发者可以根据自己的需求选择合适的集合类,以实现高效的数据管理。
