Java基础---集合

说明：
集合这一块内容看的是b站上尚硅谷宋红康老师的课程，b站视频链接，其中P513~564是集合相关的讲解，讲的时候没有用到泛型，所以可以补充看一下P566和567关于集合中使用泛型的情况。

---

集合

一、Java集合框架概述

1、数组存储对象方面的特点

• 特点：

  • 数组初始化以后，长度就确定了。

  • 数组声明的类型，就决定了进行元素初始化时的类型。

• 弊端：

  • 数组初始化以后，长度就不可变了，不利于扩展。

  • 数组中提供的属性和方法比较少，不便于添加、删除、插入等操作，且效率不高，同时无法直接获取存储元素的个数。

  • 数组存储的数据是有序的，可以重复的。—存储数据的特点单一。

2、集合的使用场景

• Android客户端：将JSON对象或JSON数组转换为Java对象或Java对象构成的List。

• 服务器端：将Java对象或Java对象构成的List转换成JSON对象或JSON数组。

• 数据库

3、集合框架结构

Java集合可分为Collection和Map两种体系：

• Collection接口：单列数据，定义了存储一组对象方法的集合。

  • List：元素有序、可重复的集合。

    • ArrayList、LinkedList、Vector

  • Set：元素无序、不可重复的集合。

    • HashSet、LinkedHashSet、TreeSet

• Map接口：双列数据，保存具有映射关系“key-value对”的集合。

  • HashMap、LinkedHashMap、TreeMap、HashTable、Properties

二、Collection接口方法

1、Collection接口的常用方法

1.add(Object e)：将元素e添加到集合col1中

2.size()：获取添加的元素的个数

3.addAll(Collection col1)：将col1集合的元素添加到当前的集合中

4.clear()：清空集合元素

5.isEmpty()：判断当前集合是否为空

6.contains(Object obj)：判断当前集合中是否包含obj，判断的是内容，调用equals()

7.containsAll(Collection col)：判断col中的所有元素是否都存在于当前集合中

8.remove(Object obj)：移除obj，还是需要重写equals因为需要比较是否有这个对象，然后进行移除，返回true表示移除成功，false表示失败。

9.removeAll(Collection col)：从当前元素中移除col中所有的元素，只移除两个集合的共同交集

10.retainAll(Object obj):获取交集，并返回给当前集合

11.equals(Object obj):要想返回true，需要当前集合和形参集合元素相同

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

13.集合可以转换为数组toArray()

14.数组可以转换成集合Arrays.asList()

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

测试代码：

package org.test1;

import org.junit.Test;

import java.util.*;

/**
 * Collection接口中方法的使用
 *
 *
 * Created by luyangsiyi on 2020/2/6
 */
public class CollectionTest {

    @Test
    public void test1(){
        Collection col1 = new ArrayList();

        //1.add(Object e)：将元素e添加到集合col1中
        col1.add("AA");
        col1.add(123);
        col1.add(new Date());
        col1.add(new String("Tom"));
        System.out.println(col1);
        //[AA, 123, Thu Feb 06 19:04:11 CST 2020, Tom]

        //2.size()：获取添加的元素的个数
        System.out.println(col1.size());//3

        //3.addAll(Collection col1)：将col1集合的元素添加到当前的集合中
        Collection col2 = new ArrayList();
        col2.add(456);
        col2.add("BB");
        col2.addAll(col1);
        System.out.println(col2.size());//5

        //4.clear()：清空集合元素
        col2.clear();

        //5.isEmpty()：判断当前集合是否为空
        System.out.println(col2.isEmpty());//true

        //6.contains(Object obj)：判断当前集合中是否包含obj，判断的是内容，调用equals()
        boolean contains = col1.contains("AA");
        System.out.println(contains);
        System.out.println(col1.contains(new String("Tom")));//true!
        //向collection接口的实现类的对象中添加数据obj时，要求obj所在类重写equals()
        //否则75行输出false
        col1.add(new Person(20,"Tom"));
        System.out.println(col1);
        //[AA, 123, Thu Feb 06 19:04:50 CST 2020, Tom, Person{age=20, name='Tom'}]
        System.out.println(col1.contains(new Person(20,"Tom")));//true!

        //7.containsAll(Collection col)：判断col中的所有元素是否都存在于当前集合中
        Collection col3 = Arrays.asList("AA",123);
        System.out.println(col1.containsAll(col3));//true

        //8.remove(Object obj)：移除obj，还是需要重写equals因为需要比较是否有这个对象，
        // 然后进行移除，返回true表示移除成功，false表示失败
        System.out.println(col1.remove(123));
        System.out.println(col1);
        //[AA, Thu Feb 06 19:03:12 CST 2020, Tom, Person{age=20, name='Tom'}]

        //9.removeAll(Collection col)：从当前元素中移除col中所有的元素，只移除两个集合的共同交集
        Collection col4 = Arrays.asList("AA",234);
        col1.removeAll(col4);//只移除了"AA"，因为不存在234
        System.out.println(col1);
        //[Thu Feb 06 19:03:12 CST 2020, Tom, Person{age=20, name='Tom'}]

        //10.retainAll(Object obj):获取交集，并返回给当前集合
        col1.add(123);
        Collection col5 = Arrays.asList(123,456);
        col1.retainAll(col5);//交集的结果赋值给col1
        System.out.println(col1);
        //[123]

        //11.equals(Object obj):要想返回true，需要当前集合和形参集合元素相同
        Collection col6 = new ArrayList();
        col6.add(123);
        System.out.println(col1.equals(col6));//true

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

        //13.集合可以转换为数组toArray()
        Object arr[] = col1.toArray();
        for(int i = 0; i < arr.length; i++){
            System.out.println(arr[i]);
        }

        //14.数组可以转换成集合Arrays.asList()
        List<String> list = Arrays.asList(new String[]{"AA","BB","CC"});
        System.out.println(list);//[AA, BB, CC]
        List list1 = Arrays.asList(123,456);
        System.out.println(list1);//[123, 456]
        List<int[]> list2 = Arrays.asList(new int[]{123,456});
        System.out.println(list2);//[[I@f2a0b8e]只有一个元素
        List list3 = Arrays.asList(new Integer[]{123,456});
        System.out.println(list3);//[123, 456]
        
        //15.iterator()：返回Iterator接口的实例，用于遍历集合元素，在额外的测试中
    }
}

class Person{
    private int age;
    private String name;

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

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

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return age == person.age &&
                Objects.equals(name, person.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(age, name);
    }
}

三、Iterator迭代器接口

1、迭代器的使用：hasNext()和next()

测试代码：

package org.test1;

import org.junit.Test;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.Iterator;

/**
 * Iterator()方法测试，遍历集合元素
 * Created by luyangsiyi on 2020/2/6
 */
public class IteratorTest {

    @Test
    public void test(){
        Collection col1 = new ArrayList();
        col1.add("AA");
        col1.add(123);
        col1.add(new Date());
        col1.add(new String("Tom"));
        col1.add(new Person(20,"Tom"));

        Iterator iterator = col1.iterator();
        //方式一：
        /*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());*/

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

        //方式三：推荐
        //hasNext()：判断是否还有下一个元素
        while(iterator.hasNext()){
            //next()：①指针下移②将下移以后集合位置上的元素返回
            System.out.println(iterator.next());
        }

        //错误方式一：调用一次next()指针就会下移一次
        while(iterator.next()!=null){
            System.out.println(iterator.next());
        }

        //错误方式二：每调用iterator()就会得到一个全新的迭代器对象，默认指针都在集合的第一个元素前，
        // 然后每次都只返回第一个元素
        while (col1.iterator().hasNext()){
            System.out.println(iterator.next());
        }
    }
}

2、迭代器remove()的使用

内部定义了一个remove()方法，可以在遍历的时候，删除集合中的元素，此方法不同于集合中的remove()方法。

@Test
public void text1(){
    Collection col1 = new ArrayList();
    col1.add("AA");
    col1.add(123);
    col1.add(new Date());
    col1.add(new String("Tom"));
    col1.add(new Person(20,"Tom"));

    //删除集合中的Tom数据
    Iterator iterator = col1.iterator();
    while(iterator.hasNext()){
        Object obj = iterator.next();
        if("Tom".equals(obj)){
            iterator.remove();
        }
    }
    //注意重新遍历需要新建一个iterator对象
    Iterator iterator1 = col1.iterator();
    while(iterator1.hasNext()){
        System.out.println(iterator1.next());
    }
}

注意：

• 如果还未调用next()或在上一次调用next()方法之后已经调用了remove()方法，再调用remove会报IllegalStateException

3、使用foreach循环遍历集合

遍历操作不需要获取Collection或数组的长度，无需使用索引访问元素。

遍历集合的底层调用Iterator完成操作。

package org.test1;

import org.junit.Test;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;

/**
 * foreach循环用于遍历集合和数组
 * Created by luyangsiyi on 2020/2/6
 */
public class ForTest {
    @Test
    public void test(){
        Collection col1 = new ArrayList();
        col1.add("AA");
        col1.add(123);
        col1.add(new Date());
        col1.add(new String("Tom"));
        col1.add(new Person(20,"Tom"));

        //for(集合元素的类型 局部变量：集合对象）
        //内部调用了迭代器
        for(Object obj:col1){
            System.out.println(obj);
        }
    }

    @Test
    public void test1(){
        int[] arr = new int[]{1,2,3,4};
        for(int i:arr){
            System.out.println(i);
        }
    }

    //练习题
    @Test
    public void test2(){
        String[] arr = new String[]{"MM","MM","MM"};
        //方式一：普通for循环
        /*for(int i = 0; i < arr.length; i++){
            arr[i] = "GG";
        }*/

        //方式二：增强for循环
        for(String s:arr){
            //s是新的变量
            s = "GG";
        }

        //输出结果？
        //方式一：都是GG
        //方式二：还是MM
        for(int i = 0; i < arr.length; i++){
            System.out.println(arr[i]);
        }
    }
}

四、Collection子接口一：List

1、List接口概述

常用List来替代数组。

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

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

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

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

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

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

2、ArrayList源码分析

jdk7和jdk8版本不同。

（1）jdk7

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

list.add(123);//elementData[0] = new Integer(123);

...

list.add(11);//如果此次的添加导致底层elementData数组容量不够，则扩容；默认情况下，扩容为原来的1.5倍，同时将原有数组的数据复制到新的数组中。

结论：建议开发中使用带参数构造器ArrayList list = new ArrayLisy(int capacity);

（2）jdk8中ArrayList的变化

ArrayList list = new ArrayList();//底层Object[] elementDate初始化为{}，并没有创建长度

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

...

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

（3）小结

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

3、LinkedList的源码分析

LinkedList list = new LinkedList();//内部声明了Node类型的first和last属性，默认值为null

list.add(123);//将123封装到Node中，创建了Node对象

4、Vector的源码分析

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

5、List接口的常用方法

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

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

3、Object get(int index):获得指定index位置的元素

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

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

6、Object remove(int index):移除指定index位置的元素，并返回此元素（也可以按照对象删除）

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

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

测试代码一：

package org.test1;

import org.junit.Test;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;


/**
 *
 * Created by luyangsiyi on 2020/2/6
 */
public class ListTest {
    @Test
    public void test(){
        ArrayList list = new ArrayList();
        list.add(123);
        list.add(456);
        list.add("AA");
        list.add(new Person(20,"Tom"));
        list.add(456);
        System.out.println(list.toString());
        //[123, 456, AA, Person{age=20, name='Tom'}, 456]

        //1、void add(int index, Object ele):在index位置插入ele元素
        list.add(1,"BB");
        System.out.println(list.toString());
        //[123, BB, 456, AA, Person{age=20, name='Tom'}, 456]

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

        //3、Object get(int index):获得指定index位置的元素
        Object obj = list.get(1);
        System.out.println(obj);

        //4、int indexOf(Object obj):返回obj在当前集合中首次出现的位置
        System.out.println(list.indexOf(456));//2
        System.out.println(list.indexOf(111));//-1

        //5、int lastIndexof(Object obj):返回obj在当前集合中末次出现的位置
        System.out.println(list.lastIndexOf(456));//5

        //6、Object remove(int index):移除指定index位置的元素，并返回此元素
        Object obj1 = list.remove(1);
        System.out.println(obj1);//BB

        //7、Object set(int index, Object ele):设置指定index位置的元素为ele
        list.set(1,"AA");
        System.out.println(list);
        //[123, AA, AA, Person{age=20, name='Tom'}, 456, 1, 2, 3]

        //8、List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置的子集合
        List sublist = list.subList(2,4);
        System.out.println(sublist);
        //[AA, Person{age=20, name='Tom'}]
    }

}

测试代码二：

@Test
public void test1(){
    ArrayList list = new ArrayList();
    list.add(123);
    list.add(456);
    list.add("AA");
    list.add(new Person(20,"Tom"));
    list.add(456);
    //方式一：Iterator迭代器
    Iterator iterator = list.iterator();
    while(iterator.hasNext()){
        System.out.println(iterator.next());
    }
    System.out.println("-------------------");
    //方式二：
    for(Object obj:list){
        System.out.println(obj);
    }
    System.out.println("-------------------");
    //方式三：普通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循环③普通的遍历

6、面试题

@Test
public void test2(){
    List list = new ArrayList();
    list.add(1);
    list.add(2);
    list.add(3);
    updateList(list);
    System.out.println(list);
}
private void updateList(List list){
    list.remove(2);//删除索引为2的数据
    list.remove(new Integer(2));//删除对象为2的数据
}

五、Collection子接口二：Set

1、Set接口概述

存储无序的、不重复的数据，没有额外新增方法，跟Collection一致。

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

  • LinkedHashSet：作为HashSet的子类，遍历其内部数据时，可以按照添加的顺序遍历

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

2、无序性、不可重复性特性理解

以HashSet为例说明：

1、无序性：不等于随机性，存储的数据在底层数组中并非按照数组索引的顺序添加，而是根据数组的哈希值决定的。

2、不可重复：保证添加的元素按照equals()判断时，不能返回true，即：相同的元素只能添加一个。

3、添加元素的过程：以HashSet为例

HashSet底层：数组+链表。

• 我们向HashSet中添加元素a，首先调用元素a所在类的hashCode()方法，计算元素a的哈希值，此哈希值接着通过某种算法计算出HashSet底层数组中的存放位置（即：索引位置）。

判断此位置上是否已经有元素，如果此位置上没有其他元素，则元素a添加成功。—>添加成功情况1

• 如果此位置上有其他元素b（或以链表形式存在的多个元素），则比较元素a和元素b的hash值：

  • 如果hash值不相同，则元素a添加成功；—>添加成功情况2

  • 如果hash值相同，进而调用元素a所在类的equals()方法：

    • equals()返回tue，元素a添加失败；

    • equals()返回false，则元素a添加成功。—>添加成功情况3

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

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

jdk8：原来的元素在数组中，指向元素a。（七上八下）

5、hashCode()和equals()的重写

要求：

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

且hashCode()和equals()要保持一致性：相等的对象必须具有相等的散列码。

重写两个方法的小技巧：对象中用作equals()方法比较的Field，都应该用来计算hashCode。或直接调用自带的重写方法。

idea自带的重写方法：

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

        Person person = (Person) o;

        if (age != person.age) return false;
        return name.equals(person.name);
    }

    @Override
    public int hashCode() {
        int result = age;
        result = 31 * result + name.hashCode();
        return result;
    }
}

说明：

Q：为什么有31这个数字？

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

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

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

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

6、LinkedHashSet的使用

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

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

7、TreeSet的使用

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

可以按照指定属性排序：自然排序（实现Comparable接口）和定制排序（Comparator）。

自然排序中，比较两个对象是否相同的标准为：compareTo()返回0，不再是equals()。

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

（1）自然排序实例

测试代码：

package org.test1;

import org.junit.Test;

import java.util.Iterator;
import java.util.TreeSet;

/**
 * Created by luyangsiyi on 2020/2/7
 */
public class SetTest {

    @Test
    public void test(){
        TreeSet set = new TreeSet();
        set.add(new Person(20,"Tom"));
        set.add(new Person(23,"Alice"));
        set.add(new Person(33,"David"));
        set.add(new Person(14,"John"));
        set.add(new Person(24,"John"));
        //只按照姓名比较，则第2个John排序返回0
        //Person{age=23, name='Alice'}
        //Person{age=33, name='David'}
        //Person{age=14, name='John'}
        //Person{age=20, name='Tom'}
        //二级排序，先姓名后年龄
        //Person{age=23, name='Alice'}
        //Person{age=33, name='David'}
        //Person{age=14, name='John'}
        //Person{age=24, name='John'}
        //Person{age=20, name='Tom'}

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

    }
}

重写Person类的排序方法：

一级排序：

@Override
//按照姓名从小到大排序
//从大到小则169改为return -this.name.compareTo(person.name);
public int compareTo(Object o) {
    if(o instanceof Person){
        Person person = (Person)o;
        return this.name.compareTo(person.name);
    }else{
        throw new RuntimeException("输入的类型不匹配");
    }
}

二级排序：

@Override
//二级排序的情况，先并比较姓名然后比较年龄
public int compareTo(Object o) {
    if(o instanceof Person){
        Person person = (Person)o;
        int compare = this.name.compareTo(person.name);
        if(compare!=0){
            return compare;
        }else{
            return Integer.compare(this.age,person.age);
        }
    }else{
        throw new RuntimeException("输入的类型不匹配");
    }
}

（2）定制排序

测试代码：

package org.test1;

import org.junit.Test;

import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;

/**
 * Created by luyangsiyi on 2020/2/7
 */
public class SetTest {

    @Test
    public void test(){
        Comparator com = new Comparator() {
            //按照年龄从小到大排序
            @Override
            public int compare(Object o1, Object o2) {
                if(o1 instanceof Person && o2 instanceof Person){
                    Person u1 = (Person)o1;
                    Person u2 = (Person)o2;
                    return Integer.compare(u1.getAge(),u2.getAge());
                } else {
                    throw new RuntimeException("输入的数据类型不匹配");
                }
            }
        };
        TreeSet set = new TreeSet(com);
        set.add(new Person(20,"Tom"));
        set.add(new Person(23,"Alice"));
        set.add(new Person(33,"David"));
        set.add(new Person(14,"John"));
        set.add(new Person(24,"John"));

        Iterator iterator = set.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }
        //Person{age=14, name='John'}
        //Person{age=20, name='Tom'}
        //Person{age=23, name='Alice'}
        //Person{age=24, name='John'}
        //Person{age=33, name='David'}
    }
}

六、Map接口

1、Map接口概述

Map：双列数据，存储key-value对的数据。

• HashMap：作为Map的主要实现类，线程不安全，效率高；存储null的key和value。

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

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

• Hashtable：作为古老的实现类：线程安全，效率低；不能存储null的key和value

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

HashMap的底层：数组+链表（jdk7及之前）；数组+链表+红黑树（jdk8）

2、Map结构的理解

Map中的key是无序的、不可重复的，使用Set存储所有的key。–>key所在的类要重写equals()和hashCode()方法（如果是HashMap）。

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

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

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

3、HashMap的底层实现原理

HashMap map = new HashMap();

//在实例化后，底层创建了长度是16的一位数组Entry[] table

...可能已经执行过多次put...

map.put(key1,value1);

首先，计算key1所在类的hashCode()计算key1哈希值，此哈希值经过某种计算以后，得到在Entry数组中的存放位置。

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

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

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

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

    - 如果equals()返回false：此时key1-value1添加成功；--->情况3
    
    - 如果equals()返回true：使用value1替换相同key的value值。
    

补充：关于情况2和情况3：此时key1-value1和原来的数据以链表的方式存储。

在不断地添加过程中，会涉及到扩容问题，默认的扩容方式：扩容为原来容量的2倍，并将原有的数据复制过来。

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

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

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

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

• jdk7底层结构：数组+链表；

jdk8中底层结构：数组+链表+红黑树。当数组的某一个索引位置上的元素以链表形式存在的数据个数>8且当前数组的长度>64时，此时此索引位置上的所有数据改为红黑树存储。扩容临界值16*0.75=12，让链表少一点，数组利用率高一点。

4、HashSet的底层实现

就是调用了HashMap，将值都存在key中，value都指向一个常量PRESENT（private static final Object PRESENT = new Object();）

public boolean add(E e) {
    return map.put(e, PRESENT)==null;
}

5、LinkedHashMap的底层实现

能够记录添加的元素的先后顺序。

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

6、Map的常用方法

总结：常用方法：

• 添加：Object put(Object key,Object value)

• 删除：Object remove(Object key)

• 修改：Object put(Object key,Object value)

• 查询：Object get(Object key)

• 长度：size()

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

测试代码：

package org.test1;

import org.junit.Test;
import java.util.*;

/**
 * Created by luyangsiyi on 2020/2/7
 */
public class MapTest {
    @Test
    public void test(){
        Map map = new HashMap();
        //1.Object put(Object key,Object value)：将指定key-value添加到（或修改）当前map对象中
        map.put("AA",123);
        map.put(45,123);
        map.put("BB",123);
        //修改
        map.put("AA",87);
        System.out.println(map);
        //{AA=87, BB=123, 45=123}

        //2.void putAll(Map m)：将m中的所有key-value对存放到当前map中
        Map map1 = new HashMap();
        map1.put("CC",123);
        map1.put("DD",123);
        map.putAll(map1);
        System.out.println(map);
        //{AA=87, BB=123, CC=123, DD=123, 45=123}

        //3.Object remove(Object key)：返回需要移除的key对应的value，如果不存在返回null
        Object value = map.remove("CC");
        System.out.println(value);//123
        System.out.println(map);//{AA=87, BB=123, DD=123, 45=123}

        //4.void clear()：清空当前map中的所有数据
        map.clear();//与map=null不同
        System.out.println(map);//{}

        //5.Object get(Object key)：获得指定key对应的value
        map.put("AA",123);
        map.put(45,123);
        map.put("BB",123);
        System.out.println(map.get(45));//123

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

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

        //8.int size()：返回map中key-value对的个数
        System.out.println(map.size());//3

        //9.boolean isEmpty()：判断当前map是否为空
        System.out.println(map.isEmpty());//false

        //10.boolean equals(Object obj)：判断当前map和参数对象obj是否相等
        Map map2 = new HashMap();
        map2.put("AA",123);
        map2.put(45,123);
        map2.put("BB",123);
        System.out.println(map.equals(map2));//true，key-value对都相等

    }

    @Test
    public void test1(){
        Map map = new HashMap();
        map.put("AA",123);
        map.put(45,124);
        map.put("BB",125);
        //11.Set keySet()：返回所有key构成的Set集合
        Set set = map.keySet();
        Iterator iterator = set.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }
        System.out.println();

        //12.Collection values()：返回所有value构成的Collection集合
        Collection collection = map.values();
        for (Object o :collection) {
            System.out.println(o);
        }
        System.out.println();

        //13.Set entrySet()：返回所有key-value对构成的Set集合
        //方式一：
        Set entrySet = map.entrySet();
        Iterator iterator1 = entrySet.iterator();
        while(iterator1.hasNext()){
            Object obj = iterator1.next();
            //entrySet集合中的元素都是entry
            Map.Entry entry = (Map.Entry)obj;
            System.out.println(entry.getKey()+"---->"+entry.getValue());
        }
        System.out.println();

        //方式二：
        Set keySet = map.keySet();
        Iterator iterator2 = keySet.iterator();
        while(iterator2.hasNext()){
            Object key = iterator2.next();
            Object value = map.get(key);
            System.out.println(key+"--->"+value);
        }
    }
}

7、TreeMap的两种添加方式

package org.test1;

import org.junit.Test;

import java.util.*;

/**
 * Created by luyangsiyi on 2020/2/8
 */
public class TreeMapTest {
    //向TreeMap中添加key-value，要求key必是由同一个类创建的对象
    //因为要按照key进行排序：自然排序、定制排序
    @Test
    public void test(){
        TreeMap map = new TreeMap();
        Person p1 = new Person(20,"Tom");
        Person p2 = new Person(24,"Mary");
        Person p3 = new Person(14,"Rose");
        Person p4 = new Person(42,"Jack");
        map.put(p1,98);
        map.put(p2,70);
        map.put(p3,86);
        map.put(p4,100);

        //自然排序，Person实现Comparable，按照姓名从大到小排序
        Set entrySet = map.entrySet();
        Iterator iterator1 = entrySet.iterator();
        while(iterator1.hasNext()){
            Object obj = iterator1.next();
            //entrySet集合中的元素都是entry
            Map.Entry entry = (Map.Entry)obj;
            System.out.println(entry.getKey()+"---->"+entry.getValue());
        }
        //Person{age=42, name='Jack'}---->100
        //Person{age=24, name='Mary'}---->70
        //Person{age=14, name='Rose'}---->86
        //Person{age=20, name='Tom'}---->98
    }

    @Test
    public void test1(){
        TreeMap map = new TreeMap(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;
                    return Integer.compare(p1.getAge(),p2.getAge());
                }
                throw new RuntimeException("输入的类型不匹配");
            }
        });
        Person p1 = new Person(20,"Tom");
        Person p2 = new Person(24,"Mary");
        Person p3 = new Person(14,"Rose");
        Person p4 = new Person(42,"Jack");
        map.put(p1,98);
        map.put(p2,70);
        map.put(p3,86);
        map.put(p4,100);

        //自然排序，Person实现Comparable，按照姓名从大到小排序
        Set entrySet = map.entrySet();
        Iterator iterator1 = entrySet.iterator();
        while(iterator1.hasNext()){
            Object obj = iterator1.next();
            //entrySet集合中的元素都是entry
            Map.Entry entry = (Map.Entry)obj;
            System.out.println(entry.getKey()+"---->"+entry.getValue());
        }
        //Person{age=14, name='Rose'}---->86
        //Person{age=20, name='Tom'}---->98
        //Person{age=24, name='Mary'}---->70
        //Person{age=42, name='Jack'}---->100
    }
}

8、Properties处理属性文件

Properties类是Hashtable的子类，该对象用于处理属性文件。

由于属性文件中的key、value都是字符串类型，所以Properties里的key和value都是字符串类型。

测试代码：

package org.test1;

import java.io.FileInputStream;
import java.io.IOException;
import java.util.Properties;

/**
 * Created by luyangsiyi on 2020/2/8
 */
public class PropertiesTest {
    public static void main(String[] args) throws Exception {
        FileInputStream fis = null;
        try{
            Properties properties = new Properties();
            fis = new FileInputStream("jdbc.properties");
            properties.load(fis);
            String name = properties.getProperty("name");
            String password = properties.getProperty("password");
            System.out.println("name = "+name+",password = "+password);
        }
        catch (IOException e){
            e.printStackTrace();
        } finally {
            if(fis!=null){
                try{
                    fis.close();
                } catch (IOException e){
                    e.printStackTrace();
                }
            }
        }
        
    }
}

jdbc.properties：

name=Tom
password=123456

七、Collections工具类

Collections是一个操作Set、List和Map等集合的工具类。（操作数组的工具类Arrays）

Collections中提供了一系列静态的方法对集合元素进行排序、查询和修改等操作，还提供了对集合对象设置不可变、对集合对象实现同步控制等方法。

• 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)：根据Comparatorhe给定顺序，返回给定集合中的最大元素

• Object min(Collection)：根据元素的自然顺序，返回给定集合中的最小元素

• Object min(Collection,Comparator)：根据Comparatorhe给定顺序，返回给定集合中的最小元素

• int frequency(Collection,Object)：返回指定集合中指定元素的出现次数

• void copy(List dest, List src)：将src中的内容复制到dest中

• boolean replaceAll(List list, Object oldVal, Object newVal)：使用新值替换List中对应的旧值

八、集合中使用泛型

• 集合接口或集合类在jdk5时都修改为带泛型的结构。

• 在实例化集合类时，可以指明具体的泛型类型。

• 指明完以后，在集合类或接口中凡是定义类或接口时，内部结构（比如：方法、构造器、属性等）使用到类的泛型的位置，都指定为实例化的泛型类型。

• 泛型的类型必须是类，而不是基本数据类型。如果是用到基本数据类型，则用包装类替换。

• 如果实例化时，没有指定泛型的类型，则默认类型为java.lang.Object类型。

测试代码：

package org.test1;

import org.junit.Test;

import java.util.*;

/**
 * Created by luyangsiyi on 2020/2/8
 */
public class ArrayListTest {
    //集合中使用泛型的情况，以ArrayList为例
    @Test
    public void test(){
        ArrayList<Integer> list = new ArrayList<>();
        list.add(78);
        list.add(87);
        list.add(99);
        //编译时，就会进行类型检查，保证数据的安全
        //list.add("Tom");

        //方式一：
        for(Integer score:list){
            //避免了强转操作
            int stuScore = score;
            System.out.println(stuScore);
        }

        //方式二：
        Iterator<Integer> iterator = list.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }

    //集合中使用泛型的情况，以HashMap为例
    @Test
    public void test1(){
        HashMap<String,Integer> map = new HashMap<>();
        map.put("Tom",87);
        map.put("Jack",23);
        map.put("Mary",44);
        //编译出错
        //map.put(89,89);

        Set<Map.Entry<String,Integer>> entry = map.entrySet();
        Iterator<Map.Entry<String,Integer>> iterator = entry.iterator();
        while (iterator.hasNext()){
            Map.Entry<String,Integer> e = iterator.next();
            String key = e.getKey();
            Integer value = e.getValue();
            System.out.println(key+"--->"+value);
        }
    }
}

九、问题整理

1、Collection中存储的如果是自定义类的对象，需要自定义类重写哪个方法？为什么？

equals()方法。contains()/remove()/retainaAll()…

• List：equals()方法

• Set：

  • HashSet、LinkedHashSet：equals()、hashCode()

  • TreeSet：

    - Comparable：compareTo(Object obj)
    

    • Comparator：compare(Object obj1, Object obj2)

2、在List内取出重复数字值，要求尽量简单

利用HashSet

public static void main(String[] args) {
    List list = new ArrayList();
    list.add(new Integer(1));
    list.add(new Integer(2));
    list.add(new Integer(2));
    list.add(new Integer(3));
    list.add(new Integer(4));
    list.add(new Integer(4));
    List list1 = helper(list);
    for(Object integer:list1){
        System.out.println(integer);
    }
}

public static List helper(List list){
    HashSet set = new HashSet();
    set.addAll(list);
    return new ArrayList(set);
}

3、理解hashCode()重写

@Test
public void test(){
    HashSet set = new HashSet();
    //Person重写了hashCode()和equals()
    Person p1 = new Person(1001,"AA");
    Person p2 = new Person(1001,"BB");
    set.add(p1);
    set.add(p2);
    System.out.println(set);
    //[Person{age=1001, name='AA'}, Person{age=1001, name='BB'}]

    p1.setName("CC");
    set.remove(p1);
    //set中remove是按照对象的hash值来删除，而hashCode()是按照name和age分别计算的，
    //因为p1的name做了修改，hash值已经不是原来的(1001,"AA")，所以此时找到的hash值上应该是空
    //即此时(1001，"CC")这个对象的hashCode()发生了变化
    System.out.println(set);
    //[Person{age=1001, name='CC'}, Person{age=1001, name='BB'}]

    set.add(new Person(1001,"CC"));
    //同理，此时按照(1001,"CC")计算出来的hash值对应的位置上没有数据，故可以添加
    System.out.println(set);
    //[Person{age=1001, name='CC'}, Person{age=1001, name='BB'}, Person{age=1001, name='CC'}]

    set.add(new Person(1001,"AA"));
    //此时按照(1001,"AA")计算出来的hash值对应的位置上有修改name后的(1001,"CC")因为equals()返回false，所以可以添加
    System.out.println(set);
    //[Person{age=1001, name='CC'}, Person{age=1001, name='BB'}, Person{age=1001, name='CC'}, Person{age=1001, name='AA'}]
}