类集框架学习

java集合

public interface Collection<E>  extends Iterable<E>  

collection 重要的子接口

 List<E>,Queue<E>, Set<E>, SortedSet<E>    SortedSet  (不可重复且有序)

重要的方法

boolean add​(E e)   --->   集合中追加数据

boolean addAll​(Collection<? extends E> c)   --->   在集合中追加一组数据

void clear()    --->    清空集合

boolean contains​(Object o)    --->    数据查询

Iterator<E> iterator()    ---->    获取Iterator实例

default Stream<E> parallelStream()    ---->    并行运算留

boolean remove​(Object o)   --->    数据的删除

int size()   --->    数据个数

Object[] toArray()     --->    将集合转换为对象数组

List

void add​(int index, E element)   ---->     可确定位置插入

E get​(int index)     ---->     获取索引上为数据

int indexOf​(Object o)     ---->    查找对象的索引位置

ListIterator<E> listIterator()  ---->    获取list的Iterator的示例

E set​(int index, E element)    ----->     插入一个数据

default void sort​(Comparator<? super E> c)    ----->    实现list的集合排序

常用子类   ArrayList、LinkedList、Vector

ArrayList

public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, Serializable

ArrayList的集合默认开辟长度为10，如果不够以50%向上增加，并且在长度增加后会产生垃圾

LinkedList

public class LinkedList<E> extends AbstractSequentialList<E>
implements List<E>, Deque<E>, Cloneable, Serializable

Vector

public class Vector<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, Serializable

CopyOnWriteArrayList

读写List，很多场景下读取数据的次数远远大于写数据，如果都加上锁会对性能有很大影响，看这CopyOnWrite可以理解对写加锁对读不加锁

Set

set与list的最大区别就是set无法保存重复元素

public interface Set<E> extends Collection<E>

主要实现有    HashSet、 LinkedHashSet（链表、有序）、TreeSet（树状有序）

public TreeSet()   ----->    构造

public TreeSet​(Comparator<? super E> comparator)    ------>   使用其他排序方法

在使用其他排序时覆写Comparable的compareTo 方法，覆写是要实体内全量比较

集合输出

四种输出模式  Iterator（常用）、ListIterator、Enumeration、foreach（一般使用）

Iterable

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

Iterator<T> iterator()   --->   返回一个Iterator接口实例

得到Iterator接口后有如下方法

boolean hasNext()    ---->    判断是否有下一个内容

E next()    ---->    获取当前内容

default void remove()    ----->    删除

如何遍历对象？

将对象实现Iterable接口，将对象转换为Iterator进行输出，其中是使用内部类进行实现Iterator输出

Map集合

主要方法

V put​(K key, V value)     ---->    向集合中插入数据，如果key存在则覆盖

V get​(Object key)      ----->     通过key查询

V remove​(Object key)      ----->    根据key移除

int size()    ---->   获取结合长度

Collection<V> values()    ---->    返回所有内容

Set<K> keySet()     ----->     返回所有的key

Set<Map.Entry<K,​V>> entrySet()    ------>   将所有的内容以  Map.Entry<K,​V>  的方式返回

常见的子类 ： HashMap、LinkedHashMap、TreeMap、HashTable（线程安全）

HashMap

public class HashMap<K,​V> extends AbstractMap<K,​V>
implements Map<K,​V>, Cloneable, Serializable

HashMap  的初始容量是16，扩充原理是oldCap  << 1 （每次扩容一倍），当存储75%的时候就会扩容，也就是第一次扩容是12，当数据存储容量超过8位，HashMap将会把链表转为红黑树结构

LinkedHashMap

public class LinkedHashMap<K,​V> extends HashMap<K,​V>
implements Map<K,​V>

Map的迭代

实例

Map<String,String> map = new HashMap<>();
        map.put("a","t");
        map.put("s","r");
        map.put("d","t");
        map.put("t","t1");
        map.put("y","r1");
        map.put("i","t1");

        Set<Map.Entry<String, String>> entries = map.entrySet();
        Iterator<Map.Entry<String, String>> itemap = entries.iterator();

        while(itemap.hasNext()){
            Map.Entry<String, String> formap = itemap.next();
            System.out.println("key = "+formap.getKey()+"--- value = "+formap.getValue());
        }

​
​

Stack（栈）先进后出

public class Stack<E> extends Vector<E>    （同步）

重要方法

public E push​(E item)    --->   入栈

public E pop()    --->    出栈

Collections 类集操作工具类

public class Collections extends Object

Queue    先进先出

public interface Queue<E> extends Collection<E>

方法

boolean add​(E e)    ---->    [Exception] 增加

boolean offer​(E e)     ---->     追加数据成功为true

E remove()   ---->     [Exception] 取出，返回取出值

E poll()    ---->     从队列中获取数据

常用子类     LinkedList、 PriorityQueue(优先级队列)

Deque  双向队列

public interface Deque<E> extends Queue<E>

常见子类   ArrayDeque、LinkedList

常见方法（可以头、尾进行操作）

void addFirst​(E e)    ---->    头部添加

void addFirst​(E e)    --->      尾部添加

Stream  流    1.8

• 并行数据流计算     default Stream<E> parallelStream()
• 数据流计算      default Stream<E> stream()

其主要是避免迭代操作造成的性能浪费

---

public interface Stream<T> extends BaseStream<T,​Stream<T>>

int sum = widgets.stream()
                      .filter(w -> w.getColor() == RED)
                      .mapToInt(w -> w.getWeight())
                      .sum();

主要方法

Stream<T> filter​(Predicate<? super T> predicate)    --->    断言型数据处理

<R,​A> R collect​(Collector<? super T,​A,​R> collector)   --->   （收集器）收集流为新的集合

用法   .collect(Collectors.toList()) 等

Stream<T> distinct()    --->   消除重复

Stream<T> limit​(long maxSize)    ------>    设置取出的最大数据量

Stream<T> skip​(long n)     ----->   跳过多少数据量