Java Collection接口之: List接口&Set接口_ide



1、 List 接口

  • List集合类中元素有序、且可重复,集合中的每个元素都有其对应的顺序索引。
  • List容器中的元素都对应一个整数型的序号记载其在容器中的位置,可以根据序号存取容器中的元素。
  • JDK API中List接口的实现类常用的有:ArrayList、LinkedList和Vector

1.1 List接口的方法

List除了从Collection集合继承的方法外,List 集合里添加了一些根据索引来操作集合元素的方法

  • void add(int index, Object ele)
  • boolean addAll(int index, Collection eles)
  • Object get(int index)
  • int indexOf(Object obj)
  • int lastIndexOf(Object obj)
  • Object remove(int index)
  • Object set(int index, Object ele)
  • List subList(int fromIndex, int toIndex)

1.2 List接口的迭代器ListIterator

除了foreach和Iterator迭代器之外,List 额外提供了一个 listIterator() 方法,该方法返回一个 ListIterator 对象, ListIterator 接口继承了 Iterator 接口,提供了专门操作 List 的方法:

  • void add()
  • void set(Object obj)
  • void remove()  
  • boolean hasPrevious()
  • Object previous()
  • int previousIndex()  
  • boolean hasNext()
  • Object next()
  • int nextIndex()

1.3 List的实现类之一:ArrayList

1、ArrayList概述

  1. ArrayList是List 接口的典型实现类、主要实现类
  2. 本质上,ArrayList是对象引用的一个”变长”数组
  3. ArrayList的JDK1.8之前与之后的实现区别?
  • JDK1.7:ArrayList像饿汉式,直接创建一个初始容量为10的数组
  • JDK1.8:ArrayList像懒汉式,一开始创建一个长度为0的数组,当添加第一个元素时再创建一个始容量为10的数组
  1. Arrays.asList(...) 方法返回的List 集合,既不是ArrayList实例,也不是Vector 实例
  2. Arrays.asList(...)  返回值是一个固定长度的List 集合

2、ArrayList 源码分析

//底层创建了长度是10的Object[]数组elementData
ArrayList list = new ArrayList();
//elementData[0] = new Integer(123);
list.add(123);
//如果此次的添加导致底层elementData数组容量不够,则扩容。
list.add(11);

JDK7情况下默认情况下,扩容为原来的容量的1.5倍,同时需要将原有数组中的数据复制到新的数组中。

小结:建议开发中使用带参的构造器:ArrayList list = new ArrayList(int capacity)

     public class ArrayList<E> extends AbstractList<E>
    implements List<E>, RandomAccess, Cloneable, java.io.Serializable
    {

    private transient Object[] elementData;

    /**
    * Constructs an empty list with an initial capacity of ten.
    */
    public ArrayList() {
    this(10);
    }

    public ArrayList(int initialCapacity) {
    super();
    if (initialCapacity < 0)
    throw new IllegalArgumentException("Illegal Capacity: "+
    initialCapacity);
    // 创建集合的时候,就创建了长度为10的集合
    this.elementData = new Object[initialCapacity];
    }

    public boolean add(E e) {
    ensureCapacityInternal(size + 1); // Increments modCount!!
    elementData[size++] = e;
    return true;
    }

    private void ensureCapacityInternal(int minCapacity) {
    modCount++;
    // overflow-conscious code
    if (minCapacity - elementData.length > 0)
    grow(minCapacity);
    }

    private void grow(int minCapacity) {
    // overflow-conscious code
    int oldCapacity = elementData.length;
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    if (newCapacity - minCapacity < 0)
    newCapacity = minCapacity;
    if (newCapacity - MAX_ARRAY_SIZE > 0)
    newCapacity = hugeCapacity(minCapacity);
    // minCapacity is usually close to size, so this is a win:
    elementData = Arrays.copyOf(elementData, newCapacity);
    }

    }

    创建集合的时候,就创建了长度为10的集合

    Constructs an empty list with an initial capacity of ten

    JDK8中ArrayList的变化

     //底层Object[] elementData初始化为{}.并没有创建长度为10的数组
    ArrayList list = new ArrayList();
    //第一次调用add()时,底层才创建了长度10的数组,并将数据123添加到elementData[0]
    list.add(123);

    底层Object[] elementData初始化为{}.并没有创建长度为10的数组

    第一次调用add()时,底层才创建了长度10的数组,并将数据123添加到elementData[0]

    后续的添加和扩容操作与jdk 7 无异。

    小结:jdk7中的ArrayList的对象的创建类似于单例的饿汉式,而jdk8中的ArrayList的对象的创建类似于单例的懒汉式,延迟了数组的创建,节省内存

     public class ArrayList<E> extends AbstractList<E>
    implements List<E>, RandomAccess, Cloneable, java.io.Serializable
    {
    /**
    * Default initial capacity.
    */
    private static final int DEFAULT_CAPACITY = 10;

    private static final Object[] EMPTY_ELEMENTDATA = {};

    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

    transient Object[] elementData; // non-private to simplify nested class access


    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;
    }

    public boolean add(E e) {
    ensureCapacityInternal(size + 1); // Increments modCount!!
    elementData[size++] = e;
    return true;
    }

    private void ensureCapacityInternal(int minCapacity) {
    // 添加第一个元素时,进入if判断
    // minCapacity=1, DEFAULT_CAPACITY=10,取最大值10
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
    minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    // 不是第一次添加元素
    ensureExplicitCapacity(minCapacity);
    }

    private void ensureExplicitCapacity(int minCapacity) {
    modCount++;
    // overflow-conscious code
    if (minCapacity - elementData.length > 0)
    grow(minCapacity);
    }

    private void grow(int minCapacity) {
    // overflow-conscious code
    int oldCapacity = elementData.length;
    // 新容量是原来的,1.5倍
    // 第一次,oldCapacity =0
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    if (newCapacity - minCapacity < 0)
    newCapacity = minCapacity;
    if (newCapacity - MAX_ARRAY_SIZE > 0)
    newCapacity = hugeCapacity(minCapacity);
    // minCapacity is usually close to size, so this is a win:
    elementData = Arrays.copyOf(elementData, newCapacity);
    }

    }

    1.4 List的实现类之二:Vector

    • Vector 是一个古老的集合,JDK1.0就有了。大多数操作与ArrayList相同,区别之处在于Vector是线程安全的
    • 在各种list中,最好把ArrayList作为缺省选择。
    • 当插入、删除频繁时,使用LinkedList;
    • Vector总是比ArrayList慢,所以尽量避免使用。
    • jdk7和jdk8中通过Vector()构造器创建对象时,底层都创建了长度为10的数组。
    • 在扩容方面,默认扩容为原来的数组长度的2倍

    1.5 List的实现类之三:LinkedList

    LinkedList:双向链表,除了保存数据,还定义了两个变量:

    1. prev变量记录前一个元素的位置
    2. next变量记录下一个元素的位置

    对于频繁的插入或删除元素的操作,建议使用LinkedList类,效率较高

       private static class Node<E> {
      E item;
      Node<E> next;
      Node<E> prev;

      Node(Node<E> prev, E element, Node<E> next) {
      this.item = element;
      this.next = next;
      this.prev = prev;
      }
      }

      问ArrayList/LinkedList/Vector的异同?谈谈你的理解?ArrayList底层是什么?扩容机制?Vector和ArrayList的最大区别?

      ArrayList:作为List接口的主要实现类;线程不安全的,效率高;底层使用Object[] elementData存储

      LinkedList:对于频繁的插入、删除操作,使用此类效率比ArrayList高;底层使用双向链表存储

      Vector:作为List接口的古老实现类;线程安全的,效率低;底层使用Object[] elementData存储

      ArrayList和LinkedList

      • 二者都线程不安全,相对线程安全的Vector,执行效率高。
      • ArrayList是实现了基于动态数组的数据结构
      • LinkedList基于链表的数据结构。
      • 对于随机访问get和set,ArrayList觉得优于LinkedList,因为LinkedList要移动指针。
      • 对于操作add(特指插入)和remove,LinkedList比较占优势,因为ArrayList要移动数据。

      ArrayList和Vector

      • Vector和ArrayList几乎是完全相同的
      • 唯一的区别在于Vector是同步类(synchronized),属于强同步类。因此开销就比ArrayList要大,访问要慢。
      • 正常情况下,大多数的Java程序员使用ArrayList而不是Vector,因为同步完全可以由程序员自己来控制。
      • Vector每次扩容请求其大小的2倍空间,而ArrayList是1.5倍。
      • Vector还有一个子类Stack。

      2、Set 接口

      • Set接口是Collection的子接口,set接口没有提供额外的方法。
      • Set 集合不允许包含相同的元素,如果试把两个相同的元素加入同一个 Set 集合中,则添加操作失败。
      • Set 判断两个对象是否相同不是使用 == 运算符,而是根据 equals 方法。因此存放到Set集合中的元素一定要注意equals方法的重写。
      • Set的常用实现类有:HashSet、TreeSet、LinkedHashSet

      2.1 Set实现类之一:HashSet

      • 特点
      1. HashSet是Set 接口的典型实现,大多数时候使用Set 集合时都使用这个实现类。
      2. HashSet按Hash 算法来存储集合中的元素,因此具有很好的存取、查找、删除性能。
      3. HashSet具有以下特点:
        1. 不能保证元素的排列顺序
        2. HashSet不是线程安全的
        3. 集合元素可以是null
      4. HashSet 集合判断两个元素相等的标准:两个对象通过hashCode() 方法比较相等,并且两个对象的equals() 方法返回值也相等。
      5. 对于存放在Set容器中的对象,对应的类一定要重写equals()和hashCode(Object obj)方法,以实现对象相等规则。即:“相等的对象必须具有相等的散列码
      6. 底层也是数组,初始容量为16,当如果使用率超过0.75(16*0.75=12)就会扩大容量为原来的2倍。(16扩容为32,依次为64,128....等)
      • 重写hashCode() 方法的基本原则
      1. 在程序运行时,同一个对象多次调用hashCode() 方法应该返回相同的值。
      2. 当两个对象的equals() 方法比较返回true 时,这两个对象的hashCode() 方法的返回值也应相等
      3. 对象中用作equals() 方法比较的Field,都应该用来计算hashCode 值。
      • 重写equals() 方法的基本原则

      以自定义的Customer类为例,何时需要重写equals()?

      1. 当一个类有自己特有的“逻辑相等”概念,当改写equals()的时候,总是要改写hashCode(),根据一个类的equals方法(改写后),两个截然不同的实例有可能在逻辑上是相等的,但是,根据Object.hashCode()方法,它们仅仅是两个对象。
      2. 因此,违反了“相等的对象必须具有相等的散列码”。
      3. 结论:复写equals方法的时候一般都需要同时复写hashCode方法。通常参与计算hashCode的对象的属性也应该参与到equals()中进行计算。


      • 源码分析:
      1. Set:存储无序的、不可重复的数据
        1. 无序性:不等于随机性。存储的数据在底层数组中并非按照数组索引的顺序添加,而是根据数据的哈希值决定的。
        2. 不可重复性:保证添加的元素按照equals()判断时,不能返回true.即:相同的元素只能添加一个。
      2. 添加元素的过程:以HashSet为例:

      我们向HashSet中添加元素a,首先调用元素a所在类的hashCode()方法,计算元素a的哈希值,

      此哈希值接着通过某种算法计算出在HashSet底层数组中的存放位置(即为:索引位置),判断

      数组此位置上是否已经有元素:

      1. 如果此位置上没有其他元素,则元素a添加成功。---> 情况1
      2. 如果此位置上有其他元素b(或以链表形式存在的多个元素),则比较元素a与元素b的hash值
        1. equals()返回true,元素a添加失败
        2. equals()返回false,则元素a添加成功。---> 情况2
        3. 如果hash值不相同,则元素a添加成功。---> 情况2
        4. 如果hash值相同,进而需要调用元素a所在类的
          equals()方法进行比较
      3. 对于添加成功的情况2情况3而言:元素a 与已经存在指定索引位置上数据以链表的方式存储。

      jdk 7 :元素a放到数组中,指向原来的元素。

      jdk 8 :原来的元素在数组中,指向元素a

      HashSet底层:数组+链表的结构。

      2.3 Set实现类之二:LinkedHashSet

      1. LinkedHashSet是HashSet的子类
      2. LinkedHashSet根据元素的hashCode值来决定元素的存储位置,但它同时使用双向链表维护元素的次序,这使得元素看起来是以插入顺序保存的
      3. LinkedHashSet插入性能略低于HashSet,但在迭代访问Set 里的全部元素时有很好的性能
      4. LinkedHashSet不允许集合元素重复。

      2.4 Set实现类之三:TreeSet

      1. TreeSet是SortedSet接口的实现类
      2. TreeSet可以确保集合元素处于排序状态
      3. TreeSet底层使用红黑树结构存储数据
      4. TreeSet两种排序方法:自然排序定制排序
      5. 默认情况下,TreeSet采用自然排序。TreeSet的自然排序是根据集合元素的大小,从小到大
      6. 特点:有序,查询速度比List快
      • 自然排序:
      1. 自然排序:TreeSet会调用集合元素的compareTo(Object obj) 方法来比较元素之间的大小关系,然后将集合元素按升序(默认情况)排列
      2. 如果试图把一个对象添加到TreeSet时,则该对象的类必须实现Comparable 接口。
      3. 实现Comparable 的类必须实现compareTo(Object obj) 方法,两个对象即通过compareTo(Object obj) 方法的返回值来比较大小。

      Comparable 的典型实现:

      1. BigDecimal、BigInteger 以及所有的数值型对应的包装类:按它们对应的数值大小进行比较
      2. Character:按字符的unicode值来进行比较
      3. Boolean:true 对应的包装类实例大于false 对应的包装类实例
      4. String:按字符串中字符的unicode 值进行比较
      5. Date、Time:后边的时间、日期比前面的时间、日期大
       public class User implements Comparable{
      private String name;
      private int age;

      public User() {
      }

      public User(String name, int age) {
      this.name = name;
      this.age = age;
      }

      public String getName() {
      return name;
      }

      public void setName(String name) {
      this.name = name;
      }

      public int getAge() {
      return age;
      }

      public void setAge(int age) {
      this.age = age;
      }

      @Override
      public String toString() {
      return "User{" +
      "name='" + name + '\'' +
      ", age=" + age +
      '}';
      }

      @Override
      public boolean equals(Object o) {
      System.out.println("User equals()....");
      if (this == o) return true;
      if (o == null || getClass() != o.getClass()) return false;

      User user = (User) o;

      if (age != user.age) return false;
      return name != null ? name.equals(user.name) : user.name == null;
      }

      @Override
      public int hashCode() { //return name.hashCode() + age;
      int result = name != null ? name.hashCode() : 0;
      result = 31 * result + age;
      return result;
      }

      //按照姓名从大到小排列,年龄从小到大排列
      @Override
      public int compareTo(Object o) {
      if(o instanceof User){
      User user = (User)o;
      int compare = -this.name.compareTo(user.name);
      if(compare != 0){
      return compare;
      }else{
      return Integer.compare(this.age,user.age);
      }
      }else{
      throw new RuntimeException("输入的类型不匹配");
      }

      }
      }
      • 定制排序:
      1. TreeSet的自然排序要求元素所属的类实现Comparable接口,如果元素所属的类没有实现Comparable接口,或不希望按照升序(默认情况)的方式排列元素或希望按照其它属性大小进行排序,则考虑使用定制排序。
      2. 定制排序,通过Comparator接口来实现。需要重写compare(T o1,T o2)方法。
      3. 利用int compare(T o1,T o2)方法,比较o1和o2的大小:如果方法返回正整数,则表示o1大于o2;如果返回0,表示相等;返回负整数,表示o1小于o2。
      4. 要实现定制排序,需要将实现Comparator接口的实例作为形参传递给TreeSet的构造器。
      5. 此时,仍然只能向TreeSet中添加类型相同的对象。否则发生ClassCastException异常。
      6. 使用定制排序判断两个元素相等的标准是:通过Comparator比较两个元素返回了0
       public void test2(){
      Comparator com = new Comparator() {
      //按照年龄从小到大排列
      @Override
      public int compare(Object o1, Object o2) {
      if(o1 instanceof User && o2 instanceof User){
      User u1 = (User)o1;
      User u2 = (User)o2;
      return Integer.compare(u1.getAge(),u2.getAge());
      }else{
      throw new RuntimeException("输入的数据类型不匹配");
      }
      }
      };

      TreeSet set = new TreeSet(com);
      set.add(new User("Tom",12));
      set.add(new User("Jerry",32));

      Iterator iterator = set.iterator();
      while(iterator.hasNext()){
      System.out.println(iterator.next());
      }
      }

      2.5 为什么用复写hashCode方法,有31这个数字?

      1. 选择系数的时候要选择尽量大的系数。因为如果计算出来的hash地址越大,所谓的“冲突”就越少,查找起来效率也会提高。(减少冲突)
      2. 并且31只占用5bits,相乘造成数据溢出的概率较小。
      3. 31可以由i*31== (i<<5)-1来表示,现在很多虚拟机里面都有做相关优化。(提高算法效率)
      4. 31是一个素数,素数作用就是如果我用一个数字来乘以这个素数,那么最终出来的结果只能被素数本身和被乘数还有1来整除!(减少冲突)