通配符类型

通配符子类型限定

<？extends A>
// 限定 类型参数 A 所有子类  因为类型擦除会将参数类型擦除为 限定类型
? extends A getA(){};  表示父类引用指向子类对象，合法---》例如A = b.getA(); b是a的子类
void setA(? extends A){}; 表示可能发生子类引用指向父类对象，不合法

通配符超类型限定

<？super A>
// 限定 类型参数 为A的所有超类
? super A getA(){};  表示子类引用执行父类对象，不合法
void setA(? super A){}; 表示可能发生父类引用指向子类对象，合法

无限定通配符

会被擦除为Object，get方法无影响，但set方法完全无法调用。

通配符捕获

反射和泛型

通过反射获取泛型的类型

泛型Class类

==java.lang.Class<T>===

// 返回无参数构造器构造的一个新实例
T newInstance();
// 如果Obj为null或可能转换成类型T，则返回obj；否则抛出一个BadCastException异常
T cast(Object obj);
// 如果T是枚举类型，则返回所有值组成的数组，否则返回null
T[] getEnumCanstants();
// 返回这个类的超类，如果T不是一个类或Object类，则返回null
Class<? super T> getSuperclass();
// 获得公共构造器，或者有给定参数类型的构造器
Constructor<T> getConstructor(Class<?>... parameterTypes);
Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes);
  
  
===java.lang.reflect.Constructor<T>===
// 返回用指定参数构造的新实例
T newInstance(Object... parameters);

虚拟机中的泛型类型信息

在虚拟机中，擦除的类任然保留原先泛型的微弱记忆。可以使用反射API来确定

• 这个泛型有一个名为T的类型参数
• 这个类型参数有一个子类型限定，其自身又是一个泛型类型
• 这个限定类型有一个通配符参数
• 这个通配符参数有一个超类型限定
• 这个泛型方法有一个泛型数组参数

说明可以重新构造实现者声明的泛型类和方法的所有有关内容。但是，不知道对于特定的对象或方法调用会如何解析类型参数。

为了表述泛型类型声明，可以使用java.lang.refect包中的接口Type，这个接口包含以下子类型

• Class类，描述具体类型 ==实现Type接口的类，其余都是继承了Type接口的接口==
• TypeVariable接口，描述类型变量(如 T extends Comparble<? super T>)
• WildcardType接口，描述通配符( 如 ？ super T)
• ParameterizedType接口，描述泛型类或接口类型（如 Comparable<? super T>）
• GenericArrayType接口，描述泛型数组（如 T[]）

相关泛型接口的类

集合

集合框架

将接口与实现分离

Collection接口

集合类的基本接口。有boolean add(E element)和Iterator<E> iterator()

迭代器

Iterator接口包含四个方法

public interface Iterator<E> {
		// 如果存在另外一个可访问的元素，返回true
    boolean hasNext();
		// 返回将要访问的下一个对象。如果已经到达了集合的末尾。将抛出一个NoSuchElement异常
    E next();
		// 删除上次访问的对象。这方法必须紧跟在访问一个元素之后执行。如果上次访问之后集合已经发送了变化，抛出IlleaglState异常
    default void remove() {
        throw new UnsupportedOperationException("remove");
    }
		// 访问元素，并传递到指定的动作，直到再没有元素，或者抛出一个异常
    default void forEachRemaining(Consumer<? super E> action) {
        Objects.requireNonNull(action);
        while (hasNext())
            action.accept(next());
    }
}

可以使用while() 循环迭代访问

也可以使用for each循环表示同样的循环操作。编译器简单地将for each循环转换为带有迭代器的循环。可以处理任何实现了Iterable接口的对象这个接口只包含了一个抽象方法Iterator<E> iterator();而Collection接口扩展了该接口。

也可以不使用循环，而是调用forEachRemaining方法。只需要提供一个lambda表达式

注意点

1. 访问元素的顺序取决于集合类型。
2. 当调用next时，迭代器就越过下一个元素，并返回刚刚越过的元素的引用。
3. 在remove时，需要先调用next。不能连续remover

​ ==java.util.Collection==

集合框架中的接口

java集合框架为不同类型的集合定义了大量接口，如图所示

集合中有两大基本接口：Collection和Map。

• map是映射键值对
• list是有序集合。元素会增加到容器中的指定位置。可以采用两种方式访问元素
  • 使用迭代器访问，
  • 使用一个整数索引来访问。也就是随机访问
• ListItertor接口定义了一个方法用于在迭代器位置前面增加一个元素
• Set接口等同于Collection接口。但不允许增加重复元素。equals方法：只要两个集包含相同的元素就认为相等，而不要求有同样的顺序。
• SortedSet就SortedMap接口。提供用于排序的比较器对象。定义了可以得到集合子集视图的方法
• NavigableSet/Map接口。其中包含一些用于搜索和遍历有序集和映射的方法。TreeSet和TreeMap类实现了这些接口

具体集合

图表示这些类的关系

链表（LinkedList）

数组以及动态的ArrayList类。在对数组中间的数据进行删除时开销很大，其原因时之后的元素都要向数组的前端移动。

数组时在连续的存储位置上存放对象引用。而链表则是将每个对象存放在单独的链接中，每个链接还存放着序列上一个以及下一个链接的引用。在Java中，所有链表都是双向链表。

add方法只依赖与迭代器的位置，而remove方法依赖于迭代器的状态。如果有两天迭代器同时操作一个链表，并且改变了其状态，就报出ConrurrentModification异常

链表不支持随机访问，每一次访问都需要从0开始便利。因为其根本没有缓存位置信息

相关方法介绍

数组列表（ArrayList）

有两种访问元素的协议：

• 通过迭代器
• 通过get和set方法随机访问每一个元素。不适用与链表，但对数组很有用

散列集(HashSet、LinkedHashSet)

用于快速查找对象。散列表为每一个对象计算一个整数，称为散列码(hash code)。散列表是由对象的实例字段得出的一个整数。

在java中，散列表用链表数组实现。每个列表被称为桶。要想查找表中对象的位置，就用先计算其散列码，然后与桶的总数取余，所得到的结果就是保存这个元素的桶的索引。

如果两个元素的桶索引重复了，这种现实称为==散列冲突==，这是需要将新对象与桶中所有对象比较，查看这个对象是否已经存在。

在java8中，如果桶满时会从链表变为平衡二叉树。

如果散列集太满，就会进行==再散列==。而==填装因子==确定何时对散列表进行==再散列==， 默认值为0.75 (0.0~1.0 之间的一个数，确定散列表填充的百分比，当大于这个百分比时，散列表进行再散列，扩大两倍)

相关方法介绍

LinkedHashSet维护着一个运行于所有条目的双重链接列表。

树集（TreeSet）

树集类与散列表十分相似，不过，树集是一个有序集合。使用二叉树(红黑树)的存储结构

可以以任意顺序将元素插入到集合中。在对集合进行遍历时，值将自动地按照排序后的顺序呈现。

要使用树集，必须能够比较元素，这些元素必须实现Comparable接口，或者构造集时必须提供一个Comparator。

相关方法介绍

队列（Queue接口）与双端队列（Deque接口）

ArrayDeque和LinkedList类实现了这个接口。这两个类都可以提供双端队列。

相关方法介绍

优先队列（priotityQueue）

元素可以按照任意的顺序插入，但会按照有序的顺序进行检索。

优先队列并没有对所有元素进行排序。如果迭代处理这些元素，并不需要对他们进行排序。

使用==堆==的数据结构，是一种可以自组织的二叉树。其添加和删除操作可以让最小的元素移动到根，而不必花费时间对元素进行排序。

和TreeSet一样。即可以保存实现了Comparable接口的类对象，也可以保存构造器中提供的Comparator对象。

相关方法介绍

映射

java类库为映射提供了两个通用的实现：HashMap和TreeMap。

散列映射对键进行散列，树映射根据键的顺序将元素组织为一个搜索树。只对键进行散列或比较函数。

基本映射操作

更新映射条目

java.util.Map<K,V>

• default V merge(K key, V value,BiFunction<? super V, ? super V, ? extends V> remappingFunction)

  如果key与一个非null键值关联，将函数应用到key和value，将key与结果关联，如果结果为空，则删除这个键。否则，将key与value关联，返回get(key)。==不为空才执行，为空则put默认值==

• default V compute(K key, BiFunction<? super K, ? super V, ? extends V> remappingFunction)

  将函数应用到key和get(key)。将key与结果关联，如果结果为空，则删除这个key。get(key)。==不管value空不空，都将新值put==

• default V computeIfPresent(K key, BiFunction<? super K, ? super V, ? extends V> remappingFunction)

  如果key与一个非空值关联，将函数应用key和get(key),.....==value不为空，将新值put==

• default V computeIfAbsent(K key,Function<? super K, ? extends V> mappingFunction)

  如果key与一个空值关联，将函数应用key和get(key),.....==value为空，将新值put==

• default void replaceAll(BiFunction<? super K, ? super V, ? extends V> function)

  在所有映射条目上应用这个函数。将键与非null结果关联，对于null结果，则将相应的键删除。

• default V putIfAbsent(K key, V value)

  如果键不存或者与null值关联，则将它与value关联，并返回null。否则返回关联的值。

映射视图

集合框架不认为映射本身是一个集合。不过，可以得到映射的视图-(一个实现了Collection接口或某个子接口的对象)

映射有三种视图：键集、值集合(不是一个集)以及键值对集。键和键值对可以构成一个集，因为映射中一个键只能有一个副本。

java.util.Map<K,V>

• Set keySet();
  返回映射中所有键的一个集视图。可以从这个集中删除元素。键和相关联的值将从映射中删除，但是不能添加任何元素

• Collection values();
  返回映射中所有值的一个集合视图。可以从这个集合中删除元素，所删除的值以及相对应的键将从这个映射中删除，不过不能添加任何元素。

• Set<Map.Entry<K, V>> entrySet();
  返回Map.Entry对象的一个集视图，可以从这个集中删除元素。它们将从映射中删除。但是不能添加任何元素

java.util.Map.Entry<K,V>

• K getKey();
• V getValue();
  返回这个映射条目的键或值
• V setValue(V value);
  将相关映射中的值改为新值，并返回原理的值。

tisp：==keySet不是hashSet或TreeSet，而是实现了Set接口的另外某个类的对象==

弱散列映射

WeakHashMap

如果有一个值，它对应的键已经不再程序中的任何地方使用，也就是说某个键的最后一个引用已经消失，那么不再有任何途经可以引用这个值的对象。但是，由于程序中的任何部分不会再有这个键，所以，无法从映射中删除这个键值对。垃圾回收器并不会回收。

垃圾回收器会跟踪活动的对象。只要映射对象是活动的，其中的所有桶也是活动的，他们不能被回收。因此，需要由程序负责从长期存活的映射表中删除那些无用的值。或者，你可以使用WeakHashMap。当对键的唯一引用来自散列表映射条目时，这个数据结构将与垃圾回收器协同工作一起删除键值对。

原理：

WeakHashMap使用弱引用保存键。其对象包含另外一个对象的引用，在这里，就是一个散列表键。对于这种类型的对象，垃圾回收器采用一种特定的方式进行处理。正常情况下，如果垃圾回收器发现某个特定的对象已经没有他人引用，就将其回收。然而，如果某个对象只能由WeakHashMap引用，垃圾回收器也会将其回收，但会将引用这个对象的弱引用放入一个队列。WeakHashMap将周期性检查队列，以便找出新添加的弱引用。一个弱引用引入队列意味着这个键不再被他人使用，并且已经回收，于是，WeakHashMap将删除相关联的映射条目

java.util.WeakHashMap<K,V>

• WeakHashMap()

• WeakHashMap(int initialCapacity)

• WeakHashMap(int initialCapacity,float loadFactor )

  用给定的容量和填装因子构造一个空的散列映射

链接散列集与映射

LinkedHashSet和LinkedHashMap类会记住插入元素项的顺序。这样就可以避免散列表中的项看起来顺序是随机的。在表中插入元素项时，就会并入到双向链表中。如图所示

java.util.LinkedHashSet

• LinkedHashSet()

• LinkedHashSet(int initialCapacity)

• LinkedHashSet(int initialCapacity,float loadFactor )

  用给定的容量和填装因子构造一个空的连接散列集

链接散列映射可以使用访问顺序而不是插入来迭代处理映射条目。每次调用get或put时，受到影响的项将从当前的位置删除，并放在项链表的尾部（只影响项在链表的位置，而散列表的桶不会受影响。映射条目总是在键散列码对应的桶中）。要构造这样一个散列映射，需要调用

==LinkedHashMap<K,V>(initialCapacity,loadFactor true)==

访问顺序对于实现缓存的"最近最少使用"原则十分重要。构造LinkedHashMap的一个子类，然后覆盖下面的这个方法：

==protected boolean removeEldestEntry(Map.Entry<K,V> eldest)==

每当方法返回true时，添加一个新映射条目就会导致删除eldest项，例如下面的缓存对多存放100个元素

LinkedHashMap<Object, Object> cache = new LinkedHashMap<Object, Object>(128, 0.75F, true){

    @Override
    protected boolean removeEldestEntry(Map.Entry<Object, Object> eldest) {
        return size() > 100;
    }
};

java.util.LinkedHashMap

• LinkedHashMap()

• LinkedHashMap(int initialCapacity)

• LinkedHashMap(int initialCapacity, float loadFactor )

• LinkedHashMap(int initialCapacity, float loadFactor，boolean accessOrder)

  用给定的容量、填装因子和顺序构造一个空的连接散列映射。accessOrder参数为true时表示访问顺序，为false是表示插入顺序

• protected boolean removeEldestEntry(Map.Entry<Object, Object> eldest)
  如果想删除eldest元素，就要覆盖为返回true。eldest参数是预期可能删除的元素。这个方法在向映射中添加一个元素之后调用。其默认实现会返回false。即在默认情况下，老元素不会被删除。不过，可以重新定义这个方法，以便有选择低返回true。例如，如果最老的元素符合一个条件，或者映射超过了一定大小，则返回true。

枚举集与映射

EnumSet是一个枚举类型元素集的高效实现。由于枚举类型只有有限个实例，所以EnumSet内部用位序列实现。如果对应的值在集中，则相应的位被置为1。

EnumSet类没有公共的构造器。要使用静态工厂方法构造这个集：

enum WeekDay {
    /**
     * 
     */
    MONDAY,
    /**
     * 
     */
    TUESDAY
}

public class MyObjects {

    EnumSet<WeekDay> always = EnumSet.allOf(WeekDay.class);
    EnumSet<WeekDay> never= EnumSet.noneOf(WeekDay.class);
    EnumSet<WeekDay> workday= EnumSet.range(WeekDay.MONDAY);
    EnumSet<WeekDay> mwf= EnumSet.of(WeekDay.TUESDAY);
}

可以使用Set接口的常用方法来修改EnumSet

java.util.EnumSet<E extends Enum>

• static <E extends Enum> EnumSet noneOf(Class elementType)
  返回一个初始为空的可变集
• static <E extends Enum> EnumSet allOf(Class elementType)
  返回一个包含给定枚举类型的所有值的可变集
• static <E extends Enum> EnumSet range(E from, E to)
  返回一个包含from到to之间的所有值(包含两个边界元素)的可变集
• static <E extends Enum> EnumSet of(E e)
• static <E extends Enum> EnumSet of(E e1, E e2)
• static <E extends Enum> EnumSet of(E e1, E e2, E e3)
• static <E extends Enum> EnumSet of(E first, E... rest)
  返回包括不为null的给定元素的可变集

EnumMap是一个键类型为枚举类型的映射。它可以直接高效地实现为一个值数组。需要在构造器中指定键类型。

java.util.EnumMap<K extends Enum, V)>

• EnumMap(Class keyType);

  构造一个键为给定类型的空的可变映射

标识散列映射

类IdentityHashMap有特殊的用途。在这个类中，键的序列值不是有hashCode函数计算的，而是用System.identityHashCode方法计算的。这是Object.hashCode根据对象的内存地址计算散列码时所使用的方法。而且，在对两个对象进行比较是，IdentityHashMap类使用==，而不使用equals。

也就是说，不同的键对象即使内容相同，也被视为不同的对象。在实现对象遍历算法(如对象串行化)时，这个类非常有用，可以用来跟踪哪些对象已经遍历过。

java.util.IdentityHashMap<K , V)> 类

• IdentityHashMap();

• IdentityHashMap(int expectedMaxSize);

  构造一个空的标识散列映射集，其容量是大于1.5*expectedMaxSize的2的最小幂值（默认21）

视图与包装器

方法返回一个实现了Set接口的类对象，由这个类的方法操纵原映射。这种集合称为视图。例如keySet方法返回值

小集合

Java9引入了一些静态方法，可以生成给定元素的集或列表，以及给定键/值对的映射。

例如：List name = List.of("Peter","Paul");

​ Set numbers =Set.of(2,3);

会分别生成包含3个元素的一个列表和一个集。对于映射，需要指定键和值，如下所示：

​ Map<String,Interger> scores = Map.of("Peter",2,"Paul",3);

元素、键或值不能为null。

​ List和Set接口有11个方法，分别有0到10个参数，另外还有一个参数个数可变的of方法。提供这种特定性是为了提高效率。

​ 对于Map接口，则无法提供一个参数可变的版本，因为参数类型会在键和值类型之间交替。不过他有一个静态方法ofEntries，能接受任意多个Map.Entry<K,V>对象（可以用静态方法entry创建这些对象）。

Map<String,Interger> scores = ofEntries(
	entry("Peter",2),
  entry("Paul",3);
)

of和ofEntries方法可以生成某些类的对象，这些类对于每个元素会有一个实例变量，或者有一个后备数组提供支持。

这些集合对象是==不可修改==的。如果试图改变他们的内容，会导致一个UnsupportedOperation异常

如果需要一个可改变的集合，可以把这个不可修改的集合传递到构造器：

​ List names = new ArrayList<>(LIist.of("Peter","Paul"));

以下方法调用：Collections.nCopies(n,anObject)会返回一个实例了List接口的不可变的对象，将创建n大小的List，内容全部为anObject。

==注释：==

• of方法是java9新引入的。之前有一个静态方法Arrays.asList,它会返回一个可更改但是大小不可变的列表，也就是说这列表可以set，但是不能add或remove。另外还有遗留方法Collections.emptySet和Collections.singLeton
• Collections类包含很多实用方法，这些方法的参数和返回值都是集合。不要将它与Collection接口混淆。

不可修改的视图

可以集合的不可修改视图。这些实体对现有集合增加一个运行时检查。如果发现视图对视图进行修改，就会报出异常。

每一个方法都定义处理接口。

在使用是可以将一个集合传递给特定的方法，返回的视图不可修改，但是集合的原始引用可以修改。

这些返回的视图只是包装了接口而不是具体的集合对象，所有==只能访问==中定义的方法。

同步视图

如果从多个线程访问集合，就必须确保集合不会被意外地破坏。例如，如果一个线程试图将元素添加到散列表中，另外一个线程视图进行在散列列，其结果是灾难性的。

而同步视图保证一个线程结束了，另外一个线程才会进行操作。

检查型视图

“检查型”视图用来对泛型类型可能出行的问题提供调试支持。实际上将错误类型的元素混入泛型集合中的情况极有可能发生。

例如add时并不会有异常，但是get时就不抛出异常。

而检查型视图在add时如果类型不符，就会抛出异常。

java.util.List 接口

• static List of() ==9==

• static List of(E e1) ==9==

  ........

• static List of(E e1,E e2,E e3,E e4,E e5,E e6,E e7,E e8,E e9,E e10) ==9==

• static List of(E... elements) ==9==

  生成给定元素的一个不可变的列表，元素不能为空

java.util.Set 接口

• static Set of() ==9==

• static Set of(E e1) ==9==

  ........

• static Set of(E e1,E e2,E e3,E e4,E e5,E e6,E e7,E e8,E e9,E e10) ==9==

• static Set of(E... elements) ==9==

  生成给定元素的一个不可变的集，元素不能为空

java.util.Map 接口

• static <K, V> Map<K, V> of() ==9==

• static <K, V> Map<K, V> of(K k1, V v1) ==9==

  ........

• static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2,K k3, V v3,K k4, V v4,K k5, V v5,K k6, V v6,K k7, V v7,K k8, V v8,K k9, V v9,K k10, V v10) ==9==

  生成给定键和值的一个不可变的映射，键和值不能为空

• static <K, V> Map.Entry<K, V> entry(K k, V v) ==9==

  生成给定键和值的一个不可变映射，键和值不能为空

• static <K, V> Map<K, V> ofEntries(Map.Entry<? extends k, ? extends V>... entries) ==9==

  生成给定映射条目的一个不可变映射

java.util.Collections 所有方法返回的集合都是内部实现的集合 类

• static Collection unmodifiableCollection(Collection<? extends T> c)
• static Set unmodifiableSet(Set<? extends T> s)
• static SortedSet unmodifiableSortedSet(SortedSet s)
• static NavigableSet unmodifiableNavigableSet(NavigableSet s)
• static List unmodifiableList(List<? extends T> list)
• static <K,V> Map<K,V> unmodifiableMap(Map<? extends K, ? extends V> m)
• static <K,V> SortedMap<K,V> unmodifiableSortedMap(SortedMap<K, ? extends V> m)
• static <K,V> NavigableMap<K,V> unmodifiableNavigableMap(NavigableMap<K, ? extends V> m)
  ==构造一个集合视图；视图的更改器方法抛出一个异常==
• static Collection synchronizedCollection(Collection c)
• static Set synchronizedSet(Set s)
• static SortedSet synchronizedSortedSet(SortedSet s)
• static NavigableSet synchronizedNavigableSet(NavigableSet s)
• static List synchronizedList(List list)
• static <K,V> Map<K,V> synchronizedMap(Map<K,V> m)
• static <K,V> SortedMap<K,V> synchronizedSortedMap(SortedMap<K,V> m)
• static <K,V> NavigableMap<K,V> synchronizedNavigableMap(NavigableMap<K,V> m)
  ==构造一个集合视图；视图的方法是同步的==
• static Collection checkedCollection(Collection c,Class type)
• static Queue checkedQueue(Queue queue, Class type)
• static Set checkedSet(Set s, Class type)
• static SortedSet checkedSortedSet(SortedSet s,Class type)
• static NavigableSet checkedNavigableSet(NavigableSet s,Class type)
• static List checkedList(List list, Class type)
• static <K, V> Map<K, V> checkedMap(Map<K, V> m,Class keyType,Class valueType)
• static <K,V> SortedMap<K,V> checkedSortedMap(SortedMap<K, V> m,Class keyType,Class valueType)
• static <K,V> NavigableMap<K,V> checkedNavigableMap(NavigableMap<K, V> m,Class keyType,Class valueType)
  ==构造一个集合视图；如果插入一个错误类型的元素，视图的方法抛出一个ClassCast异常==
• static Iterator emptyIterator()
• static ListIterator emptyListIterator()
• static Enumeration emptyEnumeration()
• static final Set emptySet()
• static SortedSet emptySortedSet()
• static NavigableSet emptyNavigableSet()
• static final List emptyList()
• static final <K,V> Map<K,V> emptyMap()
• static final <K,V> SortedMap<K,V> emptySortedMap()
• static final <K,V> NavigableMap<K,V> emptyNavigableMap()
  ==生成一个空集合、映射或迭代器==
• static Set singleton(T value)
• static List singletonList(T value)
• static <K,V> Map<K,V> singletonMap(K key, V value)
  ==生成一个单例列表、集或映射。在java9中，要使用相应的of方法==
• static List nCopies(int n, T value)
  ==生成一个不可变的列表，包含n个相等的value==

java.util.Arrays

• static List asList(E... array)
  ==返回一个数组中元素的列表视图。这个数组可修改，但大小不可变==

小小警告：

这三种视图的xxxCollection方法返回的集合，它的equals方法不调用底层集合的equals方法。实际上它继承了Object的equals方法，只能检查是否是一个对象，无法检查内容是否一致。视图采用这种工作方式，因为相等性检测在层级结构这一层上没有明确定义。

不过xxxSet和xxxList方法会使用底层集合的equals方法和hashCode方法。

子范围

可以为很多集合建立子范围(subrange)视图。在获取子范围时和字符串一样，包头不包尾

java.util.List 接口

• List subList(int fromIndex, int toIndex);
  返回给定位置范围内的所有元素的列表视图

java.util.SortedSet 接口

• SortedSet subSet(E fromElement, E toElement);
• SortedSet headSet(E toElement);
• SortedSet tailSet(E fromElement);
  返回给定范围内元素的视图

java.util.NavigableSet 接口

• SortedSet subSet(E fromElement, E toElement);
• NavigableSet subSet(E fromElement, boolean fromInclusive,E toElement, boolean toInclusive)
• SortedSet headSet(E toElement);
• SortedSet tailSet(E fromElement);
  返回给定范围内元素的视图。boolean 标志决定视图是否包含边界

java.util.SortedMap 接口

• SortedMap<K,V> subMap(K fromKey, K toKey);
• SortedMap<K,V> headMap(K toKey);
• SortedMap<K,V> tailMap(K fromKey)
  返回键在给定范围内的映射条目的映射视图

java.util.NavigableMap 接口

• SortedMap<K,V> subMap(K fromKey, K toKey);
• NavigableMap<K,V> subMap(K fromKey, boolean fromInclusive,K toKey, boolean toInclusive);
• SortedMap<K,V> headMap(K toKey);
• SortedMap<K,V> tailMap(K fromKey);
  返回键在给定范围内的映射条目的映射视图。boolean 标志决定视图是否包含边界

算法

泛型算法

例如在寻找最大值时，数组、链表数组和链表时查找方式会有区别，而使用泛型可以合并为一个。例如

public static <T extends Comparable<T>> T max(Collection<T> c) {
    if (c.isEmpty()) throw  new NoSuchElementException();
    Iterator<T> iterator = c.iterator();
    T largest = iterator.next();
    while (iterator.hasNext()){
        T next = iterator.next();
        if (largest.compareTo(next) < 0){
            largest = next;
        }
    }
    return largest;
}

排序和混排

Collections类的sort方法可以对实现了List接口的集合进行排序。列表元素实现了Comparable接口。

如果想使用其他排序方式，可以使用List接口的sort方法并传入Comparator对象。

如果需要降序排序，可以用静态Collections.reverresOrder()。这个方法返回一个比较器，比较器返回相反的比较。

降序也可以比较器的私有方法reversed()。返回当前比较强的逆序比较。

java中使用这些算法方法时的要求：列表必须是可以修改的，但不一定可以改变大小

• 支持set方法，则是可以修改
• 支持add和remove方法，则是可改变大小

java.util.Collections

• static <T extends Comparable<? super T>> void sort(List list)

• static void sort(List list, Comparator<? super T> c)
  使用稳定的排序算法(相等时不改变顺序)对列表中的元素进行排序。这个算法的时间复杂度是O(n log n),其中n为列表的长度

• static void shuffle(List<?> list)

• static void shuffle(List<?> list, Random rnd)
  随机地打乱列表中元素的顺序。这个算法的时间复杂度是O(n a(n))，n是列表的长度，a(n)是访问元素的平均时间。

java.util.List

• default void sort(Comparator<? super E> c)
  使用给定比较器对列表进行比较

java.util.Comparator

• default Comparator reversed()
  生成一个比较器，将逆置这个比较强提供的顺序

• static <T extends Comparable<? super T>> Comparator reverseOrder()

  生成一个比较器，将逆置Comparable接口提供的顺序。

二分查找

要使用这个方法，集合必须是有序的，否则会返回错误结果。

java.util.Collections

• static int binarySearch(List<? extends Comparable<? super T>> list, T key)
• static int binarySearch(List<? extends T> list, T key, Comparator<? super T> c)
  从有序列表中搜索一个键，如果元素类型实现了RandomAccess接口，就使用二分查找，其他情况下都使用线性查找。这个方法的时间复杂度为O(a(n) log n)，n为列表的长度，a(n)是访问元素的平均时间。这个方法将返回这个键在列表中的索引，如果在列表中不存在这个键则返回负值i。在这种情况下，这个键应该插入到索引-i-1的位置上。以保证列表的有序性

其它简单算法

java.util.Collections

• static <T extends Object & Comparable<? super T>> T min(Collection<? extends T> coll);
• static T min(Collection<? extends T> coll, Comparator<? super T> comp);
• static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll);
• static T max(Collection<? extends T> coll, Comparator<? super T> comp);
  返回集合中最小或者最大的元素。可提供比较器。
• tatic void copy(List<? super T> to , List<? extends T> from);
  将原列表中所有元素复制到目标列表的相应位置上。目标列表的长度至少与原列表一样。
• static void fill(List<? super T> list, T obj)
  将列表中的所有位置设置相同的值。
• static boolean addAll(Collection<? super T> c, T... elements)
  将所有的值添加到给定的集合中。如果集合改变了，则返回true。
• static boolean replaceAll(List list, T oldVal, T newVal)；
  将列表中所有值为oldVa的元素替换为newVal
• static int indexOfSubList(List source, List target)
• static int lastIndexOfSubList(List source, List target)
  返回source中第一个或最后一个等于target的子列表的索引。如果source中不存在target的子列表，则返回-1.
• static void swap(List<?> list, int i, int j)
  交换给定偏移位置的两个元素
• static void reverse(List<?> list)
  逆置列表中元素的顺序。时间复杂度为O(n),n为列表的长度
• static void rotate(List<?> list, int distance)
  旋转列表中的元素，将索引i的元素移动都位置(i+d)%list.size()。时间复杂度为O(n),n为列表的长度
• static int frequency(Collection<?> c, Object o)
  返回c中与对象o相等的元素的个数
• static boolean disjoint(Collection c1, Collection c2)
  如果两个集合没有共同的元素，则返回true

java.uitl.Collection

• default boolean removeIf(Predicate<? super E> filter)
  删除所有匹配的元素

java.uitl.List

• default void replaceAll(UnaryOperator operator)
  对这个列表的所有元素应用这个操作

批操作

java.uitl.Collection

• boolean retainAll(Collection<?> c);
  从列表中删除所有未在c中出现的元素。也就是求交集。
• boolean removeAll(Collection<?> c);
  从列表中删除所有在c中出现的元素。也就是求差集。
• boolean addAll(Collection<? extends E> c);
  从列表中添加所有在c中出现的元素。也就是求并集。

集合与数组的转换

数组转集合使用List.of:

String[] values = ...;
var staff = new HashSet<>(List.of(values));

集合转数组较为复杂：

如果使用toArray方法的话，得到的是一个对象数组（Object[]）。无法对其强制转换。

不过可以使用一个变体方法，提供一个指定类型而且指定长度的数组。这样一来，返回的数组就会创建相同的数据类型

String values = staff.toArray(new String[staff.size()]);

遗留的集合

Hashtable类

经典的Hashtable类与HashMap类的作用是一样的。实际上，接口也基本相同。与Vector类的方法一样，Hashtable方法也是同步的。

如果对遗留代码的兼容性没有任何要求，就应该使用HashMap。如果需要并发访问，则要使用ConcurrentHashMap。

枚举

遗留的集合使用Enumeration接口遍历元素序列。Enumeration接口有两个方法， hasMoreElements()和nextElement()。这两个方法完全类似与Iterator接口的hasNext方法和next()方法。

如果在遗留的类中发现实现了这个接口。可以使用Collections.list将元素收集到一个ArrayList中。

java.uitl.Collections

• static Enumeration enumeration(final Collection c)
  返回一个枚举，可以枚举c的元素
• static ArrayList list(Enumeration e)
  返回一个数据列表，其中包含e枚举的元素

java.uitl.Enumeration

• boolean hasMoreElements();
  如果还有更多的元素可以查看，则返回true
• E nextElement();
  返回要检查的下一个元素

属性映射

属性映射（property map）是一种特殊类型的映射结构，它有三种特性

• 键与值都是字符串
• 这个映射可以很容易地保存到文件以及从文件加载
• 有一个二级表存放默认值

由于Properties类实现了Map<Object,Object>。因此可以使用get以及put，但是这样可以插入去除任何对象，最好坚持处理字符串。

java.uitl.Properties

• Properties()
  创建一个空属性映射
• Properties(Properties defaults)
  用一组默认值创建一个空属性映射
• String getProperty(String key)
  获得一个属性。返回与键关联的值，或者如果这个键未在表中出现，则返回默认值表中与这个键关联的值，或者如果键在默认值表中也未出现，则返回null。
• String getProperty(String key, String defaultValue)
  调用上面的方法，如果结构为null，则返回defaultValue
• Object setProperty(String key, String value)
  设置一个属性。返回给定键之前设置的值
• void load(InputStream inStream) throws IOException
  从一个输入流加载一个属性映射
• void store(OutputStream out, String comments)
  将一个属性映射保存到一个输出流。comments是所存储文件的第一行

java.lang.System

• Properties getProperties()
  获取所有系统属性。应用必须有权限获取所有属性，否则抛出一个异常
• String getProperties(String key)
  获取给定键名对应的系统属性。应用必须有权限获取所有属性，否则抛出一个异常。以下属性总是允许获取
  • java.version
  • java.vendor
  • java.vendor.url
  • java.home
  • java.class.path
  • java.library.path
  • java.class.version
  • os.name
  • os.version
  • os.arch
  • file.separator
  • path.separator
  • line.separator
  • java.io.tempdir
  • user.name
  • user.home
  • user.dir
  • java.compiler
  • java.sepcification.version
  • java.sepcification.vendor
  • java.sepcification.name
  • java.vm.sepcification.version
  • java.vm.sepcification.vendor
  • java.vm.sepcification.name
  • java.vm.version
  • java.vm.vendor
  • java.vm.name

栈

java库的Stack类其中有熟悉的push方法和pop方法。但是Stack类扩展了Vector类，从理论角度看，Vertor类并不太令人满意，甚至可以使用非栈操作的insert和remove方法在任何地方插入和删除值，而不只是在栈顶。

java.util.Stack

• E push(E item)

  将item压入栈并返回item

• E pop()

  弹出并返回栈顶的item。如果栈为空，不要调用该方法

• E peek()

  返回栈顶元素，但不弹出。如果栈为空，不要调用该方法。

位集

BitSet类用于存储一个位序列（它不是数学上的集，如果称为位向量或位数组更合适）。

如果需要高效地存储位序列，就可以使用位集。

由于位集将位包装在字节里，所以使用位集要比使用Boolean对象的ArrayList高效得多

BitSet类提供了一个便于读取、设置或重置各个位的接口。使用这个接口可以避免掩码和其它调整位的操作，如果将存储在int或long变量中就必须做这些烦琐的操作

java.util.BitSet

• BitSet(int nbits)
  创建一个位集,并设置其大小

• int length()
  返回位集的"逻辑长度"，即1加上位集最高位的索引。

• boolean get(int bit)
  如果该位处于'开'状态，则返回true，否则返回false

• void set(int bit)
  设置该位为"开状态"，设置一个位为1

• void clear(int bit)
  设置该位为"关状态"，清除一个位为0

• void and(BitSet set)
  这个位集与另外一个位集进行逻辑”与“

• void or(BitSet set)
  这个位集与另外一个位集进行逻辑”或“

• void xot(Bitset set)
  这个位集与另外一个位集进行逻辑”异或“

• void andNot(BitSet set)
  对应另一个位集中设置为1的所有位，将这个位集中相应的位清除位0

并发

线程

多线程程序在更低一层中扩展了多任务的概念：单个程序看起来在同时完成多个任务。每个任务在一个线程中执行，线程是控制线程的简称。如果一个程序可以同时运行多个线程，则称这个程序是多线程的。

​ 多进程与多线程：本地的区别在于每个进程都拥有自己的一整套变量，而线程则共享数据。

线程状态

线程有六种状态：

• New（新建）
• Runnable（可运行）
• Blocked（堵塞）
• Waiting（等待）
• Timed waiting（计时等待）
• Terminated（终止）

要确定一个线程的状态，只需要调用getState方法即可

线程属性

中断线程

线程之前有stop方法来终止，但是已经被弃用。
不过可以使用interrupt方法来请求终止一个线程。

这个方法会设置线程的终端状态。这是每个线程都有的布尔标志。

守护线程

调用setDaemon(true)方法将一个线程转换为守护线程。

唯一的作用是为其它线程提供服务。例如计时器线程。

线程名

setName(xxx)方法设置线程名，在线程转储时可能很有用

未捕获异常的处理器

线程的run方法不能抛出任何检查型异常，但是，非检查型异常可能会导致线程终止。

但线程在死亡之前，会将异常传递到一个处理器。

setDefaultUncaughtExceptionHandler方法设置或获取默认处理器

线程优先级

在java早期版本很有用，现在不要使用线程优先级

同步

如果多个线程同时调用某个对象的修改器。相会相互覆盖。取决于线程访问数据的次序，可能会导致对象被破坏。这种情况称为竞态条件

如果不加同步锁，不同的线程会修改同一个对象。从而出现总额出错。

锁对象

pulic class xxx{
  private ReentrantLock bankLock = new ReentrantLock();

	public boolean transfer(int from ,int to ,double amount){
    	bankLock.lock();
    	try {
       	 。。。。
    		}finally {
        	bankLock.unlock();
    	}
	}
}

bankLock是锁对象，每一个xx对象都是拥有自己的一个锁对象。不同的xx对象拥有不同的锁，不同的线程可以方法不同的xx对象。

这种锁称为重入(reentrant)锁，因为线程可以反复获得已拥有的锁。锁有一个持有计数（hold count）来跟踪对lock方法的嵌套调用。线程每一次调用lock后都要调用unlock方法来释放锁。由于这个特性，被一个锁保护的代码可以调用另一个使用相同锁的方法。

java.util.concurrent.locks.Lock 接口

• void lock()
  获得这个锁；如果锁当前被另一个线程占有，则阻塞

• voidunlock();

  释放这个锁

java.util.concurrent.locks.ReentrantLock类

• ReentrantLock()
  构造一个重入锁，用来保护临界区

• ReentrantLock(Boolean fair);

  构造一个采用公平策略的锁。一个公平锁倾向与等待时间最长的线程。不过，这种公平保证可能严重影响性能。所以，默认情况下，不要求锁是公平的。

==注意点==

• 要注意确保临界区中的代码不要因为抛出异常而跳出临界区。如果在临界区代码结束之前抛出了异常，finally子句将释放锁，但是对象可能处于被破坏的状态
• 公平锁比常规锁==慢很多==

条件对象

​ 通常，线程进入临界区后却发现只有满足了某个条件之后它才能执行。可以使用一个条件对象来管理那些以及已经获得了一个锁却不能做有用工作的线程。条件对象也对称为条件变量

例如银行转账，如果当前账户没钱，将这个线程放入等待集中，如果有人往这个账户转账了，解除等待线程的阻塞。

​ 通过bankLock.newCondition()获得条件对象。在不满足条件时调用await方法。将当前线程放入这个条件的等待集。当锁可用时，该线程并不会变为可运行状态。实际上，它任保持非活动状态，直到另一个线程在同一个条件上调用signalAll方法。

​ signalAll方法调用会重新激活等待这个条件的所以线程。当这些线程从等待集中移出时，它们再次成为可运行的线程，调度器最终将再次将它们激活。同时，它们会尝试重新进入该对象。一旦锁可用，它们中的某个线程将从await调用返回，得到这个锁，并从之前暂停的地方继续执行。

==注意点==

• 但一个线程调用await方法时，它没有办法重新自行激活，它寄希望与其它线程。如果没有其它线程来重新激活等待的线程，它就永远不会在运行了。这将导致死锁线程。最终一定需要在某个其它线程调用signaAll方法。
• signalAll调用不会立即激活一个等待的线程。它只是解除等待线程的阻塞，使这些线程可以在当前线程释放锁之后竞争访问对象。

java.util.concurrent.locks.Lock 接口

• Condition newCondition();
  返回一个与这个锁相关联的条件对象

java.util.concurrent.locks.Condition 接口

• void await()
  将该线程放在这个条件的等待集中

• void signal();

  从该条件的等待集中随机选择一个线程，解除其阻塞状态

• void signalAll();

  解除该条件等待集中所有线程的阻塞状态

synchronized关键字

小总结:

• 锁用来保护代码片段，一次只能有一个线程执行被保护的代码
• 锁可以管理试图进入被保护代码段的线程
• 一个锁可以有一个或多个相关联的条件对象
• 每个条件对象管理那些已经进入被保护代码段但还不能运行的线程

在使用Lock/Condition接口时时现实定义锁。而使用synchronized关键字可以隐式定义锁，因为java中每个对象都有一个内部锁

内部对象锁只有一个关联条件。wait方法等价于await方法。notifyAll/notify方法等价于signalAll/signal方法

将静态方法声明为同步也是合法。如果调用这样的一个方法，它会获得相关类对象的内部锁。因此，没有其它线程可以调用这个类的该方法或任何其它同步静态方法。

内部锁和条件存在的限制：

• 不能中断任何正在尝试获得锁的线程
• 不能指定尝试获得锁的超时时间
• 每个锁仅有一个条件可能是不够的。

在代码中应该选择哪种做法？Lock和Condition对象还是同步方法？

• 最后既不使用Lock/Condition也不使用synchronized关键字。在许多情况下，可以使用java.util.concurrent包中的某种机制，它会处理所有锁定，例如阻塞队列。还可以使用并行流。
• 如果关键字适合程序，那么尽量使用这种做法，这样可以减少编写的代码量，还能减少出错的概率
• 如果特别需要Lock/Condition结构提供的额外能力，则使用

java.lang.Object 类

• public final native void notifyAll()
  解除在这个对象上调用wait方法的那些线程的阻塞状态。该方法只能在同步方法或同步块中调用。如果当前线程不是对象锁的所有者，该方法会抛出IllegalMonitorState异常

• public final native void notify()

  随机选择一个在这个对象上调用wait方法的线程，解除其阻塞状态。该方法只能在一个同步方法或同步块中调用。如果当前线程不是对象锁的所有者，该方法会抛出IllegalMonitorState异常

• public final void wait()

  导致一个线程进入等待状态，直到它得到通知。该方法只能在同步方法或同步块中调用。如果当前线程不是对象锁的所有者，该方法会抛出IllegalMonitorState异常

• public final void wait(long timeout, int nanos)

• public final void wait(long timeout)

  导致一个线程进入等待状态，直到它得到通知或者经过了指定的时间。该方法只能在同步方法或同步块中调用。如果当前线程不是对象锁的所有者，该方法会抛出IllegalMonitorState异常。纳秒数不能超过100 0000

同步块

​ 每一个java对象都有一个锁。线程可以通过调用同步方法获得锁。还有另外一个机制可以获得锁：即进入一个同步块。

public void transfer(Object accounts, int from ,int to, int amount){
    synchronized (accounts){
        ....
    }
    ....
}

在这里必须保证accounts对自己内部的所有更改方法使用内部锁

监视器概念

特性：

• 监视器时只包含私有字段的类
• 监视器类的每个对象有一个关联的锁
• 所有方法由这锁锁定。换句话说，如果客户端调用obj.method()，那么obj对象的锁在方法调用开始时自动获得，并且当方法返回时自动释放该锁。因为所有的字段时私有的，这样的安排可以确保一个线程处理字段时，没有其它线程能够访问这些字段。
• 锁可以有任意多个相关联的条件。

java以不太严格的方式采用了监视器概念，java中的每一个对象都有一个内部锁和一个内部条件。如果一个方法用synchronized关键字声明。那么。它表现得就像时一个监视器方法。可以通过调用wait/notifyAll/notify来访问条件变量。

不过java对象在以下3个重要方法不同于监视器，这削弱了线程的安全性：

• 字段不要求是private
• 方法不要求是synchronized
• 内部锁对客户可见

volatile字段

volatile关键字为实例字段的同步访问提供了一种免锁机制。如果声明一个字段为volatile，那边编译器和虚拟机就知道该字段可能被另外一个线程并发更新。

例如一个boolean标志位done。他的值有一个线程设置，一个线程查询。使用锁可以是

private boolean done;
pulic synchronized boolean isDone(){return done;}
pulic synchronized void setDone(){done = true;}

或者使用内部对象锁不是好办法。如果另一个线程已经对该对象加锁，isDone和setDone方法可能被堵塞。如果有这个问题，可以为这个变量使用一个单独的锁。但是，这会很麻烦。

这时使用volatile就很合适

private volatile boolean done;
pulic  boolean isDone(){return done;}
pulic  void setDone(){done = true;}

==注意==

• volatile变量不是提供原子性。不能保证读取，写入等操作不被中断

final变量

将一个字段声明为final时，可以安全的访问一个共享字段。

其它线程会在构造器完成构造后才能看到这个变量。

如果不使用final，就不能保证其它线程看到的该字段更新后的值，它们看到的可能时null。

原子性

假设对共享变量除了3赋值之外不进行其它操作，那么可以将这些共享变量声明为volatile

java.util.concurrent.atomic包中有很多类使用了很高效的机器级指令来保证其它操作的原子性。

==详细 java核心技术卷I，p582==

死锁

例如：

1. 账户1：200rmb
2. 账户2：300rmb
3. 线程1：从账户1转300rmb到账户2
4. 线程2：从账户2转300rmb到账户1

很显然，线程1和2都被阻塞。两个线程都无法执行下去，导致程序被挂起。这种情况叫做死锁

java编程语言无法避免或打破这种死锁。必须仔细设计程序，确保不会出现死锁。

线程局部变量

利用ThreadLocal类来生成一个局部变量供所有线程使用

例如

public static final ThreadLocal<SimpleDateFormat> FORMAT = ThreadLocal.withInitial(()->new SimpleDateFormat("yyyy-MM-dd"));
    private String dateStamp = FORMAT.get().format(new Date());

在一个给定线程中首次调用get时，会调用构造器中的lambda表达式。在此之后，get方法会返回属于当前线程的那个实例

java.lang.ThreadLocal类

• T get()
  得到这个线程的当前值，如果时首次调用get，会调用initialize来得到这个值

• void set（T t）

  为这个线程设置一个新值

• void remove()

  删除对应这个线程的值

• public static 《S》 ThreadLocal《S》 withInitial(Supplier<? extends S> supplier)

  创建一个线程局部变量。其初始值通过调用这给定的提供者生成

java.util.concurrent.ThreadLocalRandom类

• static ThreadLocalRandom current()
  返回特定于当前线程的Random类的实例

线程安全的集合

阻塞队列

当试图向队列中添加元素而队列已满，或是向从队列中移除元素而队列为空的时候，阻塞队列（blocking queue）将导致线程阻塞。在协调多个线程之间的合作是，十分有用。

工作线程可以周期性地将中间结果存储在阻塞队列中。其它工作线程移除中间结果，并进一步进行修改。队列对自动地平衡负载。

例如第一组线程运行的比第二组线程慢，第二组在等待结果时会阻塞。如果第一组线程运行得更快，队列会填满，直到第二组赶上来。

​ 阻塞队列的方法

在使用阻塞队列时，不要使用抛出异常的方法。而是使用相同的方法替代

在添加和移除时，可以设置超时时间。例如offer方法和poll方法

// 时间数量是100，单位是毫秒
boolean success = q.offer(x, 100, TimeUnit.MILLISECONDS);
Object head = q.poll(100, TimeUnit.MILLISECONDS);

java.util.concurrent.ArrayBlockingQueue 类

• ArrayBlockingQueue(int capacity)

• ArrayBlockingQueue(int capacity, boolean fair)

  构造一个有指定的容量和公平性设置的阻塞队列。队列实现为一个循环数组

java.util.concurrent.LinkedBlockingDeque 类

java.util.concurrent.LinkedBlockingQueue 类

• LinkedBlockingDeque()

• LinkedBlockingQueue()

  构造一个屋上限的阻塞队列或双向队列。实现为一个链表

• LinkedBlockingDeque(int capacity)

• LinkedBlockingQueue(int capacity)

  根据指定容量构建一个有限的阻塞队列或双向队列，实现为一个链表

java.util.concurrent.DelayQueue 类

• DelayQueue()

  构造一个包含Delayed元素的无上限阻塞队列。只有那些延迟已经到期的元素可以从队列中移除

java.util.concurrent.Delay 接口

• long getDelay(TimeUnit unit);

  得到该对象的延迟，用给定的时间单位度量

java.util.concurrent.PriorityBlockingQueue 类

• PriorityBlockingQueue()

• PriorityBlockingQueue(int capacity)

• PriorityBlockingQueue(int capacity, Comparator<? super E> comparator)

  构造一个无上限阻塞优先队列，实现为一个堆。优先队列的默认初始容量为11。如果没有指定比较器，则元素必须实现Comparator接口

java.util.concurrent.BlockingQueue 接口

• void put(E e)

  添加元素，必要时阻塞

• E take()

  移除并返回队头元素，必要时阻塞

• boolean offer(E e, long timeout, TimeUnit unit)

  添加给定元素，如果成功返回true。必要时阻塞，直到元素已经添加或者超时

• E poll(long timeout, TimeUnit unit)

  移除并返回队头元素，必要时阻塞，直到元素可用或者超时用完。失败时返回null

java.util.concurrent. BlockingDeque 接口

• void putFirst(E e)

• void putLast(E e)

  添加元素，必要时阻塞

• E takeFirst()

• E takeLast()

  移除并返回队头或队尾元素，必要时阻塞

• boolean offerFirst(E e, long timeout, TimeUnit unit)

• boolean offerLast(E e, long timeout, TimeUnit unit)

  添加给定元素，如果成功返回true。必要时阻塞，直到元素已经添加或者超时

• E pollFirst(long timeout, TimeUnit unit)

• E pollLast(long timeout, TimeUnit unit)

  移除并返回队头或队尾元素，必要时阻塞，直到元素可用或者超时用完。失败时返回null

java.util.concurrent. TransferQueue 接口

• void transfer(E e)

• boolean tryTransfer(E e, long timeout, TimeUnit unit)

  传输一个值，或者尝试在给定的超时时间内传输这个值，这个调用将阻塞，直到另一个线程将元素删除。第二个方法会在调用成功后返回true

高效的映射、集和队列

java.util.concurrent包提供了映射、有序集和队列的高效实现：ConcurrentHashMap、ConcurrentSkipListMap、ConcurrentSkipListSet和ConcurrentLinkedQueue

这些集合使用复杂的算法，通过运行并发地访问数据结构的不同部分尽可能的减少竞争。

这些类的size方法不一定在常量时间内完成操作。确定这些集合的大小需要遍历

集合返回弱一致性的迭代器。这意味着迭代器不一定反映出它们构造一直的所有更改，但是，它们不会将同一个值返回两次，也不会抛出异常。

并发散列映射可以高效地支持大量阅读器和一定数量的书写器。默认情况下认为可以有之多16个同时运行的书写器线程。虽然可以添加，但是如果同一时间大于16个，则其它线程将暂时阻塞。

java.util.concurrent. ConcurrentLinkedDeque 类

• ConcurrentLinkedDeque()

  构造一个可以被多线程安全访问的无上限非阻塞的队列

java.util.concurrent. ConcurrentSkipListSet 类

• ConcurrentSkipListSet()

• ConcurrentSkipListSet(Comparator<? super E> comparator)

  构造一个可以被多线程安全访问的有序集。第一个构造器要求元素实现Comparable接口

java.util.concurrent. ConcurrentHashMap<K, V> 类

java.util.concurrent. ConcurrentSkipListMap<K, V> 类

• ConcurrentHashMap()

• ConcurrentHashMap(int initialCapacity)

• ConcurrentHashMap(int initialCapacity,float loadFactor, int concurrencyLevel)
  构造一个可以被多线程安全访问的散列映射表。默认初始容量为16。如果每个桶的平均负载超过装载因子，表的大小会重新调整。默认值为0.75。并发级别是估计的并发书写器的线程数

• ConcurrentSkipListMap()

• ConcurrentSkipListMap(Comparator<? super K> comparator)

  构造一个可以被多线程安全访问的有序散列映射表。第一个构造器要求元素实现Comparable接口

映射条目的原子更新

==具体内容在java核心卷一P596==

对并发散列映射的批操作

JavaAPI为并发散列映射提供了批操作，即使有其他线程在处理映射，这些操作也能安全地执行。

批操作会遍历映射，处理遍历过程中找到的元素.这里不会冻结映射的当前快照

除非你恰好知道批操作运行时映射不会被修改，否则就要把结果看作是映射状态的一个近似.

有3种不同的操作:

• search（搜索）：为每一个键或值应用一个函数，直到函数生成一个非null的结果。然后搜索终止，返回这个函数的结果.
• reduoe (归约)：组合所有键或值，这里要使用所提供的一个累加函数。
• forEach为所有键或值应用一个函数

每个操作都有4个版本:

• operationKeys: 处理键。
• operationValues: 处理值。
• operation: 处理键和值。
• operationEntries:处理Map.Entry对象。

对于上述各个操作，需要指定一个参数化阈值( parallelism threshold)。如果映射包含的元素多于这个阈值，就会并行完成批操作。如果希望批操作在一个线程中运行，可以使用阈值Long.MAX _VALUE。如果希望用尽可能多的线程运行批操作，可以使用阈值1。

search方法。有以下版本:

U searchKeys(long threshold, BiFunction<? super K, ? extends U> f)

U searchValues(long threshold, BiFunctions? super V, ? extends U> f)

U search(long threshold, BiFunction<? super K, ? super V,? extends U> f)

U searchEntries(long threshold, BiFunction<Map Entry<K, V>, ? extends U> f)

==具体内容在java核心卷一P599==

并发集视图

==具体内容在java核心卷一P600==

写数组的拷贝

CopyOnWriteArrayList 和 CopyOnWriteArraySet是线程安全的集合，其中所有更改器会建立底层数组的一个副本。

如果迭代访问集合的线程数超过更改集合的线程数，这样的安排是很有用的。当构造一个迭代器的时候，它包含当前数组的一个引用。如果这个数组后来被更改了，迭代器仍然引用旧数组，但是，集合的数组已经替换。因而，原来的迭代器可以访问一致的(但可能过时的)视图，而且不存在任何同步开销。

并发数组算法

Arrays类提供了大量并发化操作。一般都是parallel开头。例如排序parallelSort，添加parallelSetAll

任务和线程池

异步算法

进程

流

从迭代到流

流遵循着做什么而非怎么做的原则。流表面上看起来和集合很类似，都可以让我们转换和获取数据。但是，它们之间存在着显著的差异：

​ 1、 流并不存储其原始。这些元素可能存储在底层的集合中，或者是按需生成的。

​ 2、 流的操作不会修改其数据源。例如，filter方法不会从流中移除元素，而是生成一个新的流，其中不包含被过滤的元素

​ 3、流的操作是尽可能惰性执行的。这意味着直至需要其结果时，操作才会执行。因此甚至可以操作无限流

流的工作流程包含三个阶段的操作管道：

1. 创建一个流
2. 指定将初始流转换为其它流的中间操作，可能包含多个步骤
3. 应用终止操作，从而产生结果。这个操作会强制执行之前的惰性操作。从此之后，这个流就再也不能用了。

流的创建

在执行流的操作时，我们并没有修改流背后的集合。流并没有收集其数据，数据一直存储在单独的集合中。如果修改了该集合，那么流操作的结果就会变成未定义的。JDK文档将这种要求称为不干涉性

Pattern 的splitAsStream方法会按照某个正则表达式来分割一个CharSequence对象。例如使用下面的语句来将一个字符串分割为一个个的单词

Pattern.compile("\\PL+").splitAsStream(s)

Scanner.tokens方法会产生一个扫描器的符号器。另一种从字符串中获取单词流的方式是：

// java 9
List<String> words = new Scanner(s).tokens();

如果持有一个Iterable对象不是集合，那么可以通过以下的调用将其转换为一个流

Stream<Object> stream = StreamSupport.stream(iterable.spliterator(), false);

如果我们持有的是Iterator对象，并且希望得到一个由他的结果构成的流，那么可以使用以下语句

Stream<Object> stream = StreamSupport.stream(Spliterators.spliteratorUnknownSize(iterator, Spliterator.ORDERED), false);

filter、map和flatMap方法

单子论。

抽取子流和组合流

其他的流转换

简单约简

约简是一种终结操作，它会将流约简为可以在程序中使用的非流值。

这些约简操作的方法返回的是一个Optional的值，他要么在其中包装了结果，要么表示没有任何值。

findFirst返回非空集合中的第一个值。通常在于filter组成使用时很有用。findAny不强调使用第一个匹配，而是使用任意的匹配都可以，这个方法在并行处理流时很有效，因为流可以报告任何它找到的匹配而不是被限制为必须报告第一匹配。

anyMatch方法接受一个断言引元，因此不需要使用filter

Optional类型

​ Optional对象是一种包装器对象，要么包装类型T的对象，要么没有包装任何对象，对于第一种情况，称为这种值是存在的。Optional类型被称为一种更安全的方式，用来替代类型T的引用，这种引用要么引用某个对象，要么为null。但是，他只有在正确使用的情况下才会更安全。以下几个小结为说明如何正确使用

获取Optional值

通常，在没有任何匹配时，希望使用某种默认值

消费optional值

只有在其存在的情况下才消费该值（调用指定的方法）

管道化Optional值

保持Optional完整，使用map方法来转换Optional内部的值

不适合使用Optional值的方式

正确用法的提示

1. Optional类型的变量永远都不应该为null
2. 不要使用Optional类型的域。因为其代价是额外多出来一个对象。在类的内部，使用nul表示缺失的域更易于操作
   | 类/接口 | 方法 | 描述 |
   | ------------------------ | ------------------- | ------------------------------------------------------------ |
   | java.util.Optional 类 | T get() | |
   | 10 | T orElseThrow() | 产生这个optional的值，或者在该optiona为空时，抛出一个NoSuchElementException异常 |
   | | boolean isPresent() | 如果该optional不为空，则返回true |

创建Optional值

用flatMap构建Optional值的函数

假设有一个产生Optional的函数f，并且目标类型T具有一个可以产生Optional对象的方法g。那就可以调用

Optional<U> result = s.f().flatMap(T::g)

可以直接将flatMap的调用链接起来1，从而构建这些步骤构成的管道，只要所有步骤都成功，该管道才成功。

将Optional转换为流

P17

收集结果

几种方式: