Collection接口是List、Set和Queue接口的父接口,该接口里定义的方法既可用操作Set集合,也可用于操作List和Queue集合
变量和类型 | 方法 | 描述 |
---|---|---|
boolean | add(E e) | 确保此集合包含指定的元素(可选操作) |
boolean | addAll(Collection c) | 将指定集合中的所有元素添加到此集合中(可选操作) |
void | clear() | 从此集合中删除所有元素(可选操作) |
boolean | contains(Object o) | 如果此collection包含指定的元素,则返回 true |
boolean | containsAll(Collection c) | 如果此集合包含指定集合中的所有元素,则返回 true |
boolean | equals(Object o) | 将指定对象与此集合进行比较以获得相等性 |
int | hashCode() | 返回此集合的哈希码值 |
boolean | isEmpty() | 如果此集合不包含任何元素,则返回 true |
Iterator | iterator() | 返回此集合中元素的迭代器 |
boolean | remove(Object o) | 从此集合中移除指定元素的单个实例(如果存在)(可选操作) |
boolean | removeAll(Collection c) | 删除此集合的所有元素,这些元素也包含在指定的集合中(可选操作) |
boolean | removeIf(Predicate filter) | 删除此集合中满足给定谓词的所有元素 |
boolean | retainAll(Collection c) | 仅保留此集合中包含在指定集合中的元素(可选操作) |
int | size() | 返回此集合中的元素数 |
Spliterator | spliterator() | 在此集合中的元素上创建Spliterator |
Stream | stream() | 返回以此集合为源的顺序Stream |
Object[] | toArray() | 返回包含此集合中所有元素的数组 |
T[] | toArray(IntFunction |
返回包含此集合中所有元素的数组,使用提供的 generator函数分配返回的数组 |
新增的toArray(IntFunction)方法,主要用来利用泛型。toArray()返回值总是Object[]。使用新增的toArray(IntFunctin)方法不同,当Collection使用泛型时,toArray(IntFunction)可以返回特定类型的数组
List strColl = List.of("java", "kotlin", "swift", "python");
String[] sa = (String[]) strColl.toArray(String[]::new);
System.out.println(Arrays.toString(sa));
由于使用该方法的主要目的就是利用泛型,因此toArray(IntFunction)方法参数通常是它要返回的数组类型后面加冒号和new(构造器引用)
当程序调用Iterable的forEach(Consumer action)遍历集合元素时,程序会依次将集合元素传给Consumer的accept(T t)方法(该接口中唯一的抽象方法)
import java.util.HashSet;
public class CollectionEach {
public static void main(String[] args) {
HashSet books = new HashSet();
books.add("轻量级Java EE 企业应用实战");
books.add("疯狂Java讲义");
books.add("疯狂Android讲义");
//调用forEach()方法遍历集合
books.forEach(obj -> System.out.println("迭代集合元素:" + obj));
}
}
Iterator则主要用于遍历(即迭代访问)Collection集合中的元素,Iterator 对象也被称为迭代器
import java.util.HashSet;
import java.util.Iterator;
public class IteratorTest {
public static void main(String[] args) {
HashSet books = new HashSet();
books.add("轻量级Java EE 企业应用实战");
books.add("疯狂Java讲义");
books.add("疯狂Android讲义");
Iterator it = books.iterator();
while(it.hasNext()) {
String book = (String)it.next();
System.out.println(book);
if(book.equals("疯狂Java讲义")) {
it.remove();
}
book = "测试字符串";
}
System.out.println(books);
}
}
当程序调用Iterator的forEachRemaining(Consumer action)遍历集合元素时,程序依次将集合传给Consumer的accept(T t)方法(该接口中唯一的抽象方法)
import java.util.HashSet;
import java.util.Iterator;
public class IteratorEach {
public static void main(String[] args) {
HashSet books = new HashSet();
books.add("轻量级Java EE 企业应用实战");
books.add("疯狂Java讲义");
books.add("疯狂Android讲义");
Iterator it = books.iterator();//获取books集合对应的迭代器
it.forEachRemaining(obj -> System.out.println("迭代集合元素:" + obj));
}
}
foreach循环中的迭代器变量也不是集合元素本身,系统只是依次把集合元素的值赋给迭代变量,因此在foreach循环中修改迭代变量的值也没有任何实际意义
import java.util.HashSet;
public class ForeachTest {
public static void main(String[] args) {
HashSet books = new HashSet();
books.add("轻量级JAVA EE企业实战");
books.add("疯狂JAVA讲义");
books.add("疯狂Android讲义");
for(String obj : books) {
String book = (String) obj;
System.out.println(book);
if(book.equals("疯狂Android讲义")) {
//下面代码会引起ConcurrentModificationException异常
// books.remove(book);
}
}
System.out.println(books);
}
}
Collection集合新增一个removeIf(Predicate filter)方法,该方法将会批量删除符合filter条件的所有元素。需要一个predicate(谓词)对象为参数。
import java.util.HashSet;
public class PredicateTest1 {
public static void main(String[] args) {
HashSet books = new HashSet();
books.add("轻量级JAVA EE企业实战");
books.add("疯狂JAVA讲义");
books.add("疯狂ios讲义");
books.add("疯狂Ajax讲义");
books.add("疯狂Android讲义");
//使用Lambda表达式(目标类型是Predicate)过滤集合
//长度小于10的元素全部被删除
books.removeIf(ele -> ((String) ele).length() < 10);
System.out.println(books);
}
}
使用Predicate充分简化集合的运算
import java.util.Collection;
import java.util.HashSet;
import java.util.function.Predicate;
public class PredicateTest2 {
public static void main(String[] args) {
HashSet books = new HashSet();
books.add("轻量级JAVA EE企业实战");
books.add("疯狂JAVA讲义");
books.add("疯狂ios讲义");
books.add("疯狂Ajax讲义");
books.add("疯狂Android讲义");
//统计书名包括“疯狂”的图书数量
System.out.println(calAll(books, ele -> ((String)ele).contains("疯狂")));
//统计书名包含“JAVA”的图书数量
System.out.println(calAll(books, ele -> ((String)ele).contains("JAVA")));
//统计图书名长度大于10的图书数量
System.out.println(calAll(books, ele -> ((String)ele).length() > 10));
}
public static int calAll(Collection books, Predicate
中间方法
方法 | 描述 |
---|---|
filter(Predicate predicate) | 返回由与此给定谓词匹配的此流的元素组成的流 |
mapToDouble(ToDoubleFunction mapper) | 返回 DoubleStream其中包含将给定函数应用于此流的元素的结果。 |
mapToInt(ToIntFunction mapper) | 返回 IntStream其中包含将给定函数应用于此流的元素的结果。 |
mapToLong(ToLongFunction mapper) | 返回 LongStream其中包含将给定函数应用于此流的元素的结果。 |
peek(Consumer action) | 返回由此流的元素组成的流,另外在每个元素上执行提供的操作,因为元素是从结果流中消耗的。 |
distinct() | 返回由此流的不同元素(根据 Object.equals(Object) )组成的流。 |
sorted() | 返回由此流的元素组成的流,按照自然顺序排序。 |
limit(long maxSize) | 返回由此流的元素组成的流,截断长度不超过 maxSize。 |
末端方法
方法 | 描述 |
---|---|
forEach(Consumer action) | 对此流的每个元素执行操作。 |
toArray() | 返回包含此流的元素的数组。 |
reduce(BinaryOperator accumulator) | 使用associative累积函数对此流的元素执行 reduction ,并返回描述减少值的Optional (如果有)。 |
reduce(T identity, BinaryOperator accumulator) | 使用提供的标识值和 associative累积函数对此流的元素执行reduction,并返回减小的值。 |
reduce(U identity, BiFunction accumulator, BinaryOperator combiner) | 使用提供的标识,累积和组合功能对此流的元素执行reduction 。 |
min(Comparator comparator) | 根据提供的Comparator返回此流的最小元素。 |
max(Comparator comparator) | 根据提供的Comparator返回此流的最大元素。 |
count() | 返回此流中元素的数量。 |
anyMatch(Predicate predicate) | 返回此流的任何元素是否与提供的谓词匹配。 |
allMatch(Predicate predicate) | 返回此流的所有元素是否与提供的谓词匹配。 |
noneMatch(Predicate predicate) | 返回此流的元素是否与提供的谓词匹配。 |
findAny() | 返回Optional描述流的一些元件,或一个空Optional如果流是空的。 |
findFirst() | 返回Optional描述此流的第一个元素,或空Optional如果流是空的。 |
import java.util.HashSet;
public class CollectionStream {
public static void main(String[] args) {
HashSet books = new HashSet();
books.add("轻量级JAVA EE企业实战");
books.add("疯狂JAVA讲义");
books.add("疯狂ios讲义");
books.add("疯狂Ajax讲义");
books.add("疯狂Android讲义");
//统计书名包括“疯狂”的图书数量
System.out.println(books.stream().filter(ele -> ((String) ele).contains("疯狂")).count());
//统计书名包含“JAVA”的图书数量
System.out.println(books.stream().filter(ele -> ((String) ele).contains("JAVA")).count());
//统计图书名长度大于10的图书数量
System.out.println(books.stream().filter(ele -> ((String) ele).length() > 10).count());
System.out.println("---------------------------------");
//先调用Collection对象的stream()方法将集合转换为Stream
//在调用Stream的mapToInt()方法获取原有的Stream对应的IntStream
//调用forEach()方法遍历IntStream中每个元素
books.stream().mapToInt(ele -> ((String) ele).length()).forEach(System.out::println);
}
}
特点:
HashSet集合判断两个元素相等的标准是两个对象通过equals()方法比较相等,并且两个对象的hashCode()方法返回值也相等
重写equals()方法和hashCode()方法的规则:如果两个对象通过equals()方法比较返回true,这两个对象的hashCode值也应该相同
变量和类型 | 方法 | 描述 |
---|---|---|
boolean | add(E e) | 如果指定的元素尚不存在,则将其添加到此集合中。 |
void | clear() | 从该集中删除所有元素。 |
Object | clone() | 返回此 HashSet实例的浅表副本:未克隆元素本身。 |
boolean | contains(Object o) | 如果此set包含指定的元素,则返回 true 。 |
boolean | isEmpty() | 如果此集合不包含任何元素,则返回 true 。 |
Iterator | iterator() | 返回此set中元素的迭代器。 |
boolean | remove(Object o) | 如果存在,则从该集合中移除指定的元素。 |
int | size() | 返回此集合中的元素数(基数)。 |
Spliterator | spliterator() | 在此集合中的元素上创建late-binding和失败快速 Spliterator 。 |
LinkedHashSet会保存元素的添加顺序,内部以链表来维护;不允许有重复值出现
TreeSet是SortSet接口的实现类,可确保集合元素处于排序状态
方法:
方法 | 描述 |
---|---|
first() | 返回此集合中当前的第一个(最低)元素。 |
last() | 返回此集合中当前的最后一个(最高)元素。 |
lower(E e) | 返回此集合中的最大元素严格小于给定元素,如果没有这样的元素,则 null 。 |
higher(E e) | 返回此集合中的最小元素严格大于给定元素,如果没有这样的元素,则 null 。 |
subSet(E fromElement, boolean fromInclusive, E toElement, boolean toInclusive) | 返回此set的部分视图,其元素范围为 fromElement到 toElement 。 |
SortedSet subSet(E fromElement, E toElement) | 返回此set的部分视图,其元素范围从 fromElement (含)到 toElement (独占)。 |
headSet(E toElement) | 返回此set的部分视图,其元素严格小于 toElement 。 |
headSet(E toElement, boolean inclusive) | 返回此set的部分视图,其元素小于(或等于,如果 inclusive为true) toElement 。 |
tailSet(E fromElement) | 返回此set的部分视图,其元素大于或等于 fromElement 。 |
tailSet(E fromElement, boolean inclusive) | 返回此set的部分视图,其元素大于(或等于,如果 inclusive为true) fromElement 。 |
TreeSet会调用元素的compareTo(Object obj)方法来比较元素之间的大小关系,然后将集合元素按升序排列,这种方法就是自然排序
当一个对象调用该方法与另一个对象进行比较时,例如obj1.compareTo(obj2),如果该方法返回0,则表明这两个对象相等;如果该方法返回一个正整数,则表明obj1大于obj2;如果返回一个负整数,则表明obj1小于obj2。
实现Compareable接口的常用类
TreeSet判断两个对象的唯一标准:两个对象通过compareTo(Object obj)方法比较是否返回0——返回0,则相等,否则不相等
重写规则:如果两个对象通过equals()方法返回true时,通过compareTo(Object obj)方法比较应返回0
EnumSet中的所有元素都必须是指定枚举类型的枚举值,该枚举类型在创建EnumSet时显式或隐式的指定
EnumSet在内部以位向量的形式存储,这种存储形式非常紧凑、高效,因此EnumSet对象占用内存很小,而且运行效率很好
EnumSet不允许加入null元素,如果只是想判断EnumSet是否包含null元素或视图删除null元素都不会抛出异常
方法:
方法 | 描述 |
---|---|
allOf(Class elementType) | 创建一个包含指定元素类型中所有元素的枚举集。 |
clone() | 返回此集的副本。 |
complementOf(EnumSet s) | 创建一个枚举集,其元素类型与指定的枚举集相同,最初包含此类型中未包含在指定集中的所有元素。 |
EnumSet copyOf(Collection c) | 创建从指定集合初始化的枚举集。 |
EnumSet copyOf(EnumSet s) | 创建一个枚举集,其元素类型与指定的枚举集相同,最初包含相同的元素(如果有)。 |
EnumSet noneOf(Class elementType) | 创建具有指定元素类型的空枚举集。 |
EnumSet of(E first, E…rest) | 创建一个包含一个或多个枚举值的EnumSet集合,传入的多个枚举值必须属于同一个枚举类 |
EnumSet range(E from, E to) | 创建一个枚举集,最初包含由两个指定端点定义的范围中的所有元素。 |
import java.util.EnumSet;
enum Season{
SPRING,SUMMER,FALL,WINTER;
}
public class EnumSetTest {
public static void main(String[] args) {
EnumSet es1 = EnumSet.allOf(Season.class);
System.out.println(es1);
EnumSet es2 = EnumSet.noneOf(Season.class);
System.out.println(es2);
es2.add(Season.WINTER);
es2.add(Season.SPRING);
System.out.println(es2);
EnumSet es3 = EnumSet.of(Season.SUMMER, Season.WINTER);
System.out.println(es3);
EnumSet es4 = EnumSet.range(Season.SUMMER, Season.WINTER);
System.out.println(es4);
EnumSet es5 = EnumSet.complementOf(es4);
System.out.println(es5);
}
}
需要一个保持排序的Set时,应该使用TreeSet,否则使用HashSet
需要遍历Set时,LinkedHashSet更快
List集合代表一个元素有序、可重复的集合,集合中每个元素都有其对应的顺序索引
变量和类型 | 方法 | 描述 |
---|---|---|
void | add(int index, E element) | 将指定元素插入此列表中的指定位置(可选操作)。 |
boolean | add(E e) | 将指定的元素追加到此列表的末尾(可选操作)。 |
boolean | addAll(int index, Collection c) | 将指定集合中的所有元素插入到指定位置的此列表中(可选操作)。 |
boolean | addAll(Collection c) | 将指定集合中的所有元素按指定集合的迭代器(可选操作)返回的顺序追加到此列表的末尾。 |
void | clear() | 从此列表中删除所有元素(可选操作)。 |
boolean | contains(Object o) | 如果此列表包含指定的元素,则返回 true 。 |
boolean | containsAll(Collection c) | 如果此列表包含指定集合的所有元素,则返回 true。 |
static < E > List< E > | copyOf(Collection coll) | 以迭代顺序返回包含给定Collection的元素的 unmodifiable List 。 |
boolean | equals(Object o) | 将指定对象与此列表进行比较以获得相等性。 |
E | get(int index) | 返回此列表中指定位置的元素。 |
int | hashCode() | 返回此列表的哈希码值。 |
int | indexOf(Object o) | 返回此列表中第一次出现的指定元素的索引,如果此列表不包含该元素,则返回-1。 |
boolean | isEmpty() | 如果此列表不包含任何元素,则返回 true 。 |
Iterator< E > | iterator() | 以适当的顺序返回此列表中元素的迭代器。 |
int | lastIndexOf(Object o) | 返回此列表中指定元素最后一次出现的索引,如果此列表不包含该元素,则返回-1。 |
ListIterator< E > | listIterator() | 返回此列表中元素的列表迭代器(按适当顺序)。 |
ListIterator< E > | listIterator(int index) | 从列表中的指定位置开始,返回列表中元素的列表迭代器(按正确顺序)。 |
static < E > List< E > | of(E e1, E e2, E e3, E e4, E e5) | 返回包含五个元素的不可修改列表。 |
E | remove(int index) | 删除此列表中指定位置的元素(可选操作)。 |
boolean | remove(Object o) | 从该列表中删除指定元素的第一个匹配项(如果存在)(可选操作)。 |
boolean | removeAll(Collection c) | 从此列表中删除指定集合中包含的所有元素(可选操作)。 |
void | replaceAll(UnaryOperator< E > operator) | 将该列表的每个元素替换为将运算符应用于该元素的结果。 |
boolean | retainAll(Collection c) | 仅保留此列表中包含在指定集合中的元素(可选操作)。 |
E | set(int index, E element) | 用指定的元素替换此列表中指定位置的元素(可选操作)。 |
int | size() | 返回此列表中的元素数。 |
void | sort(Comparator c) | 根据指定的Comparator引发的顺序对此列表进行排序。 |
Spliterator< E > | spliterator() | 在此列表中的元素上创建Spliterator 。 |
List< E > | subList(int fromIndex, int toIndex) | 返回指定的 fromIndex (包含)和 toIndex (不包括)之间的此列表部分的视图。 |
Object[] toArray()** :以适当的顺序(从第一个元素到最后一个元素)返回包含此列表中所有元素的数组。
T[] |toArray(T[] a) |以适当的顺序返回包含此列表中所有元素的数组(从第一个元素到最后一个元素); 返回数组的运行时类型是指定数组的运行时类型。
import java.util.ArrayList;
public class ListTest {
@SuppressWarnings({ "unchecked", "rawtypes" })
public static void main(String[] args) {
ArrayList books = new ArrayList();
books.add("轻量级JAVA EE企业实战");
books.add("疯狂JAVA讲义");
books.add("疯狂Ajax讲义");
books.add("疯狂Android讲义");
books.sort((o1, o2) -> ((String) o1).length() - ((String) o2).length());
System.out.println(books);
books.replaceAll(ele -> ((String) ele).length());
System.out.println(books);
}
}
ArrayList是List类的实现类,支持前面List接口的全部方法
变量和类型 | 方法 | 描述 |
---|---|---|
void | ensureCapacity(int minCapacity) | 如有必要,增加此 ArrayList实例的容量,以确保它至少可以容纳由minimum capacity参数指定的元素数 |
void | forEach(Consumer action) | 对 Iterable每个元素执行给定操作,直到处理 Iterable所有元素或操作引发异常 |
protected void | removeRange(int fromIndex, int toIndex) | 从此列表中删除索引介于 fromIndex (含)和 toIndex (独占)之间的所有元素 |
void | trimToSize() | 将此 ArrayList实例的容量调整为列表的当前大小 |
Queue用于模拟队列这种数据结构,队列是指“先进先出”(FIFO)的容器
变量和类型 | 方法 | 描述 |
---|---|---|
boolean | add(E e) | 如果可以在不违反容量限制的情况下立即执行此操作,则将指定的元素插入此队列,成功时返回 true ,如果当前没有空间,则抛出 IllegalStateException 。 |
E | element() | 检索但不删除此队列的头部。 |
boolean | offer(E e) | 如果可以在不违反容量限制的情况下立即执行此操作,则将指定的元素插入此队列。 |
E | peek() | 检索但不删除此队列的头部,如果此队列为空,则返回 null 。 |
E | poll() | 检索并删除此队列的头部,如果此队列为空,则返回 null 。 |
E | remove() | 检索并删除此队列的头部。 |
PriorityQueue按队列元素的大小进行重新排序
变量和类型 | 方法 | 描述 |
---|---|---|
boolean | add(E e) | 将指定的元素插入此优先级队列。 |
void | clear() | 从此优先级队列中删除所有元素。 |
Comparator | comparator() | 返回用于为了在这个队列中的元素,或比较null如果此队列根据所述排序natural ordering的元素。 |
boolean | contains(Object o) | 如果此队列包含指定的元素,则返回 true 。 |
void | forEach(Consumer action) | 对 Iterable每个元素执行给定操作,直到处理 Iterable所有元素或操作引发异常。 |
Iterator< E > | iterator() | 返回此队列中元素的迭代器。 |
boolean | offer(E e) | 将指定的元素插入此优先级队列。 |
boolean | remove(Object o) | 从此队列中删除指定元素的单个实例(如果存在)。 |
boolean | removeAll(Collection c) | 删除此集合的所有元素,这些元素也包含在指定的集合中(可选操作)。 |
boolean | removeIf(Predicate filter) | 删除此集合中满足给定谓词的所有元素。 |
boolean | retainAll(Collection c) | 仅保留此集合中包含在指定集合中的元素(可选操作)。 |
Spliterator< E > | spliterator() | 在此队列中的元素上创建late-binding和故障快速 Spliterator 。 |
Object[] | toArray() | 返回包含此队列中所有元素的数组。 |
T[] | toArray(T[] a) | 返回包含此队列中所有元素的数组; 返回数组的运行时类型是指定数组的运行时类型。 |
Deque接口是Queue接口的子接口,它代表一个双端队列;默认底层数组长度为16
变量和类型 | 方法 | 描述 |
---|---|---|
boolean | add(E e) | 将指定的元素插入此双端队列表示的队列中(换句话说,在此双端队列的尾部),如果它是立即可行且不会违反容量限制,返回 true成功时和抛出 IllegalStateException如果当前没有空间可用的。 |
boolean | addAll(Collection c) | 在此双端队列的末尾添加指定集合中的所有元素,就像通过在每个对象上调用 addLast(E)一样 ,按照集合的迭代器返回它们的顺序。 |
void | addFirst(E e) | 如果可以在不违反容量限制的情况下立即插入指定元素,则在此双端队列的前面插入指定元素,如果当前没有可用空间,则抛出 IllegalStateException 。 |
void | addLast(E e) | 如果可以在不违反容量限制的情况下立即插入指定元素,则在此双端队列的末尾插入指定元素,如果当前没有可用空间,则抛出 IllegalStateException 。 |
boolean | contains(Object o) | 如果此双端队列包含指定的元素,则返回 true 。 |
Iterator< E > | descendingIterator() | 以相反的顺序返回此双端队列中元素的迭代器。 |
E | element() | 检索但不删除此双端队列表示的队列的头部(换句话说,此双端队列的第一个元素)。 |
E | getFirst() | 检索但不删除此双端队列的第一个元素。 |
E | getLast() | 检索但不删除此双端队列的最后一个元素。 |
Iterator< E> | iterator() | 以适当的顺序返回此双端队列中元素的迭代器。 |
boolean | offer(E e) | 将指定的元素插入此双端队列表示的队列中(换句话说,在此双端队列的尾部),如果它是立即可行且不会违反容量限制,返回 true在成功和 false如果当前没有空间可用。 |
boolean | offerFirst(E e) | 将指定元素插入此双端队列的前面,除非它违反容量限制。 |
boolean | offerLast(E e) | 在此双端队列的末尾插入指定的元素,除非它违反容量限制。 |
E | peek() | 检索但不移除此双端队列表示的队列的头部(换句话说,此双端队列的第一个元素),如果此双端队列为空,则返回 null 。 |
E | peekFirst() | 检索但不删除此双端队列的第一个元素,如果此双端队列为空,则返回 null 。 |
E | peekLast() | 检索但不删除此双端队列的最后一个元素,如果此双端队列为空,则返回 null 。 |
E | poll() | 检索并删除此双端队列表示的队列的头部(换句话说,此双端队列的第一个元素),如果此双端队列为空,则返回 null 。 |
E | pollFirst() | 检索并删除此双端队列的第一个元素,如果此双端队列为空,则返回 null 。 |
E | pollLast() | 检索并删除此双端队列的最后一个元素,如果此双端队列为空,则返回 null 。 |
E | pop() | 从此双端队列表示的堆栈中弹出一个元素。 |
void | push(E e) | 如果可以在不违反容量限制的情况下立即执行此操作, IllegalStateException到此双端队列表示的堆栈(换句话说,在此双端队列的头部),如果当前没有可用空间则抛出 IllegalStateException 。 |
E | **remove() | 检索并删除此双端队列表示的队列的头部(换句话说,此双端队列的第一个元素)。 |
boolean | remove(Object o) | 从此双端队列中删除第一次出现的指定元素。 |
E | removeFirst() | 检索并删除此双端队列的第一个元素。 |
boolean | removeFirstOccurrence(Object o) | 从此双端队列中删除第一次出现的指定元素。 |
E | removeLast() | 检索并删除此双端队列的最后一个元素。 |
boolean | removeLastOccurrence(Object o) | 从此双端队列中删除最后一次出现的指定元素。 |
int | size() | 返回此双端队列中的元素数。 |
将ArrayDeque作为“栈”
import java.util.ArrayDeque;
public class ArrayDequeStack {
public static void main(String[] args) {
ArrayDeque stack = new ArrayDeque();
stack.push("疯狂JAVA讲义");
stack.push("轻量级JAVA EE企业实战");
stack.push("疯狂Android讲义");
System.out.println(stack);
System.out.println(stack.peek());//输出并不删除
System.out.println(stack);
System.out.println(stack.pop());
System.out.println(stack);
}
}
将ArrayDeque作为“队列”
import java.util.ArrayDeque;
public class ArrayDequeQueue {
public static void main(String[] args) {
ArrayDeque queue = new ArrayDeque();
queue.offer("疯狂JAVA讲义");
queue.offer("轻量级JAVA EE企业实战");
queue.offer("疯狂Android讲义");
System.out.println(queue);
//访问队头元素,并不poll出队列
System.out.println(queue.peek());
System.out.println(queue);
//访问队头元素,并poll出队列
System.out.println(queue.poll());
System.out.println(queue);
}
}
LinkedList类是List接口的实现类,它还实现了Deque接口,可以被当做双端队列来使用,因此既可以当做“栈”,也可以当做队列使用。
ArrayList、ArrayDeque内部以数组的形式来保存集合中的元素,随机访问时有很好的性能
LinkedList内部以链表的形式来保存集合中的元素,在插入、删除元素时性能出色
Map用于保存具有映射关系的数据,因此Map集合保存着两组值,一组值用于保存Map里的key,另一组用于保存Map里的value,key和value可以是任何引用类型的数据,key不允许重复
变量和类型 | 方法 | 描述 |
---|---|---|
void | clear() | 从此映射中删除所有映射(可选操作)。 |
V | compute(K key, BiFunction remappingFunction) | 尝试计算指定键及其当前映射值的映射(如果没有当前映射,null )。 |
V | computeIfAbsent(K key, Function mappingFunction) | 如果指定的键尚未与值关联(或映射到 null),则尝试使用给定的映射函数计算其值并将其输入此映射,除非 null 。 |
V | computeIfPresent(K key, BiFunction remappingFunction) | 如果指定键的值存在且为非null,则尝试在给定键及其当前映射值的情况下计算新映射。 |
boolean | containsKey(Object key) | 如果此映射包含指定键的映射,则返回 true 。 |
boolean | containsValue(Object value) | 如果此映射将一个或多个键映射到指定值,则返回 true 。 |
static |
copyOf(Map map) | 返回包含给定Map的条目的 unmodifiable Map 。 |
static |
entry(K k, V v) | 返回包含给定键和值的不可修改的Map.Entry 。 |
Set |
entrySet() | 返回此映射中包含的映射的Set视图。 |
boolean | equals(Object o) | 将指定对象与此映射进行比较以获得相等性。 |
void | forEach(BiConsumer action) | 对此映射中的每个条目执行给定操作,直到处理完所有条目或操作引发异常。 |
V | get(Object key) | 返回指定键映射到的值,如果此映射不包含键的映射,则返回 null 。 |
V | getOrDefault(Object key, V defaultValue) | 返回指定键映射到的值,如果此映射不包含键的映射,则返回 defaultValue 。 |
int | hashCode() | 返回此映射的哈希码值。 |
boolean | isEmpty() | 如果此映射不包含键-值映射,则返回 true 。 |
Set | keySet() | 返回此映射中包含的键的Set视图。 |
V | merge(K key, V value, BiFunction remappingFunction) | 如果指定的键尚未与值关联或与null关联,则将其与给定的非空值关联。 |
static |
of(K k1, V v1, K k2, V v2, K k3, V v3) | 返回包含三个映射的不可修改的映射。 |
static |
ofEntries(Map.Entry… entries) | 返回包含从给定条目中提取的键和值的不可修改的映射。 |
V | put(K key, V value) | 将指定的值与此映射中的指定键相关联(可选操作)。 |
void | putAll(Map m) | 将指定映射中的所有映射复制到此映射(可选操作)。 |
V | putIfAbsent(K key, V value) | 如果指定的键尚未与值关联(或映射到 null ),null其与给定值关联并返回null ,否则返回当前值。 |
V | remove(Object key) | 如果存在,则从该映射中移除键的映射(可选操作)。 |
boolean | remove(Object key, Object value) | 仅当指定键当前映射到指定值时才删除该条目的条目。 |
V | replace(K key, V value) | 仅当指定键当前映射到某个值时,才替换该条目的条目。 |
boolean | replace(K key, V oldValue, V newValue) | 仅当前映射到指定值时,才替换指定键的条目。 |
void | replaceAll(BiFunction function) | 将每个条目的值替换为在该条目上调用给定函数的结果,直到所有条目都已处理或函数抛出异常。 |
int | size() | 返回此映射中键 - 值映射的数量。 |
Collection | values() | 返回此映射中包含的值的Collection视图。 |