05-集合框架

集合框架

集合框架的体系结构

Collection

子类可通过构造方法进行Collection集合之间的转换，和Map集合之间转换通过entrySet()和values()方法

Collection和set（集）

存储元素特点：无序无下标，不可重复
元素只能存储一个null

方法名	描述
`Iterator<E> iterator();`	获取集合迭代器对象（继承的）
`boolean add(E e)`	集合中追加元素
`boolean remove(Object o)`	根据对象equals方法，移除集合中元素
`void clear()`	清空集合元素
`boolean contains(Object o)`	根据对象equals方法，判断集合是否包含该元素
`boolean isEmpty()`	集合是否为空
`int size()`	集合大小
`<T> T[] toArray(T[] a)`	集合转换为数组
`boolean addAll(Collection<? extends E> c)`	将集合c中元素添加到当集合（并）
`boolean removeAll(Collection<?> c)`	将当前集合包含c集合的元素删除（差）
`boolean retainAll(Collection<?> c)`	将当前集合不包含c集合的元素删除（交）

HashSet

底层基于HashMap实现，因此查询效率和增删效率都比较高
存放到HashSet集合中的元素相当于放入HashMap集合的key部分
只能存一个null元素
默认容量是16

LinkedHashSet

底层基于哈希表+链表，有序，不可重复
只能存一个null元素

TreeSet

底层基于TreeMap实现，无序，不可重复，自动排序
存放到HashSet集合中的元素相当于放入HashMap集合的key部分
不允许存null

方法名	描述
`TreeSet()`	自然顺序排序，继承Comparable接口
`TreeSet(Comparator<? super E> comparator)`	传入比较器Comparator接口

List（链表）

存储元素特点：有序有下标，可重复
可存储多个元素为null

方法名	描述
`ListIterator<E> listIterator(int index)`	返回list迭代器对象
`void add(int index, E element)`	集合中指定索引后追加元素
`E remove(int index)`	根据索引移除集合中元素并返回
`E get(int index)`	获取指定索引元素
`E set(int index, E element)`	根据索引修改元素
`int indexOf(Object o)`	查找指定对象第一次出现的索引，找不到返回-1
`int lastIndexOf(Object o)`	倒着查找指定对象第一次出现的索引，找不到返回-1
`List<E> subList(int fromIndex, int toIndex)`	返回截取的子[fromIndex,toIndex)集合

ArrayList

底层是基于数组形式实现集合操作，所以查询效率高，增删效率低，且线程不安全
数组存满后，ArrayList底层就会新开辟一个更大（大50%）的数组，将原数组加入到新数组中，从而实现扩容操作，这样就会产生旧的数组成为垃圾空间，若明知道会超过默认容量（10）建议使用有参构造设置更大容量

方法名	描述
`ArrayList()`	使用默认容量10
`ArrayList(int initialCapacity)`	使用自定义容量

LinkedList

底层是基于双向链表的数据结构实现的集合操作，所以查询效率低，增删效率高，且线程不安全
存在一个Node的内部类，存放元素信息和指针信息

Vector

方法名	描述
`Enumeration<E> elements()`	获取Enumeration迭代对象

底层实现集合操作与ArrayList一样的，但是方法都使用了synchronized同步处理机制，所以线程安全，效率低

Stack（栈）

方法都使用了synchronized同步处理机制，所以线程安全

方法名	描述
`E push(E item)`	入栈
`E pop()`	出栈
`boolean empty()`	检查栈中是否为空
`E peek()`	返回栈顶元素
`int search(Object o)`	栈中利用对象equals方法查找数据，栈顶是1，找不到返回-1

Queue（单向队列）

操作	失败抛出异常	失败返回值
队尾增加元素	`boolean add(E e)`	`boolean offer(E e)`
队头删除元素	`E remove()`	`E poll()`
查看队头	`E element()`	`E peek()`

Deque(双向队列)

操作	失败抛出异常	失败返回值
队头增加元素	`void addFirst(E e)`	`boolean offerFirst(E e)`
队头删除元素	`E removeFirst()`	`E pollFirst()`
查看队头	`E getFirst()`	`E peekFirst()`
队尾增加元素	`void addLast(E e)`	`boolean offerLast(E e)`
队尾删除元素	`E removeLast()`	`E pollLast()`
查看队头尾	`E getLast()`	`E peekLast()`

迭代器

迭代器体系结构

Iterator

方法名	描述
`boolean hasNext()`	检查是否有下一个元素
`E next()`	获取当前内容，并且指针下移
`default void remove()`	删除当前元素

ListIterator

方法名	描述
`boolean hasPrevious()`	检查是否有上一个元素
`E previous();`	获取上一个元素
`int previousIndex();`	获取上一个的元素下标
`int nextIndex()`	获取下一个元素下标
`void set(E e);`	修改当前元素
`void add(E e)`	当前位置添加元素

Enumeration

方法名	描述
`boolean hasMoreElements()`	检查是否有下一个元素
`E nextElement()`	获取当前元素

foreach

原理

自定义类要想使用foreach输出，则必须实现<<Iterable>>接口返回迭代对象，迭代对象又依赖于内部类要实现<<Iterator>>接口重写hasNext()和next()方法

自定义单项链表实现foreach

public class MyList<T> implements Iterable<T>{
  private class Node<T>{
    private T date; //节点数据
    private Node<T> next; //下一个节点
    private Node(T date){
      this.date = date;
    }
  }
  private Node<T> rootNode; //根节点信息
  private Node<T> lastNode; //最后一个节点信息
  private Node<T> currentNode;  //当前节点指针
  public boolean add(T data){
    Node newNode = new Node(data);  //将数据进行节点包裹
    if (rootNode == null){
      rootNode = newNode; //保存第一个节点
    }else {
      this.lastNode.next = newNode; //向最后一个节点添加下一个的节点指针信息
    }
    this.lastNode = newNode;  //更新最后一个节点为传入的新节点
    return true;  //添加成功返回true
  }
  @Override
  public Iterator<T> iterator() { //重写Iterable接口获取迭代器
    return new Iterator<T>(){ //返回迭代器对象
      {
        MyList.this.currentNode = MyList.this.rootNode;
        //每次获取迭代器将当前节点指针置为第一个
      }
      @Override
      public boolean hasNext() {  // 匿名内部类重写hasNext
        return MyList.this.currentNode != null;
        //若当前指针是null则是最后一个节点，返回false，否则返回true
      }
      @Override
      public T next() {
        T date =  MyList.this.currentNode.date;
        //取出当前节点数据
        MyList.this.currentNode = MyList.this.currentNode.next;
        //更新当前节点指针为当前节点的存放的下一个节点指针
        return date;  //返回当前节点数据
      }
    };
  }
  public static void main(String[] args) {
    MyList<String> myList = new MyList<>();
    myList.add("1");
    myList.add("2");
    myList.add("3");
    for (String str: myList){
      System.out.println(str);
    }
  }
}

Map（映射）

通过键值对形式存储，改键值对是以Map.Entry类型的对象实例存在
存储元素特点：无序，键不可重复，值可重复
通过键可快速查找到value

方法名	描述
`V put(K key, V value)`	存放键值对，key存在返回旧元素并替换value，key不存在返回null
`V get(Object key)`	通过键对象equals方法，获取值
`boolean containsKey(Object key)`	通过键对象equals方法，检查是否包含该键
`boolean containsValue(Object value)`	通过值对象equals方法，检查是否包含该值
`V remove(Object key)`	通过键对象equals方法，删除键值对，并返回值
`void clear()`	清空集合元素
`int size()`	获取键值对数量
`boolean isEmpty()`	检查集合是否为空
`void putAll(Map<? extends K, ? extends V> m)`	将集合m中元素添加到当集合（并）
`Collection<V> values()`	获取值集合
`Set<K> keySet()`	获取键集合
`Set<Map.Entry<K, V>> entrySet()`	获取Map.Entry接口实例集合形式返回

HashMap

底层是哈希表数据结构，数组+链表，效率高，线程不安全
允许key或value为null，但是key为null只能有一个
默认初始化容量是16，二倍扩容，自定义容量建议是2的倍数

LinkedHashMap

底层基于哈希表+链表，有序，键不可重复
只能存一个null元素

Hashtable

底层是哈希表数据结构，效率低，线程安全
不允许key和value为null
默认初始容量（16）

TreeMap

底层是二叉树数据结构，TreeMap集合的key自动排序
不允许key为null，允许value为null

Properties

线程安全，key和value只能存储字符串
不允许key或value为null

方法名	描述
`Object setProperty(String key, String value)`	向Property对象加入键值对
`String getProperty(String key)`	通过键获取值，获取不到返回null
`String getProperty(String key, String defaultValue)`	通过键获取值，为获取到则是默认内容
`Set<String> stringPropertyNames()`	获取全部属性名的set集合
`void store(Writer writer, String comments)`	将Property中的信息输出到writer字符输出流中，comments是写入的注释信息
`void load(Reader reader)`	将reader字符输入流中的数据读入到Property
`void store(OutputStream out, String comments)`	将Property中的信息输出到out字节输出流中，comments是写入的注释信息
`void load(InputStream inStream)`	将inStream字节输入流中的数据读入到Property

Collections（集合工具类）

方法名	描述
`void sort(List<T> list)`	集合自然排序
`void sort(List<T> list, Comparator<? super T> c)`	集合比较器排序
`void shuffle(List<?> list)`	集合洗牌
`void reverse(List<?> list)`	集合逆序
`boolean addAll(Collection<? super T> c, T... elements)`	向集合c添加多个元素