Java11 集合总结 Set List

Java集合

文章目录

  • Java集合
    • Collection接口
      • 方法
    • 遍历集合
      • 使用Lambda表达式遍历集合
      • 使用iterator遍历集合元素
      • 使用Lambda表达式遍历Iterator
      • 使用foreach循环遍历集合元素
      • 使用Predicate操作集合
      • Stream
    • set集合
      • HashSet
      • LinkedHashSet
      • TreeSet
      • EnumSet
      • 各Set实现类的性能分析
    • List集合
      • List接口
      • ArrayList
    • Queue集合
      • PriorityQueue实现类
      • Deque
      • LinkedList
      • 实现机制
      • Map

Collection接口

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) 返回包含此集合中所有元素的数组,使用提供的 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(构造器引用)

遍历集合

使用Lambda表达式遍历集合

当程序调用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遍历集合元素

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);
		
	}

}

使用Lambda表达式遍历Iterator

当程序调用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循环中的迭代器变量也不是集合元素本身,系统只是依次把集合元素的值赋给迭代变量,因此在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);
		
	}

}

使用Predicate操作集合

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 p) {
		int total = 0;
		for(Object obj : books) {
			if(p.test(obj)) {
				total++;
			}
		}
		
		return total;
	}

}

Stream

中间方法

方法 描述
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);
		
	}

  }

set集合

HashSet

特点:

  1. 不能保证元素的排列顺序
  2. HashSet不是同步的,当多个线程同时访问一个时,必须使用代码保持其同步
  3. 集合元素可以是null

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

LinkedHashSet会保存元素的添加顺序,内部以链表来维护;不允许有重复值出现

TreeSet

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接口的常用类

  • BigDecimal、BigInteger以及所有的数值型对应的包装类:按照他们对应的数字大小进行比较
  • Character:按字符的Unicode值进行比较
  • Boolean:true对应的包装类实例大于false对应的包装类实例
  • String:依次比较字符串中每个字符的Unicode值
  • Date、Time:后面的时间、日期比前面的的时间、日期大

TreeSet判断两个对象的唯一标准:两个对象通过compareTo(Object obj)方法比较是否返回0——返回0,则相等,否则不相等

重写规则:如果两个对象通过equals()方法返回true时,通过compareTo(Object obj)方法比较应返回0

EnumSet

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实现类的性能分析

需要一个保持排序的Set时,应该使用TreeSet,否则使用HashSet
需要遍历Set时,LinkedHashSet更快

List集合

List集合代表一个元素有序、可重复的集合,集合中每个元素都有其对应的顺序索引

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

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集合

Queue用于模拟队列这种数据结构,队列是指“先进先出”(FIFO)的容器

变量和类型 方法 描述
boolean add​(E e) 如果可以在不违反容量限制的情况下立即执行此操作,则将指定的元素插入此队列,成功时返回 true ,如果当前没有空间,则抛出 IllegalStateException 。
E element() 检索但不删除此队列的头部。
boolean offer​(E e) 如果可以在不违反容量限制的情况下立即执行此操作,则将指定的元素插入此队列。
E peek() 检索但不删除此队列的头部,如果此队列为空,则返回 null 。
E poll() 检索并删除此队列的头部,如果此队列为空,则返回 null 。
E remove() 检索并删除此队列的头部。

PriorityQueue实现类

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

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

LinkedList类是List接口的实现类,它还实现了Deque接口,可以被当做双端队列来使用,因此既可以当做“栈”,也可以当做队列使用。

实现机制

ArrayList、ArrayDeque内部以数组的形式来保存集合中的元素,随机访问时有很好的性能
LinkedList内部以链表的形式来保存集合中的元素,在插入、删除元素时性能出色

Map

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 Map copyOf​(Map map) 返回包含给定Map的条目的 unmodifiable Map 。
static Map.Entry 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 Map of​(K k1, V v1, K k2, V v2, K k3, V v3) 返回包含三个映射的不可修改的映射。
static Map 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视图。

你可能感兴趣的:(Java11 集合总结 Set List)