JavaEE基础第11章Java集合

第11章Java集合

集合概述

集合框架的概述

一、集合：

1.集合、数组都是对多个数据进行存储操作的结构，简称Java容器。

​ 说明：此时的存储，主要指的是内存层面的存储，不涉及到持久化的存储(.txt，jpg，avi，数据库)

2.1 数组在存储多个数据方面的特点：

​ ①一旦初始化以后，其长度就确定了。

​ ②数组一旦定义好，其元素的类型也就确定了。我们也就只能操作指定类型的数据了。比如:String[] arr; int[] arr1; Object[] arr2;涉及多态，可以传入Object的子类对象。

2.2 数组在存储多个数据方面的缺点：

​ ①一旦初始化以后，其长度就不可修改

​ ②数组中提供的方法非常有限，对于添加、删除、插入数据等操作，非常不便，同时效率不高。

​ ③获取数组中实际元素的个数的需求，数组没有现成的属性或方法可用。

​ ④数组存储数据的特点：有序、可重复。对于无序、不可重复的需求，不能满足。

当然集合的底层源码也还是通过数组来进行操作的，所以数组也很重要。

集合框架

二、集合框架

|-----Collection接口：单列集合，用来存储一个一个的对象

​ |----List接口：存储有序的、可重复的数据。—> “动态”数组

​ |----ArrayList、LinkedList、Vector

​ |----Set接口：存储无序的、不可重复的数据 —> 类似高中讲的“集合”，具有无序性，确定性，互异性（可以利用Set接口过滤数据，过滤掉重复数据）

​ |----HashSet、LinkedHashSet、TreeSet

|-----Map接口：双列集合，用来存储一对（key - value）一对的数据。保存具有映射关系“key-value对”的集合。（Map是”映射“的意思） — > 类似高中函数：y = f(x),

其中 x 相当于key， y 相当于value，多个 x 可以对应同一个 y ，同样多个key可以对应同一个value，但是反过来不可以，一个 x 不能对应多个 y ，一个key 也不能对应多个value。

​ |----HashMap、LinkedHashMap、TreeMap、Hashtable、Properties

Collection接口，Map接口的继承树（其中实线表示继承关系，虚线表示实现关系）

Collection接口中的常用方法

add(Object e):将元素e添加到集合coll中，可以是任意类型Object

size():获取添加的元素的个数

addAll(Collection coll1):将coll1集合中的元素添加到当前的集合中

isEmpty():判断当前集合是否为空。这个空指的是size == 0 ，而不是null

clear():清空集合元素。指的是将所有元素清空，size变为0 ， 而不是置为null

    @Test
    public void test1(){
        //实例化接口实现类的对象
        //接口定义的是规范，虽然执行的是子类重写的方法，但是也能知道接口中方法的作用
        Collection coll = new ArrayList();

        //add(Object e):将元素e添加到集合coll中，可以是任意类型Object
        coll.add("AA");
        coll.add("BB");
        coll.add(123);
        coll.add(new Date());

        //size():获取添加的元素的个数
        System.out.println(coll.size());//4

        //addAll(Collection coll1):将coll1集合中的元素添加到当前的集合中
        Collection coll1 = new ArrayList();
        coll1.add("CC");
        coll1.add(456);
        coll.addAll(coll1);
        System.out.println(coll.size());//6
        System.out.println(coll);//实际调用的是实现类中重写的toString()

        //isEmpty():判断当前集合是否为空。这个空指的是size == 0 ，而不是null
        System.out.println(coll.isEmpty());//false

        //clear():清空集合元素。指的是将所有元素清空，size变为0 ， 而不是置为null
        coll.clear();
        System.out.println(coll.isEmpty());//true
    }

一定一定要注意这一点，要重写equals()方法。

向Collection接口的实现类的对象中添加数据obj时，要求obj所在类重写equals().

contains(Object obj),判断当前集合中是否包含obj，底层源码使用的时equals()方法

containsAll(Collection coll1):判断形参coll1中的所有元素是否都存在于当前集合中。

remove(Object obj):从当前集合中移除obj元素。底层实现逻辑：拿obj对象的equals()方法去比较看看集合中有没有这个元素，有就删除返回true，没有这个元素就返回false

removeAll(Collection coll1):从当前集合中移除coll1中所有元素。相当于 差集

retainAll(Collection coll1):交集：获取当前集合和coll1集合的交集，并返回给当前集合

equals(Object obj):形参也是一个集合。要想返回true，需要当前集合和形参集合的元素都相同。具体要求顺序是否一样还要看具体的集合是否支持有序或者无序，如果是有序集合则还需要要求顺序一样才返回true。比如ArrayList是有序的

hashCode():返回当前对象的哈希值

toArray():集合—> 数组

数组—> 集合：调用Arrays类的静态方法asList()

iterator():返回Iterator接口的实例，用于遍历集合元素。

    /**
     * Collection接口中声明的方法的测试
     * 向Collection接口的实现类的对象中添加数据obj时，要求obj所在类重写equals().
     */
    @Test
    public void test2(){
        Collection coll = new ArrayList();
        coll.add(123);//添加的都是类，基本数据类型添加的都是对应的包装类
        coll.add(456);
        coll.add(new String("Tom"));
        coll.add(false);
        coll.add(new Person("Jerry",20));

        //contains(Object obj),判断当前集合中是否包含obj，底层源码使用的时equals()方法
        boolean contains = coll.contains(123);
        System.out.println(contains);//true

        /*返回的也是ture，但这都是new了一个对象，地址值不一样，返回的是true说明肯定用的不是 == 进行比较
        用的是equals()方法，比较的是内容。注意如果没有重写equals()则调用的是Object类中的equals()方法
        其底层调用的还是 == ，而String重写了equals()，比较的是内容。所以这里输出的是true
        */
        //在判断时会调用obj对象所在类的equals()
        System.out.println(coll.contains(new String("Tom")));//true

        /*
        没有重写equals()方法时调用的是Object的equals()方法，其底层还是用的 == ，比较的是地址值，所以
        这时候返回false。当重写equals()返回的就是true了。而且可以知道equals()被调用了几次，因为ArrayList
        是有序的，contains()方法是拿传入的参数用equals()方法从头开始一个一个的进行比较，直到找到第一个内容相同
        的便返回true
         */
        System.out.println(coll.contains(new Person("Jerry",20)));//false

        //containsAll(Collection coll1):判断形参coll1中的所有元素是否都存在于当前集合中。
        //也是用的equals()方法。只有全部都存在时才返回true，只要有一个不在就返回false
        Collection coll1 = Arrays.asList(123,456);
        System.out.println(coll.containsAll(coll1));//ture
        Collection coll2 = Arrays.asList(123,4567);
        System.out.println(coll.containsAll(coll2));//false

        //remove(Object obj):从当前集合中移除obj元素。底层实现逻辑：拿obj对象的equals()方法去
        //比较看看集合中有没有这个元素，有就删除返回true，没有这个元素就返回false
        boolean remove = coll.remove(123);
        System.out.println(remove);//true
        System.out.println(coll);

        //removeAll(Collection coll1):从当前集合中移除coll1中所有元素。相当于 差集
        //coll1中哪个元素存在当前集合中，就将那个删除
        coll.removeAll(coll1);
        System.out.println(coll);

        //retainAll(Collection coll1):交集：获取当前集合和coll1集合的交集，并返回给当前集合
        //意思就是在当前集合上面做修改
        coll.retainAll(coll1);

        //equals(Object obj):形参也是一个集合。要想返回true，需要当前集合和形参集合的元素都相同。具体要求顺序是否一样
        //还要看具体的集合是否支持有序或者无序，如果是有序集合则还需要要求顺序一样才返回true。比如ArrayList是有序的
        coll.equals(coll1);

        //hashCode():返回当前对象的哈希值
        System.out.println(coll.hashCode());

        //toArray():集合---> 数组
        Object[] objects = coll.toArray();
        for (int i = 0; i < objects.length; i++) {
            System.out.println(objects[i]);
        }

        //数组---> 集合：调用Arrays类的静态方法asList()
        List<String> strings = Arrays.asList(new String[]{"AA", "BB", "CC"});
        //开发中写的时候不用再new 了，直接写元素即可
        System.out.println(strings);

        List ints = Arrays.asList(new int[]{123, 456});
        System.out.println(ints.size());//1。输出结果为1是因为asList()会把基本数据类型数组看作是一个整体

        List integers = Arrays.asList(new Integer[]{123, 456});
        System.out.println(integers.size());//2。换成类，就可以识别为两个了
		//开发中就用这种写法，直接写对象。不用再new了
        List integers1 = Arrays.asList(123, 456);
        System.out.println(integers1.size());//2。或者用这种方法直接写出来也会自动装箱识别为Integer

        //iterator():返回Iterator接口的实例，用于遍历集合元素。放在IteratorTest.java中测试
    }

Iterator迭代器

Iterator对象称为迭代器(设计模式的一种)，主要用于遍历 Collection 集合中的元素。迭代器模式的定义为：提供一种方法访问一个容器(container)对象中各个元素，而又不需暴露该对象的内部细节。迭代器模式，就是为容器而生。

Collection接口继承了java.lang.Iterable接口，该接口有一个iterator()方法，那么所有实现了Collection接口的集合类都有一个iterator()方法，用以返回一个实现了Iterator接口的对象。
Iterator 仅用于遍历集合，Iterator 本身并不提供承装对象的能力。如果需要创建Iterator 对象，则必须有一个被迭代的集合。
集合对象每次调用iterator()方法都得到一个全新的迭代器对象，默认游标都在集合的第一个元素之前。

iterator():返回Iterator接口的实例，用于遍历集合元素。

遍历集合推荐，hasNext()，next()搭配使用：方式三

集合元素的遍历操作，使用迭代器Iterator接口：
Iterator只用来遍历Collection，不能遍历Map
1.调用内部的方法：hasNext() 和 next()
2.集合对象每次调用iterator()方法都得到一个全新的迭代器对象，默认游标都在集合的第一个元素之前。
3.内部定义了remove(),可以在遍历的时候，删除集合中的元素。此方法不同于集合直接调用remove()

    /**
     * 集合元素的遍历操作，使用迭代器Iterator接口
     * Iterator只用来遍历Collection，不能遍历Map
     * 1.调用内部的方法：hasNext() 和 next()
     * 2.集合对象每次调用iterator()方法都得到一个全新的迭代器对象，默认游标都在集合的第一个元素之前。
     * 3.内部定义了remove(),可以在遍历的时候，删除集合中的元素。此方法不同于集合直接调用remove()
     */
    @Test
    public void test3(){
        Collection coll = new ArrayList();
        coll.add(123);//添加的都是类，基本数据类型添加的都是对应的包装类
        coll.add(456);
        coll.add(new String("Tom"));
        coll.add(false);
        coll.add(new Person("Jerry",20));

        Iterator iterator = coll.iterator();
        //方式一：不推荐
        //next()每次取一个，都是下一个
//        System.out.println(iterator.next());
//        System.out.println(iterator.next());
//        System.out.println(iterator.next());
//        System.out.println(iterator.next());
//        System.out.println(iterator.next());
//        //取的个数超过了就会报NoSuchElementException
//        System.out.println(iterator.next());

        //方式二：不推荐
//        for (int i = 0; i < coll.size(); i++) {
//            System.out.println(iterator.next());
//        }

        //方式三：推荐，hasNext()，next()搭配使用
        //如果有下一个就进入循环执行语句输出下一个
        while (iterator.hasNext()){
            //next():①指针下移 ②将下移以后集合位置上的元素返回
            System.out.println(iterator.next());
        }
    }

}

如果不按照方式三书写就可能会出现如下错误：

    @Test
    public void test4(){
        Collection coll = new ArrayList();
        coll.add(123);//添加的都是类，基本数据类型添加的都是对应的包装类
        coll.add(456);
        coll.add(new String("Tom"));
        coll.add(false);
        coll.add(new Person("Jerry",20));

        //错误方式一
        /*
        由于next():①指针下移 ②将下移以后集合位置上的元素返回会执行两个操作，先将指针下移，再返回
        所以在这里面判断的时候指针就会下移一次，输出的时候再下移一次就会导致中间会隔一个输出，并且会报异常
        NoSuchElementException
         */
//        Iterator iterator = coll.iterator();
//        while (iterator.next() != null){
//            System.out.println(iterator.next());
//        }
        //错误方式二
        /*
        每次调用一次iterator()就会返回一个新的Iterator对象，所以每次都是输出第一个位置的值，且是死循环
         */
        while (coll.iterator().hasNext()){
            System.out.println(coll.iterator().next());
        }
    }

Iterator中的remove()方法:

Iterator可以删除集合的元素，但是是遍历过程中通过迭代器对象的remove方法，不是集合对象的remove方法。
如果还未调用next()或在上一次调用 next 方法之后已经调用了 remove 方法，再调用remove都会报IllegalStateException。

还未调用next()时指针指向第一个元素前面，无法删除。调用了remove 之后再调用一次此时指针还未向下移动，错误。

    @Test
    public void test5(){
        Collection coll = new ArrayList();
        coll.add(123);//添加的都是类，基本数据类型添加的都是对应的包装类
        coll.add(456);
        coll.add(new String("Tom"));
        coll.add(false);
        coll.add(new Person("Jerry",20));

        //删除集合中的"Tom"
        Iterator iterator = coll.iterator();
        while (iterator.hasNext()){
            Object obj = iterator.next();
            if ("Tom".equals(obj)){
                iterator.remove();
            }
        }
        //此时再遍历结合需要重新调用iterator()，因为之前那个Iterator对象的指针已经到末尾了
        iterator = coll.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }

迭代器Iterator的执行原理

需要注意的是hasNext()仅是判断当前指针下面是否还有元素，有就返回true，没有就返回false，没有其他操作。执行到next()之后指针才会下移，并且将下移后指针所指的元素返回。 还有**Iterator并不是容器，仅用于遍历集合，**一切操作都是对这个集合执行的。

foreach循环遍历集合

jdk5.0 新增了foreach循环，用于遍历集合、数组

foreach的结构：

for(集合元素的类型 局部变量 ： 集合对象){}

其原理是：内部仍然调用了迭代器

    /**
     * jdk5.0 新增了foreach循环，用于遍历集合、数组
     */
    @Test
    public void test6(){
        Collection coll = new ArrayList();
        coll.add(123);//添加的都是类，基本数据类型添加的都是对应的包装类
        coll.add(456);
        coll.add(new String("Tom"));
        coll.add(false);
        coll.add(new Person("Jerry",20));

        //for(集合元素的类型  局部变量  ： 集合对象)
        //内部仍然调用了迭代器
        //foreach （增强for循环）是将集合对象一个个取出来赋值给局部变量
        for (Object obj : coll) {
            System.out.println(obj);
        }
    }

    @Test
    public void test7(){
        int[] arr = new int[]{1,2,3,4,5};
        //for(数组元素的类型  局部变量  ： 数组对象)
        //foreach （增强for循环）是将数组对象一个个取出来赋值给局部变量
        for (int i :
                arr) {
            System.out.println(i);
        }
    }

    @Test
    public void test8(){
        String[] arr = new String[]{"MM","MM","MM"};

        //方式一:普通for赋值
        //输出的是"GG"，这是直接在数组元素上修改的
//        for (int i = 0; i < arr.length; i++) {
//            arr[i] = "GG";
//        }

        //方式二：增强for循环
        //输出的是"MM"，因为根据String的内存解析，增强for循环是将数组里每一个元素赋值给一个新的变量
        //改变新的变量的值，不影响原来的值。类似于方法调用里面的形参，传递的只是一个地址值，再根据String的
        //内存结构便可以得出结果
        for (String s :
                arr) {
            s = "GG";
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }

List接口

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

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

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

List又称为“动态数组”

List：同样也要重写equals()

面试题：ArrayList、LinkedList、Vector三者的异同？

这个面试题除了要把下面这一段说说，还要分析一下底层源码(下面的源码分析)。

这个是高频面试题

相同点：三个类都是实现了List接口，存储数据的特点相同；存储有序的、可重复的数据。

不同点：(即是题目，也是知识点，需要掌握的)

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

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

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

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

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

双向链表里面保存数据的是Node类型，Node内部类定义了prev前指针，next后指针，和数据item。一个Node就是

前指针	数据	后指针
prev	item	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;
	}
}

ArrayList的源码分析：

jdk7情况下

ArrayList list = new ArrayList();//底层创建了长度是10的Object[]数组elementData

list.add(123);//elementData[0] = new Integer(123);传入的都是Object对象

…

list.add(11);//如果此次的添加导致底层elementData数组容量不够，则扩容。

默认情况下，扩容为原来的容量的1.5倍（也是通过位运算符），同时需要将原有数组中的数据复制到新的数组中。

结论：建议开发中使用带参的构造器：

ArrayList list = new ArrayList(int capacity) //capacity表示容量

jdk8新变化

ArrayList list = new ArrayList();//底层Object[] elementData初始化为{}. 并没有创建长度为10的数组

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

…

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

小结

jdk 7 中的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;
	}
}

Node next，prev

也就是说next，prev也是Node类型的对象。next，prev就是各自对象的**地址。**这就是定义链表的方式。

数据结构：定义链表

总结：如何定义链表结构：**一个类里面声明了这个类的类型的属性。**如

public class Person{
	//双链表
    Person next;
    Person prev;
}

**一个类里面又声明了两个这个类本身类型的属性，一个属性指向下一个对象，另一个属性指向前一个对象，就构成了指针。**存储的都是地址值。

public class Person{
	//单链表
    Person next;
   
}

next也是一个这个类的对象，存放的是地址值，指向下一个对象。

public class Person{
	//二叉树
    Person left;
    Person right;
}

同样，在二叉树中，类的对象作为属性，指向下一个对象，形成指针。

User user = new User();

进行add()操作的判断逻辑

    void linkLast(E e) {
        final Node<E> l = last;
        final Node<E> newNode = new Node<>(l, e, null);
        last = newNode;
        if (l == null)
            first = newNode;
        else
            l.next = newNode;
        size++;
        modCount++;
    }

Vector源码分析

jdk7和jdk8中通过Vector()构造器创建对象时，底层都创建了长度为10的数组，在扩容方面，默认扩容为原来的数组长度的2倍。

栈是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在集合中首次出现的位置.如果不存在则返回-1

int lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置.如果不存在则返回-1

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

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

List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置的左闭右开的子集合,注意返回的是一个新的list，原来的list保持不变

遍历操作：三种。

    @Test
    public void test9(){
        ArrayList list = new ArrayList();
        list.add(123);
        list.add(456);
        list.add("AA");
        list.add(new Person("Tom",20));
        list.add(456);
        System.out.println(list);

        //void add(int index, Object ele):在index位置插入ele元素
        list.add(1,"BB");
        System.out.println(list);

        //boolean addAll(int index, Collection eles):从index位置开始将eles中的所有元素添加进来
        List list1 = Arrays.asList(1,2,3);
        list.addAll(list1);
        System.out.println(list);

        //Object get(int index):获取指定index位置的元素
        System.out.println(list.get(0));

        //int indexOf(Object obj):返回obj在集合中首次出现的位置.如果不存在则返回-1
        System.out.println(list.indexOf(456));

        //int lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置.如果不存在则返回-1
        System.out.println(list.lastIndexOf(456));

        //Object remove(int index):移除指定index位置的元素，并返回此元素
        //按照索引删除，与父类Collection中remove的形参列表不同，构成重载
        Object remove = list.remove(0);//返回的是删除的元素
        System.out.println(list);

        //Object set(int index, Object ele):设置指定index位置的元素为ele
        list.set(1,"CC");
        System.out.println(list);

        //List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置的左闭右开的子集合
        List list2 = list.subList(2, 4);//注意返回的是一个新的list，原来的list保持不变
        System.out.println(list2);
        System.out.println(list);

        //遍历
        //方式一：Iterator迭代器
        Iterator iterator = list.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
        //方式二：增强for循环
        for (Object obj :
                list) {
            System.out.println(obj);
        }
        //方式三：因为有索引可以用普通for循环
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
    }

总结常用方法

增：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循环

​ ③普通的循环

面试题：区分List中remove(int index) 和 remove(Object obj)

    /**
     * 区分List中remove(int index) 和 remove(Object obj)
     */
    @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));//这时候认为2是包装类，删除的是值为2的元素
        
    }

Set接口

Set接口：存储无序的、不可重复的数据----> 高中讲的“集合”

HashSet、LinkedHashSet、TreeSet区别

HashSet：作为Set接口的主要实现类；线程不安全的；可以存储null值

​ LinkedHashSet：作为HashSet的子类；遍历其内部数据时，可以按照添加的顺序遍历。对应频繁的遍历操作，LinkedHashSet效率高于HashSet

TreeSet：可以按照添加对象的指定属性，进行排序。

要求

1.Set接口中没有额外定义新的方法，使用的都是Collection中声明过的方法。

2.要求：向Set中添加的数据，其所在的类一定要重写hashCode()和equals()

要求：重写的hashCode()和equals()尽可能保持一致性：相等的对象必须具有相等的散列码。重写两个方法的小技巧：对象中用作 equals() 方法比较的 Field，都应该用来计算 hashCode 值。当然最好的方法是IDE直接生成对应的两个方法。

（补充：如果不重写hashCode则调用的是Object类中的hashCode方法，该方法返回的是一个随机数，就不符合我们的要求，故需要重写该方法。）

---

了解看一眼即可：以Eclipse/IDEA为例，在自定义类中可以调用工具自动重写equals和hashCode。问题：为什么用Eclipse/IDEA复写hashCode方法，有31这个数字？

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

---

解释Set：存储无序的、不可重复的数据

以HashSet为例说明：

1.无序性：不等于随机性。存储的数据在底层数组中并非按照数组索引的顺序添加，而是根据数据的哈希值确定的，是散列分布在底层数组中的。如下图

List的有序指的是存储的数据在底层数组中是按照数组索引的顺序添加的，前一个添加的挨着后一个添加的。如下图

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添加成功。----- > 情况3

对于添加成功的情况2和情况3而言:元素a与已经存在指定索引位置上数据以链表的方式存储。

jdk7：元素a放到数组中，指向原来的元素。

jdk8：原来的元素在数组中，指向元素a。

下图中第一张是jdk7，第二张是jdk8

总结：七上八下

HashSet底层：数组 + 链表的结构。（前提：jdk7）

HashSet的使用

	//HashSet的使用
	@Test
    public void test10(){
        Set set = new HashSet();
        set.add(456);
        set.add(123);
        set.add(123);
        set.add("AA");
        set.add("CC");
        set.add(new Person("Tom",12));
        set.add(new Person("Tom",12));//重写hashCode之后添加失败

        set.add(129);

        Iterator iterator = set.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());//输出顺序AA、CC、129、456、123、Person{name='Tom', age=12}
            //此时的输出顺序不是按照添加顺序，当换成LinkedHashSet是输出的是按照添加顺序输出的。二者都是无序的。因为无序性跟输出顺序是没有关系的。没有因果关系。无序性的解释看上面。
        }
    }

HashSet实际上是用HashMap存储的

    public HashSet() {
        map = new HashMap<>();
    }
	//在Set里存放的数据实际上是存在map里的key中
    public boolean add(E e) {
        return map.put(e, PRESENT)==null;
    }
	//静态不可变的常量，也就是所有的key值对应的value都一样
    private static final Object PRESENT = new Object();

LinkedHashSet的使用

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

LinkedHashSet作为HashSet的子类，在添加数据的同时，每个数据还维护了两个引用，记录此数据前一个数据和后一个数据。

优点：对应频繁的遍历操作，LinkedHashSet效率高于HashSet

    /**
     *  LinkedHashSet的使用
     *  LinkedHashSet作为HashSet的子类，在添加数据的同时，每个数据还维护了两个引用，记录此数据前一个数据和后一个数据。
     * 优点：对应频繁的遍历操作，LinkedHashSet效率高于HashSet
     */
    @Test
    public void test10(){
        Set set = new LinkedHashSet();
        set.add(456);
        set.add(123);
        set.add(123);
        set.add("AA");
        set.add("CC");
        set.add(new Person("Tom",12));
        set.add(new Person("Tom",12));//重写hashCode之后添加失败

        set.add(129);

        Iterator iterator = set.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());//输出顺序456、123、AA、CC、Person{name='Tom', age=12}、129
            //输出的是按照添加顺序输出的
        }
    }

图解LinkedHashSet底层结构

TreeSet的使用

TreeSet可以按照添加对象的指定属性，进行排序。

1.向TreeSet中添加的数据，要求是相同类的对象。

2.两种排序方式：自然排序(实现Comparable接口) 和定制排序(Comparator)

3.自然排序中，比较两个对象是否相同的标准为：compareTo()返回0 ，不再是equals().也就是说如果compareTo()返回0，则认为元素相等添加失败。像按照什么标准进行比较就怎样重写compareTo()方法。

4.定制排序中，比较两个对象是否相同的标准为：compare()返回0，不再是equals().

5.TreeSet里判断两个元素是否一样用的都是比较方法compareTo()、compare()，不同于前面的几种用的是equals()

    /**
     * 1.向TreeSet中添加的数据，要求是相同类的对象。
     * 2.两种排序方式：自然排序(实现Comparable接口) 和定制排序(Comparator)
     * 3.自然排序中，比较两个对象是否相同的标准为：compareTo()返回0 ，不再是equals().也就是说
     *   如果compareTo()返回0，则认为元素相等添加失败。像按照什么标准进行比较就怎样重写compareTo()方法。
     * 4.定制排序中，比较两个对象是否相同的标准为：compare()返回0，不再是equals().
     */
    @Test
    public void test11(){
        TreeSet treeSet = new TreeSet();

        /*
        失败：不能添加不同类型的对象
        treeSet.add(123);
        treeSet.add(456);
        treeSet.add("AA");
        treeSet.add(new Person("Tom",20));*/

        //举例一
        /*treeSet.add(34);
        treeSet.add(-34);
        treeSet.add(43);
        treeSet.add(11);
        treeSet.add(8);
        Iterator iterator = treeSet.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
            //输出顺序从小到大
            //TreeSet可以按照添加对象的指定属性，进行排序。
        }*/

        //举例二
        treeSet.add(new Person("Tom",12));
        treeSet.add(new Person("Jerry",32));
        treeSet.add(new Person("Jim",2));
        treeSet.add(new Person("Mike",65));
        treeSet.add(new Person("Jack",33));
        treeSet.add(new Person("Jack",65));
        Iterator iterator = treeSet.iterator();
        //调用无参构造器此时是自然排序，当没有重写compareTo方法时报错
        //重写之后可以排序
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }


	//Person实现Comparable接口并重写compareTo()方法
    //实现姓名从小到大排序，且年龄从大到小
    @Override
    public int compareTo(Object o) {
        if (o instanceof Person){
            Person person = (Person) o;
            if (this.name.compareTo(person.name) == 0){
                return -Integer.compare(this.age,person.age);
            }else {
                return this.name.compareTo(person.name);
            }
        }
        throw new RuntimeException("输入数据类型不匹配");
    }



    @Test
    public void test12(){
        Comparator com = new Comparator() {
            //按照年龄从小到大排序
            @Override
            public int compare(Object o1, Object o2) {
                if (o1 instanceof Person && o2 instanceof Person){
                    Person p1 = (Person) o1;
                    Person p2 = (Person) o2;
                    //字符串比较调用compareTo(),基本数据类型比较调用包装类的compare()方法
                    return Integer.compare(p1.age,p2.age);
                }else {
                    throw new RuntimeException("输入的数据类型不匹配!");
                }
            }
        };
        TreeSet treeSet = new TreeSet(com);//无参构造器是自然排序，有参构造器是定制排序
                                            //类比前面Array.sort()方法
        treeSet.add(new Person("Tom",12));
        treeSet.add(new Person("Jerry",32));
        treeSet.add(new Person("Jim",2));
        treeSet.add(new Person("Mike",65));
        treeSet.add(new Person("Jack",33));
        //根据我们排序的规则，仅比较了年龄，所以年龄相同的compare方法返回0，此时认为二者相同，添加失败。
        treeSet.add(new Person("Jack",65));
        Iterator iterator = treeSet.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }

TreeSet的存储结构：红黑树。（红黑树里面不能有相同元素）

集合这一部分面试的时候容易问，问一些底层的源码还是数据结构等。

使用Set作为过滤器应用

练习：在List内去除重复数字值，要求尽量简单

分析：如果使用ArrayList利用equals()方法一个个进行比较那当数据比较多时需要比较的次数增加且删除数据时需要移动大量的元素效率低。可以利用Set集合天然的不可重复性对数据进行过滤。只需将要过滤的集合调用addAll()方法装入Set即可，返回的数据里面就没有重复数据了。

注意，**由于用到HashSet，所以自定义类需要重写equals()、hashCode()两个方法，**String、包装类等已经重写好了。

(单元测试里面不能再定义方法了)

    //练习：在List内去除重复数字值，要求尽量简单
    @Test
    public void test13(){

        List list = new ArrayList();
        list.add(new Integer(1));
        list.add(new Integer(2));
        list.add(new Integer(2));
        list.add(new Integer(4));
        list.add(new Integer(4));
        List list2 = duplicateList(list);
        for (Object integer : list2) {
            System.out.println(integer);
        }

    }


	//单元测试里面不能再定义方法了
    public List duplicateList(List list){
        HashSet set = new HashSet();
        set.addAll(list);
        return new ArrayList(set);
    }

面试题：

注意：对HashSet要注意无论做什么操作第一步是先进行计算哈希值

HashSet set = new HashSet();
Person p1 = new Person(1001,"AA"); 
Person p2 = new Person(1002,"BB");
set.add(p1);
set.add(p2);
p1.name = "CC";//将"AA"改为"CC",但此时这个位置还是根据1001,"AA"计算的哈希值
set.remove(p1);//移除p1，此时p1是1001，"CC"，先计算哈希值，得到的存储位置极大概率和另外两个不再一起。所以这个位置上并没有数据，移除失败
System.out.println(set);//输出"CC","BB"
set.add(new Person(1001,"CC")); //先根据1001，"CC"计算哈希值，得到的位置跟另外两个不一样，添加成功
System.out.println(set);//输出三个"CC","BB","CC"
set.add(new Person(1001,"AA"));//先根据1001，"AA"计算哈希值，得到与第一个数据一样的位置，此时再调用equals()进行比较是否相等，由于第一个已经修改为"CC"，故equals()返回false，添加成功
System.out.println(set);//输出四个，"CC","BB","CC","AA".由于无序性输出顺序还需要程序执行进行确定
//其中Person类中重写了hashCode()和equal()方法

Map接口

对比

key - value是**“映射”**关系。

|—Map：双列数据，存储key-value对的数据 ----类似于高中的函数:y=f(x)

​ |—HashMap:作为Map的主要实现类；线程不安全的，效率高；**存储null的key和value,**二者可以任一为null，或者同时为null

​ |—LinkedHashMap:保证在遍历map元素时，可以按照添加的顺序实现遍历。原因：在原有的HashMap底层结构基础上，添加了一对指针，指向前一个和后一个元素。对于频繁的遍历操作，此类执行效率高于HashMap。

​ |—TreeMap:保证按照添加的key-value对进行排序，实现排序遍历。此时考虑key的自然排序或定制排序，是根据key排的。底层使用红黑树。

​ |—Hashtable:作为古老的实现类；线程安全的，效率低；不能存储null的key和value。

​ |—Properties:常用来处理配置文件。key和value都是String类型。

HashMap的底层:数组+链表 （jdk7及之前）

​ 数组+链表+红黑树（jdk8）

面试题：

1.HashMap的底层实现原理？

2.HashMap 和 Hashtable的异同？

3.CurrentHashMap 与 Hashtable的异同？(暂时不讲)

Map 中的 key 用Set来存放，不允许重复，同时是无序的，即同一个Map 对象所对应的类，须重写hashCode()和equals()方法。常用String类作为Map的“键”

而对应的value可以重复，是无序的。

Map里存放的是一个一个的Entry对象，而Entry(key,value)是有两个属性的。

所以Entry当然也是无序的、不可重复的，可以装到Set中

Map结构的理解

Map中的key：无序的、不可重复的，使用Set存储所有的key—>key所在的类要重写equals()和hashCode() （以HashMap为例，TreeMap就是比较方法了）

Map中的value：无序的、可重复的，使用Collection存储所有的value—>value所在的类要重写equals()

一个键值对：key-value构成了一个Entry对象。

Map中的entry：无序的、不可重复的，使用Set存储所有的entry.

HashMap的底层实现原理

HashMap的底层实现原理，以jdk7为例：

HashMap map = new HashMap();

在实例化以后，底层创建了长度为16的一维数组Entry[] table。

…可能已经执行过多次…

map.put(key1,value1):

首先，调用key1所在类的hashCode()计算key1哈希值（这时候这个哈希值并不是只根据hashCode得出来的，调用的是hash(key)方法，hashCode()只是在这个方法里面被调用了，所以hashCode只是计算哈希值的一部分，具体的可看源码），此哈希值经过某种算法计算以后，得到在Entry数组中的存放位置。

如果此位置上的数据为空，此时的key1-value1添加成功。 ---- > 情况1

如果此位置上的数据不为空，(意味着此位置上存在一个或多个数据(以链表形式存在))，比较key1和已经存在的一个或多个数据的哈希值：

​ 如果key1的哈希值与已经存在的数据的哈希值都不相同，此时key1-value1添加成功。---- >情况2

​ 如果key1的哈希值和已经存在的某一个数据(key2-value2)的哈希值相同，继续比较：调用key1所在类的equals(key2).

​ 如果equals()返回false:此时key1-value1添加成功。—>情况3

​ 如果equals()返回true:使用value1替换value2.

补充：关于情况2和情况3：此时key1-value1和原来的数据以链表的方式存储。(在jdk7和jdk8中与HashSet的情况一致。)

在不断的添加过程中，会涉及到扩容问题，**当超出临界值时(且要存放的位置非空)时，**扩容。默认的扩容方式：扩容为原来容量的2倍，并将原来的数据复制过来。

jdk8相较于jdk7在底层实现方面的不同：

1.new HashMap()：底层没有创建一个长度为16的数组

2.jdk8底层的数组是：Node[]，而非Entry[]

3.首次调用put()方法时，底层创建长度为16的数组

4.jdk7底层结构只有：数组+链表。jdk8中底层结构：数组+链表+红黑树。

​ 当数组的某一个索引位置上的元素以链表形式存在的数据个数 > 8 且当前数组的长度 > 64 时，此时此索引位置上的所有数据改为使用红黑树存储。

DEFAULT_INITIAL_CAPACITY : HashMap的默认容量，16

DEFAULT_LOAD_FACTOR：HashMap的默认加载因子：0.75f

threshold：扩容的临界值，=容量**填充因子：16* *0.75 => 12

TREEIFY_THRESHOLD：Bucket中链表长度大于该默认值，转化为红黑树:8

MIN_TREEIFY_CAPACITY：桶中的Node被树化时最小的hash表容量:64。（当桶中Node的数量大到需要变红黑树时，若hash表容量小于MIN_TREEIFY_CAPACITY时，此时应执行resize扩容操作这个MIN_TREEIFY_CAPACITY的值至少是TREEIFY_THRESHOLD的4倍。）

ArrayList的默认容量是10,当存前十个元素的时候都不会扩容，只有存第11个元素时开始扩容。而HashMap默认容量是16，**当超出临界值时(且要存放的位置非空)时，**才开始扩容，也就是会提前扩容。这与存储结构有关，jdk8中是数组+ 链表+红黑树，也就是说数组中并不是每个位置都会有元素，且有的位置会出现链表。为了保证操作效率，会让数组的利用率较高(不会出现大部分数组没有数据的情况)，且不会让链表的长度过长(不要出现都是链表的情况)，所以提出填充因子的概念，**当超出临界值时(且要存放的位置非空)时，**数据表明当填充因子为0.75时数组利用率和链表长度达到平衡，是最好的状态。（填充因子太小时数组利用率低，太大时链表多）

HashMap hashMap = new HashMap();

数据存放在数组中，数组是对象的一个属性而已。

面试题：

关于映射关系的key是否可以修改？

answer：不要修改
映射关系存储到HashMap中会存储key的hash值，这样就不用在每次查找时重新计算每一个Entry或Node（TreeNode）的hash值了，因此如果已经put到Map中的映射关系，再修改key的属性，而这个属性又参与hashcode值的计算，那么会导致匹配不上。

面试题：负载因子值的大小，对HashMap有什么影响？

• 负载因子的大小决定了HashMap的数据密度。
• 负载因子越大密度越大，发生碰撞的几率越高，数组中的链表越容易长,造成查询或插入时的比较次数增多，性能会下降。
• 负载因子越小，就越容易触发扩容，数据密度也越小，意味着发生碰撞的几率越小，数组中的链表也就越短，查询和插入时比较的次数也越小，性能会更高。但是会浪费一定的内容空间。而且经常扩容也会影响性能，建议初始化预设大一点的空间。
• 按照其他语言的参考及研究经验，会考虑将负载因子设置为0.7~0.75，此时平均检索长度接近于常数。

LinkedHashMap的底层实现原理(了解)

LinkedHashMap 是 HashMap 的子类

源码中:

    static class Entry<K,V> extends HashMap.Node<K,V> {
        Entry<K,V> before, after;//能够记录添加的元素的先后顺序
        Entry(int hash, K key, V value, Node<K,V> next) {
            super(hash, key, value, next);
        }
    }

在HashMap存储结构的基础上，使用了一对双向链表来记录添加元素的顺序，也就是实际上是HashMap加了前后指针，可以实现按输入顺序进行输出，方便快速遍历。

Map中的常用方法

要注意size()方法返回的是元素的个数，而不是造的数组的长度

添加、删除、修改操作：

Object put(Object key,Object value)：将指定key-value添加到(或修改)当前map对象中
void putAll(Map m):将m中的所有key-value对存放到当前map中
Object remove(Object key)：移除指定key的key-value对，并返回value
void clear()：清空当前map中的所有数据

元素查询的操作：

Object get(Object key)：获取指定key对应的value
boolean containsKey(Object key)：是否包含指定的key
boolean containsValue(Object value)：是否包含指定的value
int size()：返回map中key-value对的个数
boolean isEmpty()：判断当前map是否为空
boolean equals(Object obj)：判断当前map和参数对象obj是否相等

元视图操作的方法：(实际上就是遍历操作)

Map的遍历方法只有下面三种，没有迭代器Iterator，迭代器只支持Collection。

Set keySet()：返回所有key构成的Set集合
Collection values()：返回所有value构成的Collection集合
Set entrySet()：返回所有key-value对构成的Set集合

    @Test
    public void test14(){
        Map map = new HashMap();
        //添加
        map.put("AA",123);
        map.put(45,123);
        map.put("BB",56);
        //修改
        map.put("AA",87);

        System.out.println(map);

        Map map1 = new HashMap();
        map1.put("CC",123);
        map1.put("DD",123);
        map.putAll(map1);
        System.out.println(map);

        //Object remove(Object key)：移除
//        Object aa = map.remove("AA");
//        System.out.println(aa);
        System.out.println(map);

        //clear()
//        map.clear();//只是情况数据，与map = null 不同
//        System.out.println(map.size());//0

        //Object get(Object key)：获取指定key对应的value
        System.out.println(map.get("AA"));

        //boolean containsKey(Object key)：是否包含指定的key
        boolean isExist = map.containsKey("AA");
        System.out.println(isExist);

        //boolean containsValue(Object value)：是否包含指定的value
        isExist = map.containsValue(123);
        System.out.println(isExist);

        //int size()：返回map中key-value对的个数

        //boolean isEmpty()：判断当前map是否为空.是否size = 0，而不是null
        boolean empty = map.isEmpty();
        System.out.println(empty);

        //boolean equals(Object obj)：判断当前map和参数对象obj是否相等

        //遍历：遍历操作的目的是将key值和value值取出来
        //由于map没有直接的迭代器可以执行遍历操作，但是key是由Set存储的，可以使用Set的迭代器遍历key
        //value是Collection存储的，也可以使用迭代器遍历
        //key-value组成的数组Entry也是由Set存储的，也可以调用迭代器遍历

        //遍历所有的key集：keySet()
        Set set = map.keySet();
        Iterator iterator = set.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }

        //遍历所有的value集：values()
        Collection values = map.values();
        Iterator iterator1 = values.iterator();
        while (iterator1.hasNext()){
            System.out.println(iterator1.next());
            //会发现遍历key值和遍历value值出现的顺序是一致的，这是因为实际上先查找的是Entry(或者Node)
            //找到之后需要key就取出来key，需要value就取出来value
        }

        //遍历所有得到key-value：
        // 方式一entrySet()
        Set entrySet = map.entrySet();
        Iterator iterator2 = entrySet.iterator();
        while (iterator2.hasNext()){
            Object next = iterator2.next();
            //entrySet集合中的元素都是entry
            Map.Entry entry = (Map.Entry) next;
            System.out.println(entry.getKey() + "---->" + entry.getValue());
        }
        //方式二，利用得到的key集，再用Object get(Object key)：获取指定key对应的value
        iterator = set.iterator();//需要重新调用一次，因为上面用过了，此时指针已经指向末尾
        while (iterator.hasNext()){
            Object key = iterator.next();
            Object value = map.get(key);
            System.out.println(key + "=" + value);
        }
    }

常用方法总结：

添加：put(Object key,Object value)

删除：remove(Object key)

修改：put(Object key,Object value)

查询：get(Object key)

长度：size()

遍历：keySet() / values() / entrySet()

由于是无序的所以没有插入方法。

TreeMap使用

底层使用红黑树存储。

TreeMap会按照key进行排序:自然排序、定制排序

所以向TreeMap中添加key-value，要求key必须是由同一个类创建的对象。

TreeMap 的 Key 的排序：

• 自然排序：TreeMap 的所有的 Key 必须实现 Comparable 接口，而且所有的 Key 应该是同一个类的对象，否则将会抛出 ClasssCastException
• 定制排序：创建 TreeMap 时，传入一个 Comparator 对象，该对象负责对TreeMap 中的所有 key 进行排序。此时不需要 Map 的 Key 实现Comparable 接口

**TreeMap判断两个key相等的标准：**两个key通过compareTo()方法或者compare()方法返回 0。

Properties的使用

Properties常用来处理配置文件。 里的 key和 value 都是字符串类型

创建配置文件，new ----> File ----> 输入全称(包括后缀)

new — > Resource Bundle — > 输入名称即可(后缀会自动补上)

创建完成jdbc.properties

里面的内容一定中间不能有空格

如果配置文件里有中文，为保证不是乱码要进行如下设置，将选项勾上(再重新创建文件)。

public class PropertiesTest {
    public static void main(String[] args) throws Exception {

        //Properties:常用来处理配置文件。key和value都是String类型

        Properties properties = new Properties();
        //获取文件内容
        FileInputStream fileInputStream = new FileInputStream("jdbc.properties");
        //加载流对应的文件
        properties.load(fileInputStream);
        //key值不能写错
        String name = properties.getProperty("name");
        String password = properties.getProperty("password");

        //目前进行简单输出，后续操作后面再学
        System.out.println("name = " + name + "password = " + password);
    }
}

目前的代码并不完善，因为涉及文件读取抛出异常，文件流关闭，等学到之后再完善。

标准代码处理如下：

public class PropertiesTest {
    public static void main(String[] args){

        //Properties:常用来处理配置文件。key和value都是String类型

        FileInputStream fileInputStream = null;
        try {
            Properties properties = new Properties();
            //获取文件内容
            fileInputStream = new FileInputStream("jdbc.properties");
            //加载流对应的文件
            properties.load(fileInputStream);
            //key值不能写错
            String name = properties.getProperty("name");
            String password = properties.getProperty("password");

            //目前进行简单输出，后续操作后面再学
            System.out.println("name = " + name + "password = " + password);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fileInputStream != null){
                try {
                    fileInputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}

Collections 工具类

Collections 是一个操作 Set、List 和 Map 等集合的工具类

Collections：操作Collection、Map的工具类。（是可以操作Map的）

面试题：Collection 和 Collections 的区别? 一个是创建集合的接口，一个是操作集合的工具类。

常用方法：

排序操作：（均为static方法）
reverse(List)：反转 List 中元素的顺序
shuffle(List)：对 List 集合元素进行随机排序
sort(List)：根据元素的自然顺序对指定 List 集合元素按升序排序
sort(List，Comparator)：根据指定的 Comparator 产生的顺序对 List 集合元素进行排序
swap(List，int， int)：将指定 list 集合中的 i 处元素和 j 处元素进行交换

查找、替换：

Object max(Collection)：根据元素的自然顺序，返回给定集合中的最大元素
Object max(Collection，Comparator)：根据 Comparator 指定的顺序，返回给定集合中的最大元素
Object min(Collection)
Object min(Collection，Comparator)
int frequency(Collection，Object)：返回指定集合中指定元素的出现次数
这个方法容易用错，注意看怎么用。void copy(List dest,List src)：将src中的内容复制到dest中

        //void copy(List dest,List src)：将src中的内容复制到dest中。这个方法容易用错
        //List dest = new ArrayList();//错误的用法
        //Collections.copy(dest,list);//报异常IndexOutOfBoundsException
        //看源码发现如果srcSize > dest.size()就会报异常。注意size()方法查看的是元素的个数，而不是数组的长度
        //所以要给里面装填数据

        List dest = Arrays.asList(new Object[list.size()]);//标准写法
        Collections.copy(dest,list);
        System.out.println(dest);

boolean replaceAll(List list，Object oldVal，Object newVal)：使用新值替换List 对象的所有旧值

    @Test
    public void test1(){
        List list = new ArrayList();
        list.add(123);
        list.add(43);
        list.add(765);
        list.add(-97);
        list.add(0);
        System.out.println(list);

        //reverse(List)：反转 List 中元素的顺序.返回值是void说明是在原来的基础上修改的，返回的还是原来的List
        Collections.reverse(list);
        System.out.println(list);

        //shuffle(List)：对 List 集合元素进行随机排序
//        Collections.shuffle(list);
//        System.out.println(list);

        //sort(List)：根据元素的自然顺序对指定 List 集合元素按升序排序.自然排序，实现Comparable接口
        Collections.sort(list);
        System.out.println(list);
        //sort(List，Comparator)：根据指定的 Comparator 产生的顺序对 List 集合元素进行排序。定制排序

        //swap(List，int， int)：将指定 list 集合中的 i 处元素和 j 处元素进行交换
        Collections.swap(list,1,2);
        System.out.println(list);

        //Object max(Collection)：根据元素的自然顺序，返回给定集合中的最大元素
        Comparable max = Collections.max(list);
        System.out.println(max);
        System.out.println(list);

        //int frequency(Collection，Object)：返回指定集合中指定元素的出现次数
        int frequency = Collections.frequency(list, 765);
        System.out.println(frequency);

        //void copy(List dest,List src)：将src中的内容复制到dest中。这个方法容易用错
        //List dest = new ArrayList();//错误的用法
        //Collections.copy(dest,list);//报异常IndexOutOfBoundsException
        //看源码发现如果srcSize > dest.size()就会报异常。注意size()方法查看的是元素的个数，而不是数组的长度
        //所以要给里面装填数据

        List dest = Arrays.asList(new Object[list.size()]);//标准写法
        Collections.copy(dest,list);
        System.out.println(dest);

        //boolean replaceAll(List list，Object oldVal，Object newVal)：使用新值替换List 对象的**所有**旧值
    }

同步控制：

Collections 类中提供了多个 synchronizedXxx() 方法，该方法可使将指定集合包装成线程同步的集合，从而可以解决多线程并发访问集合时的线程安全问题。

ArrayList、HashMap都是线程不安全的，但是当涉及线程安全时我们也不会放弃使用。因为可以通过Collections类的synchronizedXxx()方法返回一个线程安全的集合。

    /**
     * Collections 类中提供了多个 synchronizedXxx() 方法，
     * 该方法可使将指定集合包装成线程同步的集合，从而可以解决多线程并发访问集合时的线程安全问题
     */
    @Test
    public void test2(){
        List list = new ArrayList();
        list.add(123);
        list.add(43);
        list.add(765);
        list.add(-97);
        list.add(0);

        //ArrayList、HashMap都是线程不安全的，但是当涉及线程安全时我们也不会放弃使用
        //因为可以通过Collections类的synchronizedXxx()方法返回一个线程安全的集合。
        //返回的list1即为线程安全的List
        List list1 = Collections.synchronizedList(list);
    }

关于Collections的其他方法可以查看API，关于Collections操作Map的相关方法与操作List的等差不多，具体可参看API。

面试题：

请把学生名与考试分数录入到Set中，并按分数显示前三名成绩学员的名字.怎么用Set实现?

public class ScoreTest {
	private Scanner scanner;

	@Test
	public void test1() {
		scanner = new Scanner(System.in);
		TreeSet<Student> treeSet = new TreeSet<>();
		System.out.println("请输入学生的姓名和成绩，当输入为负数时结束输入");
		for (int i = 1;; i++) {
			int score = 0;
			System.out.println("请输入第" + i + "位学生的姓名：");
			String name = scanner.next();
			System.out.println("请输入第" + i + "位学生的成绩：(输入负数，结束录入)");
			try {
				score = scanner.nextInt();
			} catch (ClassCastException e) {
				// TODO: handle exception
				System.out.println("您输入的分数有误");
			}

			if (score < 0) {
				break;
			} else {
				treeSet.add(new Student(name, score));
			}

		}
		System.out.println("您输入的成绩生成成绩单结果：");
		for (Student student : treeSet) {
			System.out.println(student.getName() + "--->" + student.getScore());
		}
		// 前三名学生的姓名
		System.out.println("前三名学生的姓名为：");
		int count = 0;
        //由于Set是无序的，所以要用count计数
		for (Student student : treeSet) {
			if (count == 3) {
				break;
			} else {
				System.out.println(student.getName() + "--->"
						+ student.getScore());
				count++;
			}

		}
	}
}

class Student implements Comparable<Student> {
	private String name;
	private int score;

	public Student(String name, int score) {
		super();
		this.name = name;
		this.score = score;
	}

	public String getName() {
		return name;
	}

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

	public int getScore() {
		return score;
	}

	public void setScore(int score) {
		this.score = score;
	}

	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		result = prime * result + score;
		return result;
	}

	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Student other = (Student) obj;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		if (score != other.score)
			return false;
		return true;
	}

	@Override
	public int compareTo(Student o) {
		// TODO Auto-generated method stub
		int num = o.score - score;
		if (num != 0) {
			return num;
		} else {
			return this.name.compareTo(o.name);
		}
	}

}

数据结构简述：

学好数据结构。

真实存在的结构是顺序表（数组Array、ArrayList等）、链表这两个。抽象结构都是由这两个组合构造出来的，抽象结构(ADT)包括栈、队列、树、图、其他。

其中顺序表、链表、栈、队列是一对一的关系。

哈希算法

哈希算法(Hash)又称摘要算法(Digest),它的作用是:对任意一组输入数据进行计算，得到一个对固定长度额输出摘要。

哈希算法最重要的特点就是:

• 相同的输入一定得到相同的输出；

• 不同的输入大概率得到不同的输出。

Java字符串的hashCode()就是一个哈希算法，它的输入是任意字符串，输出是固定的4字节int整数:

"hello".hashCode(); //0x5e918d2

"hello, java".hashCode(); //0x7a9d88e8

"hello, bob".hashCode(); //0xa0dbae2f

两个相同的字符串永远会计算出相同的hashCode，否则基于hashCode定位的HashMap就无法正常工作。这也是为什么当我们自定义一个class时，覆写equals()方法时我们必须正确覆写hashCode()方法。

哈希碰撞

哈希碰撞是指，两个不同的输入得到了相同的输出:

"AaAaAa".hashCode();  //0x7460e8c0

"BBAaBB".hashCode(); //0x7460e8c0

碰撞能不能避免？答案是不能。碰撞是一定会出现的，因为输出的字节长度是固定的，String的hashCode()输出是4字节整数，最多只有4294967296种输出，但输入的数据长度是不固定的，有无数种输入。所以，哈希算法是把一个无线的输入集合映射到一个有限的输出集合，必然会产生碰撞。

碰撞不可怕，我们担心的不是碰撞，而是碰撞的概率，因为碰撞概率的高低关系到哈希算法的安全性。一个安全的哈希算法必须满足:

• 碰撞概率低;
• 不能猜测输出。

不能猜测输出是指，输入的任意一个bit的变化会造成输出完全不同，这样就很难从输出反推输入(只能依靠暴力穷举)。假设一种哈希算法有如下规律:

 
hashA("java001") = "123456"

hashA("java002") = "123457"

hashA("java003") = "123458"

那么很容易从输出123459反推输入，这种哈希算法就不安全。安全的哈希算法从输出是看不出任何规律的:

hashB("java001") = "123456"

hashB("java002") = "580271"

hashB("java003") = ???

根据碰撞概率，哈希算法的输出长度越长，就越难产生碰撞，也就越安全。Java标准库提供了常用的哈希算法，并且有一套统一的接口。