Java-集合

一、集合框架概述

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

【说明】

集合、数组都是对多个数据进行存储操作,此时的存储,主要指的是内存层面的存储,不涉及到持久化的存储(.txt,.jpg,.avi,数据库中);

1、数组存储

1.1 数组存储的特点

  • 一旦初始化以后,其长度就确定了;
  • 数组一旦定义好,其元素的类型也就确定了。我们也就只能操作指定类型的数据了;

比如:String[] arr;int[] arr1;Object[] arr2;

1.2 数组存储的弊端

  1. 一旦初始化以后,其长度就不可修改;
  2. 数组中提供的方法非常限,对于添加、删除、插入数据等操作,非常不便,同时效率不高;
  3. 获取数组中实际元素的个数的需求,数组没有现成的属性或方法可用;
  4. 数组存储数据的特点:有序、可重复。对于无序、不可重复的需求,不能满足;

2、集合存储

解决数组存储数据方面的弊端;

2.1 集合的分类

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

  • Collection接口:单列数据,定义了存取一组对象的方法的集合;

    • List:元素有序、可重复的集合;
    • Set:元素无序、不可重复的集;
  • Map接口:双列数据,保存具有映射关系“key-value对”的集合;

2.2 集合的框架结构

|----Collection接口:单列集合,用来存储一个一个的对象;
     |----List接口:存储有序的、可重复的数据;
           |----ArrayList:作为List接口的主要实现类,线程不安全的,效率高;底层采用Object[] elementData数组存储;
           |----LinkedList:对于频繁的插入删除操作,使用此类效率比ArrayList效率高;底层采用双向链表存储;
           |----Vector:作为List的古老实现类,线程安全的,效率低;底层采用Object[] elementData数组存储;
           
     |----Set接口:存储无序的、不可重复的数据;
           |----HashSet:作为Set接口主要实现类;线程不安全;可以存null值;
           		|----LinkedHashSet:作为HashSet的子类;遍历其内部数据时,可以按照添加顺序遍历;对于频繁的遍历操作,LinkedHashSet效率高于HashSet;
           |----TreeSet:可以按照添加对象的指定属性,进行排序;     
                    
				====================================================

                    
|----Map:双列数据,存储key-value对的数据;
     |----HashMap:作为Map的主要实现类;线程不安全的,效率高;可以存储null的key和value;
          |----LinkedHashMap:保证在遍历map元素时,可以照添加的顺序实现遍历;原因:在原的HashMap底层结构基础上,添加了一对指针,指向前一个和后一个元素;对于频繁的遍历操作,此类执行效率高于HashMap;
              
     |----TreeMap:保证照添加的key-value对进行排序,实现排序遍历。此时考虑key的自然排序或定制排序; 底层使用红黑树;
     |----Hashtable:作为古老的实现类;线程安全的,效率低;不能存储null的key和value;
          |----Properties:常用来处理配置文件。key和value都是String类型;

二、Collection接口

【说明】

  • Collection接口是List、Set和Queue接口的父接口,该接口里定义的方法既可用于操作Set集合,也可用于操作List和 Queue集合;
  • JDK不提供此接口的任何直接实现,而是提供更具体的子接口(如:Set和List)实现;
  • 在JDK 5.0之前,Java集合会丢失容器中所有对象的数据类型,把所有对象都当成 Object类型处理;从JDK 5.0增加了泛型以后,Java集合可以记住容器中对象的数据类型;

1、Collection单列集合框架结构

在这里插入图片描述

2、Collection接口常用方法

【创建一个集合对象】

Collection coll = new ArrayList();
  • add(Object obj):添加一个对象;
coll.add(123);//自动装箱
coll.add(false);
coll.add(new Date());
//调用重写的toString方法输出;
System.out.println(coll);//[123,false, Tue May 19 14:03:03 CST 2020]
  • addAll(Collection coll):添加一个集合里的所有对象;
//将coll1集合中的元素添加到当前的集合中;
Collection coll1 = new ArrayList();
coll1.add(456);
coll1.add("FF");
coll.addAll(coll1);
  • int size():获取添加的元素的个数,没有就是0;
System.out.println(coll.size());//输出5
  • void clear():清空集合元素;size = 0
coll.clear();
  • boolean isEmpty():判断size是否等于0;
System.out.println(coll.isEmpty());//true
  • boolean contains(Object obj):会调用元素的equals方法来判断当前集合中是否包含obj;
coll.add(123);
coll.add(456)
boolean contains = coll.contains(123);
System.out.println(contains);//true

//添加一个自定义类的对象
coll.add(new Person("Ben", 20));
//false,因为Person没有重写equals方法,判断的是地址值;
System.out.println(coll.contains(new Person("Ben", 20)));
  • boolean containsAll(Collection c):判断形参c中的所有元素是否都存在于当前集合中;通过调用元素的equals方法来判断;
Collection coll1 = Arrays.asList(123, 456);
System.out.println(coll.containsAll(coll1));//true
  • boolean remove(Object obj):通过元素的equals方法判断是否是要删除的那个元素。只会删除找到的第一个元素;
coll.clear();
coll.addAll(coll1);
boolean remove = coll.remove(123);
System.out.println(coll);//输出[456]
  • boolean removeAll(Collection coll):取当前集合的差集;
  • boolean retainAll(Collection c):把交集的结果存在当前的集合中,不影响c;
  • boolean equals(Object obj):返回true需要当前集合和形参集合的元素相同;(如果是有序的,顺序也要相同)
  • Object [] toArray():将集合转化为数组 ;
Object[] objects = coll.toArray();
for (Object object : objects) {
    System.out.println(object); //456
}
  • hashCode():返回当前对象的哈希值;
System.out.println(coll.hashCode());//4871
  • iterator():返回迭代器对象,用于集合遍历;

【补充】

数组转为集合:调用Arrays类的静态方法asList(T … t);

//此时集合里存放的是一个一维数组对象本身;(int[]对象)
List<int[]> ints = Arrays.asList(new int[]{1, 2});
System.out.println(ints);//[[I@22927a81]
//此时集合里存放的是数组里的元素;
List<Integer> integers = Arrays.asList(new Integer[]{1, 2});
List<Integer> integers1 = Arrays.asList(1, 2, 3);
System.out.println(integers);//[1, 2]
System.out.println(integers1);//[1, 2, 3]

【注意】

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

3、遍历集合

3.1 Iterator遍历集合

Iterator对象称为迭代器(设计模式的一种),主要用于遍历 Collection 集合中的元素;

【获取实例】

coll.iterator():返回一个迭代器实例;

Iterator iterator = coll.iterator();

【代码示例】

使用 hasNext() 方法和 next()方法;

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

在这里插入图片描述

【remove()方法】

可以在遍历的时候,删除集合中的元素。此方法不同于集合直接调用remove();

代码示例:

@Test
public void test3(){
    Collection coll = new ArrayList();
    coll.add(123);
    coll.add("Tom")
    //删除集合中"Tom"
    Iterator iterator = coll.iterator();
    while (iterator.hasNext()){  
        Object obj = iterator.next();
        if("Tom".equals(obj)){
            iterator.remove();        
        }
    }
    //将指针重新放到头部,遍历集合
    iterator = coll.iterator(); //返回一个新的迭代器对象
    while (iterator.hasNext()){
        System.out.println(iterator.next());
    }
}

【注意】

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

3.1增强for循环遍历集合

增强for循环是JDK 5.0新特性(foreach循环);也可以遍历数组;

【代码示例】

@Test
public void test1(){
    Collection coll = new ArrayList();
    coll.add(123);
    coll.add(456);
    coll.add(new Person("Jerry",20));
    coll.add(new String("Tom"));
    coll.add(false);

    //for(集合元素的类型 局部变量 : 集合对象)
    
    for(Object obj : coll){
        System.out.println(obj);
    }
}

增强for循环内部仍然调用了迭代器;

【遍历数组】

@Test
public void test2(){
    int[] arr = new int[]{1,2,3,4,5,6};
    //for(数组元素的类型 局部变量 : 数组对象)
    for(int i : arr){
        System.out.println(i);
    }
}

三、Collection子接口:List接口

List 存储有序的、可重复的数据;实现类常用的有:ArrayList、LinkedList;

【说明】

  • 鉴于Java中数组用来存储数据的局限性,我们通常使用List替代数组;
  • List集合类中元素有序、且可重复,集合中的每个元素都有其对应的顺序索引

1、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位置的子集合;

【代码示例】

@Test
public void test1(){
    ArrayList list = new ArrayList();
    list.add(123);
    list.add("AA");

	//add
    list.add(1, "BB");
    System.out.println(list);//输出[123, BB, AA]

    List<Integer> integers = Arrays.asList(1, 2, 3);
   
    //addAll
    list.addAll(integers);
    System.out.println(list.size()); // 6

    //get
    System.out.println(list.get(1));//输出 BB

}

@Test
public void test2(){
    ArrayList list = new ArrayList();
    list.add(123);
    list.add("AA");
    list.add("bb");
    list.add(new Person("zhangsan",15));
	
    //indexof
    int index = list.indexOf("AA");
    System.out.println(index); //输出1
	//lastIndexof
    System.out.println(list.lastIndexOf(123));//0

    //remove
    Object obj = list.remove(0);
    System.out.println(obj); //输出123
    System.out.println(list);//输出[AA, bb, Person{name='zhangsan', age=15}]
	
    //set
    list.set(1, "cc");
    System.out.println(list); //输出[AA, cc, Person{name='zhangsan', age=15}]

    //subList
    List subList = list.subList(0, 2);
    System.out.println(subList);//输出[AA, cc]
}

【总结】

  • 增:add(Object obj);
  • 删:remove(int index) / remove(Object obj);
  • 改:set(int index, Object ele);
  • 查:get(int index);
  • 插:add(int index, Object ele);
  • 长度:size();
  • 遍历: ① Iterator迭代器方式② foreach(增强for循环) ③ 普通的循环;

2、List常用实现类

  • ArrayList:作为List接口的主要实现类;线程不安全的,效率高;底层使用Object[] elementData存储;
  • LinkedList:对于频繁的插入、删除操作,使用此类效率比ArrayList高;底层使用双向链表存储;
  • Vector:作为List接口的古老实现类;线程安全的,效率低;底层使用Object[] elementData存储;

2.1 ArrayList

【说明】

  • ArrayList是List接口的典型实现类、主要实现类;
  • 本质上,ArrayList是对象引用的一个”变长”数组;

【Array Listi的JDK 1.8之前与之后的实现区别】

  • JDK 1.7:ArrayList像饿汉式,直接创建一个初始容量为10的数组;

  • JDK 1.8:ArrayList像懒汉式,一开始创建一个长度为0的数组,当添加第一个元素时再创建一个始容量为10的数组;

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

2.2 linkedList

【说明】

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

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

在这里插入图片描述

【新增方法】

  • void addFirst(Object obj);
  • void addLast(Object obj);
  • Object getFirst();
  • Object getlast)();
  • Object removeFirst();
  • Object removeLast();

对与对于频繁的插入和删除元素操作,建议使用LinkedList类,效率更高;

3、原理分析

3.1 ArrayList原理分析

3.1.1 JDK 7.0

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

list.add(123);//elementData[0] = new Integer(123);
...
list.add(11);//如果此次的添加导致底层elementData数组容量不够,则扩容;
  • 默认情况下,扩容为原来的容量的1.5倍,同时需要将原有数组中的数据复制到新的数组中;
  • 结论:建议开发中使用带参的构造器:ArrayList list = new ArrayList(int capacity);

3.1.2 JDK 8.0

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

后续的添加和扩容操作与JDK 7.0 无异;

【总结】

JDK 7.0中的ArrayList的对象的创建类似于单例的饿汉式,而JDK 8.0中的ArrayList的对象的创建类似于单例的懒汉式,延迟了数组的创建,节省内存;

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

3.3 Vector原理分析

基本要退休了。。

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

4、存储对象所在类的要求

向List接口的实现类的对象中添加数据obj时,一般要求obj所在类要重写equals();

面试题

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

  • ArrayList和 Linkedlist的异同:

    二者都线程不安全,相比线程安全的 Vector,ArrayList执行效率高。 此外,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接口是Collection的子接口,set接口没有提供额外的方法,使用的都是Collection中声明的方法;
  • Set集合不允许包含相同的元素,如果试把两个相同的元素加入同一个Set集合中,则添加操作失败。(多用于过滤操作,去掉重复数据);
  • Set判断两个对象是否相同不是使用==运算符,而是根据equals()方法;

1、set接口概述

1.1 Set存储的数据特点

用于存放无序的、不可重复的元素;

【以HashSet为例说明】

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

1.2 元素添加过程(以HashSet为例)

调用对象所属类的hashCode()和equals()方法来实现无序和不重复;

【添加过程】

①我们向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 与已经存在指定索引位置上数据以链表的方式存储;

  • JDK 7.0 :元素a放到数组中,指向原来的元素;

  • JDK 8.0 :原来的元素在数组中,指向元素a;

    总结:七上八下;

数组+链表的结构;(JDK 7.0以前)

image-20200427162158726

2、常用实现类

  • HashSet:作为Set接口的主要实现类;线程不安全的;可以存储null值;
    • LinkedHashSet:作为HashSet的子类;遍历其内部数据时,可以按照添加的顺序遍历,对于频繁的遍历操作; LinkedHashSet效率高于HashSet;
  • TreeSet:可以按照添加对象的指定属性,进行排序;

2.1 HashSet

  • Hashset是Set接口的典型实现,大多数时候使用Set集合时都使用这个实现类;
  • HashSet按Hash算法来存储集合中的元素,因此具有很好的存取、查找、删除性能;
  • HashSet具有以下特点:
    • 不能保证元素的排列顺序;
    • HashSet不是线程安全的;
    • 集合元素可以是nul;
  • HashSet集合判断两个元素相等的标准:两个对象通过hashCode()方法比较相等,并且两个对象的equals()方法返回值也相等;
  • 对于存放在Set容器中的对象,对应的类一定要重写equals()和hashCode(Object obj)方法,以实现对象相等规则。即:“相等的对象必须具有相等的散列码”;

2.2 LinkedHashSet

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

在这里插入图片描述

用双向链表来表示元素的插入的先后顺序,所以我们遍历LinkedHashSet的时候和插入的先后顺序是一样的;但存放的顺序还是无序的;

2.3 TreeSet

【概述】

  • Treeset是SortedSet接口的实现类,TreeSet可以确保集合元素处于排序状态
  • TreeSet底层使用红黑树结构存储数据;
  • TreeSet两种排序方法:自然排序和定制排序。默认情况下,TreeSet采用自然排序;

【红黑树图示】

image-20200427213936119

红黑树的特点:有序,查询效率比List快;

详细介绍:https://www.cnblogs.com/LiaHon/p/11203229.html

【注意】向TreeSet中添加的数据,要求是相同类的对象;

【排序方式】

方式一:自然排序

实现Comparable接口;

  • 自然排序:TreeSet会调用集合元素的compareTo(object obj)方法来比较元素之间的大小关系,然后将集合元素按升序(默认情况)排列;
  • 如果试图把一个对象添加到Treeset时,则该对象的类必须实现Comparable接口;
    • 实现Comparable的类必须实现compareTo(Object obj)方法,两个对象即通过compareTo(Object obj)方法的返回值来比较大小;
  • Comparable的典型实现:
    • BigDecimal、BigInteger以及所有的数值型对应的包装类:按它们对应的数值大小进行比较;
    • Character:按字符的unicode值来进行比较;
    • Boolean:true对应的包装类实例大于fase对应的包装类实例;
    • String:按字符串中字符的unicode值进行比较;
    • Date、Time:后边的时间、日期比前面的时间、日期大;
  • 向TreeSet中添加元素时,只有第一个元素无须比较compareTo()方法,后面添加的所有元素都会调用compareTo()方法进行比较;
  • 因为只有相同类的两个实例才会比较大小,所以向 TreeSet中添加的应该是同一个类的对象。 对于TreeSet集合而言,它判断两个对象是否相等的唯一标准是:两个对象通过compareTo(Object obj)方法比较返回值
  • 当需要把一个对象放入TreeSet中,重写该对象对应的equals()方法时,应保证该方法与compareTo(Object obj)方法有一致的结果:如果两个对象通过equals()方法比较返回true,则通过compareTo(object ob)方法比较应返回0。否则,让人难以理解;

方式二:定制排序

实现Comparator;

  • 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;
@Test
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));
    set.add(new User("Jack",33));
    set.add(new User("Jack",56));

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

3、存储对象所在类的要求

3.1 HashSet/LinkedHashSet

  • 要求:向Set(主要指:HashSet、LinkedHashSet)中添加的数据,其所在的类一定要重写hashCode()和equals();
  • 要求:重写的hashCode()和equals()尽可能保持一致性:相等的对象必须具有相等的散列码;

【代码示例】

@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(name, age);
}

3.2 TreeSet

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

五、Map接口

【说明】

  • Map与Collection并列存在。用于保存具有映射关系的数据:key-value;
  • Map中的key和value都可以是任何引用类型的数据;
  • Map中的key用set来存放,不允许重复,即同一个Map对象所对应的类,须重写 hashCode()和 equals()方法;
  • 常用 String类作为Map的“键”;
  • key和value之间存在单向一对一关系,即通过指定的key总能找到唯一的、确定的value;
  • Map接口的常用实现类:HashMap、TreeMap、LinkedHashMap和Properties。其中,HashMap是Map接口使用频率最高的实现类;

1、常用实现类

  • HashMap:作为Map的主要实现类;线程不安全的,效率高;可以存储null的key和value;
    • LinkedHashMap:保证在遍历map元素时,可以照添加的顺序实现遍历;原因:在原的HashMap底层结构基础上,添加了一对指针,指向前一个和后一个元素;对于频繁的遍历操作,此类执行效率高于HashMap;
  • TreeMap:保证照添加的key-value对进行排序,实现排序遍历。此时考虑key的自然排序或定制排序; 底层使用红黑树;
  • Hashtable:作为古老的实现类;线程安全的,效率低;不能存储null的key和value;
    • Properties:常用来处理配置文件。key和value都是String类型;

image-20200429112012230

1.1 HashMap

HashMap的底层:数组+链表 (JDK 7.0及之前);数组+链表+红黑树 (JDK 8.0以后);

【说明】

  • HashMap是Map接口使用频率最高的实现类;
  • 允许使用null键和null值,与 HashSet一样,不保证映射的顺序;
  • 所有的key构成的集合是set无序的、不可重复的。所以,key所在的类要重写equals()和 hashCode();
  • 所有的value构成的集合是Collection:无序的、可以重复的。所以,value所在的类要重写:equals();
  • 一个key-value构成一个entry;
  • 所有的entry构成的集合是Set:无序的、不可重复的;
  • HashMap判断两个key相等的标准是:两个key通过equals()方法返回true,hashCode值也相等;
  • HashMap判断两个value相等的标准是:两个value通过equals()方法返回true;

【代码示例】

@Test
public void test1(){
    Map map = new HashMap();
    map.put(null,123);
}

1.2 LinkedHashMap

  • LinkedHashMap底层使用的结构与HashMap相同,因为LinkedHashMap继承于HashMap;
  • 区别就在于:LinkedHashMap内部提供了Entry,替换HashMap中的Node;
  • 与Linkedhash Set类似,LinkedHashMap可以维护Map的迭代顺序:迭代顺序与Key-value对的插入顺序一致;

【代码示例】

@Test
public void test2(){
    Map map = new LinkedHashMap();
    map.put(345,"BB");
    map.put(12,"dC");
    System.out.println(map);
} 

1.3 TreeMap

【说明】

  • TreeMap存储Key-Value对时,需要根据key-value对进行排序;TreeMap可以保证所有的 Key-Value对处于有序状态
  • TreeSet底层使用红黑树结构存储数据;
  • TreeMap的Key的排序:
    • 自然排序: TreeMap的所有的Key必须实现Comparable接口,而且所有的Key应该是同一个类的对象,否则将会抛出ClasssCastEXception();
    • 定制排序:创建 TreeMap时,传入一个 Comparator对象,该对象负责对TreeMap中的所有key进行排序。此时不需要Map的Key实现Comparable接口;
  • TreeMap判断两个key相等的标准:两个key通过 compareTo()方法或者compare()方法返回0;

【使用】

向TreeMap中添加key-value,要求key必须是由同一个类创建的对象 ,要照key进行排序:自然排序 、定制排序;

1.4 Hashtable

基本不再使用;t是小写。。。

  • Hashtable是个古老的Map实现类,JDK1.0就提供了。不同于 HashMap,Hashtable是线程安全的;
  • Hashtable实现原理和HashMap相同,功能相同。底层都使用哈希表结构,查询速度快,很多情况下可以互用;
  • 与HashMap.不同,Hashtable不允许使用null作为key和value;
  • 与HashMap一样,Hashtable也不能保证其中Key-value对的顺序;
  • Hashtable判断两个key相等、两个value相等的标准,与HashMap-致;

1.5 Properties

【说明】

  • Properties类是Hashtable的子类,该对象用于处理属性文件
  • 由于属性文件里的key、value都是字符串类型,所以Properties里的key和value都是String类型
  • 存取数据时,建议使用setProperty(String key,String value)方法和getProperty(String key)方法;

【代码示例】

//实例Properties类;
Properties pros = new Properties();
//读取配置文件  ;   
fis = new FileInputStream("jdbc.properties");
pros.load(fis);//加载流对应的文件;
//获取属性,getProperty();
String name = pros.getProperty("name");
String password = pros.getProperty("password");

2、存储结构的理解

  • Map中的key:无序的、不可重复的,使用Set存储所的key; → key所在的类要重写equals()和hashCode(); (以HashMap为例)
  • Map中的value:无序的、可重复的,使用Collection存储所的value; → value所在的类要重写equals();
  • 一个键值对:key-value构成了一个Entry对象;
  • Map中的entry:无序的、不可重复的,使用Set存储所的entry

在这里插入图片描述

3、常用方法

3.1 添加、删除、修改操作

  • 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中的所有数据;

【代码示例】

@Test
public void test1() {
    Map map = new HashMap();
    //Object put(Object key,Object value);
    map.put("AA",123);
    map.put("BB",12);
    //key值相同,则替换value;
    map.put("AA",87);
    System.out.println(map);
    
    //void putAll(Map m);
    System.out.println(map);
    Map map1 = new HashMap();
    map1.put("EE",1);
    map1.put("FF",3);
    map.putAll(map1);
    System.out.println(map);

    //Object remove(Object key);
    Object value = map.remove("BB");
    System.out.println(value); 
    System.out.println(map);

    //void clear();
    map.clear();
    System.out.println(map.size());//0
    System.out.println(map);//{}
}

3.2 元素查询的操作

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

【代码示例】

Map map = new HashMap();
map.put("AA",123);
map.put("BB",123);
//get
System.out.println(map.get("AA")); //输出123
//containsKey
boolean isExist = map.containsKey("BB");
System.out.println(isExist); //true
//containsValue
isExist = map.containsValue(123); //true

3.3 元视图操作的方法

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

【代码示例】

@Test
public void test3(){
    Map map = new HashMap();
    map.put("AA",2);
    map.put("BB",3);
    map.put("CC", 4);
    System.out.println(map);//调用HashMap的父类的toString;

    //遍历所有的key集:keySet();
    Set set = map.keySet();
    for (Object o : set) {
        System.out.println(o);
        //也可以这样遍历value
		Object value = map.get(o); 
    }

    //遍历所有的value:values();
    Collection values = map.values();
    for (Object value : values) {
        System.out.println(value);
    }

    //遍历所有的key-value:entrySet();
    Set entrySet = map.entrySet();
    for (Object o : entrySet) {
        System.out.println(o);//调用HashMap.Node的toString方法;
    }

	//使用迭代器遍历;
    Iterator iterator = entrySet.iterator();
    while (iterator.hasNext()){
        Object obj = iterator.next();
        //直接输出entry;
        System.out.println(obj);
        //entrySet集合中的元素都是entry;
        Map.Entry entry = (Map.Entry) obj;
        //getKey()和getValue();
        System.out.println(entry.getKey() + "→"+entry.getValue());
    }

}

总结

  • 添加:put(Object key,Object value)
  • 删除:remove(Object key);
  • 修改:put(Object key,Object value);
  • 查询:get(Object key);
  • 长度:size();
  • 遍历:keySet() / values() / entrySet();

4、原理说明

4.1 HashMap在JDK 7.0中实现原理

4.1.1 HashMap的存储结构

HashMap是数组+链表结构(地址链表法);

image-20200429140534825

4.1.2 对象创建和添加过程

HashMap map = new HashMap():
......假设经过多次put操作......
map.put(key1,value1);

【创建】在实例化以后,底层创建了长度是16的一维数组Entry[] table;

【添加】进行put时:

首先,调用key1所在类的hashCode()计算key1哈希值,此哈希值经过某种算法计算以后,得到在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和原来的数据以链表的方式存储;

4.1.3 HashMap的扩容

【扩容问题】

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

【说明】

当HashMap中的元素越来越多的时候,hash冲突的几率也就越来越高,因为数组的长度是固定的。所以为了提高查询的效率,就要对 HashMap的数组进行扩容,而在HashMap数组扩容之后,原数组中的数据必须重新计算其在新数组中的位置,并放进去,这就是 resize;

【扩容时机】

当HashMap中的元素个数超过数组大小(数组总大小 length,不是数组中个数)* loadFactor时,就会进行数组扩容,loadFactor的默认值(DEFAULT_LOAD_ FACTOR)为0.75,这是一个折中的取值。也就是说,默认情况下,数组大小(DEFAULT INITIAL CAPACITY)为16,那么当 HashMap中元素个数超过16 * 0.75=12(这个值就是代码中的 threshold值,也叫做临界值)的时候,就把数组的大小扩展为2 * 16=32,即扩大一倍,然后重新计算每个元素在数组中的位置,而这是一个非常消耗性能的操作,所以如果我们已经预知 HashMap中元素的个数,那么预设元素的个数能够有效的提高HashMap的性能;

4.2 HashMap在JDK 8.0底层实现原理

4.2.1 HashMap的存储结构

HashMap的内部存储结构是数组+链表+红黑树的组合;

image-20200429140606819

4.2.2 HashMap添加元素的说明

当实例化一个HashMap时,会初始化loadFactor,在put第一对映射关系时,系统会创建一个长度为 initialCapacity的Node数组,这个长度在哈希表中被称为容量(Capacity),在这个数组中可以存放元素的位置我们称之为“桶”( bucket),每个bucket都有自己的索引,系统可以根据索引快速的查找bucket中的元素。

每个 bucket中存储一个元素,即一个Node对象,但每一个Noe对象可以带个引用变量next,用于指向下一个元素,因此,在一个桶中,就有可能生成一个Node链。也可能是一个一个 TreeNode对象,每一个Tree node对象可以有两个叶子结点left和right,因此,在一个桶中,就有可能生成一个TreeNode树。而新添加的元素作为链表的last,或树的叶子结点;

4.2.3 HashMap的扩容机制

  • 当HashMap中的其中一个链的对象个数没有达到8个和JDK 7.0以前的扩容方式一样;
  • 当HashMapl中的其中一个链的对象个数如果达到了8个,此时如果 capacity没有达到64,那么HashMap会先扩容解决,如果已经达到了64,那么这个链会变成树,结点类型由Node变成 Tree Node类型。当然,如果当映射关系被移除后,下次resize方法时判断树的结点个数低于6个,也会把树再转为链表;

4.2.4 JDK 8.0与JDK 7.0中HashMap底层的不同

  1. new HashMap():底层没有创建一个长度为16的数组;
  2. JDK 8.0底层的数组是:Node[],而非Entry[];
  3. 首次调用put()方法时,底层创建长度为16的数组;
  4. JDK 7.0底层结构只有:数组+链表。JDK 8.0中底层结构:数组+链表+红黑树;
    • 形成链表时,七上八下(jdk7:新的元素指向旧的元素。jdk8:旧的元素指向新的元素);
    • 当数组的某一个索引位置上的元素以链表形式存在的数据个数 > 8 且当前数组的长度 > 64时,此时此索引位置上的所数据改为使用红黑树存储;

4.3 HashMap底层属性说明

  • DEFAULT_INITIAL_CAPACITY : HashMap的默认容量,16;
  • DEFAULT_LOAD_FACTOR:HashMap的默认加载因子:0.75;
  • threshold:扩容的临界值,= 容量*填充因子:16 * 0.75 => 12;
  • TREEIFY_THRESHOLD:Bucket中链表长度大于该默认值,转化为红黑树:JDK 8.0引入;
  • MIN_TREEIFY_CAPACITY:桶中的Node被树化时最小的hash表容量:64;

4.4 LinkedHashMap的底层实现原理

  • LinkedHashMap底层使用的结构与HashMap相同,因为LinkedHashMap继承于HashMap;
  • 区别就在于:LinkedHashMap内部提供了Entry,替换HashMap中的Node;
  • 与Linkedhash Set类似,LinkedHashMap可以维护Map的迭代顺序:迭代顺序与Key-value对的插入顺序一致;

【HashMap中内部类Node源码】

static class Node<K,V> implements Map.Entry<K,V>{
    final int hash;
    final K key;
    V value;
    Node<K,V> next;
}

【LinkedHashM中内部类Entry源码】

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

面试题

  1. HashMap的底层实现原理?
  2. HashMap 和 Hashtable的异同?
  3. CurrentHashMap 与 Hashtable的异同?

【负载因子值的大小,对HashMap的影响】

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

threshold:扩容的临界值,= 容量*填充因子:16 * 0.75 => 12;

  • TREEIFY_THRESHOLD:Bucket中链表长度大于该默认值,转化为红黑树:JDK 8.0引入;
  • MIN_TREEIFY_CAPACITY:桶中的Node被树化时最小的hash表容量:64;
展开阅读全文

没有更多推荐了,返回首页

©️2019 CSDN 皮肤主题: 游动-白 设计师: 上身试试
应支付0元
点击重新获取
扫码支付

支付成功即可阅读