Iterator<T> iterator();

返回每个元素的迭代器

default void forEach(Consumer<? super T> action)

循环操作每个元素

default Spliterator<T> spliterator()

创建一个spliterator

/*** iteable测试类*/
public class TestItearble {// 返回迭代器，hasNext方法判断是否有下一个元素 next方法取下一个元素public static void testIterator(List<Integer> list) {Iterator<Integer> iterator = list.iterator();while (iterator.hasNext()) {System.out.println(iterator.next());}}// foreach 内部用的还是iteratorpublic static void testForeach(Set<String> set) {set.forEach(System.out::println);}public static void main(String[] args) {List<Integer> list = new ArrayList<>();list.add(1);list.add(3);list.add(4);testIterator(list);Set<String> set = new HashSet<>();set.add("one");set.add("three");set.add("four");set.add("one");testForeach(set);}

public class TestSplitror {private static class Thread<T> extends java.lang.Thread {private final Spliterator<T> list;private Thread(Spliterator<T> list) {this.list = list;}@Overridepublic void run() {list.forEachRemaining(System.out::println);}}public static void main(String[] args) {List<String> list = new ArrayList<>();for (int i = 0; i < 2000; i++) {list.add("split" + i);}// 拆分迭代器Spliterator<String> spliterator = list.spliterator();Spliterator<String> stringSpliterator = spliterator.trySplit();Thread<String> stringthread = new Thread<>(spliterator);Thread<String> stringthread1 = new Thread<>(stringSpliterator);stringthread.start();stringthread1.start();while (true) {if (stringthread.isAlive() || stringthread1.isAlive()) {try {Thread.sleep(300);} catch (InterruptedException e) {e.printStackTrace();}} else {break;}}System.out.println("main end");}}

int size();

返回集合的元素数量

如果元素数量超过Integer.MAX_VALUE返回Integer.MAX_VALUE.

boolean isEmpty();

返回集合是否没有元素

boolean contains(Object o)；

如果集合有该元素返回true

ClassCastException 元素类型不相容

Object[] toArray();

返回一个装有改集合元素的数组

排序

<T> T[] toArray(T[] a)该方法可以对返回的数组类型进行精确控制。而非像toArray方法一样返回Object[]。

boolean add(E e);

添加一个元素，添加成功返回true

boolean remove(Object o);

移除一个元素，移除成功返回true

boolean containsAll(Collection<?> c);

是否存在当前集合中的所有元素

boolean addAll(Collection<? extends E> c);

添加当前集合中的所有元素

boolean removeAll(Collection<?> c);

移除当前集合中的所有元素

default boolean removeIf(Predicate<? super E> filter)

根据给定的公式移除元素

default Stream<E> stream()

返回streeam流

default Stream<E> parallelStream()

返回并行stream流

public class TestCollectionApi {public static void main(String[] args) {Collection set = new HashSet<>();boolean one = set.add("one");boolean one1 = set.add("one");System.out.println("set第一次添加add" + one);System.out.println("set第二次添加add" + one1);Collection list = new ArrayList<>();boolean one2 = list.add("list");boolean one3 = list.add("list");System.out.println("list第一次添加add" + one2);System.out.println("list第二次添加add" + one3);}}
返回结果为：true false true true

default void replaceAll(UnaryOperator<E> operator)

default void sort(Comparator<? super 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);

ListIterator<E> listIterator();

int lastIndexOf(Object o);返回最后一个该元素的索引位置或者-1（不存在）

List<E> subList(int fromIndex, int toIndex);

public class TestListApi {public static void main(String[] args) {List<String> list = new LinkedList<>();list.add("a");list.add("b");list.add("c");list.set(1, "d");System.out.println(list);list.add(1, "k");System.out.println(list);list.replaceAll(x -> {if (x.equals("a")) {return "tt";}return x;});System.out.println(list);list.sort(String::compareTo);System.out.println(list);List<String> list1 = list.subList(0, 2);list1.set(0, "kkkk");System.out.println(list);}
}
返回结果为：
[a, d, c]
[a, k, d, c]
[tt, k, d, c]
[c, d, k, tt]
[kkkk, d, k, tt]

boolean contains(Object o)；

如果集合有该元素返回true

ClassCastException 元素类型不相容

Object[] toArray();

返回一个装有改集合元素的数组

排序

<T> T[] toArray(T[] a)该方法可以对返回的数组类型进行精确控制。而非像toArray方法一样返回Object[]。

boolean add(E e);

添加一个元素，添加成功返回true

boolean remove(Object o);

移除一个元素，移除成功返回true

boolean containsAll(Collection<?> c);

是否存在当前集合中的所有元素

boolean retainAll(Collection<?> c);

取交集

boolean addAll(Collection<? extends E> c);

添加当前集合中的所有元素

boolean removeAll(Collection<?> c);

移除当前集合中的所有元素

default boolean removeIf(Predicate<? super E> filter)

根据给定的公式移除元素

 public V put(K key, V value) { // 先以 t 保存链表的 root 节点Entry<K,V> t = root; // 如果 t==null，表明是一个空链表，即该 TreeMap 里没有任何 Entry if (t == null) { // 将新的 key-value 创建一个 Entry，并将该 Entry 作为 root root = new Entry<K,V>(key, value, null); // 设置该 Map 集合的 size 为 1，代表包含一个 Entry size = 1; // 记录修改次数为 1 modCount++; return null; } int cmp; Entry<K,V> parent; Comparator<? super K> cpr = comparator; // 如果比较器 cpr 不为 null，即表明采用定制排序if (cpr != null) { do { // 使用 parent 上次循环后的 t 所引用的 Entry parent = t; // 拿新插入 key 和 t 的 key 进行比较cmp = cpr.compare(key, t.key); // 如果新插入的 key 小于 t 的 key，t 等于 t 的左边节点if (cmp < 0) t = t.left; // 如果新插入的 key 大于 t 的 key，t 等于 t 的右边节点else if (cmp > 0) t = t.right; // 如果两个 key 相等，新的 value 覆盖原有的 value，// 并返回原有的 value else return t.setValue(value); } while (t != null); } else { if (key == null) throw new NullPointerException(); Comparable<? super K> k = (Comparable<? super K>) key; do { // 使用 parent 上次循环后的 t 所引用的 Entry parent = t; // 拿新插入 key 和 t 的 key 进行比较cmp = k.compareTo(t.key); // 如果新插入的 key 小于 t 的 key，t 等于 t 的左边节点if (cmp < 0) t = t.left; // 如果新插入的 key 大于 t 的 key，t 等于 t 的右边节点else if (cmp > 0) t = t.right; // 如果两个 key 相等，新的 value 覆盖原有的 value，// 并返回原有的 value else return t.setValue(value); } while (t != null); } // 将新插入的节点作为 parent 节点的子节点Entry<K,V> e = new Entry<K,V>(key, value, parent); // 如果新插入 key 小于 parent 的 key，则 e 作为 parent 的左子节点if (cmp < 0) parent.left = e; // 如果新插入 key 小于 parent 的 key，则 e 作为 parent 的右子节点else parent.right = e; // 修复红黑树fixAfterInsertion(e);                               // ①size++; modCount++; return null; }
// 每当程序希望添加新节点时：系统总是从树的根节点开始比较 —— 即将根节点当成当前节点，如果新增节点大于当前节点、并且当前节点的右子节点存在，则以右子节点作为当前节点；如果新增节点小于当前节点、并且当前节点的左子节点存在，则以左子节点作为当前节点；如果新增节点等于当前节点，则用新增节点覆盖当前节点，并结束循环 —— 直到找到某个节点的左、右子节点不存在，将新节点添加该节点的子节点 —— 如果新节点比该节点大，则添加为右子节点；如果新节点比该节点小，则添加为左子节点。

 public class TreeSet<E> extends AbstractSet<E> implements NavigableSet<E>, Cloneable, java.io.Serializable { // 使用 NavigableMap 的 key 来保存 Set 集合的元素private transient NavigableMap<E,Object> m; // 使用一个 PRESENT 作为 Map 集合的所有 value。private static final Object PRESENT = new Object(); // 包访问权限的构造器，以指定的 NavigableMap 对象创建 Set 集合TreeSet(NavigableMap<E,Object> m) { this.m = m; } public TreeSet()                                      // ①{ // 以自然排序方式创建一个新的 TreeMap，// 根据该 TreeSet 创建一个 TreeSet，// 使用该 TreeMap 的 key 来保存 Set 集合的元素this(new TreeMap<E,Object>()); } public TreeSet(Comparator<? super E> comparator)     // ②{ // 以定制排序方式创建一个新的 TreeMap，// 根据该 TreeSet 创建一个 TreeSet，// 使用该 TreeMap 的 key 来保存 Set 集合的元素this(new TreeMap<E,Object>(comparator)); } public TreeSet(Collection<? extends E> c) { // 调用①号构造器创建一个 TreeSet，底层以 TreeMap 保存集合元素this(); // 向 TreeSet 中添加 Collection 集合 c 里的所有元素addAll(c); } public TreeSet(SortedSet<E> s) { // 调用②号构造器创建一个 TreeSet，底层以 TreeMap 保存集合元素this(s.comparator()); // 向 TreeSet 中添加 SortedSet 集合 s 里的所有元素addAll(s); } }
//从上面代码可以看出，TreeSet 的 ① 号、② 号构造器的都是新建一个 TreeMap 作为实际存储 Set 元素的容器，而另外 2 个构造器则分别依赖于 ① 号和 ② 号构造器，由此可见，TreeSet 底层实际使用的存储容器就是 TreeMap。

public class ArrayList<E> extends AbstractList<E>implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{private static final long serialVersionUID = 8683452581122892189L;/*** 默认的容量*/private static final int DEFAULT_CAPACITY = 10;/*** 空数组，当调用无参数构造函数的时候默认给个空数组*/private static final Object[] EMPTY_ELEMENTDATA = {};/*** * 空数组，当调用无参数构造函数的时候默认给个空数组，我们将其与空的元素数据区分开来，以了解添加第一个元素时要膨胀多少。*/private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};/*** 存储ArrayList中元素的数组容器，ArrayList的容量就是数组的长度，任何一个空的数组都会被拓展到DEFAULT_CAPACITY个容量，当第一个元素添加时。*/transient Object[] elementData; // non-private to simplify nested class access/*** 包含的元素的数量*/private int size;/*** 构造方法传入默认的capacity 设置默认数组大小*/public ArrayList(int initialCapacity) {if (initialCapacity > 0) {this.elementData = new Object[initialCapacity];} else if (initialCapacity == 0) {this.elementData = EMPTY_ELEMENTDATA;} else {throw new IllegalArgumentException("Illegal Capacity: "+initialCapacity);}}/*** 无参数构造方法默认为空数组*/public ArrayList() {this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;}
// get方法
public E get(int index) {rangeCheck(index);return elementData(index);
}
E elementData(int index) {return (E) elementData[index];
}}

public class ArrayList<E> extends AbstractList<E>implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{/*** 添加一个元素到列表的尾部*/
public boolean add(E e) {ensureCapacityInternal(size + 1);  // Increments modCount!!elementData[size++] = e;return true;
}private void ensureCapacityInternal(int minCapacity) {ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
private void ensureExplicitCapacity(int minCapacity) {modCount++;// overflow-conscious codeif (minCapacity - elementData.length > 0)grow(minCapacity);
}
private static int calculateCapacity(Object[] elementData, int minCapacity) {if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {return Math.max(DEFAULT_CAPACITY, minCapacity);}return minCapacity;
}
/*** 增加容量确保他可以保存minCapacity的元素*/
private void grow(int minCapacity) {// 首先容量翻1.5倍int oldCapacity = elementData.length;int newCapacity = oldCapacity + (oldCapacity >> 1);// 翻倍之后还不满足，容量赋值为所需最小容量if (newCapacity - minCapacity < 0)newCapacity = minCapacity;// 最大值为Integer.MAX_VALUEif (newCapacity - MAX_ARRAY_SIZE > 0)newCapacity = hugeCapacity(minCapacity);// 将原来数组的值copy新数组中去， ArrayList的引用指向新数组elementData = Arrays.copyOf(elementData, newCapacity);
}private static int hugeCapacity(int minCapacity) {if (minCapacity < 0) // overflowthrow new OutOfMemoryError();return (minCapacity > MAX_ARRAY_SIZE) ?Integer.MAX_VALUE : MAX_ARRAY_SIZE;
}/*** 移除制定位置的元素，返回值为被移除的元素*/
public E remove(int index) {rangeCheck(index);modCount++;E oldValue = elementData(index);int numMoved = size - index - 1;if (numMoved > 0)// 移除元素右边的元素左移System.arraycopy(elementData, index+1, elementData, index,numMoved);// 最后一位置空elementData[--size] = null; // clear to let GC do its work ???return oldValue;
}
}

public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {@SuppressWarnings("unchecked")T[] copy = ((Object)newType == (Object)Object[].class)? (T[]) new Object[newLength]: (T[]) Array.newInstance(newType.getComponentType(), newLength);System.arraycopy(original, 0, copy, 0,Math.min(original.length, newLength));return copy;
}

/*** 默认初始容量16*/
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16/*** 最大容量必须小于 1 << 3*/
static final int MAXIMUM_CAPACITY = 1 << 30;/***  load factor */
static final float DEFAULT_LOAD_FACTOR = 0.75f;/*** 当add一个元素到某个位桶，其链表长度达到8时将链表转换为红黑树*/
static final int TREEIFY_THRESHOLD = 8;/****/
static final int UNTREEIFY_THRESHOLD = 6;
/*** 存储元素的数组*/
transient Node<K,V>[] table;/*** */
transient Set<Map.Entry<K,V>> entrySet;/*** 包含的键值对的个数*/
transient int size;/*** 结构性修改的次数，fast—fail机制*/
transient int modCount;
/*** */
int threshold;/*** The load factor for the hash table.*/
final float loadFactor;static class Node<K,V> implements Map.Entry<K,V> {//哈希值        final int hash;final K key;V value;//链表后置节点Node<K,V> next;Node(int hash, K key, V value, Node<K,V> next) {this.hash = hash;this.key = key;this.value = value;this.next = next;}public final K getKey()        { return key; }public final V getValue()      { return value; }public final String toString() { return key + "=" + value; }//每一个节点的hash值，是将key的hashCode 和 value的hashCode 亦或得到的。public final int hashCode() {return Objects.hashCode(key) ^ Objects.hashCode(value);}//设置新的value 同时返回旧valuepublic final V setValue(V newValue) {V oldValue = value;value = newValue;return oldValue;}public final boolean equals(Object o) {if (o == this)return true;if (o instanceof Map.Entry) {Map.Entry<?,?> e = (Map.Entry<?,?>)o;if (Objects.equals(key, e.getKey()) &&Objects.equals(value, e.getValue()))return true;}return false;}}

 public HashMap() {//默认构造函数，赋值加载因子为默认的0.75fthis.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted}public HashMap(int initialCapacity) {//指定初始化容量的构造函数this(initialCapacity, DEFAULT_LOAD_FACTOR);}//同时指定初始化容量 以及 加载因子， 用的很少，一般不会修改loadFactorpublic HashMap(int initialCapacity, float loadFactor) {//边界处理if (initialCapacity < 0)throw new IllegalArgumentException("Illegal initial capacity: " +initialCapacity);//初始容量最大不能超过2的30次方if (initialCapacity > MAXIMUM_CAPACITY)initialCapacity = MAXIMUM_CAPACITY;//加载因子不能为负数if (loadFactor <= 0 || Float.isNaN(loadFactor))throw new IllegalArgumentException("Illegal load factor: " +loadFactor);this.loadFactor = loadFactor;//设置阈值为  》=初始化容量的 2的n次方的值this.threshold = tableSizeFor(initialCapacity);}//新建一个哈希表，同时将另一个map m 里的所有元素加入表中public HashMap(Map<? extends K, ? extends V> m) {this.loadFactor = DEFAULT_LOAD_FACTOR;putMapEntries(m, false);}//根据期望容量cap，返回2的n次方形式的 哈希桶的实际容量 length。 返回值一般会>=cap static final int tableSizeFor(int cap) {//经过下面的 或 和位移 运算， n最终各位都是1。int n = cap - 1;n |= n >>> 1;n |= n >>> 2;n |= n >>> 4;n |= n >>> 8;n |= n >>> 16;//判断n是否越界，返回 2的n次方作为 table（哈希桶）的阈值return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;}

public V put(K key, V value) {return putVal(hash(key), key, value, false, true);
}
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,boolean evict) {//tab存放 当前的哈希桶， p用作临时链表节点  Node<K,V>[] tab; Node<K,V> p; int n, i;//如果当前哈希表是空的，代表是初始化if ((tab = table) == null || (n = tab.length) == 0)//那么直接去扩容哈希表，并且将扩容后的哈希桶长度赋值给nn = (tab = resize()).length;//如果当前index的节点是空的，表示没有发生哈希碰撞。 直接构建一个新节点Node，挂载在index处即可。// index 是利用 哈希值 & 哈希桶的长度-1，替代模运算if ((p = tab[i = (n - 1) & hash]) == null)tab[i] = newNode(hash, key, value, null);else {//否则 发生了哈希冲突。//eNode<K,V> e; K k;//如果哈希值相等，key也相等，则是覆盖value操作if (p.hash == hash &&((k = p.key) == key || (key != null && key.equals(k))))e = p;//将当前节点引用赋值给eelse if (p instanceof TreeNode)//红黑树暂且不谈e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);else {//不是覆盖操作，则插入一个普通链表节点//遍历链表for (int binCount = 0; ; ++binCount) {if ((e = p.next) == null) {//遍历到尾部，追加新节点到尾部p.next = newNode(hash, key, value, null);//如果追加节点后，链表数量》=8，则转化为红黑树if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1sttreeifyBin(tab, hash);break;}//如果找到了要覆盖的节点if (e.hash == hash &&((k = e.key) == key || (key != null && key.equals(k))))break;p = e;}}//如果e不是null，说明有需要覆盖的节点，if (e != null) { // existing mapping for key//则覆盖节点值，并返回原oldValueV oldValue = e.value;if (!onlyIfAbsent || oldValue == null)e.value = value;//这是一个空实现的函数，用作LinkedHashMap重写使用。afterNodeAccess(e);return oldValue;}}//如果执行到了这里，说明插入了一个新的节点，所以会修改modCount，以及返回null。//修改modCount++modCount;//更新size，并判断是否需要扩容。if (++size > threshold)resize();//这是一个空实现的函数，用作LinkedHashMap重写使用。afterNodeInsertion(evict);return null;}final Node<K,V>[] resize() {//oldTab 为当前表的哈希桶Node<K,V>[] oldTab = table;//当前哈希桶的容量 lengthint oldCap = (oldTab == null) ? 0 : oldTab.length;//当前的阈值int oldThr = threshold;//初始化新的容量和阈值为0int newCap, newThr = 0;//如果当前容量大于0if (oldCap > 0) {//如果当前容量已经到达上限if (oldCap >= MAXIMUM_CAPACITY) {//则设置阈值是2的31次方-1threshold = Integer.MAX_VALUE;//同时返回当前的哈希桶，不再扩容return oldTab;}//否则新的容量为旧的容量的两倍。 else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&oldCap >= DEFAULT_INITIAL_CAPACITY)//如果旧的容量大于等于默认初始容量16//那么新的阈值也等于旧的阈值的两倍newThr = oldThr << 1; // double threshold}//如果当前表是空的，但是有阈值。代表是初始化时指定了容量、阈值的情况else if (oldThr > 0) // initial capacity was placed in thresholdnewCap = oldThr;//那么新表的容量就等于旧的阈值else {}//如果当前表是空的，而且也没有阈值。代表是初始化时没有任何容量/阈值参数的情况              newCap = DEFAULT_INITIAL_CAPACITY;//此时新表的容量为默认的容量 16newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);//新的阈值为默认容量16 * 默认加载因子0.75f = 12}if (newThr == 0) {//如果新的阈值是0，对应的是  当前表是空的，但是有阈值的情况float ft = (float)newCap * loadFactor;//根据新表容量 和 加载因子 求出新的阈值//进行越界修复newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?(int)ft : Integer.MAX_VALUE);}//更新阈值 threshold = newThr;@SuppressWarnings({"rawtypes","unchecked"})//根据新的容量 构建新的哈希桶Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];//更新哈希桶引用table = newTab;//如果以前的哈希桶中有元素//下面开始将当前哈希桶中的所有节点转移到新的哈希桶中if (oldTab != null) {//遍历老的哈希桶for (int j = 0; j < oldCap; ++j) {//取出当前的节点 eNode<K,V> e;//如果当前桶中有元素,则将链表赋值给eif ((e = oldTab[j]) != null) {//将原哈希桶置空以便GColdTab[j] = null;//如果当前链表中就一个元素，（没有发生哈希碰撞）if (e.next == null)//直接将这个元素放置在新的哈希桶里。//注意这里取下标 是用 哈希值 与 桶的长度-1 。 由于桶的长度是2的n次方，这么做其实是等于 一个模运算。但是效率更高newTab[e.hash & (newCap - 1)] = e;//如果发生过哈希碰撞 ,而且是节点数超过8个，转化成了红黑树else if (e instanceof TreeNode)((TreeNode<K,V>)e).split(this, newTab, j, oldCap);//如果发生过哈希碰撞，节点数小于8个。则要根据链表上每个节点的哈希值，依次放入新哈希桶对应下标位置。else { // preserve order//因为扩容是容量翻倍，所以原链表上的每个节点，现在可能存放在原来的下标，即low位， 或者扩容后的下标，即high位。 high位=  low位+原哈希桶容量//低位链表的头结点、尾节点Node<K,V> loHead = null, loTail = null;//高位链表的头节点、尾节点Node<K,V> hiHead = null, hiTail = null;Node<K,V> next;//临时节点 存放e的下一个节点do {next = e.next;//这里又是一个利用位运算 代替常规运算的高效点： 利用哈希值 与 旧的容量，可以得到哈希值去模后，是大于等于oldCap还是小于oldCap，等于0代表小于oldCap，应该存放在低位，否则存放在高位if ((e.hash & oldCap) == 0) {//给头尾节点指针赋值if (loTail == null)loHead = e;elseloTail.next = e;loTail = e;}//高位也是相同的逻辑else {if (hiTail == null)hiHead = e;elsehiTail.next = e;hiTail = e;}//循环直到链表结束} while ((e = next) != null);//将低位链表存放在原index处，if (loTail != null) {loTail.next = null;newTab[j] = loHead;}//将高位链表存放在新index处if (hiTail != null) {hiTail.next = null;newTab[j + oldCap] = hiHead;}}}}}return newTab;}

private transient HashMap<E,Object> map;// 默认的value值
private static final Object PRESENT = new Object();/*** 无参构造方法，默认容量16，loadfactory0.75*/
public HashSet() {map = new HashMap<>();
}/*** 构造方法，默认容量为大于参数容量的2.幂次方，loadfactory0.75*/
public HashSet(Collection<? extends E> c) {map = new HashMap<>(Math.max((int) (c.size()/.75f) + 1, 16));addAll(c);
}/*** 自定义容量和loadfactory*/
public HashSet(int initialCapacity, float loadFactor) {map = new HashMap<>(initialCapacity, loadFactor);
}/*** 自定义容量  loadfactory0.75*/
public HashSet(int initialCapacity) {map = new HashMap<>(initialCapacity);
}/*** 自定义容量 loadfactory 和默认value*/
HashSet(int initialCapacity, float loadFactor, boolean dummy) {map = new LinkedHashMap<>(initialCapacity, loadFactor);
}/*** */
public boolean contains(Object o) {return map.containsKey(o);
}/*** 讲元素置为key*/
public boolean add(E e) {return map.put(e, PRESENT)==null;
}

/** 位集被放到一个long型的数组中，由64位组成，需要6个地址位。*/
private final static int ADDRESS_BITS_PER_WORD = 6;
private final static int BITS_PER_WORD = 1 << ADDRESS_BITS_PER_WORD;
private final static int BIT_INDEX_MASK = BITS_PER_WORD - 1;/* Used to shift left or right for a partial word mask */
private static final long WORD_MASK = 0xffffffffffffffffL;/*** @serialField bits long[]** The bits in this BitSet.  The ith bit is stored in bits[i/64] at* bit position i % 64 (where bit position 0 refers to the least* significant bit and 63 refers to the most significant bit).*/
private static final ObjectStreamField[] serialPersistentFields = {new ObjectStreamField("bits", long[].class),
};/*** 底层存储结构*/
private long[] words;

public BitSet() {initWords(BITS_PER_WORD);sizeIsSticky = false;
}public BitSet(int nbits) {// nbits不能为负；大小为0可以if (nbits < 0)throw new NegativeArraySizeException("nbits < 0: " + nbits);initWords(nbits);sizeIsSticky = true;
}// 给定索引，返回新的数组private void initWords(int nbits) {words = new long[wordIndex(nbits-1) + 1];
}private static int wordIndex(int bitIndex) {return bitIndex >> ADDRESS_BITS_PER_WORD;
}

public void set(int bitIndex) {// 传入的下标是否越界if (bitIndex < 0)throw new IndexOutOfBoundsException("bitIndex < 0: " + bitIndex);
// 判断要存入的bitIndex应该在那个数组中int wordIndex = wordIndex(bitIndex);
// 如果现有数组不能满足，拓展大小expandTo(wordIndex);
// 进行的逻辑运算，对1进行左移，然后与words[wordIndex]做或(or)运算。words[wordIndex] |= (1L << bitIndex); // Restores invariantscheckInvariants();
}

BitSet bitSet = new BitSet();
bitSet.set(50);
// 位数 64
System.out.println(bitSet.size());
bitSet.set(130);
// 位数 192
System.out.println(bitSet.size());
// 是否存在
boolean b = bitSet.get(130);
System.out.println(b);
// stream
boolean match = bitSet.stream().anyMatch(bit -> Objects.equals(bit, 130));
System.out.println(match);
// 清空所有bit位 清空某一位 clear(int bitIndex)
bitSet.clear();
// 反转
bitSet.flip(30);BitSet bitSet1 = new BitSet();
bitSet1.set(50);
bitSet1.set(250);
// 并集
bitSet1.or(bitSet);
// 交集
bitSet.and(bitSet1);
// 补集
bitSet.andNot(bitSet1);

public class GuavaTester {public static void main(String args[]){BiMap<Integer, String> empIDNameMap = HashBiMap.create();empIDNameMap.put(new Integer(101), "Mahesh");empIDNameMap.put(new Integer(102), "Sohan");empIDNameMap.put(new Integer(103), "Ramesh");//Emp Id of Employee "Mahesh"System.out.println(empIDNameMap.inverse().get("Mahesh"));}    输出结果:101

public class GuavaTester {public static void main(String args[]){//create a multiset collectionMultiset<String> multiset = HashMultiset.create();multiset.add("a");multiset.add("b");multiset.add("c");multiset.add("d");multiset.add("a");multiset.add("b");multiset.add("c");multiset.add("b");multiset.add("b");multiset.add("b");//print the occurrence of an elementSystem.out.println("Occurrence of 'b' : "+multiset.count("b"));//print the total size of the multisetSystem.out.println("Total Size : "+multiset.size());//get the distinct elements of the multiset as setSet<String> set = multiset.elementSet();//display the elements of the setSystem.out.println("Set [");for (String s : set) {           System.out.println(s);          }System.out.println("]");//display all the elements of the multiset using iteratorIterator<String> iterator  = multiset.iterator();System.out.println("MultiSet [");while(iterator.hasNext()){System.out.println(iterator.next());}System.out.println("]");        //display the distinct elements of the multiset with their occurrence countSystem.out.println("MultiSet [");for (Multiset.Entry<String> entry : multiset.entrySet()){System.out.println("Element: "+entry.getElement() +", Occurrence(s): " + entry.getCount());         }System.out.println("]");     //remove extra occurrences multiset.remove("b",2);//print the occurrence of an elementSystem.out.println("Occurence of 'b' : "+multiset.count("b"));}
输出结果:
Occurence of 'b' : 5
Total Size : 10
Set [
d
b
c
a
]
MultiSet [
d
b
b
b
b
b
c
c
a
a
]
MultiSet [
Element: d, Occurence(s): 1
Element: b, Occurence(s): 5
Element: c, Occurence(s): 2
Element: a, Occurence(s): 2
]
Occurence of 'b' : 3

ImmutableSet digits = ImmutableSet.of("zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine");Function<String, Integer> lengthFunction = new Function<String, Integer>() {public Integer apply(String string) {return string.length();}
};
ImmutableListMultimap<Integer, String> digitsByLength= Multimaps.index(digits, lengthFunction);
/*
*  digitsByLength maps:
*  3 => {"one", "two", "six"}
*  4 => {"zero", "four", "five", "nine"}
*  5 => {"three", "seven", "eight"}
*/

ArrayListMultimap<String, Integer> multimap = ArrayListMultimap.create();
multimap.putAll("b", Ints.asList(2, 4, 6));
multimap.putAll("a", Ints.asList(4, 2, 1));
multimap.putAll("c", Ints.asList(2, 5, 3));
TreeMultimap<Integer, String> inverse = Multimaps.invertFrom(multimap, TreeMultimap<String, Integer>.create());
//注意我们选择的实现，因为选了TreeMultimap，得到的反转结果是有序的
/*
* inverse maps:
*  1 => {"a"}
*  2 => {"a", "b", "c"}
*  3 => {"c"}
*  4 => {"a", "b"}
*  5 => {"c"}
*  6 => {"b"}
*/

Map<String, Integer> map = ImmutableMap.of("a", 1, "b", 1, "c", 2);
SetMultimap<String, Integer> multimap = Multimaps.forMap(map);
// multimap：["a" => {1}, "b" => {1}, "c" => {2}]
Multimap<Integer, String> inverse = Multimaps.invertFrom(multimap, HashMultimap<Integer, String>.create());
// inverse：[1 => {"a","b"}, 2 => {"c"}]

public class GuavaTester {public static void main(String args[]){//Table<R,C,V> == Map<R,Map<C,V>>/**  Company: IBM, Microsoft, TCS*  IBM       -> {101:Mahesh, 102:Ramesh, 103:Suresh}*  Microsoft  -> {101:Sohan, 102:Mohan, 103:Rohan } *  TCS         -> {101:Ram, 102: Shyam, 103: Sunil } * * *///create a tableTable<String, String, String> employeeTable = HashBasedTable.create();//initialize the table with employee detailsemployeeTable.put("IBM", "101","Mahesh");employeeTable.put("IBM", "102","Ramesh");employeeTable.put("IBM", "103","Suresh");employeeTable.put("Microsoft", "111","Sohan");employeeTable.put("Microsoft", "112","Mohan");employeeTable.put("Microsoft", "113","Rohan");employeeTable.put("TCS", "121","Ram");employeeTable.put("TCS", "122","Shyam");employeeTable.put("TCS", "123","Sunil");//get Map corresponding to IBMMap<String,String> ibmEmployees =  employeeTable.row("IBM");System.out.println("List of IBM Employees");for(Map.Entry<String, String> entry : ibmEmployees.entrySet()){System.out.println("Emp Id: " + entry.getKey() + ", Name: " + entry.getValue());}//get all the unique keys of the tableSet<String> employers = employeeTable.rowKeySet();System.out.print("Employers: ");for(String employer: employers){System.out.print(employer + " ");}System.out.println();//get a Map corresponding to 102Map<String,String> EmployerMap =  employeeTable.column("102");for(Map.Entry<String, String> entry : EmployerMap.entrySet()){System.out.println("Employer: " + entry.getKey() + ", Name: " + entry.getValue());}     }
}输出：
List of IBM Employees
Emp Id: 102, Name: Ramesh
Emp Id: 101, Name: Mahesh
Emp Id: 103, Name: Suresh
Employers: IBM TCS Microsoft
Employer: IBM, Name: Ramesh

HashMap<String, String> map6 = Maps.newHashMap();
// 如果不存在则存入
map6.putIfAbsent("one", "1");
map6.putIfAbsent("one", "2");
// 存在覆盖，不存在存入
map6.put("one","3");
map6.put("two", "2");
// 根据给出的function计算value
map6.compute("three", (x, y) -> x + y + "compute");
map6.computeIfPresent("two",(x,y) ->  x + y + "compute1");
map6.computeIfAbsent()
// 根据key和funtion对value进行merge
map6.merge("one", "8", (x, y) -> x + y);

List<YearMonthBo> yearMonthBoList = Lists.newArrayList();
// 根据给定的方式移除元素，有元素移除返回true,可以为空，不可以为null,注意源码移除方式，用其他循环代替是否可行？
boolean isRemove = yearMonthBoList.removeIf(x -> Objects.nonNull(x));
yearMonthBoList.add(new YearMonthBo(2020, 11));
yearMonthBoList.add(new YearMonthBo(2020, 12));
yearMonthBoList.add(new YearMonthBo(2020, 11));
yearMonthBoList.add(new YearMonthBo(2019, 11));
// 根据给定排序方式排序，可以为空，不可以为null
yearMonthBoList.sort(Comparator.comparing(YearMonthBo::getMonth));
// 添加集合元素，可以为空，不可以为null
yearMonthBoList.addAll(Lists.newArrayList(new YearMonthBo(2020,6)));
yearMonthBoList.add(new YearMonthBo(2020,4));
// get set remove foreach size indexOf等方法不再赘述

// stack继承vector，实现了List接口，有List接口所有功能
Stack<String> stack = new Stack<>();
// 放入一个元素
stack.push("a");
// 弹出元素
String pop = stack.pop();
// 取栈顶元素
String peek = stack.peek();

// 队列先进先出
Queue<String> queue = new ArrayBlockingQueue<String>(10);
// 添加元素
queue.offer("a");
queue.offer("b");
// 队列头部元素
String peek = queue.peek();
// 取出队列头部元素
String poll = queue.poll();

Set<Integer> sets = Sets.newHashSet(1, 2, 3, 4, 5, 6);Set<Integer> sets2 = Sets.newHashSet(3, 4, 5, 6, 7, 8, 9);// 交集System.out.println("交集为：");SetView<Integer> intersection = Sets.intersection(sets, sets2);for (Integer temp : intersection) {System.out.println(temp);}// 差集System.out.println("差集为：");SetView<Integer> diff = Sets.difference(sets, sets2);for (Integer temp : diff) {System.out.println(temp);}// 并集System.out.println("并集为：");SetView<Integer> union = Sets.union(sets, sets2);for (Integer temp : union) {System.out.println(temp);}

public static void main(String[] args) {List<String> list1 = new ArrayList<String>();list1.add("A");list1.add("B");list1.add("C");List<String> list2 = new ArrayList<String>();list2.add("C");list2.add("B");list2.add("D");// 并集list1.addAll(list2);// 去重复并集list2.removeAll(list1);list1.addAll(list2);// 交集list1.retainAll(list2);// 差集list1.removeAll(list2);
}

List<YearMonthBo> list1 = new ArrayList<YearMonthBo>();
list1.add(new YearMonthBo(2020, 1));
list1.add(new YearMonthBo(2020, 2));
list1.add(new YearMonthBo(2019, 12));List<YearMonthBo> list2 = new ArrayList<YearMonthBo>();
list2.add(new YearMonthBo(2020, 2));
list2.add(new YearMonthBo(2020, 3));
list2.add(new YearMonthBo(2019, 11));
// 1：集合并集
List<YearMonthBo> collect = Stream.of(list1, list2).flatMap(List::stream).collect(Collectors.toList());
// 2：去重取并集
Set<YearMonthBo> collect1 = Stream.of(list1, list2).flatMap(List::stream).collect(Collectors.toSet());
// 3：合并去重
List<YearMonthBo> collect2 = Stream.of(list1, list2).flatMap(List::stream).distinct().collect(Collectors.toList());
// 4:合并并根据对象中的某些字段去重(相乘相加等操作均可)
ArrayList<YearMonthBo> yearMonthBoArrayList = Lists.newArrayList(Stream.of(list1, list2).flatMap(List::stream).collect(Collectors.toMap(YearMonthBo::getYear, Function.identity(), (x, y) -> x == null ? y : x)).values());
// 5:集合合并
List<YearMonthBo> collect3 = Stream.concat(list1.stream(), list2.stream()).collect(Collectors.toList());

// 1：根据compare接口排序，需实现Comparable接口
Collections.sort(testList);
// 2：根据自定义比较器排序
Collections.sort(testList, YearMonthBo::compareTo);
// 3：根据自定义排序器排序
testList.sort(Comparator.comparingInt(YearMonthBo::getYear));

 // collectors方法 tomap
Map<Integer, YearMonthBo> map2 = testList.stream().collect(Collectors.toMap(YearMonthBo::getYear, Function.identity(), (a1, a2) -> new YearMonthBo(a1.getYear() + a2.getYear(), a2.getMonth() + a1.getMonth())));
// collectors方法 grouping by
Map<Integer, List<YearMonthBo>> map3 = testList.stream().collect(Collectors.groupingBy(YearMonthBo::getYear));
// guava tomap
Map<Integer, YearMonthBo> map1 = Maps.uniqueIndex(testList, YearMonthBo::getYear);

List<YearMonthBo> list1 = new ArrayList<YearMonthBo>();
list1.add(new YearMonthBo(2020, 1));
list1.add(new YearMonthBo(2020, 2));
list1.add(new YearMonthBo(2019, 12));List<YearMonthBo> list2 = new ArrayList<YearMonthBo>();
list2.add(new YearMonthBo(2020, 2));
list2.add(new YearMonthBo(2020, 3));
list2.add(new YearMonthBo(2019, 11));
// 1：根据equals和hashcode去重
List<YearMonthBo> collect4 = Stream.of(list1, list2).flatMap(List::stream).distinct().collect(Collectors.toList());
// 2：”根据对象属性去重
Collection<YearMonthBo> values = Stream.of(list1).flatMap(List::stream).collect(Collectors.toMap(YearMonthBo::getYear, Function.identity(), (x, y) -> x == null ? y : x)).values();
// 3：根据对象属性去重
List<YearMonthBo> collect5 = Stream.of(list1, list2).flatMap(List::stream).filter(distinctByKey(YearMonthBo::getYear)).collect(Collectors.toList());

public static void main(String[] args) {List<String> list1 = Lists.newArrayList("a","b","c");List<String> list2 = new ArrayList<String>();list2.add("C");list2.add("B");list2.add("D");// guava反转Lists.reverse(list1 );// java反转for循环反转
}

HashSet<Integer> set = Sets.newHashSet(1, 4, 3);
HashSet<Integer> set1 = Sets.newHashSet(1, 9, 8);
Set<List<Integer>> lists = Sets.cartesianProduct(set, set1);
System.out.println(lists);

List<String> strList = new ArrayList<>();
strList.addAll(Lists.newArrayList("aa", "vv", "ww"));
String collect = strList.stream().collect(Collectors.joining());
String collect = strList.stream().collect(Collectors.joining(","));
String collect = strList.stream().collect(Collectors.joining(",","prefix","suffix"));

ArrayList<String> objects1 = new ArrayList<>();

ArrayList<String> objects1 = new ArrayList<>(cap);

ArrayList<String> objects1 = new ArrayList<>(Collection);

HashSet<Integer> integers = Sets.newHashSet(1, 2, 4);

HashSet<Object> objects = Sets.newHashSet();

Sets.newHashSetWithExpectedSize(5);

Sets.newHashSet(Itearable);

ConcurrentHashMap

/*** 获取对应三级部门下的采购员*/
public Set<PurchaserVo> getPurControllerByDept(Integer deptId3) {// 根据三级部门获取采购/销售/部门/品牌/品类关系List<CateBrandPurSalerRelVo> relVoList = sccAuthJsfService.getCateBrandPurSalerRelByDept3(deptId3);// 部门下不存在权限关系则记录异常日志，返回空关系集合if (CollectionUtils.isEmpty(relVoList)) {log.error("三级部门:{}下权限关系数据为空!", deptId3);return Collections.emptySet();}// 将权限关系放到set集合中，自动去重Set<PurchaserVo> purchaserVoSet = Sets.newHashSet();relVoList.forEach(relVo -> {PurchaserVo purchaserVo = new PurchaserVo();purchaserVo.setPurchaserErp(relVo.getPurchaserControlErp());purchaserVo.setPurchaserName(relVo.getPurchaserControlName());purchaserVoSet.add(purchaserVo);});return purchaserVoSet;
}

/*** 合并去重排序*/
private List<CommonDropdownDto> unionAndDistinct2List(List<CommonDropdownDto> purDataList,List<CommonDropdownDto> purDataInDb) {return Stream.concat(purDataList.stream(), purDataInDb.stream()).distinct().collect(Collectors.collectingAndThen(Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(o -> o.getValue()))),ArrayList::new));
}

List<YearMonthBo> yearMonthBoList = Lists.newArrayList();
yearMonthBoList.add(new YearMonthBo(2020, 11));
yearMonthBoList.add(new YearMonthBo(2020, 12));
yearMonthBoList.add(new YearMonthBo(2020, 11));
// Exception in thread "main" java.lang.IllegalStateException: Duplicate key 11
Map<YearMonthBo, Integer> map1 = yearMonthBoList.stream().collect(Collectors.toMap(Function.identity(), YearMonthBo::getMonth));
// success
Map<YearMonthBo, Integer> map2 = yearMonthBoList.stream().collect(Collectors.toMap(Function.identity(), YearMonthBo::getMonth, Integer::sum));
// success
Map<Integer, List<YearMonthBo>> map4 = yearMonthBoList.stream().collect(Collectors.groupingBy(yearMonthBo -> yearMonthBo.getYear()));