Day48（List接口，ArrayList，LinkedList，Vector，Set接口，HashSet，LinkedHashSet，TreeSet，自然排序，定制排序）

Collection子接口之一：List接口

List接口概述

• 鉴于Java中数组用来存储数据的局限性，我们通常使用List替代数组

• List集合类中元素有序、且可重复，集合中的每个元素都有其对应的顺序索引。

• List容器中的元素都对应一个整数型的序号记载其在容器中的位置，可以根据序号存取容器中的元素。

• JDK API中List接口的实现类常用的有：ArrayList、LinkedList和Vector。

List接口方法

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

• void add(int index, Object ele):在index位置插入ele元素

• boolean addAll(int index, Collection eles):从index位置开始将eles中的所有元素添加进来

• Object get(int index):获取指定index位置的元素

• int indexOf(Object obj):返回obj在集合中首次出现的位置

• int lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置

• Object remove(int index):移除指定index位置的元素，并返回此元素

• Object set(int index, Object ele):设置指定index位置的元素为ele

• List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置的子集合

/**
 * |----Collection接口：单列集合，用来存储一个一个的对象
 *   |----List接口：存储序的、可重复的数据。  -->“动态”数组,替换原的数组
 *       |----ArrayList：作为List接口的主要实现类；线程不安全的，效率高；底层使用Object[] elementData存储
 *       |----LinkedList：对于频繁的插入、删除操作，使用此类效率比ArrayList高；底层使用双向链表存储
 *       |----Vector：作为List接口的古老实现类；线程安全的，效率低；底层使用Object[] elementData存储
 *
 *      ArrayList的源码分析：
 *      1 jdk 7情况下
 *        ArrayList list = new ArrayList();//底层创建了长度是10的Object[]数组elementData
 *        list.add(123);//elementData[0] = new Integer(123);
 *        ...
 *        list.add(11);//如果此次的添加导致底层elementData数组容量不够，则扩容。
 *        默认情况下，扩容为原来的容量的1.5倍，同时需要将原有数组中的数据复制到新的数组中。
 *
 *        结论：建议开发中使用带参的构造器：ArrayList list = new ArrayList(int capacity)
 *
 *      2 jdk 8中ArrayList的变化：
 *        ArrayList list = new ArrayList();//底层Object[] elementData初始化为{}.并没创建长度为10的数组
 *
 *        list.add(123);//第一次调用add()时，底层才创建了长度10的数组，并将数据123添加到elementData[0]
 *        ...
 *        后续的添加和扩容操作与jdk 7 无异。
 *      3 小结：jdk7中的ArrayList的对象的创建类似于单例的饿汉式，而jdk8中的ArrayList的对象
 *              的创建类似于单例的懒汉式，延迟了数组的创建，节省内存。
 *
 *      LinkedList的源码分析：
 *        LinkedList list = new LinkedList(); 内部声明了Node类型的first和last属性，默认值为null
 *        list.add(123);//将123封装到Node中，创建了Node对象。
 *
 *        其中，Node定义为：体现了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;
 *             }
 *         }
 *
 *      Vector的源码分析：
 *          jdk7和jdk8中通过Vector()构造器创建对象时，底层都创建了长度为10的数组。
 *          在扩容方面，默认扩容为原来的数组长度的2倍。
 *
 *   面试题：ArrayList、LinkedList、Vector者的异同？
 *   同：三个类都是实现了List接口，存储数据的特点相同：存储序的、可重复的数据
 *   不同：见上（第3部分+第4部分）
 *
 *      常用方法：(记住)
 *      增：add(Object obj)
 *      删：remove(int index) / remove(Object obj)
 *      改：set(int index, Object ele)
 *      查：get(int index)
 *      插：add(int index, Object ele)
 *      长度：size()
 * 遍历：① Iterator迭代器方式
 *      ② 增强for循环
 *      ③ 普通的循环
 *
 * - void add(intindex, Object ele):在index位置插入ele元素
 *
 * - boolean addAll(int index, Collection eles):从index位置开始将eles中的所有元素添加进来
 *
 * - Object get(int index):获取指定index位置的元素
 *
 * - int indexOf(Object obj):返回obj在集合中首次出现的位置
 *
 * - int lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置
 *
 * - Object remove(int index):移除指定index位置的元素，并返回此元素
 *
 * - Object set(int index, Object ele):设置指定index位置的元素为ele
 *
 * - List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置的子集合
 */
public class ListTest {
    @Test
    public void test1(){
        ArrayList list = new ArrayList();
        list.add(123);
        list.add(456);
        list.add("AA");
        list.add(new Person("Tom",12));
        list.add(456);
//void add(int index, Object ele):在index位置插入ele元素
        list.add(1,"DD");
        System.out.println(list);//[123, DD, 456, AA, Person{name='Tom', age=12}, 456]
//boolean addAll(int index, Collection eles):从index位置开始将eles中的所有元素添加进来
        Collection list1 = Arrays.asList("CC", 123);
        list.addAll(1,list1);
        System.out.println(list);//[123, CC, 123, DD, 456, AA, Person{name='Tom', age=12}, 456]
//Object get(int index):获取指定index位置的元素
        System.out.println(list.get(0));//123
//int indexOf(Object obj):返回obj在集合中首次出现的位置，如果不存在返回-1
        int index = list.indexOf(456);
        System.out.println(index);//4
//int lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置
        int lastIndex = list.lastIndexOf(456);
        System.out.println(lastIndex);//7
//Object remove(int index):移除指定index位置的元素，并返回此元素
        Object obj = list.remove(0);
        System.out.println(obj);//123
        System.out.println(list);//[CC, 123, DD, 456, AA, Person{name='Tom', age=12}, 456]
//Object set(int index, Object ele):设置指定index位置的元素为ele
        list.set(0,"cc");
        System.out.println(list);//[cc, 123, DD, 456, AA, Person{name='Tom', age=12}, 456]
//List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex(左闭右开)位置的子集合
        List list2 = list.subList(1, 4);
        System.out.println(list);//[cc, 123, DD, 456, AA, Person{name='Tom', age=12}, 456]
        System.out.println(list2);//[123, DD, 456]
    }
//遍历
    @Test
    //方式一: Iterator方法
    public void test2(){
        ArrayList list = new ArrayList();
        list.add(123);
        list.add(456);
        list.add("AA");
        Iterator ite = list.iterator();
        while(ite.hasNext()){
            System.out.println(ite.next());
        }
        System.out.println("-----------");
    //方式二：增强for循环
        for (Object obj : list){
            System.out.println(obj);
        }
        System.out.println("-----------");
    //方式三：普通for循环
        for (int i = 0; i 

练习题：

public class Exercise {
    @Test
    public void testListRemove(){
        List list = new ArrayList();
        list.add(1);
        list.add(2);
        list.add(3);
        updateList(list);
        System.out.println(list);//
    }
    private static void updateList(List list) {
        list.remove(2);
        //要删除2的话：
        //list.remove(new Integer(2));
    }
}

List实现类之一：ArrayList

ArrayList是List 接口的典型实现类、主要实现类

本质上，ArrayList是对象引用的一个”变长”数组

ArrayList的JDK1.8之前与之后的实现区别？

• JDK1.7：ArrayList像饿汉式，直接创建一个初始容量为10的数组

• JDK1.8：ArrayList像懒汉式，一开始创建一个长度为0的数组，当添加第一个元素时再创建一个始容量为10的数组

Arrays.asList(…) 方法返回的List 集合，既不是ArrayList实例，也不是Vector 实例。Arrays.asList(…) 返回值是一个固定长度的List 集合

List实现类之二：LinkedList

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

新增方法：

• void addFirst(Object obj)

• void addLast(Object obj)

• Object getFirst()

• Object getLast()

• Object removeFirst()

• Object removeLast()

LinkedList：双向链表，内部没有声明数组，而是定义了Node类型的first和last，用于记录首末元素。同时，定义内部类Node，作为LinkedList中保存数据的基本结构。Node除了保存数据，还定义了两个变量：

• prev变量记录前一个元素的位置

• next变量记录下一个元素的位置

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

List 实现类之三：Vector

Vector 是一个古老的集合，JDK1.0就有了。大多数操作与ArrayList相同，区别之处在于Vector是线程安全的。

在各种list中，最好把ArrayList作为缺省选择。当插入、删除频繁时，使用LinkedList；Vector总是比ArrayList慢，所以尽量避免使用。

新增方法：

• void addElement(Object obj)

• void insertElementAt(Object obj,int index)

• void setElementAt(Object obj,int index)

• void removeElement(Object obj)

• void removeAllElements()

面试题：

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

• 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。

Collection子接口之二：Set接口

Set 接口概述

• Set接口是Collection的子接口，set接口没有提供额外的方法

• Set 集合不允许包含相同的元素，如果试把两个相同的元素加入同一个Set 集合中，则添加操作失败。

• Set 判断两个对象是否相同不是使用== 运算符，而是根据equals() 方法

Set实现类之一：HashSet

HashSet是Set 接口的典型实现，大多数时候使用Set 集合时都使用这个实现类。

HashSet按Hash 算法来存储集合中的元素，因此具有很好的存取、查找、删除性能。

HashSet具有以下特点：

• 不能保证元素的排列顺序

• HashSet不是线程安全的

• 集合元素可以是null

HashSet 集合判断两个元素相等的标准：两个对象通过hashCode() 方法比较相等，并且两个对象的equals() 方法返回值也相等。

对于存放在Set容器中的对象，对应的类一定要重写equals()和hashCode(Object obj)方法，以实现对象相等规则。即：“相等的对象必须具有相等的散列码”。

/**
 *     |----Collection接口：单列集合，用来存储一个一个的对象
 *          |----Set接口：存储无序的、不可重复的数据   -->高中讲的“集合”
 *              |----HashSet：作为Set接口的主要实现类；线程不安全的；可以存储null值
 *                  |----LinkedHashSet：作为HashSet的子类；遍历其内部数据时，可以按照添加的顺序遍历
 *                                 在添加数据的同时，每个数据还维护了两个引用，
 *                                 记录此数据前一个数据和后一个数据。
 *                   对于频繁的遍历操作，LinkedHashSet效率高于HashSet.
 *              |----TreeSet：可以照添加对象的指定属性，进行排序。
 *
 *      Set接口中没额外定义新的方法，使用的都是Collection中声明过的方法。
 *
  */

public class SetTest {
    /*
    一，存储的数据特点：无序的、不可重复的元素
    以HashSet为例说明：
    1. 无序性：不等于随机性。存储的数据在底层数组中并非照数组索引的顺序添加，而是根据数据的哈希值决定的。
    2. 不可重复性：保证添加的元素照equals()判断时，不能返回true.即：相同的元素只能添加一个。
    二，元素添加过程：(以HashSet为例)
    我们向HashSet中添加元素a,首先调用元素a所在类的hashCode()方法，计算元素a的哈希值，
    此哈希值接着通过某种算法计算出在HashSet底层数组中的存放位置（即为：索引位置，判断
    数组此位置上是否已经元素：
        如果此位置上没其他元素，则元素a添加成功。 --->情况1
        如果此位置上其他元素b(或以链表形式存在的多个元素，则比较元素a与元素b的hash值：
            如果hash值不相同，则元素a添加成功。--->情况2
            如果hash值相同，进而需要调用元素a所在类的equals()方法：
                   equals()返回true,元素a添加失败
                   equals()返回false,则元素a添加成功。--->情况2

    对于添加成功的情况2和情况3而言：元素a 与已经存在指定索引位置上数据以链表的方式存储。
    jdk 7 :元素a放到数组中，指向原来的元素。
    jdk 8 :原来的元素在数组中，指向元素a
    总结：七上八下

    HashSet底层：数组+链表的结构。（前提：jdk7)
     */
    @Test
    public void test1(){
        Set set = new HashSet();
        set.add(123);
        set.add(123);
        set.add(456);
        set.add("AA");
        set.add("DD");
        set.add(new User("Jerry",20));
        set.add(789);
        Iterator setIter = set.iterator();
        while(setIter.hasNext()){
            System.out.print(setIter.next() + "\t");
        }
        //AA	DD	789	456	123	User{name='Jerry', age=20}
    }

向HashSet中添加元素的过程：

• 当向HashSet集合中存入一个元素时，HashSet会调用该对象的hashCode()方法来得到该对象的hashCode值，然后根据hashCode值，通过某种散列函数决定该对象在HashSet底层数组中的存储位置。（这个散列函数会与底层数组的长度相计算得到在数组中的下标，并且这种散列函数计算还尽可能保证能均匀存储元素，越是散列分布，该散列函数设计的越好）

• 如果两个元素的hashCode()值相等，会再继续调用equals方法，如果equals方法结果为true，添加失败；如果为false，那么会保存该元素，但是该数组的位置已经有元素了，那么会通过链表的方式继续链接。

如果两个元素的equals() 方法返回true，但它们的hashCode() 返回值不相等，hashSet将会把它们存储在不同的位置，但依然可以添加成功。

底层也是数组，初始容量为16，当如果使用率超过0.75，（16*0.75=12）就会扩大容量为原来的2倍。（16扩容为32，依次为64,128…等）

重写hashCode() 方法的基本原则

• 在程序运行时，同一个对象多次调用hashCode() 方法应该返回相同的值。

• 当两个对象的equals() 方法比较返回true 时，这两个对象的hashCode() 方法的返回值也应相等。

• 对象中用作equals() 方法比较的Field，都应该用来计算hashCode 值。

重写equals() 方法的基本原则

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

• 当一个类有自己特有的“逻辑相等”概念,当改写equals()的时候，总是要改写hashCode()，根据一个类的equals方法（改写后），两个截然不同的实例有可能在逻辑上是相等的，但是，根据Object.hashCode()方法，它们仅仅是两个对象。

• 因此，违反了“相等的对象必须具有相等的散列码”。

• 结论：复写equals方法的时候一般都需要同时复写hashCode方法。通常参与计算hashCode的对象的属性也应该参与到equals()中进行计算。

Eclipse/IDEA工具里hashCode()的重写

以Eclipse/IDEA为例，在自定义类中可以调用工具自动重写equals和hashCode。

问题：为什么用Eclipse/IDEA复写hashCode方法，有31这个数字？

• 选择系数的时候要选择尽量大的系数。因为如果计算出来的hash地址越大，所谓的“冲突”就越少，查找起来效率也会提高。（减少冲突）

• 并且31只占用5bits,相乘造成数据溢出的概率较小。

• 31可以由i*31== (i<<5)-1来表示,现在很多虚拟机里面都有做相关优化。（提高算法效率）

• 31是一个素数，素数作用就是如果我用一个数字来乘以这个素数，那么最终出来的结果只能被素数本身和被乘数还有1来整除！(减少冲突)

public class User {
    private String name;
    private int age;
    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) {
        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() {
        int result = name != null ? name.hashCode() : 0;
        result = 31 * result + age;
        return result;
    }
}

Set实现类之二：LinkedHashSet

• LinkedHashSet是HashSet的子类

• LinkedHashSet根据元素的hashCode值来决定元素的存储位置，但它同时使用双向链表维护元素的次序，这使得元素看起来是以插入顺序保存的。

• LinkedHashSet插入性能略低于HashSet，但在迭代访问Set 里的全部元素时有很好的性能。

• LinkedHashSet不允许集合元素重复。

//LinkedHashSet的使用
//LinkedHashSet作为HashSet的子类，在添加数据的同时，每个数据还维护了两个引用，记录次数据
//和后一个数据。
//优点：对于频繁的遍历操作，LinkedHashSet的效率高于HashSet
public void test2(){
    Set set = new LinkedHashSet();
    set.add(123);
    set.add(123);
    set.add(456);
    set.add("AA");
    set.add("DD");
    set.add(new User("Jerry",20));
    set.add(789);
    Iterator setIter = set.iterator();
    while(setIter.hasNext()){
        System.out.print(setIter.next() + "\t");
        //123  456    AA DD User{name='Jerry', age=20} 789
    }
}

LinkedHashSet底层结构：

Set实现类之三：TreeSet

TreeSet是SortedSet接口的实现类，TreeSet可以确保集合元素处于排序状态。

TreeSet底层使用红黑树结构存储数据

新增的方法如下：(了解)

• Comparator comparator()

• Object first()

• Object last()

• Object lower(Object e)

• Object higher(Object e)

• SortedSetsubSet(fromElement, toElement)

• SortedSetheadSet(toElement)

• SortedSettailSet(fromElement)

    /*
    TreeSet使用说明:
    1.向TreeSet中添加的数据，要求是相同类的对象。
    2.两种排序方式：自然排序（实现Comparable接口 和 定制排序（Comparator）

    1.自然排序中，比较两个对象是否相同的标准为：compareTo()返回0.不再是equals()
    2.定制排序中，比较两个对象是否相同的标准为：compare()返回0.不再是equals()
     */

TreeSet两种排序方法：自然排序和定制排序。默认情况下，TreeSet采用自然排序。

排序—自然排序

• 自然排序：TreeSet会调用集合元素的compareTo(Object obj) 方法来比较元素之间的大小关系，然后将集合元素按升序(默认情况)排列

  • 如果试图把一个对象添加到TreeSet时，则该对象的类必须实现Comparable 接口。

• 实现Comparable 的类必须实现compareTo(Object obj) 方法，两个对象即通过compareTo(Object obj) 方法的返回值来比较大小。

• Comparable 的典型实现：

  • BigDecimal、BigInteger 以及所有的数值型对应的包装类：按它们对应的数值大小进行比较

  • Character：按字符的unicode值来进行比较

  • Boolean：true 对应的包装类实例大于false 对应的包装类实例

  • String：按字符串中字符的unicode 值进行比较

  • Date、Time：后边的时间、日期比前面的时间、日期大

• 向TreeSet中添加元素时，只有第一个元素无须比较compareTo()方法，后面添加的所有元素都会调用compareTo()方法进行比较。

• 因为只有相同类的两个实例才会比较大小，所以向TreeSet中添加的应该是同一个类的对象。

• 对于TreeSet集合而言，它判断两个对象是否相等的唯一标准是：两个对象通过compareTo(Object obj) 方法比较返回值。

• 当需要把一个对象放入TreeSet中，重写该对象对应的equals() 方法时，应保证该方法与compareTo(Object obj) 方法有一致的结果：如果两个对象通过equals() 方法比较返回true，则通过compareTo(Object obj) 方法比较应返回0。否则，让人难以理解。

    public void test1(){
        TreeSet treeSet = new TreeSet();
        //不能添加不同类型的数据
        //treeSet.add(123);
        //treeSet.add(456);
        //treeSet.add("AA");
        //treeSet.add(new User("Tom",20));
    //举例一：
        treeSet.add(122);
        treeSet.add(11);
        treeSet.add(55);
        treeSet.add(-14);
        treeSet.add(39);
        Iterator treeIte = treeSet.iterator();
        while(treeIte.hasNext()){
            System.out.print(treeIte.next()+"\t");//-14	11	39	55	122
        }
        System.out.println("\n----------------------");
    //先名字后年龄顺序排序
        TreeSet treeSet1 = new TreeSet();
        treeSet1.add(new User("Tom",17));
        treeSet1.add(new User("Tom",15));
        treeSet1.add(new User("Jerry",12));
        treeSet1.add(new User("Jack",23));
        treeSet1.add(new User("Rose",21));
        treeSet1.add(new User("Puple",25));
        Iterator treeIte1 = treeSet1.iterator();
        while(treeIte1.hasNext()){
            System.out.println(treeIte1.next());
        }
    }

//先按照姓名从小到大排列，名字相同按年龄从小到大
@Override
public int compareTo(Object o) {
    if(o instanceof User){
        User u = (User)o ;
        if (this.name.equals(u.name)){
            return Integer.compare(this.age,u.age);
        }else{
            return this.name.compareTo(u.name);
        }
    }else{
        throw new RuntimeException("参数有误");
    }
}

排序—定制排序

• TreeSet的自然排序要求元素所属的类实现Comparable接口，如果元素所属的类没有实现Comparable接口，或不希望按照升序(默认情况)的方式排列元素或希望按照其它属性大小进行排序，则考虑使用定制排序。定制排序，通过Comparator接口来实现。需要重写compare(T o1,T o2)方法。

• 利用int compare(T o1,T o2)方法，比较o1和o2的大小：如果方法返回正整数，则表示o1大于o2；如果返回0，表示相等；返回负整数，表示o1小于o2。

• 要实现定制排序，需要将实现Comparator接口的实例作为形参传递给TreeSet的构造器。

• 此时，仍然只能向TreeSet中添加类型相同的对象。否则发生ClassCastException异常。

• 使用定制排序判断两个元素相等的标准是：通过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 ;
                    if (u1.getAge() == u2.getAge()){
                        return -u1.getName().compareTo(u2.getName());
                    }else{
                        return -Integer.compare(u1.getAge(),u2.getAge());
                    }
                }else{
                    throw new RuntimeException("参数有误");
                }
            }
        };
        TreeSet treeSet = new TreeSet(com);
        treeSet.add(new User("Tom",17));
        treeSet.add(new User("Tom",12));
        treeSet.add(new User("Jerry",12));
        treeSet.add(new User("Jack",12));
        treeSet.add(new User("Rose",21));
        treeSet.add(new User("Puple",25));
        Iterator treeIte1 = treeSet.iterator();
        while(treeIte1.hasNext()) {
            System.out.println(treeIte1.next());
        }
    }