IT教程 ·

聚集与容器类

Netty学习(2):IO模型之NIO初探

鸠合与容器类

系统

早在 Java 2 中之前,Java 就供应了特设类。比方:Dictionary, Vector, Stack 和 Properties 这些类用来存储和操纵对象组。虽然这些类都非常有效,然则它们缺乏一个中心的,一致的主题。由于这个缘由,运用 Vector 类的体式格局和运用 Properties 类的体式格局有着很大差别。为此,全部鸠合框架就缭绕一组标准接口而设想。

鸠合框架被设想成要满足以下几个目的。

  • 该框架必需是高性能的。基础鸠合(动态数组,链表,树,哈希表)的完成也必需是高效的。
  • 该框架许可差别范例的鸠合,以类似的体式格局事情,具有高度的互操纵性。
  • 对一个鸠合的扩大和顺应必需是简朴的。

graph LR Collection接口-->List接口 Map接口-->HashMap类 Collection接口-->Set接口 List接口-->ArrayList类 List接口-->LinkedList类 Set接口-->HashSet类 Set接口-->SortedSet类 Map接口-->SortedMap类 SortedMap类-->TreeMap类 HashSet类-->LinkedHashSet类 SortedSet类-->Treeset类 Iterator接口-->ListIterator接口

接口

Collection

  1. 最基础的鸠合接口,存储一组不唯一、无序的对象
  2. 大众要领

    | 要领 | 形貌 | | :----------------------------------: | :---------------------------------: | | int size() | 返回元素个数 | | boolean isEmpty() | 推断是不是为空 | | boolean contains(Object obj) | 推断是不是包括 obj | | boolean add(E element) | 增加元素,返回胜利与否 | | int hashCode() | 返回哈希码 | | Object[] toArray() | 转换为Object数组 | | boolean remove(Object obj) | 删除元素 | | void clear() | 清空容器 | | Iterator iterator | 返回迭代器 | | boolean equals(Object o) | 是不是与 o 相称 | | void shuffle(List list) | 随机重排元素 | | boolean containsAll(Collection c) | 推断是不是包括 c 中一切元素 | | boolean addAll(Contain c) | 鸠兼并运算 | | boolean removeAll(Collection c) | 鸠合差运算 | | boolean retainAll(Collection<?> c) | 鸠合交运算,只保留也被 c 包括的元素 |

Map

  1. 存储键值对,供应 key 到 value 的映照,key唯一
  2. 大众要领
    要领 形貌
    V put(K key,V value) 插进去键值对
    void putAll(Map<? extends K,? extends V> m) 复制映照
    boolean containsKey(Object key) 推断是不是包括 key
    boolean containsValue(Object value) 推断是不是包括 value
    V get(Object key) 返回键对应值
    Set keySet() 返回键的鸠合
    Collection values() 返回值的鸠合
    V remove(Object key) 删除 key 对应条目
    Set<Map.Entry<K,V>> entrySet() 返回键值对的鸠合

    运用 keySet() 抽取 key 序列,将 map 中的一切keys生成一个 Set。

    运用 values() 抽取 value 序列,将 map 中的一切 values 生成一个 Collection。

    为何一个生成 Set,一个生成 Collection?那是由于,key 老是举世无双的,value 许可反复。

List

  1. Collection 的子接口,经由过程索引接见元素,存储一组不唯一、有序的对象
  2. 大众要领
    要领 形貌
    E get(int index) 返回指定位置元素
    E set(int index,E element) 替代指定位置,返回被庖代元素
    int indexOf(Object o) 返回 o 初次涌现序号,不存在返回 -1
    int lastIndexOf(Object o) 返回 o 末了涌现序号
    void add(int index,E element) 指定位置插进去
    boolean add(E element) 末了位置插进去
    E remove(int index) 删除并返回指定位置元素
    boolean addAll(Collection<? extends E> c) 列表末了增加 c 中一切元素
    boolean addAll(int index,Collection<? extends E> c) 指定位置增加 c 中一切元素
    ListIterator listIterator() 返回迭代器
    ListIterator listIterator(int index) 返回指定位置入手下手的迭代器

Set

  1. Collection 的子接口,不保留反复元素,存储一组唯一、无序的对象
  2. 大众要领:继续自 Collection,未声明其他要领,不供应 get 要领猎取元素

完成类

List派生类

  1. ArrayList
    • 数组列表,自动扩容,增进长度为本来的 50%
    • 基于数组,随机接见、遍历效力高,插进去删除效力低
    • 可插进去 null
  2. LiinkedList
    • 链式数据结构
    • 基于双向链表,插进去删除效力高,随机接见、查找效力低
    • 可插进去 null
    • 经常使用要领
      要领 形貌
      public void addFirst(E e) 插进去开头
      public void addLast(E e) 插进去尾部
      public E getFirst() 返回第一元素
      public E getLast() 返回末了元素
      public E removeFirst() 删除并返回第一元素
      public E removeLast() 删除并返回末了元素

Map派生类

  1. HashMap
    • 查找元素的时候复杂度 O(1)
    • 许可 null 键和 null 值
    • 键必需唯一,值能够反复,无序
    • 上座率:元素个数到达容量与上座率乘积时,容量自动翻倍
  2. TreeMap
    • 基于二叉搜刮树,查找元素时候复杂度 O(logn)
    • 完成了 SortedMap 接口
    • 不许可 null 键(空指针非常),许可 null 值
    • 键必需唯一,值能够反复,按键值从大到小分列
    • 经常使用要领
      要领 形貌
      public K firstKey() 返回最低键
      public K lastKey() 返回最高键
      public SortedMap<K,V> headMap(K toKey) 返回键值小于 toKey 那部份映照
      public SortedMap<K,V> tailMap(K toKey) 返回大于即是 toKey 那部份映照
      public K lowerKey(K key) 返回小于给定键的最大键
      public K floorKey(K key) 返回小于即是给定键的最大键
      public K higherKey(K key) 返回大于给定键的最小键
      public K ceilingKey(K key) 返回大于即是给定键的最小键

Set派生类

  1. HashSet
    • 内部封装了一个 HashMap,HashSet 作为 map 的 key 而存在,value 则是一个类属性
    • 许可 null 元素
    • 不能增加反复元素,要领增加反复对象时不转变鸠合返回 false
    • 无序,不按插进去次序,也不按 HashCode 次序
    • 经常使用要领
      要领 形貌
      public boolean add(E e) 增加对象,返回胜利与否
      public void clear() 清空鸠合
      public boolean contains(Object o) 推断是不是包括 o 元素
      public int size() 返回鸠合容量
  2. TreeSet
    • 基于 TreeMap 的键完成,完成 了SortedSet 接口
    • 不许可插进去 null 元素(空指针非常)
    • 按元素从小到大排序
    • 不能增加反复元素
    • 经常使用要领
    要领 形貌
    public K first() 返回最低元素
    public K last() 返回最高元素
    public SortedSet headSet(E e) 返回小于 e 那部份映照
    public SortedSet tailSet(E e) 返回大于即是 e 那部份映照
    public E lower(E e) 返回小于 e 最大元素
    public E floor(E e) 返回小于即是 e 的最大元素
    public E higher(E e) 返回大于 e 的最小元素
    public E ceiling(E e) 返回大于即是 e 的最小元素
  3. LinkedHashset
    • 继续自 HashMap,内部到场链表保留元素次序
    • 基于元素进入鸠合的次序或许被接见的次序排序

传统类

  1. HashTable
    • Dictionary 的子类,完成了 Map 接口
    • 不许可 null 键,不许可 null 值
    • 键必需唯一,值能够反复,无序
    • 线程平安,支撑同步
  2. Vector
    • 线程平安,同步接见
    • 继续自 AbstractList
  3. Properties
    • 继续自 HashTable,完成了 Map 接口
    • 示意一个耐久的属性集,属性列表中每一个键及其对应值都是一个字符串
    • 经常使用要领
      要领 形貌
      String getProperty(String key) 返回指定键对应属性
      Object setProperty(String key, String value) 挪用 Hashtable 的 put 要领
      void list(PrintStream streamOut) 将属性列表输出到指定的输出流
      void list(PrintWriter streamOut) 将属性列表输出到指定的输出流
      void load(InputStream streamIn) throws IOException 从输入流中读取属性列表
      //加载 properties 配置文件的两种要领,JDBCUtils 为例
      //要领一
      URL res = JDBCUtils.class.getClassLoader().getResource("jdbc.properties");
      String path = res.getPath();
      pro.load(new FileReader(URLDecoder.decode(path, "utf-8")));
      //要领二
      // InputStream is = JDBCUtils.class.getClassLoader().getResourceAsStream("jdbc.properties");
      InputStream is = JDBCUtils.class.getResourceAsStream("/jdbc.properties");
      pro.load(is);
      
  4. Stack
    • 继续自 Vector ,先进后出
    • 线程平安
    • 经常使用要领
      要领 形貌
      boolean empty() 推断是不是栈空
      Object peek() 检察栈顶元素,不删除
      Object pop() 删除栈顶元素,并返回
      Object push(Object element) 元素压栈
      int search(Object element) 返回位置,以 1 为基数
  5. Dictionary
    • 抽象类,用来存储键/值对,作用和Map类类似
  6. BitSet
    • 位鸠合, 按需增进的位向量
    • 运用场景:整数,无反复
    • 每一位的值都是一个 boolean 值 ,占用一 bit(不是一字节)
    • 内部基于 long 数组, 所以 BitSet 的大小为 long 范例大小(64位)的整数倍
    • 经常使用要领
      要领 形貌
      void set(int index) 将指定索引处的位设置为 true
      void set(int index, boolean v) 将指定索引处的位设置为指定值
      void set(int startIndex, int endIndex) 将范围内的位设置为 true(左开右闭)
      void set(int startIndex, int endIndex, boolean v) 将范围内的位设置为指定值(左开右闭)
      boolean get(int index) 返回指定索引处的位值

算法

Collections

要领 形貌
Collections.reverse(List l) 反转
Collections.shuffle(List l) 殽杂
Collections.sort(List l) 排序
Collections.swap(List l,int index1,int index2) 替代下标位置元素
Collections.rotate(List l,int step) 向右转动 ,尾部移动到开头
Collections.synchronizedList() 线程平安化
Collections.fill(List l,Object o) 添补
Collections.copy(List m,List n) n 中的元素复制到 m 中,并掩盖响应索引的元素

迭代器

  1. Collection 定义了 toArray()、iterator()、size()要领,但并不是一切完成类都重写了这些要领,Set 不供应 get 要领,不能运用 size() 体式格局遍历。
    //Set 遍历体式格局
    Set<String> set = new HashSet<String>();
    //迭代器遍历
    Iterator<String> it = set.iterator();
    while (it.hasNext()) 
    {
      String str = it.next();
      System.out.println(str);
    }
    
    //for轮回遍历:
    for (String str : set) 
          System.out.println(str);
    
    
  2. Iterator 接口经常使用要领
    要领 形貌
    public abstract boolean hasNext() 推断是不是另有后续元素
    public abstract E next() 返回后续元素
    public abstract void remove() 删除当前指向元素
  3. ListIterator 接口经常使用要领
    要领 形貌
    public abstract boolean hashPrevious() 推断是不是有先驱元素
    public abstract E previous() 返回先驱元素
    public abstract add(E e) 插进去 next() 返回值之前,previoous() 以后
    public abstract set(E e) 替代当前指向元素
    public abstract int nextIndex() 返回基于 next() 元素序号
    public abstract int previousIndex() 返回基于 previous() 元素序号

比较器

  1. Comparator类:一个类有多个属性,不知道按哪一个属性举行排序时,经由过程 Comparator 类重写 compare(Object o1,Object o2 )指定比较算法,再应用 Collections.sort(List l,Comparator c) 举行排序
  2. Comparable接口:完成接口,重写 compareTO(Object another) 要领,应用 Collections.sort(List l)排序

Arrays

  1. 数组复制
    1. public static <T,U> T[] copyOfRange(U[] original, int from, int to)
      

      original:原数组 from:原数组的肇端位置 to:尽头位置(不包括)

    2. public static <T> T[] copyOf(T[] original, int newLength)
      

      original:原数组 newLength:要复制的长度

      StringBuider 中底层数组的扩容运用了 copyOf()

      copyOf() 内部是经由过程 System.arraycopy() 完成的

    3. System.arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
      

      src:原数组 srcPos:原数组肇端位置

      dest:目的数组 destPost:目的数组的肇端位置 length:复制长度

      List 中的 remove 要领运用了 arraycopy()

  2. 其他要领
要领 形貌
public static String toString() 转换为字符串
public static void sort() 排序
public static int binarySearch(Object[] a, Object key ) 搜刮
public static boolean equals(long[] a, long[] b) 推断是不是雷同
public static void fill(int[] a, int val)) 添补

HashCode

哈希鸠合查找元素为时候复杂度为 O(1) 的道理

  1. 取得散列值:

    经由过程特定的哈希函数,每一个对象都有对应的哈希值、

  2. hashcode对应到内存地点:

    能够运用一个数组 array,将要存的数据放在 arrayhashcode 位置上

  3. 哈希碰撞

    经由过程哈希要领,两个差别的元素,取得了雷同的哈希值

    最经常使用用的解决办法是拉链法,在统一地点上竖立链表来存储多个 hashcode 雷同的元素

  4. 查找

    经由过程哈希值找到地点,若地点上有多个元素,则用 equals 推断存储位置是不是雷同

    关于哈希鸠合来讲,假如重写了元素对应的 equals() 要领或 hashcode()要领中的一个,也必需重写另一个

SpringBoot2.x操作缓存的新姿势

参与评论