精华内容
参与话题
问答
  • Java集合容器面试题(2020最新版)

    万次阅读 多人点赞 2020-03-01 11:08:34
    文章目录集合容器概述什么是集合集合的特点集合和数组的区别使用集合框架的好处常用的集合类有哪些?List,Set,Map三者的区别?List、Set、Map 是否继承自 Collection 接口?List、Map、Set 三个接口存取元素时,各...

    文章目录

    Java面试总结汇总,整理了包括Java基础知识,集合容器,并发编程,JVM,常用开源框架Spring,MyBatis,数据库,中间件等,包含了作为一个Java工程师在面试中需要用到或者可能用到的绝大部分知识。欢迎大家阅读,本人见识有限,写的博客难免有错误或者疏忽的地方,还望各位大佬指点,在此表示感激不尽。文章持续更新中…

    序号 内容 链接地址
    1 Java基础知识面试题(2020最新版) https://thinkwon.blog.csdn.net/article/details/104390612
    2 Java集合容器面试题(2020最新版) https://thinkwon.blog.csdn.net/article/details/104588551
    3 Java异常面试题(2020最新版) https://thinkwon.blog.csdn.net/article/details/104390689
    4 并发编程面试题(2020最新版) https://thinkwon.blog.csdn.net/article/details/104863992
    5 JVM面试题(2020最新版) https://thinkwon.blog.csdn.net/article/details/104390752
    6 Spring面试题(2020最新版) https://thinkwon.blog.csdn.net/article/details/104397516
    7 Spring MVC面试题(2020最新版) https://thinkwon.blog.csdn.net/article/details/104397427
    8 Spring Boot面试题(2020最新版) https://thinkwon.blog.csdn.net/article/details/104397299
    9 Spring Cloud面试题(2020最新版) https://thinkwon.blog.csdn.net/article/details/104397367
    10 MyBatis面试题(2020最新版) https://thinkwon.blog.csdn.net/article/details/101292950
    11 Redis面试题(2020最新版) https://thinkwon.blog.csdn.net/article/details/103522351
    12 MySQL数据库面试题(2020最新版) https://thinkwon.blog.csdn.net/article/details/104778621
    13 消息中间件MQ与RabbitMQ面试题(2020最新版) https://thinkwon.blog.csdn.net/article/details/104588612
    14 Dubbo面试题(2020最新版) https://thinkwon.blog.csdn.net/article/details/104390006
    15 Linux面试题(2020最新版) https://thinkwon.blog.csdn.net/article/details/104588679
    16 Tomcat面试题(2020最新版) https://thinkwon.blog.csdn.net/article/details/104397665
    17 ZooKeeper面试题(2020最新版) https://thinkwon.blog.csdn.net/article/details/104397719
    18 Netty面试题(2020最新版) https://thinkwon.blog.csdn.net/article/details/104391081
    19 架构设计&分布式&数据结构与算法面试题(2020最新版) https://thinkwon.blog.csdn.net/article/details/105870730

    集合容器概述

    什么是集合

    集合框架:用于存储数据的容器。

    集合框架是为表示和操作集合而规定的一种统一的标准的体系结构。
    任何集合框架都包含三大块内容:对外的接口、接口的实现和对集合运算的算法。

    接口:表示集合的抽象数据类型。接口允许我们操作集合时不必关注具体实现,从而达到“多态”。在面向对象编程语言中,接口通常用来形成规范。

    实现:集合接口的具体实现,是重用性很高的数据结构。

    算法:在一个实现了某个集合框架中的接口的对象身上完成某种有用的计算的方法,例如查找、排序等。这些算法通常是多态的,因为相同的方法可以在同一个接口被多个类实现时有不同的表现。事实上,算法是可复用的函数。
    它减少了程序设计的辛劳。

    集合框架通过提供有用的数据结构和算法使你能集中注意力于你的程序的重要部分上,而不是为了让程序能正常运转而将注意力于低层设计上。
    通过这些在无关API之间的简易的互用性,使你免除了为改编对象或转换代码以便联合这些API而去写大量的代码。 它提高了程序速度和质量。

    集合的特点

    集合的特点主要有如下两点:

    • 对象封装数据,对象多了也需要存储。集合用于存储对象。

    • 对象的个数确定可以使用数组,对象的个数不确定的可以用集合。因为集合是可变长度的。

    集合和数组的区别

    • 数组是固定长度的;集合可变长度的。

    • 数组可以存储基本数据类型,也可以存储引用数据类型;集合只能存储引用数据类型。

    • 数组存储的元素必须是同一个数据类型;集合存储的对象可以是不同数据类型。

    数据结构:就是容器中存储数据的方式。

    对于集合容器,有很多种。因为每一个容器的自身特点不同,其实原理在于每个容器的内部数据结构不同。

    集合容器在不断向上抽取过程中,出现了集合体系。在使用一个体系的原则:参阅顶层内容。建立底层对象。

    使用集合框架的好处

    1. 容量自增长;
    2. 提供了高性能的数据结构和算法,使编码更轻松,提高了程序速度和质量;
    3. 允许不同 API 之间的互操作,API之间可以来回传递集合;
    4. 可以方便地扩展或改写集合,提高代码复用性和可操作性。
    5. 通过使用JDK自带的集合类,可以降低代码维护和学习新API成本。

    常用的集合类有哪些?

    Map接口和Collection接口是所有集合框架的父接口:

    1. Collection接口的子接口包括:Set接口和List接口
    2. Map接口的实现类主要有:HashMap、TreeMap、Hashtable、ConcurrentHashMap以及Properties等
    3. Set接口的实现类主要有:HashSet、TreeSet、LinkedHashSet等
    4. List接口的实现类主要有:ArrayList、LinkedList、Stack以及Vector等

    List,Set,Map三者的区别?List、Set、Map 是否继承自 Collection 接口?List、Map、Set 三个接口存取元素时,各有什么特点?

    img

    Java 容器分为 Collection 和 Map 两大类,Collection集合的子接口有Set、List、Queue三种子接口。我们比较常用的是Set、List,Map接口不是collection的子接口。

    Collection集合主要有List和Set两大接口

    • List:一个有序(元素存入集合的顺序和取出的顺序一致)容器,元素可以重复,可以插入多个null元素,元素都有索引。常用的实现类有 ArrayList、LinkedList 和 Vector。
    • Set:一个无序(存入和取出顺序有可能不一致)容器,不可以存储重复元素,只允许存入一个null元素,必须保证元素唯一性。Set 接口常用实现类是 HashSet、LinkedHashSet 以及 TreeSet。

    Map是一个键值对集合,存储键、值和之间的映射。 Key无序,唯一;value 不要求有序,允许重复。Map没有继承于Collection接口,从Map集合中检索元素时,只要给出键对象,就会返回对应的值对象。

    Map 的常用实现类:HashMap、TreeMap、HashTable、LinkedHashMap、ConcurrentHashMap

    集合框架底层数据结构

    Collection

    1. List
    • Arraylist: Object数组
    • Vector: Object数组
    • LinkedList: 双向循环链表
    1. Set
    • HashSet(无序,唯一):基于 HashMap 实现的,底层采用 HashMap 来保存元素
    • LinkedHashSet: LinkedHashSet 继承与 HashSet,并且其内部是通过 LinkedHashMap 来实现的。有点类似于我们之前说的LinkedHashMap 其内部是基于 Hashmap 实现一样,不过还是有一点点区别的。
    • TreeSet(有序,唯一): 红黑树(自平衡的排序二叉树。)

    Map

    • HashMap: JDK1.8之前HashMap由数组+链表组成的,数组是HashMap的主体,链表则是主要为了解决哈希冲突而存在的(“拉链法”解决冲突).JDK1.8以后在解决哈希冲突时有了较大的变化,当链表长度大于阈值(默认为8)时,将链表转化为红黑树,以减少搜索时间
    • LinkedHashMap:LinkedHashMap 继承自 HashMap,所以它的底层仍然是基于拉链式散列结构即由数组和链表或红黑树组成。另外,LinkedHashMap 在上面结构的基础上,增加了一条双向链表,使得上面的结构可以保持键值对的插入顺序。同时通过对链表进行相应的操作,实现了访问顺序相关逻辑。
    • HashTable: 数组+链表组成的,数组是 HashMap 的主体,链表则是主要为了解决哈希冲突而存在的
    • TreeMap: 红黑树(自平衡的排序二叉树)

    哪些集合类是线程安全的?

    • vector:就比arraylist多了个同步化机制(线程安全),因为效率较低,现在已经不太建议使用。在web应用中,特别是前台页面,往往效率(页面响应速度)是优先考虑的。
    • statck:堆栈类,先进后出。
    • hashtable:就比hashmap多了个线程安全。
    • enumeration:枚举,相当于迭代器。

    Java集合的快速失败机制 “fail-fast”?

    是java集合的一种错误检测机制,当多个线程对集合进行结构上的改变的操作时,有可能会产生 fail-fast 机制。

    例如:假设存在两个线程(线程1、线程2),线程1通过Iterator在遍历集合A中的元素,在某个时候线程2修改了集合A的结构(是结构上面的修改,而不是简单的修改集合元素的内容),那么这个时候程序就会抛出 ConcurrentModificationException 异常,从而产生fail-fast机制。

    原因:迭代器在遍历时直接访问集合中的内容,并且在遍历过程中使用一个 modCount 变量。集合在被遍历期间如果内容发生变化,就会改变modCount的值。每当迭代器使用hashNext()/next()遍历下一个元素之前,都会检测modCount变量是否为expectedmodCount值,是的话就返回遍历;否则抛出异常,终止遍历。

    解决办法:

    1. 在遍历过程中,所有涉及到改变modCount值得地方全部加上synchronized。

    2. 使用CopyOnWriteArrayList来替换ArrayList

    怎么确保一个集合不能被修改?

    可以使用 Collections. unmodifiableCollection(Collection c) 方法来创建一个只读集合,这样改变集合的任何操作都会抛出 Java. lang. UnsupportedOperationException 异常。

    示例代码如下:

    List<String> list = new ArrayList<>();
    list. add("x");
    Collection<String> clist = Collections. unmodifiableCollection(list);
    clist. add("y"); // 运行时此行报错
    System. out. println(list. size());
    

    Collection接口

    List接口

    迭代器 Iterator 是什么?

    Iterator 接口提供遍历任何 Collection 的接口。我们可以从一个 Collection 中使用迭代器方法来获取迭代器实例。迭代器取代了 Java 集合框架中的 Enumeration,迭代器允许调用者在迭代过程中移除元素。

    Iterator 怎么使用?有什么特点?

    Iterator 使用代码如下:

    List<String> list = new ArrayList<>();
    Iterator<String> it = list. iterator();
    while(it. hasNext()){
      String obj = it. next();
      System. out. println(obj);
    }
    

    Iterator 的特点是只能单向遍历,但是更加安全,因为它可以确保,在当前遍历的集合元素被更改的时候,就会抛出 ConcurrentModificationException 异常。

    如何边遍历边移除 Collection 中的元素?

    边遍历边修改 Collection 的唯一正确方式是使用 Iterator.remove() 方法,如下:

    Iterator<Integer> it = list.iterator();
    while(it.hasNext()){
       *// do something*
       it.remove();
    }
    

    一种最常见的错误代码如下:

    for(Integer i : list){
       list.remove(i)
    }
    

    运行以上错误代码会报 ConcurrentModificationException 异常。这是因为当使用 foreach(for(Integer i : list)) 语句时,会自动生成一个iterator 来遍历该 list,但同时该 list 正在被 Iterator.remove() 修改。Java 一般不允许一个线程在遍历 Collection 时另一个线程修改它。

    Iterator 和 ListIterator 有什么区别?

    • Iterator 可以遍历 Set 和 List 集合,而 ListIterator 只能遍历 List。
    • Iterator 只能单向遍历,而 ListIterator 可以双向遍历(向前/后遍历)。
    • ListIterator 实现 Iterator 接口,然后添加了一些额外的功能,比如添加一个元素、替换一个元素、获取前面或后面元素的索引位置。

    遍历一个 List 有哪些不同的方式?每种方法的实现原理是什么?Java 中 List 遍历的最佳实践是什么?

    遍历方式有以下几种:

    1. for 循环遍历,基于计数器。在集合外部维护一个计数器,然后依次读取每一个位置的元素,当读取到最后一个元素后停止。

    2. 迭代器遍历,Iterator。Iterator 是面向对象的一个设计模式,目的是屏蔽不同数据集合的特点,统一遍历集合的接口。Java 在 Collections 中支持了 Iterator 模式。

    3. foreach 循环遍历。foreach 内部也是采用了 Iterator 的方式实现,使用时不需要显式声明 Iterator 或计数器。优点是代码简洁,不易出错;缺点是只能做简单的遍历,不能在遍历过程中操作数据集合,例如删除、替换。

    最佳实践:Java Collections 框架中提供了一个 RandomAccess 接口,用来标记 List 实现是否支持 Random Access。

    • 如果一个数据集合实现了该接口,就意味着它支持 Random Access,按位置读取元素的平均时间复杂度为 O(1),如ArrayList。
    • 如果没有实现该接口,表示不支持 Random Access,如LinkedList。

    推荐的做法就是,支持 Random Access 的列表可用 for 循环遍历,否则建议用 Iterator 或 foreach 遍历。

    说一下 ArrayList 的优缺点

    ArrayList的优点如下:

    • ArrayList 底层以数组实现,是一种随机访问模式。ArrayList 实现了 RandomAccess 接口,因此查找的时候非常快。
    • ArrayList 在顺序添加一个元素的时候非常方便。

    ArrayList 的缺点如下:

    • 删除元素的时候,需要做一次元素复制操作。如果要复制的元素很多,那么就会比较耗费性能。
    • 插入元素的时候,也需要做一次元素复制操作,缺点同上。

    ArrayList 比较适合顺序添加、随机访问的场景。

    如何实现数组和 List 之间的转换?

    • 数组转 List:使用 Arrays. asList(array) 进行转换。
    • List 转数组:使用 List 自带的 toArray() 方法。

    代码示例:

    // list to array
    List<String> list = new ArrayList<String>();
    list.add("123");
    list.add("456");
    list.toArray();
    
    // array to list
    String[] array = new String[]{"123","456"};
    Arrays.asList(array);
    

    ArrayList 和 LinkedList 的区别是什么?

    • 数据结构实现:ArrayList 是动态数组的数据结构实现,而 LinkedList 是双向链表的数据结构实现。
    • 随机访问效率:ArrayList 比 LinkedList 在随机访问的时候效率要高,因为 LinkedList 是线性的数据存储方式,所以需要移动指针从前往后依次查找。
    • 增加和删除效率:在非首尾的增加和删除操作,LinkedList 要比 ArrayList 效率要高,因为 ArrayList 增删操作要影响数组内的其他数据的下标。
    • 内存空间占用:LinkedList 比 ArrayList 更占内存,因为 LinkedList 的节点除了存储数据,还存储了两个引用,一个指向前一个元素,一个指向后一个元素。
    • 线程安全:ArrayList 和 LinkedList 都是不同步的,也就是不保证线程安全;

    综合来说,在需要频繁读取集合中的元素时,更推荐使用 ArrayList,而在插入和删除操作较多时,更推荐使用 LinkedList。

    补充:数据结构基础之双向链表

    双向链表也叫双链表,是链表的一种,它的每个数据结点中都有两个指针,分别指向直接后继和直接前驱。所以,从双向链表中的任意一个结点开始,都可以很方便地访问它的前驱结点和后继结点。

    ArrayList 和 Vector 的区别是什么?

    这两个类都实现了 List 接口(List 接口继承了 Collection 接口),他们都是有序集合

    • 线程安全:Vector 使用了 Synchronized 来实现线程同步,是线程安全的,而 ArrayList 是非线程安全的。
    • 性能:ArrayList 在性能方面要优于 Vector。
    • 扩容:ArrayList 和 Vector 都会根据实际的需要动态的调整容量,只不过在 Vector 扩容每次会增加 1 倍,而 ArrayList 只会增加 50%。

    Vector类的所有方法都是同步的。可以由两个线程安全地访问一个Vector对象、但是一个线程访问Vector的话代码要在同步操作上耗费大量的时间。

    Arraylist不是同步的,所以在不需要保证线程安全时时建议使用Arraylist。

    插入数据时,ArrayList、LinkedList、Vector谁速度较快?阐述 ArrayList、Vector、LinkedList 的存储性能和特性?

    ArrayList、LinkedList、Vector 底层的实现都是使用数组方式存储数据。数组元素数大于实际存储的数据以便增加和插入元素,它们都允许直接按序号索引元素,但是插入元素要涉及数组元素移动等内存操作,所以索引数据快而插入数据慢。

    Vector 中的方法由于加了 synchronized 修饰,因此 Vector 是线程安全容器,但性能上较ArrayList差

    LinkedList 使用双向链表实现存储,按序号索引数据需要进行前向或后向遍历,但插入数据时只需要记录当前项的前后项即可,所以 LinkedList 插入速度较快

    多线程场景下如何使用 ArrayList?

    ArrayList 不是线程安全的,如果遇到多线程场景,可以通过 Collections 的 synchronizedList 方法将其转换成线程安全的容器后再使用。例如像下面这样:

    List<String> synchronizedList = Collections.synchronizedList(list);
    synchronizedList.add("aaa");
    synchronizedList.add("bbb");
    
    for (int i = 0; i < synchronizedList.size(); i++) {
        System.out.println(synchronizedList.get(i));
    }
    

    为什么 ArrayList 的 elementData 加上 transient 修饰?

    ArrayList 中的数组定义如下:

    private transient Object[] elementData;
    

    再看一下 ArrayList 的定义:

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

    可以看到 ArrayList 实现了 Serializable 接口,这意味着 ArrayList 支持序列化。transient 的作用是说不希望 elementData 数组被序列化,重写了 writeObject 实现:

    private void writeObject(java.io.ObjectOutputStream s) throws java.io.IOException{
        *// Write out element count, and any hidden stuff*
            int expectedModCount = modCount;
        s.defaultWriteObject();
        *// Write out array length*
            s.writeInt(elementData.length);
        *// Write out all elements in the proper order.*
            for (int i=0; i<size; i++)
                s.writeObject(elementData[i]);
        if (modCount != expectedModCount) {
            throw new ConcurrentModificationException();
    }
    

    每次序列化时,先调用 defaultWriteObject() 方法序列化 ArrayList 中的非 transient 元素,然后遍历 elementData,只序列化已存入的元素,这样既加快了序列化的速度,又减小了序列化之后的文件大小。

    List 和 Set 的区别

    List , Set 都是继承自Collection 接口

    List 特点:一个有序(元素存入集合的顺序和取出的顺序一致)容器,元素可以重复,可以插入多个null元素,元素都有索引。常用的实现类有 ArrayList、LinkedList 和 Vector。

    Set 特点:一个无序(存入和取出顺序有可能不一致)容器,不可以存储重复元素,只允许存入一个null元素,必须保证元素唯一性。Set 接口常用实现类是 HashSet、LinkedHashSet 以及 TreeSet。

    另外 List 支持for循环,也就是通过下标来遍历,也可以用迭代器,但是set只能用迭代,因为他无序,无法用下标来取得想要的值。

    Set和List对比

    Set:检索元素效率低下,删除和插入效率高,插入和删除不会引起元素位置改变。
    List:和数组类似,List可以动态增长,查找元素效率高,插入删除元素效率低,因为会引起其他元素位置改变

    Set接口

    说一下 HashSet 的实现原理?

    HashSet 是基于 HashMap 实现的,HashSet的值存放于HashMap的key上,HashMap的value统一为PRESENT,因此 HashSet 的实现比较简单,相关 HashSet 的操作,基本上都是直接调用底层 HashMap 的相关方法来完成,HashSet 不允许重复的值。

    HashSet如何检查重复?HashSet是如何保证数据不可重复的?

    向HashSet 中add ()元素时,判断元素是否存在的依据,不仅要比较hash值,同时还要结合equles 方法比较。
    HashSet 中的add ()方法会使用HashMap 的put()方法。

    HashMap 的 key 是唯一的,由源码可以看出 HashSet 添加进去的值就是作为HashMap 的key,并且在HashMap中如果K/V相同时,会用新的V覆盖掉旧的V,然后返回旧的V。所以不会重复( HashMap 比较key是否相等是先比较hashcode 再比较equals )。

    以下是HashSet 部分源码:

    private static final Object PRESENT = new Object();
    private transient HashMap<E,Object> map;
    
    public HashSet() {
        map = new HashMap<>();
    }
    
    public boolean add(E e) {
        // 调用HashMap的put方法,PRESENT是一个至始至终都相同的虚值
    	return map.put(e, PRESENT)==null;
    }
    

    hashCode()与equals()的相关规定

    1. 如果两个对象相等,则hashcode一定也是相同的
    2. 两个对象相等,对两个equals方法返回true
    3. 两个对象有相同的hashcode值,它们也不一定是相等的
    4. 综上,equals方法被覆盖过,则hashCode方法也必须被覆盖
    5. hashCode()的默认行为是对堆上的对象产生独特值。如果没有重写hashCode(),则该class的两个对象无论如何都不会相等(即使这两个对象指向相同的数据)。

    ==与equals的区别

    1. ==是判断两个变量或实例是不是指向同一个内存空间 equals是判断两个变量或实例所指向的内存空间的值是不是相同
    2. ==是指对内存地址进行比较 equals()是对字符串的内容进行比较3.==指引用是否相同 equals()指的是值是否相同

    HashSet与HashMap的区别

    HashMap HashSet
    实现了Map接口 实现Set接口
    存储键值对 仅存储对象
    调用put()向map中添加元素 调用add()方法向Set中添加元素
    HashMap使用键(Key)计算Hashcode HashSet使用成员对象来计算hashcode值,对于两个对象来说hashcode可能相同,所以equals()方法用来判断对象的相等性,如果两个对象不同的话,那么返回false
    HashMap相对于HashSet较快,因为它是使用唯一的键获取对象 HashSet较HashMap来说比较慢

    Queue

    BlockingQueue是什么?

    Java.util.concurrent.BlockingQueue是一个队列,在进行检索或移除一个元素的时候,它会等待队列变为非空;当在添加一个元素时,它会等待队列中的可用空间。BlockingQueue接口是Java集合框架的一部分,主要用于实现生产者-消费者模式。我们不需要担心等待生产者有可用的空间,或消费者有可用的对象,因为它都在BlockingQueue的实现类中被处理了。Java提供了集中BlockingQueue的实现,比如ArrayBlockingQueue、LinkedBlockingQueue、PriorityBlockingQueue,、SynchronousQueue等。

    在 Queue 中 poll()和 remove()有什么区别?

    • 相同点:都是返回第一个元素,并在队列中删除返回的对象。
    • 不同点:如果没有元素 poll()会返回 null,而 remove()会直接抛出 NoSuchElementException 异常。

    代码示例:

    Queue<String> queue = new LinkedList<String>();
    queue. offer("string"); // add
    System. out. println(queue. poll());
    System. out. println(queue. remove());
    System. out. println(queue. size());
    

    Map接口

    说一下 HashMap 的实现原理?

    HashMap概述: HashMap是基于哈希表的Map接口的非同步实现。此实现提供所有可选的映射操作,并允许使用null值和null键。此类不保证映射的顺序,特别是它不保证该顺序恒久不变。

    HashMap的数据结构: 在Java编程语言中,最基本的结构就是两种,一个是数组,另外一个是模拟指针(引用),所有的数据结构都可以用这两个基本结构来构造的,HashMap也不例外。HashMap实际上是一个“链表散列”的数据结构,即数组和链表的结合体。

    HashMap 基于 Hash 算法实现的

    1. 当我们往Hashmap中put元素时,利用key的hashCode重新hash计算出当前对象的元素在数组中的下标
    2. 存储时,如果出现hash值相同的key,此时有两种情况。(1)如果key相同,则覆盖原始值;(2)如果key不同(出现冲突),则将当前的key-value放入链表中
    3. 获取时,直接找到hash值对应的下标,在进一步判断key是否相同,从而找到对应值。
    4. 理解了以上过程就不难明白HashMap是如何解决hash冲突的问题,核心就是使用了数组的存储方式,然后将冲突的key的对象放入链表中,一旦发现冲突就在链表中做进一步的对比。

    需要注意Jdk 1.8中对HashMap的实现做了优化,当链表中的节点数据超过八个之后,该链表会转为红黑树来提高查询效率,从原来的O(n)到O(logn)

    HashMap在JDK1.7和JDK1.8中有哪些不同?HashMap的底层实现

    在Java中,保存数据有两种比较简单的数据结构:数组和链表。数组的特点是:寻址容易,插入和删除困难;链表的特点是:寻址困难,但插入和删除容易;所以我们将数组和链表结合在一起,发挥两者各自的优势,使用一种叫做拉链法的方式可以解决哈希冲突。

    JDK1.8之前

    JDK1.8之前采用的是拉链法。拉链法:将链表和数组相结合。也就是说创建一个链表数组,数组中每一格就是一个链表。若遇到哈希冲突,则将冲突的值加到链表中即可。

    jdk1.7中HashMap数据结构

    JDK1.8之后

    相比于之前的版本,jdk1.8在解决哈希冲突时有了较大的变化,当链表长度大于阈值(默认为8)时,将链表转化为红黑树,以减少搜索时间。

    jdk1.8中HashMap数据结构

    JDK1.7 VS JDK1.8 比较

    JDK1.8主要解决或优化了一下问题:

    1. resize 扩容优化
    2. 引入了红黑树,目的是避免单条链表过长而影响查询效率,红黑树算法请参考
    3. 解决了多线程死循环问题,但仍是非线程安全的,多线程时可能会造成数据丢失问题。
    不同 JDK 1.7 JDK 1.8
    存储结构 数组 + 链表 数组 + 链表 + 红黑树
    初始化方式 单独函数:inflateTable() 直接集成到了扩容函数resize()
    hash值计算方式 扰动处理 = 9次扰动 = 4次位运算 + 5次异或运算 扰动处理 = 2次扰动 = 1次位运算 + 1次异或运算
    存放数据的规则 无冲突时,存放数组;冲突时,存放链表 无冲突时,存放数组;冲突 & 链表长度 < 8:存放单链表;冲突 & 链表长度 > 8:树化并存放红黑树
    插入数据方式 头插法(先讲原位置的数据移到后1位,再插入数据到该位置) 尾插法(直接插入到链表尾部/红黑树)
    扩容后存储位置的计算方式 全部按照原来方法进行计算(即hashCode ->> 扰动函数 ->> (h&length-1)) 按照扩容后的规律计算(即扩容后的位置=原位置 or 原位置 + 旧容量)

    HashMap的put方法的具体流程?

    当我们put的时候,首先计算 keyhash值,这里调用了 hash方法,hash方法实际是让key.hashCode()key.hashCode()>>>16进行异或操作,高16bit补0,一个数和0异或不变,所以 hash 函数大概的作用就是:高16bit不变,低16bit和高16bit做了一个异或,目的是减少碰撞。按照函数注释,因为bucket数组大小是2的幂,计算下标index = (table.length - 1) & hash,如果不做 hash 处理,相当于散列生效的只有几个低 bit 位,为了减少散列的碰撞,设计者综合考虑了速度、作用、质量之后,使用高16bit和低16bit异或来简单处理减少碰撞,而且JDK8中用了复杂度 O(logn)的树结构来提升碰撞下的性能。

    putVal方法执行流程图

    putVal方法执行流程图

    public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
    }
    
    static final int hash(Object key) {
        int h;
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
    }
    
    //实现Map.put和相关方法
    final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                       boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        // 步骤①:tab为空则创建 
        // table未初始化或者长度为0,进行扩容
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        // 步骤②:计算index,并对null做处理  
        // (n - 1) & hash 确定元素存放在哪个桶中,桶为空,新生成结点放入桶中(此时,这个结点是放在数组中)
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        // 桶中已经存在元素
        else {
            Node<K,V> e; K k;
            // 步骤③:节点key存在,直接覆盖value 
            // 比较桶中第一个元素(数组中的结点)的hash值相等,key相等
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                    // 将第一个元素赋值给e,用e来记录
                    e = p;
            // 步骤④:判断该链为红黑树 
            // hash值不相等,即key不相等;为红黑树结点
            // 如果当前元素类型为TreeNode,表示为红黑树,putTreeVal返回待存放的node, e可能为null
            else if (p instanceof TreeNode)
                // 放入树中
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            // 步骤⑤:该链为链表 
            // 为链表结点
            else {
                // 在链表最末插入结点
                for (int binCount = 0; ; ++binCount) {
                    // 到达链表的尾部
                    
                    //判断该链表尾部指针是不是空的
                    if ((e = p.next) == null) {
                        // 在尾部插入新结点
                        p.next = newNode(hash, key, value, null);
                        //判断链表的长度是否达到转化红黑树的临界值,临界值为8
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            //链表结构转树形结构
                            treeifyBin(tab, hash);
                        // 跳出循环
                        break;
                    }
                    // 判断链表中结点的key值与插入的元素的key值是否相等
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        // 相等,跳出循环
                        break;
                    // 用于遍历桶中的链表,与前面的e = p.next组合,可以遍历链表
                    p = e;
                }
            }
            //判断当前的key已经存在的情况下,再来一个相同的hash值、key值时,返回新来的value这个值
            if (e != null) { 
                // 记录e的value
                V oldValue = e.value;
                // onlyIfAbsent为false或者旧值为null
                if (!onlyIfAbsent || oldValue == null)
                    //用新值替换旧值
                    e.value = value;
                // 访问后回调
                afterNodeAccess(e);
                // 返回旧值
                return oldValue;
            }
        }
        // 结构性修改
        ++modCount;
        // 步骤⑥:超过最大容量就扩容 
        // 实际大小大于阈值则扩容
        if (++size > threshold)
            resize();
        // 插入后回调
        afterNodeInsertion(evict);
        return null;
    }
    

    ①.判断键值对数组table[i]是否为空或为null,否则执行resize()进行扩容;

    ②.根据键值key计算hash值得到插入的数组索引i,如果table[i]==null,直接新建节点添加,转向⑥,如果table[i]不为空,转向③;

    ③.判断table[i]的首个元素是否和key一样,如果相同直接覆盖value,否则转向④,这里的相同指的是hashCode以及equals;

    ④.判断table[i] 是否为treeNode,即table[i] 是否是红黑树,如果是红黑树,则直接在树中插入键值对,否则转向⑤;

    ⑤.遍历table[i],判断链表长度是否大于8,大于8的话把链表转换为红黑树,在红黑树中执行插入操作,否则进行链表的插入操作;遍历过程中若发现key已经存在直接覆盖value即可;

    ⑥.插入成功后,判断实际存在的键值对数量size是否超多了最大容量threshold,如果超过,进行扩容。

    HashMap的扩容操作是怎么实现的?

    ①.在jdk1.8中,resize方法是在hashmap中的键值对大于阀值时或者初始化时,就调用resize方法进行扩容;

    ②.每次扩展的时候,都是扩展2倍;

    ③.扩展后Node对象的位置要么在原位置,要么移动到原偏移量两倍的位置。

    在putVal()中,我们看到在这个函数里面使用到了2次resize()方法,resize()方法表示的在进行第一次初始化时会对其进行扩容,或者当该数组的实际大小大于其临界值值(第一次为12),这个时候在扩容的同时也会伴随的桶上面的元素进行重新分发,这也是JDK1.8版本的一个优化的地方,在1.7中,扩容之后需要重新去计算其Hash值,根据Hash值对其进行分发,但在1.8版本中,则是根据在同一个桶的位置中进行判断(e.hash & oldCap)是否为0,重新进行hash分配后,该元素的位置要么停留在原始位置,要么移动到原始位置+增加的数组大小这个位置上

    final Node<K,V>[] resize() {
        Node<K,V>[] oldTab = table;//oldTab指向hash桶数组
        int oldCap = (oldTab == null) ? 0 : oldTab.length;
        int oldThr = threshold;
        int newCap, newThr = 0;
        if (oldCap > 0) {//如果oldCap不为空的话,就是hash桶数组不为空
            if (oldCap >= MAXIMUM_CAPACITY) {//如果大于最大容量了,就赋值为整数最大的阀值
                threshold = Integer.MAX_VALUE;
                return oldTab;//返回
            }//如果当前hash桶数组的长度在扩容后仍然小于最大容量 并且oldCap大于默认值16
            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                     oldCap >= DEFAULT_INITIAL_CAPACITY)
                newThr = oldThr << 1; // double threshold 双倍扩容阀值threshold
        }
        // 旧的容量为0,但threshold大于零,代表有参构造有cap传入,threshold已经被初始化成最小2的n次幂
        // 直接将该值赋给新的容量
        else if (oldThr > 0) // initial capacity was placed in threshold
            newCap = oldThr;
        // 无参构造创建的map,给出默认容量和threshold 16, 16*0.75
        else {               // zero initial threshold signifies using defaults
            newCap = DEFAULT_INITIAL_CAPACITY;
            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
        }
        // 新的threshold = 新的cap * 0.75
        if (newThr == 0) {
            float ft = (float)newCap * loadFactor;
            newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                      (int)ft : Integer.MAX_VALUE);
        }
        threshold = newThr;
        // 计算出新的数组长度后赋给当前成员变量table
        @SuppressWarnings({"rawtypes","unchecked"})
            Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];//新建hash桶数组
        table = newTab;//将新数组的值复制给旧的hash桶数组
        // 如果原先的数组没有初始化,那么resize的初始化工作到此结束,否则进入扩容元素重排逻辑,使其均匀的分散
        if (oldTab != null) {
            // 遍历新数组的所有桶下标
            for (int j = 0; j < oldCap; ++j) {
                Node<K,V> e;
                if ((e = oldTab[j]) != null) {
                    // 旧数组的桶下标赋给临时变量e,并且解除旧数组中的引用,否则就数组无法被GC回收
                    oldTab[j] = null;
                    // 如果e.next==null,代表桶中就一个元素,不存在链表或者红黑树
                    if (e.next == null)
                        // 用同样的hash映射算法把该元素加入新的数组
                        newTab[e.hash & (newCap - 1)] = e;
                    // 如果e是TreeNode并且e.next!=null,那么处理树中元素的重排
                    else if (e instanceof TreeNode)
                        ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                    // e是链表的头并且e.next!=null,那么处理链表中元素重排
                    else { // preserve order
                        // loHead,loTail 代表扩容后不用变换下标,见注1
                        Node<K,V> loHead = null, loTail = null;
                        // hiHead,hiTail 代表扩容后变换下标,见注1
                        Node<K,V> hiHead = null, hiTail = null;
                        Node<K,V> next;
                        // 遍历链表
                        do {             
                            next = e.next;
                            if ((e.hash & oldCap) == 0) {
                                if (loTail == null)
                                    // 初始化head指向链表当前元素e,e不一定是链表的第一个元素,初始化后loHead
                                    // 代表下标保持不变的链表的头元素
                                    loHead = e;
                                else                                
                                    // loTail.next指向当前e
                                    loTail.next = e;
                                // loTail指向当前的元素e
                                // 初始化后,loTail和loHead指向相同的内存,所以当loTail.next指向下一个元素时,
                                // 底层数组中的元素的next引用也相应发生变化,造成lowHead.next.next.....
                                // 跟随loTail同步,使得lowHead可以链接到所有属于该链表的元素。
                                loTail = e;                           
                            }
                            else {
                                if (hiTail == null)
                                    // 初始化head指向链表当前元素e, 初始化后hiHead代表下标更改的链表头元素
                                    hiHead = e;
                                else
                                    hiTail.next = e;
                                hiTail = e;
                            }
                        } while ((e = next) != null);
                        // 遍历结束, 将tail指向null,并把链表头放入新数组的相应下标,形成新的映射。
                        if (loTail != null) {
                            loTail.next = null;
                            newTab[j] = loHead;
                        }
                        if (hiTail != null) {
                            hiTail.next = null;
                            newTab[j + oldCap] = hiHead;
                        }
                    }
                }
            }
        }
        return newTab;
    }
    

    HashMap是怎么解决哈希冲突的?

    答:在解决这个问题之前,我们首先需要知道什么是哈希冲突,而在了解哈希冲突之前我们还要知道什么是哈希才行;

    什么是哈希?

    Hash,一般翻译为“散列”,也有直接音译为“哈希”的,这就是把任意长度的输入通过散列算法,变换成固定长度的输出,该输出就是散列值(哈希值);这种转换是一种压缩映射,也就是,散列值的空间通常远小于输入的空间,不同的输入可能会散列成相同的输出,所以不可能从散列值来唯一的确定输入值。简单的说就是一种将任意长度的消息压缩到某一固定长度的消息摘要的函数

    所有散列函数都有如下一个基本特性**:根据同一散列函数计算出的散列值如果不同,那么输入值肯定也不同。但是,根据同一散列函数计算出的散列值如果相同,输入值不一定相同**。

    什么是哈希冲突?

    当两个不同的输入值,根据同一散列函数计算出相同的散列值的现象,我们就把它叫做碰撞(哈希碰撞)

    HashMap的数据结构

    在Java中,保存数据有两种比较简单的数据结构:数组和链表。数组的特点是:寻址容易,插入和删除困难;链表的特点是:寻址困难,但插入和删除容易;所以我们将数组和链表结合在一起,发挥两者各自的优势,使用一种叫做链地址法的方式可以解决哈希冲突:

    img

    这样我们就可以将拥有相同哈希值的对象组织成一个链表放在hash值所对应的bucket下,但相比于hashCode返回的int类型,我们HashMap初始的容量大小DEFAULT_INITIAL_CAPACITY = 1 << 4(即2的四次方16)要远小于int类型的范围,所以我们如果只是单纯的用hashCode取余来获取对应的bucket这将会大大增加哈希碰撞的概率,并且最坏情况下还会将HashMap变成一个单链表,所以我们还需要对hashCode作一定的优化

    hash()函数

    上面提到的问题,主要是因为如果使用hashCode取余,那么相当于参与运算的只有hashCode的低位,高位是没有起到任何作用的,所以我们的思路就是让hashCode取值出的高位也参与运算,进一步降低hash碰撞的概率,使得数据分布更平均,我们把这样的操作称为扰动,在JDK 1.8中的hash()函数如下:

    static final int hash(Object key) {
        int h;
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);// 与自己右移16位进行异或运算(高低位异或)
    }
    

    这比在JDK 1.7中,更为简洁,相比在1.7中的4次位运算,5次异或运算(9次扰动),在1.8中,只进行了1次位运算和1次异或运算(2次扰动)

    JDK1.8新增红黑树

    img

    通过上面的链地址法(使用散列表)扰动函数我们成功让我们的数据分布更平均,哈希碰撞减少,但是当我们的HashMap中存在大量数据时,加入我们某个bucket下对应的链表有n个元素,那么遍历时间复杂度就为O(n),为了针对这个问题,JDK1.8在HashMap中新增了红黑树的数据结构,进一步使得遍历复杂度降低至O(logn);

    总结

    简单总结一下HashMap是使用了哪些方法来有效解决哈希冲突的:

    1. 使用链地址法(使用散列表)来链接拥有相同hash值的数据;
    2. 使用2次扰动函数(hash函数)来降低哈希冲突的概率,使得数据分布更平均;
    3. 引入红黑树进一步降低遍历的时间复杂度,使得遍历更快;

    能否使用任何类作为 Map 的 key?

    可以使用任何类作为 Map 的 key,然而在使用之前,需要考虑以下几点:

    • 如果类重写了 equals() 方法,也应该重写 hashCode() 方法。

    • 类的所有实例需要遵循与 equals() 和 hashCode() 相关的规则。

    • 如果一个类没有使用 equals(),不应该在 hashCode() 中使用它。

    • 用户自定义 Key 类最佳实践是使之为不可变的,这样 hashCode() 值可以被缓存起来,拥有更好的性能。不可变的类也可以确保 hashCode() 和 equals() 在未来不会改变,这样就会解决与可变相关的问题了。

    为什么HashMap中String、Integer这样的包装类适合作为K?

    答:String、Integer等包装类的特性能够保证Hash值的不可更改性和计算准确性,能够有效的减少Hash碰撞的几率

    1. 都是final类型,即不可变性,保证key的不可更改性,不会存在获取hash值不同的情况
    2. 内部已重写了equals()hashCode()等方法,遵守了HashMap内部的规范(不清楚可以去上面看看putValue的过程),不容易出现Hash值计算错误的情况;

    如果使用Object作为HashMap的Key,应该怎么办呢?

    答:重写hashCode()equals()方法

    1. 重写hashCode()是因为需要计算存储数据的存储位置,需要注意不要试图从散列码计算中排除掉一个对象的关键部分来提高性能,这样虽然能更快但可能会导致更多的Hash碰撞;
    2. 重写equals()方法,需要遵守自反性、对称性、传递性、一致性以及对于任何非null的引用值x,x.equals(null)必须返回false的这几个特性,目的是为了保证key在哈希表中的唯一性

    HashMap为什么不直接使用hashCode()处理后的哈希值直接作为table的下标?

    答:hashCode()方法返回的是int整数类型,其范围为-(2 ^ 31)~(2 ^ 31 - 1),约有40亿个映射空间,而HashMap的容量范围是在16(初始化默认值)~2 ^ 30,HashMap通常情况下是取不到最大值的,并且设备上也难以提供这么多的存储空间,从而导致通过hashCode()计算出的哈希值可能不在数组大小范围内,进而无法匹配存储位置;

    那怎么解决呢?

    1. HashMap自己实现了自己的hash()方法,通过两次扰动使得它自己的哈希值高低位自行进行异或运算,降低哈希碰撞概率也使得数据分布更平均;
    2. 在保证数组长度为2的幂次方的时候,使用hash()运算之后的值与运算(&)(数组长度 - 1)来获取数组下标的方式进行存储,这样一来是比取余操作更加有效率,二来也是因为只有当数组长度为2的幂次方时,h&(length-1)才等价于h%length,三来解决了“哈希值与数组大小范围不匹配”的问题;

    HashMap 的长度为什么是2的幂次方

    为了能让 HashMap 存取高效,尽量较少碰撞,也就是要尽量把数据分配均匀,每个链表/红黑树长度大致相同。这个实现就是把数据存到哪个链表/红黑树中的算法。

    这个算法应该如何设计呢?

    我们首先可能会想到采用%取余的操作来实现。但是,重点来了:“取余(%)操作中如果除数是2的幂次则等价于与其除数减一的与(&)操作(也就是说 hash%length==hash&(length-1)的前提是 length 是2的 n 次方;)。” 并且 采用二进制位操作 &,相对于%能够提高运算效率,这就解释了 HashMap 的长度为什么是2的幂次方。

    那为什么是两次扰动呢?

    答:这样就是加大哈希值低位的随机性,使得分布更均匀,从而提高对应数组存储下标位置的随机性&均匀性,最终减少Hash冲突,两次就够了,已经达到了高位低位同时参与运算的目的;

    HashMap 与 HashTable 有什么区别?

    1. 线程安全: HashMap 是非线程安全的,HashTable 是线程安全的;HashTable 内部的方法基本都经过 synchronized 修饰。(如果你要保证线程安全的话就使用 ConcurrentHashMap 吧!);
    2. 效率: 因为线程安全的问题,HashMap 要比 HashTable 效率高一点。另外,HashTable 基本被淘汰,不要在代码中使用它;
    3. 对Null key 和Null value的支持: HashMap 中,null 可以作为键,这样的键只有一个,可以有一个或多个键所对应的值为 null。但是在 HashTable 中 put 进的键值只要有一个 null,直接抛NullPointerException。
    4. **初始容量大小和每次扩充容量大小的不同 **: ①创建时如果不指定容量初始值,Hashtable 默认的初始大小为11,之后每次扩充,容量变为原来的2n+1。HashMap 默认的初始化大小为16。之后每次扩充,容量变为原来的2倍。②创建时如果给定了容量初始值,那么 Hashtable 会直接使用你给定的大小,而 HashMap 会将其扩充为2的幂次方大小。也就是说 HashMap 总是使用2的幂作为哈希表的大小,后面会介绍到为什么是2的幂次方。
    5. 底层数据结构: JDK1.8 以后的 HashMap 在解决哈希冲突时有了较大的变化,当链表长度大于阈值(默认为8)时,将链表转化为红黑树,以减少搜索时间。Hashtable 没有这样的机制。
    6. 推荐使用:在 Hashtable 的类注释可以看到,Hashtable 是保留类不建议使用,推荐在单线程环境下使用 HashMap 替代,如果需要多线程使用则用 ConcurrentHashMap 替代。

    如何决定使用 HashMap 还是 TreeMap?

    对于在Map中插入、删除和定位元素这类操作,HashMap是最好的选择。然而,假如你需要对一个有序的key集合进行遍历,TreeMap是更好的选择。基于你的collection的大小,也许向HashMap中添加元素会更快,将map换为TreeMap进行有序key的遍历。

    HashMap 和 ConcurrentHashMap 的区别

    1. ConcurrentHashMap对整个桶数组进行了分割分段(Segment),然后在每一个分段上都用lock锁进行保护,相对于HashTable的synchronized锁的粒度更精细了一些,并发性能更好,而HashMap没有锁机制,不是线程安全的。(JDK1.8之后ConcurrentHashMap启用了一种全新的方式实现,利用CAS算法。)
    2. HashMap的键值对允许有null,但是ConCurrentHashMap都不允许。

    ConcurrentHashMap 和 Hashtable 的区别?

    ConcurrentHashMap 和 Hashtable 的区别主要体现在实现线程安全的方式上不同。

    • 底层数据结构: JDK1.7的 ConcurrentHashMap 底层采用 分段的数组+链表 实现,JDK1.8 采用的数据结构跟HashMap1.8的结构一样,数组+链表/红黑二叉树。Hashtable 和 JDK1.8 之前的 HashMap 的底层数据结构类似都是采用 数组+链表 的形式,数组是 HashMap 的主体,链表则是主要为了解决哈希冲突而存在的;
    • 实现线程安全的方式(重要): ① 在JDK1.7的时候,ConcurrentHashMap(分段锁) 对整个桶数组进行了分割分段(Segment),每一把锁只锁容器其中一部分数据,多线程访问容器里不同数据段的数据,就不会存在锁竞争,提高并发访问率。(默认分配16个Segment,比Hashtable效率提高16倍。) 到了 JDK1.8 的时候已经摒弃了Segment的概念,而是直接用 Node 数组+链表+红黑树的数据结构来实现,并发控制使用 synchronized 和 CAS 来操作。(JDK1.6以后 对 synchronized锁做了很多优化) 整个看起来就像是优化过且线程安全的 HashMap,虽然在JDK1.8中还能看到 Segment 的数据结构,但是已经简化了属性,只是为了兼容旧版本;② Hashtable(同一把锁) :使用 synchronized 来保证线程安全,效率非常低下。当一个线程访问同步方法时,其他线程也访问同步方法,可能会进入阻塞或轮询状态,如使用 put 添加元素,另一个线程不能使用 put 添加元素,也不能使用 get,竞争会越来越激烈效率越低。

    两者的对比图

    HashTable:

    img

    JDK1.7的ConcurrentHashMap:

    img

    JDK1.8的ConcurrentHashMap(TreeBin: 红黑二叉树节点 Node: 链表节点):

    img

    答:ConcurrentHashMap 结合了 HashMap 和 HashTable 二者的优势。HashMap 没有考虑同步,HashTable 考虑了同步的问题。但是 HashTable 在每次同步执行时都要锁住整个结构。 ConcurrentHashMap 锁的方式是稍微细粒度的。

    ConcurrentHashMap 底层具体实现知道吗?实现原理是什么?

    JDK1.7

    首先将数据分为一段一段的存储,然后给每一段数据配一把锁,当一个线程占用锁访问其中一个段数据时,其他段的数据也能被其他线程访问。

    在JDK1.7中,ConcurrentHashMap采用Segment + HashEntry的方式进行实现,结构如下:

    一个 ConcurrentHashMap 里包含一个 Segment 数组。Segment 的结构和HashMap类似,是一种数组和链表结构,一个 Segment 包含一个 HashEntry 数组,每个 HashEntry 是一个链表结构的元素,每个 Segment 守护着一个HashEntry数组里的元素,当对 HashEntry 数组的数据进行修改时,必须首先获得对应的 Segment的锁。

    img

    1. 该类包含两个静态内部类 HashEntry 和 Segment ;前者用来封装映射表的键值对,后者用来充当锁的角色;
    2. Segment 是一种可重入的锁 ReentrantLock,每个 Segment 守护一个HashEntry 数组里得元素,当对 HashEntry 数组的数据进行修改时,必须首先获得对应的 Segment 锁。

    JDK1.8

    JDK1.8中,放弃了Segment臃肿的设计,取而代之的是采用Node + CAS + Synchronized来保证并发安全进行实现,synchronized只锁定当前链表或红黑二叉树的首节点,这样只要hash不冲突,就不会产生并发,效率又提升N倍。

    结构如下:

    img

    附加源码,有需要的可以看看

    插入元素过程(建议去看看源码):

    如果相应位置的Node还没有初始化,则调用CAS插入相应的数据;

    else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
        if (casTabAt(tab, i, null, new Node<K,V>(hash, key, value, null)))
            break;                   // no lock when adding to empty bin
    }
    

    如果相应位置的Node不为空,且当前该节点不处于移动状态,则对该节点加synchronized锁,如果该节点的hash不小于0,则遍历链表更新节点或插入新节点;

    if (fh >= 0) {
        binCount = 1;
        for (Node<K,V> e = f;; ++binCount) {
            K ek;
            if (e.hash == hash &&
                ((ek = e.key) == key ||
                 (ek != null && key.equals(ek)))) {
                oldVal = e.val;
                if (!onlyIfAbsent)
                    e.val = value;
                break;
            }
            Node<K,V> pred = e;
            if ((e = e.next) == null) {
                pred.next = new Node<K,V>(hash, key, value, null);
                break;
            }
        }
    }
    
    1. 如果该节点是TreeBin类型的节点,说明是红黑树结构,则通过putTreeVal方法往红黑树中插入节点;如果binCount不为0,说明put操作对数据产生了影响,如果当前链表的个数达到8个,则通过treeifyBin方法转化为红黑树,如果oldVal不为空,说明是一次更新操作,没有对元素个数产生影响,则直接返回旧值;
    2. 如果插入的是一个新节点,则执行addCount()方法尝试更新元素个数baseCount;

    辅助工具类

    Array 和 ArrayList 有何区别?

    • Array 可以存储基本数据类型和对象,ArrayList 只能存储对象。
    • Array 是指定固定大小的,而 ArrayList 大小是自动扩展的。
    • Array 内置方法没有 ArrayList 多,比如 addAll、removeAll、iteration 等方法只有 ArrayList 有。

    对于基本类型数据,集合使用自动装箱来减少编码工作量。但是,当处理固定大小的基本数据类型的时候,这种方式相对比较慢。

    如何实现 Array 和 List 之间的转换?

    • Array 转 List: Arrays. asList(array) ;
    • List 转 Array:List 的 toArray() 方法。

    comparable 和 comparator的区别?

    • comparable接口实际上是出自java.lang包,它有一个 compareTo(Object obj)方法用来排序
    • comparator接口实际上是出自 java.util 包,它有一个compare(Object obj1, Object obj2)方法用来排序

    一般我们需要对一个集合使用自定义排序时,我们就要重写compareTo方法或compare方法,当我们需要对某一个集合实现两种排序方式,比如一个song对象中的歌名和歌手名分别采用一种排序方法的话,我们可以重写compareTo方法和使用自制的Comparator方法或者以两个Comparator来实现歌名排序和歌星名排序,第二种代表我们只能使用两个参数版的Collections.sort().

    Collection 和 Collections 有什么区别?

    • java.util.Collection 是一个集合接口(集合类的一个顶级接口)。它提供了对集合对象进行基本操作的通用接口方法。Collection接口在Java 类库中有很多具体的实现。Collection接口的意义是为各种具体的集合提供了最大化的统一操作方式,其直接继承接口有List与Set。
    • Collections则是集合类的一个工具类/帮助类,其中提供了一系列静态方法,用于对集合中元素进行排序、搜索以及线程安全等各种操作。

    TreeMap 和 TreeSet 在排序时如何比较元素?Collections 工具类中的 sort()方法如何比较元素?

    TreeSet 要求存放的对象所属的类必须实现 Comparable 接口,该接口提供了比较元素的 compareTo()方法,当插入元素时会回调该方法比较元素的大小。TreeMap 要求存放的键值对映射的键必须实现 Comparable 接口从而根据键对元素进 行排 序。

    Collections 工具类的 sort 方法有两种重载的形式,

    第一种要求传入的待排序容器中存放的对象比较实现 Comparable 接口以实现元素的比较;

    第二种不强制性的要求容器中的元素必须可比较,但是要求传入第二个参数,参数是Comparator 接口的子类型(需要重写 compare 方法实现元素的比较),相当于一个临时定义的排序规则,其实就是通过接口注入比较元素大小的算法,也是对回调模式的应用(Java 中对函数式编程的支持)。

    展开全文
  • MyBatis面试题(2020最新版)

    万次阅读 多人点赞 2019-09-24 16:40:33
    整理好的MyBatis面试题库,史上最全的MyBatis面试题,MyBatis面试宝典,特此分享给大家 MyBatis 介绍 MyBatis 是一款优秀的持久层框架,它支持定制化 SQL、存储过程以及高级映射。MyBatis 避免了几乎所有的 JDBC ...

    文章目录

    Java面试总结汇总,整理了包括Java基础知识,集合容器,并发编程,JVM,常用开源框架Spring,MyBatis,数据库,中间件等,包含了作为一个Java工程师在面试中需要用到或者可能用到的绝大部分知识。欢迎大家阅读,本人见识有限,写的博客难免有错误或者疏忽的地方,还望各位大佬指点,在此表示感激不尽。文章持续更新中…

    序号 内容 链接地址
    1 Java基础知识面试题(2020最新版) https://thinkwon.blog.csdn.net/article/details/104390612
    2 Java集合容器面试题(2020最新版) https://thinkwon.blog.csdn.net/article/details/104588551
    3 Java异常面试题(2020最新版) https://thinkwon.blog.csdn.net/article/details/104390689
    4 并发编程面试题(2020最新版) https://thinkwon.blog.csdn.net/article/details/104863992
    5 JVM面试题(2020最新版) https://thinkwon.blog.csdn.net/article/details/104390752
    6 Spring面试题(2020最新版) https://thinkwon.blog.csdn.net/article/details/104397516
    7 Spring MVC面试题(2020最新版) https://thinkwon.blog.csdn.net/article/details/104397427
    8 Spring Boot面试题(2020最新版) https://thinkwon.blog.csdn.net/article/details/104397299
    9 Spring Cloud面试题(2020最新版) https://thinkwon.blog.csdn.net/article/details/104397367
    10 MyBatis面试题(2020最新版) https://thinkwon.blog.csdn.net/article/details/101292950
    11 Redis面试题(2020最新版) https://thinkwon.blog.csdn.net/article/details/103522351
    12 MySQL数据库面试题(2020最新版) https://thinkwon.blog.csdn.net/article/details/104778621
    13 消息中间件MQ与RabbitMQ面试题(2020最新版) https://thinkwon.blog.csdn.net/article/details/104588612
    14 Dubbo面试题(2020最新版) https://thinkwon.blog.csdn.net/article/details/104390006
    15 Linux面试题(2020最新版) https://thinkwon.blog.csdn.net/article/details/104588679
    16 Tomcat面试题(2020最新版) https://thinkwon.blog.csdn.net/article/details/104397665
    17 ZooKeeper面试题(2020最新版) https://thinkwon.blog.csdn.net/article/details/104397719
    18 Netty面试题(2020最新版) https://thinkwon.blog.csdn.net/article/details/104391081
    19 架构设计&分布式&数据结构与算法面试题(2020最新版) https://thinkwon.blog.csdn.net/article/details/105870730

    整理好的MyBatis面试题库,史上最全的MyBatis面试题,MyBatis面试宝典,特此分享给大家

    MyBatis简介

    MyBatis是什么?

    MyBatis 是一款优秀的持久层框架,一个半 ORM(对象关系映射)框架,它支持定制化 SQL、存储过程以及高级映射。MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。MyBatis 可以使用简单的 XML 或注解来配置和映射原生类型、接口和 Java 的 POJO(Plain Old Java Objects,普通老式 Java 对象)为数据库中的记录。

    ORM是什么

    ORM(Object Relational Mapping),对象关系映射,是一种为了解决关系型数据库数据与简单Java对象(POJO)的映射关系的技术。简单的说,ORM是通过使用描述对象和数据库之间映射的元数据,将程序中的对象自动持久化到关系型数据库中。

    为什么说Mybatis是半自动ORM映射工具?它与全自动的区别在哪里?

    Hibernate属于全自动ORM映射工具,使用Hibernate查询关联对象或者关联集合对象时,可以根据对象关系模型直接获取,所以它是全自动的。

    而Mybatis在查询关联对象或关联集合对象时,需要手动编写sql来完成,所以,称之为半自动ORM映射工具。

    传统JDBC开发存在的问题

    • 频繁创建数据库连接对象、释放,容易造成系统资源浪费,影响系统性能。可以使用连接池解决这个问题。但是使用jdbc需要自己实现连接池。
    • sql语句定义、参数设置、结果集处理存在硬编码。实际项目中sql语句变化的可能性较大,一旦发生变化,需要修改java代码,系统需要重新编译,重新发布。不好维护。
    • 使用preparedStatement向占有位符号传参数存在硬编码,因为sql语句的where条件不一定,可能多也可能少,修改sql还要修改代码,系统不易维护。
    • 结果集处理存在重复代码,处理麻烦。如果可以映射成Java对象会比较方便。

    JDBC编程有哪些不足之处,MyBatis是如何解决这些问题的?

    1、数据库链接创建、释放频繁造成系统资源浪费从而影响系统性能,如果使用数据库连接池可解决此问题。

    解决:在mybatis-config.xml中配置数据链接池,使用连接池管理数据库连接。

    2、Sql语句写在代码中造成代码不易维护,实际应用sql变化的可能较大,sql变动需要改变java代码。

    解决:将Sql语句配置在XXXXmapper.xml文件中与java代码分离。

    3、向sql语句传参数麻烦,因为sql语句的where条件不一定,可能多也可能少,占位符需要和参数一一对应。

    解决: Mybatis自动将java对象映射至sql语句。

    4、对结果集解析麻烦,sql变化导致解析代码变化,且解析前需要遍历,如果能将数据库记录封装成pojo对象解析比较方便。

    解决:Mybatis自动将sql执行结果映射至java对象。

    Mybatis优缺点

    优点

    与传统的数据库访问技术相比,ORM有以下优点:

    • 基于SQL语句编程,相当灵活,不会对应用程序或者数据库的现有设计造成任何影响,SQL写在XML里,解除sql与程序代码的耦合,便于统一管理;提供XML标签,支持编写动态SQL语句,并可重用
    • 与JDBC相比,减少了50%以上的代码量,消除了JDBC大量冗余的代码,不需要手动开关连接
    • 很好的与各种数据库兼容(因为MyBatis使用JDBC来连接数据库,所以只要JDBC支持的数据库MyBatis都支持)
    • 提供映射标签,支持对象与数据库的ORM字段关系映射;提供对象关系映射标签,支持对象关系组件维护
    • 能够与Spring很好的集成

    缺点

    • SQL语句的编写工作量较大,尤其当字段多、关联表多时,对开发人员编写SQL语句的功底有一定要求
    • SQL语句依赖于数据库,导致数据库移植性差,不能随意更换数据库

    MyBatis框架适用场景

    • MyBatis专注于SQL本身,是一个足够灵活的DAO层解决方案。
    • 对性能的要求很高,或者需求变化较多的项目,如互联网项目,MyBatis将是不错的选择。

    Hibernate 和 MyBatis 的区别

    相同点

    都是对jdbc的封装,都是持久层的框架,都用于dao层的开发。

    不同点

    映射关系

    • MyBatis 是一个半自动映射的框架,配置Java对象与sql语句执行结果的对应关系,多表关联关系配置简单
    • Hibernate 是一个全表映射的框架,配置Java对象与数据库表的对应关系,多表关联关系配置复杂

    SQL优化和移植性

    • Hibernate 对SQL语句封装,提供了日志、缓存、级联(级联比 MyBatis 强大)等特性,此外还提供 HQL(Hibernate Query Language)操作数据库,数据库无关性支持好,但会多消耗性能。如果项目需要支持多种数据库,代码开发量少,但SQL语句优化困难。
    • MyBatis 需要手动编写 SQL,支持动态 SQL、处理列表、动态生成表名、支持存储过程。开发工作量相对大些。直接使用SQL语句操作数据库,不支持数据库无关性,但sql语句优化容易。

    开发难易程度和学习成本

    • Hibernate 是重量级框架,学习使用门槛高,适合于需求相对稳定,中小型的项目,比如:办公自动化系统

    • MyBatis 是轻量级框架,学习使用门槛低,适合于需求变化频繁,大型的项目,比如:互联网电子商务系统

    总结

    MyBatis 是一个小巧、方便、高效、简单、直接、半自动化的持久层框架,

    Hibernate 是一个强大、方便、高效、复杂、间接、全自动化的持久层框架。

    MyBatis的解析和运行原理

    MyBatis编程步骤是什么样的?

    1、 创建SqlSessionFactory

    2、 通过SqlSessionFactory创建SqlSession

    3、 通过sqlsession执行数据库操作

    4、 调用session.commit()提交事务

    5、 调用session.close()关闭会话

    请说说MyBatis的工作原理

    在学习 MyBatis 程序之前,需要了解一下 MyBatis 工作原理,以便于理解程序。MyBatis 的工作原理如下图

    MyBatis工作原理

    1)读取 MyBatis 配置文件:mybatis-config.xml 为 MyBatis 的全局配置文件,配置了 MyBatis 的运行环境等信息,例如数据库连接信息。

    2)加载映射文件。映射文件即 SQL 映射文件,该文件中配置了操作数据库的 SQL 语句,需要在 MyBatis 配置文件 mybatis-config.xml 中加载。mybatis-config.xml 文件可以加载多个映射文件,每个文件对应数据库中的一张表。

    3)构造会话工厂:通过 MyBatis 的环境等配置信息构建会话工厂 SqlSessionFactory。

    4)创建会话对象:由会话工厂创建 SqlSession 对象,该对象中包含了执行 SQL 语句的所有方法。

    5)Executor 执行器:MyBatis 底层定义了一个 Executor 接口来操作数据库,它将根据 SqlSession 传递的参数动态地生成需要执行的 SQL 语句,同时负责查询缓存的维护。

    6)MappedStatement 对象:在 Executor 接口的执行方法中有一个 MappedStatement 类型的参数,该参数是对映射信息的封装,用于存储要映射的 SQL 语句的 id、参数等信息。

    7)输入参数映射:输入参数类型可以是 Map、List 等集合类型,也可以是基本数据类型和 POJO 类型。输入参数映射过程类似于 JDBC 对 preparedStatement 对象设置参数的过程。

    8)输出结果映射:输出结果类型可以是 Map、 List 等集合类型,也可以是基本数据类型和 POJO 类型。输出结果映射过程类似于 JDBC 对结果集的解析过程。

    MyBatis的功能架构是怎样的

    Mybatis功能框架
    我们把Mybatis的功能架构分为三层:

    • API接口层:提供给外部使用的接口API,开发人员通过这些本地API来操纵数据库。接口层一接收到调用请求就会调用数据处理层来完成具体的数据处理。
    • 数据处理层:负责具体的SQL查找、SQL解析、SQL执行和执行结果映射处理等。它主要的目的是根据调用的请求完成一次数据库操作。
    • 基础支撑层:负责最基础的功能支撑,包括连接管理、事务管理、配置加载和缓存处理,这些都是共用的东西,将他们抽取出来作为最基础的组件。为上层的数据处理层提供最基础的支撑。

    MyBatis的框架架构设计是怎么样的

    Mybatis框架架构

    这张图从上往下看。MyBatis的初始化,会从mybatis-config.xml配置文件,解析构造成Configuration这个类,就是图中的红框。

    (1)加载配置:配置来源于两个地方,一处是配置文件,一处是Java代码的注解,将SQL的配置信息加载成为一个个MappedStatement对象(包括了传入参数映射配置、执行的SQL语句、结果映射配置),存储在内存中。

    (2)SQL解析:当API接口层接收到调用请求时,会接收到传入SQL的ID和传入对象(可以是Map、JavaBean或者基本数据类型),Mybatis会根据SQL的ID找到对应的MappedStatement,然后根据传入参数对象对MappedStatement进行解析,解析后可以得到最终要执行的SQL语句和参数。

    (3)SQL执行:将最终得到的SQL和参数拿到数据库进行执行,得到操作数据库的结果。

    (4)结果映射:将操作数据库的结果按照映射的配置进行转换,可以转换成HashMap、JavaBean或者基本数据类型,并将最终结果返回。

    为什么需要预编译

    1. 定义:
      SQL 预编译指的是数据库驱动在发送 SQL 语句和参数给 DBMS 之前对 SQL 语句进行编译,这样 DBMS 执行 SQL 时,就不需要重新编译。

    2. 为什么需要预编译
      JDBC 中使用对象 PreparedStatement 来抽象预编译语句,使用预编译。预编译阶段可以优化 SQL 的执行。预编译之后的 SQL 多数情况下可以直接执行,DBMS 不需要再次编译,越复杂的SQL,编译的复杂度将越大,预编译阶段可以合并多次操作为一个操作。同时预编译语句对象可以重复利用。把一个 SQL 预编译后产生的 PreparedStatement 对象缓存下来,下次对于同一个SQL,可以直接使用这个缓存的 PreparedState 对象。Mybatis默认情况下,将对所有的 SQL 进行预编译。

    Mybatis都有哪些Executor执行器?它们之间的区别是什么?

    Mybatis有三种基本的Executor执行器,SimpleExecutor、ReuseExecutor、BatchExecutor。

    SimpleExecutor:每执行一次update或select,就开启一个Statement对象,用完立刻关闭Statement对象。

    ReuseExecutor:执行update或select,以sql作为key查找Statement对象,存在就使用,不存在就创建,用完后,不关闭Statement对象,而是放置于Map<String, Statement>内,供下一次使用。简言之,就是重复使用Statement对象。

    BatchExecutor:执行update(没有select,JDBC批处理不支持select),将所有sql都添加到批处理中(addBatch()),等待统一执行(executeBatch()),它缓存了多个Statement对象,每个Statement对象都是addBatch()完毕后,等待逐一执行executeBatch()批处理。与JDBC批处理相同。

    作用范围:Executor的这些特点,都严格限制在SqlSession生命周期范围内。

    Mybatis中如何指定使用哪一种Executor执行器?

    在Mybatis配置文件中,在设置(settings)可以指定默认的ExecutorType执行器类型,也可以手动给DefaultSqlSessionFactory的创建SqlSession的方法传递ExecutorType类型参数,如SqlSession openSession(ExecutorType execType)。

    配置默认的执行器。SIMPLE 就是普通的执行器;REUSE 执行器会重用预处理语句(prepared statements); BATCH 执行器将重用语句并执行批量更新。

    Mybatis是否支持延迟加载?如果支持,它的实现原理是什么?

    Mybatis仅支持association关联对象和collection关联集合对象的延迟加载,association指的就是一对一,collection指的就是一对多查询。在Mybatis配置文件中,可以配置是否启用延迟加载lazyLoadingEnabled=true|false。

    它的原理是,使用CGLIB创建目标对象的代理对象,当调用目标方法时,进入拦截器方法,比如调用a.getB().getName(),拦截器invoke()方法发现a.getB()是null值,那么就会单独发送事先保存好的查询关联B对象的sql,把B查询上来,然后调用a.setB(b),于是a的对象b属性就有值了,接着完成a.getB().getName()方法的调用。这就是延迟加载的基本原理。

    当然了,不光是Mybatis,几乎所有的包括Hibernate,支持延迟加载的原理都是一样的。

    映射器

    #{}和${}的区别

    • #{}是占位符,预编译处理;${}是拼接符,字符串替换,没有预编译处理。

    • Mybatis在处理#{}时,#{}传入参数是以字符串传入,会将SQL中的#{}替换为?号,调用PreparedStatement的set方法来赋值。

    • Mybatis在处理{}时,是原值传入,就是把{}替换成变量的值,相当于JDBC中的Statement编译

    • 变量替换后,#{} 对应的变量自动加上单引号 ‘’;变量替换后,${} 对应的变量不会加上单引号 ‘’

    • #{} 可以有效的防止SQL注入,提高系统安全性;${} 不能防止SQL 注入

    • #{} 的变量替换是在DBMS 中;${} 的变量替换是在 DBMS 外

    模糊查询like语句该怎么写

    (1)’%${question}%’ 可能引起SQL注入,不推荐

    (2)"%"#{question}"%" 注意:因为#{…}解析成sql语句时候,会在变量外侧自动加单引号’ ',所以这里 % 需要使用双引号" ",不能使用单引号 ’ ',不然会查不到任何结果。

    (3)CONCAT(’%’,#{question},’%’) 使用CONCAT()函数,推荐

    (4)使用bind标签

    <select id="listUserLikeUsername" resultType="com.jourwon.pojo.User">
      <bind name="pattern" value="'%' + username + '%'" />
      select id,sex,age,username,password from person where username LIKE #{pattern}
    </select>
    

    在mapper中如何传递多个参数

    方法1:顺序传参法

    public User selectUser(String name, int deptId);
    
    <select id="selectUser" resultMap="UserResultMap">
        select * from user
        where user_name = #{0} and dept_id = #{1}
    </select>
    

    #{}里面的数字代表传入参数的顺序。

    这种方法不建议使用,sql层表达不直观,且一旦顺序调整容易出错。

    方法2:@Param注解传参法

    public User selectUser(@Param("userName") String name, int @Param("deptId") deptId);
    
    <select id="selectUser" resultMap="UserResultMap">
        select * from user
        where user_name = #{userName} and dept_id = #{deptId}
    </select>
    

    #{}里面的名称对应的是注解@Param括号里面修饰的名称。

    这种方法在参数不多的情况还是比较直观的,推荐使用。

    方法3:Map传参法

    public User selectUser(Map<String, Object> params);
    
    <select id="selectUser" parameterType="java.util.Map" resultMap="UserResultMap">
        select * from user
        where user_name = #{userName} and dept_id = #{deptId}
    </select>
    

    #{}里面的名称对应的是Map里面的key名称。

    这种方法适合传递多个参数,且参数易变能灵活传递的情况。

    方法4:Java Bean传参法

    public User selectUser(User user);
    
    <select id="selectUser" parameterType="com.jourwon.pojo.User" resultMap="UserResultMap">
        select * from user
        where user_name = #{userName} and dept_id = #{deptId}
    </select>
    

    #{}里面的名称对应的是User类里面的成员属性。

    这种方法直观,需要建一个实体类,扩展不容易,需要加属性,但代码可读性强,业务逻辑处理方便,推荐使用。

    Mybatis如何执行批量操作

    使用foreach标签

    foreach的主要用在构建in条件中,它可以在SQL语句中进行迭代一个集合。foreach标签的属性主要有item,index,collection,open,separator,close。

    • item  表示集合中每一个元素进行迭代时的别名,随便起的变量名;
    • index  指定一个名字,用于表示在迭代过程中,每次迭代到的位置,不常用;
    • open  表示该语句以什么开始,常用“(”;
    • separator表示在每次进行迭代之间以什么符号作为分隔符,常用“,”;
    • close  表示以什么结束,常用“)”。

    在使用foreach的时候最关键的也是最容易出错的就是collection属性,该属性是必须指定的,但是在不同情况下,该属性的值是不一样的,主要有一下3种情况:

    1. 如果传入的是单参数且参数类型是一个List的时候,collection属性值为list
    2. 如果传入的是单参数且参数类型是一个array数组的时候,collection的属性值为array
    3. 如果传入的参数是多个的时候,我们就需要把它们封装成一个Map了,当然单参数也可以封装成map,实际上如果你在传入参数的时候,在MyBatis里面也是会把它封装成一个Map的,
      map的key就是参数名,所以这个时候collection属性值就是传入的List或array对象在自己封装的map里面的key

    具体用法如下:

    <!-- 批量保存(foreach插入多条数据两种方法)
           int addEmpsBatch(@Param("emps") List<Employee> emps); -->
    <!-- MySQL下批量保存,可以foreach遍历 mysql支持values(),(),()语法 --> //推荐使用
    <insert id="addEmpsBatch">
        INSERT INTO emp(ename,gender,email,did)
        VALUES
        <foreach collection="emps" item="emp" separator=",">
            (#{emp.eName},#{emp.gender},#{emp.email},#{emp.dept.id})
        </foreach>
    </insert>
    
    <!-- 这种方式需要数据库连接属性allowMutiQueries=true的支持
     如jdbc.url=jdbc:mysql://localhost:3306/mybatis?allowMultiQueries=true -->  
    <insert id="addEmpsBatch">
        <foreach collection="emps" item="emp" separator=";">                                 
            INSERT INTO emp(ename,gender,email,did)
            VALUES(#{emp.eName},#{emp.gender},#{emp.email},#{emp.dept.id})
        </foreach>
    </insert>
    

    使用ExecutorType.BATCH

    Mybatis内置的ExecutorType有3种,默认为simple,该模式下它为每个语句的执行创建一个新的预处理语句,单条提交sql;而batch模式重复使用已经预处理的语句,并且批量执行所有更新语句,显然batch性能将更优; 但batch模式也有自己的问题,比如在Insert操作时,在事务没有提交之前,是没有办法获取到自增的id,这在某型情形下是不符合业务要求的

    具体用法如下

    //批量保存方法测试
    @Test  
    public void testBatch() throws IOException{
        SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
        //可以执行批量操作的sqlSession
        SqlSession openSession = sqlSessionFactory.openSession(ExecutorType.BATCH);
    
        //批量保存执行前时间
        long start = System.currentTimeMillis();
        try {
            EmployeeMapper mapper = openSession.getMapper(EmployeeMapper.class);
            for (int i = 0; i < 1000; i++) {
                mapper.addEmp(new Employee(UUID.randomUUID().toString().substring(0, 5), "b", "1"));
            }
    
            openSession.commit();
            long end = System.currentTimeMillis();
            //批量保存执行后的时间
            System.out.println("执行时长" + (end - start));
            //批量 预编译sql一次==》设置参数==》10000次==》执行1次   677
            //非批量  (预编译=设置参数=执行 )==》10000次   1121
    
        } finally {
            openSession.close();
        }
    }
    

    mapper和mapper.xml如下

    public interface EmployeeMapper {   
        //批量保存员工
        Long addEmp(Employee employee);
    }
    
    <mapper namespace="com.jourwon.mapper.EmployeeMapper"
         <!--批量保存员工 -->
        <insert id="addEmp">
            insert into employee(lastName,email,gender)
            values(#{lastName},#{email},#{gender})
        </insert>
    </mapper>
    

    如何获取生成的主键

    对于支持主键自增的数据库(MySQL)

    <insert id="insertUser" useGeneratedKeys="true" keyProperty="userId" >
        insert into user( 
        user_name, user_password, create_time) 
        values(#{userName}, #{userPassword} , #{createTime, jdbcType= TIMESTAMP})
    </insert>
    

    parameterType 可以不写,Mybatis可以推断出传入的数据类型。如果想要访问主键,那么应当parameterType 应当是java实体或者Map。这样数据在插入之后 可以通过ava实体或者Map 来获取主键值。通过 getUserId获取主键

    不支持主键自增的数据库(Oracle)

    对于像Oracle这样的数据,没有提供主键自增的功能,而是使用序列的方式获取自增主键。
    可以使用<selectKey>标签来获取主键的值,这种方式不仅适用于不提供主键自增功能的数据库,也适用于提供主键自增功能的数据库
    <selectKey>一般的用法

    <selectKey keyColumn="id" resultType="long" keyProperty="id" order="BEFORE">
    </selectKey> 
    
    属性 描述
    keyProperty selectKey 语句结果应该被设置的目标属性。如果希望得到多个生成的列,也可以是逗号分隔的属性名称列表。
    keyColumn 匹配属性的返回结果集中的列名称。如果希望得到多个生成的列,也可以是逗号分隔的属性名称列表。
    resultType 结果的类型,MyBatis 通常可以推算出来。MyBatis 允许任何简单类型用作主键的类型,包括字符串。如果希望作用于多个生成的列,则可以使用一个包含期望属性的 Object 或一个 Map。
    order 值可为BEFORE 或 AFTER。如果是 BEFORE,那么它会先执行selectKey设置 keyProperty 然后执行插入语句。如果为AFTER则相反。
    statementType 使用何种语句类型,默认PREPARED。 有STATEMENT,PREPARED 和 CALLABLE 语句的映射类型。
    <insert id="insertUser" >
    	<selectKey keyColumn="id" resultType="long" keyProperty="userId" order="BEFORE">
    		SELECT USER_ID.nextval as id from dual 
    	</selectKey> 
    	insert into user( 
    	user_id,user_name, user_password, create_time) 
    	values(#{userId},#{userName}, #{userPassword} , #{createTime, jdbcType= TIMESTAMP})
    </insert>
    

    此时会将Oracle生成的主键值赋予userId变量。这个userId 就是USER对象的属性,这样就可以将生成的主键值返回了。如果仅仅是在insert语句中使用但是不返回,此时keyProperty=“任意自定义变量名”,resultType 可以不写。
    Oracle 数据库中的值要设置为 BEFORE ,这是因为 Oracle中需要先从序列获取值,然后将值作为主键插入到数据库中。

    扩展
    如果Mysql 使用selectKey的方式获取主键,需要注意下面两点:

    order : AFTER
    获取递增主键值 :SELECT LAST_INSERT_ID()

    当实体类中的属性名和表中的字段名不一样 ,怎么办

    第1种: 通过在查询的SQL语句中定义字段名的别名,让字段名的别名和实体类的属性名一致。

    <select id="getOrder" parameterType="int" resultType="com.jourwon.pojo.Order">
           select order_id id, order_no orderno ,order_price price form orders where order_id=#{id};
    </select>
    

    第2种: 通过<resultMap>来映射字段名和实体类属性名的一一对应的关系。

    <select id="getOrder" parameterType="int" resultMap="orderResultMap">
    	select * from orders where order_id=#{id}
    </select>
    
    <resultMap type="com.jourwon.pojo.Order" id="orderResultMap">
        <!–用id属性来映射主键字段–>
        <id property="id" column="order_id">
    
        <!–用result属性来映射非主键字段,property为实体类属性名,column为数据库表中的属性–>
        <result property ="orderno" column ="order_no"/>
        <result property="price" column="order_price" />
    </reslutMap>
    

    Mapper 编写有哪几种方式?

    第一种:接口实现类继承 SqlSessionDaoSupport:使用此种方法需要编写mapper 接口,mapper 接口实现类、mapper.xml 文件。

    (1)在 sqlMapConfig.xml 中配置 mapper.xml 的位置

    <mappers>
        <mapper resource="mapper.xml 文件的地址" />
        <mapper resource="mapper.xml 文件的地址" />
    </mappers>
    

    (2)定义 mapper 接口

    (3)实现类集成 SqlSessionDaoSupport

    mapper 方法中可以 this.getSqlSession()进行数据增删改查。

    (4)spring 配置

    <bean id=" " class="mapper 接口的实现">
        <property name="sqlSessionFactory"
        ref="sqlSessionFactory"></property>
    </bean>
    

    第二种:使用 org.mybatis.spring.mapper.MapperFactoryBean:

    (1)在 sqlMapConfig.xml 中配置 mapper.xml 的位置,如果 mapper.xml 和mappre 接口的名称相同且在同一个目录,这里可以不用配置

    <mappers>
        <mapper resource="mapper.xml 文件的地址" />
        <mapper resource="mapper.xml 文件的地址" />
    </mappers>
    

    (2)定义 mapper 接口:

    (3)mapper.xml 中的 namespace 为 mapper 接口的地址

    (4)mapper 接口中的方法名和 mapper.xml 中的定义的 statement 的 id 保持一致

    (5)Spring 中定义

    <bean id="" class="org.mybatis.spring.mapper.MapperFactoryBean">
        <property name="mapperInterface" value="mapper 接口地址" />
        <property name="sqlSessionFactory" ref="sqlSessionFactory" />
    </bean>
    

    第三种:使用 mapper 扫描器:

    (1)mapper.xml 文件编写:

    mapper.xml 中的 namespace 为 mapper 接口的地址;

    mapper 接口中的方法名和 mapper.xml 中的定义的 statement 的 id 保持一致;

    如果将 mapper.xml 和 mapper 接口的名称保持一致则不用在 sqlMapConfig.xml中进行配置。

    (2)定义 mapper 接口:

    注意 mapper.xml 的文件名和 mapper 的接口名称保持一致,且放在同一个目录

    (3)配置 mapper 扫描器:

    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="mapper 接口包地址
        "></property>
        <property name="sqlSessionFactoryBeanName"
        value="sqlSessionFactory"/>
    </bean>
    

    (4)使用扫描器后从 spring 容器中获取 mapper 的实现对象。

    什么是MyBatis的接口绑定?有哪些实现方式?

    接口绑定,就是在MyBatis中任意定义接口,然后把接口里面的方法和SQL语句绑定,我们直接调用接口方法就可以,这样比起原来了SqlSession提供的方法我们可以有更加灵活的选择和设置。

    接口绑定有两种实现方式

    通过注解绑定,就是在接口的方法上面加上 @Select、@Update等注解,里面包含Sql语句来绑定;

    通过xml里面写SQL来绑定, 在这种情况下,要指定xml映射文件里面的namespace必须为接口的全路径名。当Sql语句比较简单时候,用注解绑定, 当SQL语句比较复杂时候,用xml绑定,一般用xml绑定的比较多。

    使用MyBatis的mapper接口调用时有哪些要求?

    1、Mapper接口方法名和mapper.xml中定义的每个sql的id相同。

    2、Mapper接口方法的输入参数类型和mapper.xml中定义的每个sql 的parameterType的类型相同。

    3、Mapper接口方法的输出参数类型和mapper.xml中定义的每个sql的resultType的类型相同。

    4、Mapper.xml文件中的namespace即是mapper接口的类路径。

    最佳实践中,通常一个Xml映射文件,都会写一个Dao接口与之对应,请问,这个Dao接口的工作原理是什么?Dao接口里的方法,参数不同时,方法能重载吗

    Dao接口,就是人们常说的Mapper接口,接口的全限名,就是映射文件中的namespace的值,接口的方法名,就是映射文件中MappedStatement的id值,接口方法内的参数,就是传递给sql的参数。Mapper接口是没有实现类的,当调用接口方法时,接口全限名+方法名拼接字符串作为key值,可唯一定位一个MappedStatement,举例:com.mybatis3.mappers.StudentDao.findStudentById,可以唯一找到namespace为com.mybatis3.mappers.StudentDao下面id = findStudentById的MappedStatement。在Mybatis中,每一个<select><insert><update><delete>标签,都会被解析为一个MappedStatement对象。

    Dao接口里的方法,是不能重载的,因为是全限名+方法名的保存和寻找策略。

    Dao接口的工作原理是JDK动态代理,Mybatis运行时会使用JDK动态代理为Dao接口生成代理proxy对象,代理对象proxy会拦截接口方法,转而执行MappedStatement所代表的sql,然后将sql执行结果返回。

    Mybatis的Xml映射文件中,不同的Xml映射文件,id是否可以重复?

    不同的Xml映射文件,如果配置了namespace,那么id可以重复;如果没有配置namespace,那么id不能重复;毕竟namespace不是必须的,只是最佳实践而已。

    原因就是namespace+id是作为Map<String, MappedStatement>的key使用的,如果没有namespace,就剩下id,那么,id重复会导致数据互相覆盖。有了namespace,自然id就可以重复,namespace不同,namespace+id自然也就不同。

    简述Mybatis的Xml映射文件和Mybatis内部数据结构之间的映射关系?

    答:Mybatis将所有Xml配置信息都封装到All-In-One重量级对象Configuration内部。在Xml映射文件中,<parameterMap>标签会被解析为ParameterMap对象,其每个子元素会被解析为ParameterMapping对象。<resultMap>标签会被解析为ResultMap对象,其每个子元素会被解析为ResultMapping对象。每一个<select><insert><update><delete>标签均会被解析为MappedStatement对象,标签内的sql会被解析为BoundSql对象。

    Mybatis是如何将sql执行结果封装为目标对象并返回的?都有哪些映射形式?

    第一种是使用<resultMap>标签,逐一定义列名和对象属性名之间的映射关系。

    第二种是使用sql列的别名功能,将列别名书写为对象属性名,比如T_NAME AS NAME,对象属性名一般是name,小写,但是列名不区分大小写,Mybatis会忽略列名大小写,智能找到与之对应对象属性名,你甚至可以写成T_NAME AS NaMe,Mybatis一样可以正常工作。

    有了列名与属性名的映射关系后,Mybatis通过反射创建对象,同时使用反射给对象的属性逐一赋值并返回,那些找不到映射关系的属性,是无法完成赋值的。

    Xml映射文件中,除了常见的select|insert|updae|delete标签之外,还有哪些标签?

    还有很多其他的标签,<resultMap><parameterMap><sql><include><selectKey>,加上动态sql的9个标签,trim|where|set|foreach|if|choose|when|otherwise|bind等,其中<sql>为sql片段标签,通过<include>标签引入sql片段,<selectKey>为不支持自增的主键生成策略标签。

    Mybatis映射文件中,如果A标签通过include引用了B标签的内容,请问,B标签能否定义在A标签的后面,还是说必须定义在A标签的前面?

    虽然Mybatis解析Xml映射文件是按照顺序解析的,但是,被引用的B标签依然可以定义在任何地方,Mybatis都可以正确识别。

    原理是,Mybatis解析A标签,发现A标签引用了B标签,但是B标签尚未解析到,尚不存在,此时,Mybatis会将A标签标记为未解析状态,然后继续解析余下的标签,包含B标签,待所有标签解析完毕,Mybatis会重新解析那些被标记为未解析的标签,此时再解析A标签时,B标签已经存在,A标签也就可以正常解析完成了。

    高级查询

    MyBatis实现一对一,一对多有几种方式,怎么操作的?

    有联合查询和嵌套查询。联合查询是几个表联合查询,只查询一次,通过在resultMap里面的association,collection节点配置一对一,一对多的类就可以完成

    嵌套查询是先查一个表,根据这个表里面的结果的外键id,去再另外一个表里面查询数据,也是通过配置association,collection,但另外一个表的查询通过select节点配置。

    Mybatis是否可以映射Enum枚举类?

    Mybatis可以映射枚举类,不单可以映射枚举类,Mybatis可以映射任何对象到表的一列上。映射方式为自定义一个TypeHandler,实现TypeHandler的setParameter()和getResult()接口方法。

    TypeHandler有两个作用,一是完成从javaType至jdbcType的转换,二是完成jdbcType至javaType的转换,体现为setParameter()和getResult()两个方法,分别代表设置sql问号占位符参数和获取列查询结果。

    动态SQL

    Mybatis动态sql是做什么的?都有哪些动态sql?能简述一下动态sql的执行原理不?

    Mybatis动态sql可以让我们在Xml映射文件内,以标签的形式编写动态sql,完成逻辑判断和动态拼接sql的功能,Mybatis提供了9种动态sql标签trim|where|set|foreach|if|choose|when|otherwise|bind。

    其执行原理为,使用OGNL从sql参数对象中计算表达式的值,根据表达式的值动态拼接sql,以此来完成动态sql的功能。

    插件模块

    Mybatis是如何进行分页的?分页插件的原理是什么?

    Mybatis使用RowBounds对象进行分页,它是针对ResultSet结果集执行的内存分页,而非物理分页,可以在sql内直接书写带有物理分页的参数来完成物理分页功能,也可以使用分页插件来完成物理分页。

    分页插件的基本原理是使用Mybatis提供的插件接口,实现自定义插件,在插件的拦截方法内拦截待执行的sql,然后重写sql,根据dialect方言,添加对应的物理分页语句和物理分页参数。

    举例:select * from student,拦截sql后重写为:select t.* from (select * from student) t limit 0, 10

    简述Mybatis的插件运行原理,以及如何编写一个插件。

    Mybatis仅可以编写针对ParameterHandler、ResultSetHandler、StatementHandler、Executor这4种接口的插件,Mybatis使用JDK的动态代理,为需要拦截的接口生成代理对象以实现接口方法拦截功能,每当执行这4种接口对象的方法时,就会进入拦截方法,具体就是InvocationHandler的invoke()方法,当然,只会拦截那些你指定需要拦截的方法。

    实现Mybatis的Interceptor接口并复写intercept()方法,然后在给插件编写注解,指定要拦截哪一个接口的哪些方法即可,记住,别忘了在配置文件中配置你编写的插件。

    缓存

    Mybatis的一级、二级缓存

    1)一级缓存: 基于 PerpetualCache 的 HashMap 本地缓存,其存储作用域为 Session,当 Session flush 或 close 之后,该 Session 中的所有 Cache 就将清空,默认打开一级缓存。

    2)二级缓存与一级缓存其机制相同,默认也是采用 PerpetualCache,HashMap 存储,不同在于其存储作用域为 Mapper(Namespace),并且可自定义存储源,如 Ehcache。默认不打开二级缓存,要开启二级缓存,使用二级缓存属性类需要实现Serializable序列化接口(可用来保存对象的状态),可在它的映射文件中配置<cache/>

    3)对于缓存数据更新机制,当某一个作用域(一级缓存 Session/二级缓存Namespaces)的进行了C/U/D 操作后,默认该作用域下所有 select 中的缓存将被 clear。

    展开全文
  • 面试 SQL整理 常见的SQL面试题:经典50题

    万次阅读 多人点赞 2019-09-12 22:16:11
    常见的SQL面试题:经典50题 三、50道面试题 2.汇总统计分组分析 3.复杂查询 sql面试题:topN问题 4.多表查询 【面试题类型总结】这类题目属于行列如何互换,解题思路如下: 其他面试题: SQL基础知识整理...

     

    目录

    SQL基础知识整理:

    常见的SQL面试题:经典50题

    三、50道面试题

     

    2.汇总统计分组分析

    3.复杂查询

    sql面试题:topN问题

    4.多表查询

    【面试题类型总结】这类题目属于行列如何互换,解题思路如下:

    其他面试题:



    preview

    SQL基础知识整理:

    select 查询结果    如: [学号,平均成绩:组函数avg(成绩)]
    from 从哪张表中查找数据   如:[涉及到成绩:成绩表score]
    where 查询条件    如:[b.课程号='0003' and b.成绩>80]
    group by 分组    如:[每个学生的平均:按学号分组](oracle,SQL server中出现在select 子句后的非分组函数,必须出现                                                                                        在group by子句后出现),MySQL中可以不用
    having 对分组结果指定条件    如:[大于60分]
    order by 对查询结果排序    如:[增序: 成绩  ASC / 降序: 成绩 DESC];

    limit   使用limt子句返回topN(对应这个问题返回的成绩前两名)如:[ limit  2 ==>从0索引开始读取2个]
    limit==>从0索引开始 [0,N-1]

    ① select * from table limit 2,1;                
    
    //含义是跳过2条取出1条数据,limit后面是从第2条开始读,读取1条信息,即读取第3条数据
    
    ② select * from table limit 2 offset 1;     
    
    //含义是从第1条(不包括)数据开始取出2条数据,limit后面跟的是2条数据,offset后面是从第1条开始读取,即读取第2,3条

     

    组函数: 去重 distinct()  统计总数sum()   计算个数count()  平均数avg()  最大值max() 最小数min() 

    多表连接: 内连接(省略默认inner) join ...on..左连接left join tableName ason a.key ==b.key右连接right join  连接union(无重复(过滤去重))和union all(有重复[不过滤去重])

    --union 并集
    --union all(有重复)

    oracle(SQL server)数据库

    --intersect 交集 
    --minus(except) 相减(差集)

    oracle

    一、数据库对象: 表(table)  视图(view)  序列(sequence)  索引(index)  同义词(synonym)

    1. 视图: 存储起来的 select 语句
    create view emp_vw
    as
    select employee_id, last_name, salary
    from employees
    where department_id = 90;

    select * from emp_vw;

    --可以对简单视图进行 DML 操作
    update emp_vw
    set last_name = 'HelloKitty'
    where employee_id = 100;

    select * from employees
    where employee_id = 100;

    1). 复杂视图
    create view emp_vw2
    as
    select department_id, avg(salary) avg_sal
    from employees
    group by department_id;

    select * from emp_vw2;

    --复杂视图不能进行 DML 操作
    update emp_vw2
    set avg_sal = 10000
    where department_id = 100;

    2. 序列:用于生成一组有规律的数值。(通常用于为主键设置值)
    create sequence emp_seq1
    start with 1
    increment by 1
    maxvalue 10000
    minvalue 1
    cycle
    nocache;

    select emp_seq1.currval from dual;

    select emp_seq1.nextval from dual;

    --问题:裂缝 .  原因:①当多个表共用同一个序列时。  ②rollback  ③发生异常
    create table emp1(
           id number(10),
           name varchar2(30)
    );

    insert into emp1
    values(emp_seq1.nextval, '张三');

    select * from emp1;

    3. 索引:提高查询效率
    --自动创建:Oracle 会为具有唯一约束(唯一约束,主键约束)的列,自动创建索引
    create table emp2(
           id number(10) primary key,
           name varchar2(30)
    )

    --手动创建
    create index emp_idx
    on emp2(name);

    create index emp_idx2
    on emp2(id, name);

    4. 同义词
    create synonym d1 for departments;

    select * from d1;

    5. 表:
    DDL :数据定义语言 create table .../ drop table ... / rename ... to..../ truncate table.../alter table ...
    DML : 数据操纵语言

    insert into ... values ...
    update ... set ... where ...
    delete from ... where ...

    【重要】
    select ... 组函数(MIN()/MAX()/SUM()/AVG()/COUNT())
    from ...join ... on ... 左外连接:left join ... on ... 右外连接: right join ... on ...
    where ... 
    group by ...
    (oracle,SQL server中出现在select 子句后的非分组函数,必须出现在 group by子句后)
    having ... 用于过滤 组函数
    order by ... asc 升序, desc 降序

    limit (0,4) 限制N条数据 如: topN数据

    --union 并集
    --union all(有重复)
    --intersect 交集 
    --minus 相减

    DCL : 数据控制语言  commit : 提交 / rollback : 回滚 / 授权grant...to...  /revoke 

     

     

     

    索引

    何时创建索引:

     

    一、
    select employee_id, last_name, salary, department_id
    from employees
    where department_id in (70, 80) --> 70:1  80:34
    --union 并集
    --union all(有重复部分)
    --intersect 交集 
    --minus 相减

    select employee_id, last_name, salary, department_id
    from employees
    where department_id in (80, 90)  --> 90:4  80:34


    --问题:查询工资大于149号员工工资的员工的信息
    select * 
    from employees
    where salary > (
          select salary
          from employees
          where employee_id = 149
    )

    --问题:查询与141号或174号员工的manager_id和department_id相同的其他员工的
    --employee_id, manager_id, department_id  
    select employee_id, manager_id, department_id
    from employees
    where manager_id in (
          select manager_id
          from employees
          where employee_id in(141, 174)
    ) and department_id in (
          select department_id
          from employees
          where employee_id in(141, 174)
    ) and employee_id not in (141, 174);

    select employee_id, manager_id, department_id
    from employees
    where (manager_id, department_id) in (
          select manager_id, department_id
          from employees
          where employee_id in (141, 174)
    ) and employee_id not in(141, 174);

    --1. from 子句中使用子查询
    select max(avg(salary))
    from employees
    group by department_id;

    select max(avg_sal)
    from (
          select avg(salary) avg_sal
          from employees
          group by department_id
    ) e

    --问题:返回比本部门平均工资高的员工的last_name, department_id, salary及平均工资

    select last_name, department_id, salary, (select avg(salary) from employees where department_id = e1.department_id)
    from employees e1
    where salary > (
          select avg(salary)
          from employees e2
          where e1.department_id = e2.department_id
    )

    select last_name, e1.department_id, salary, avg_sal
    from employees e1, (
         select department_id, avg(salary) avg_sal
         from employees
         group by department_id
    ) e2
    where e1.department_id = e2.department_id
    and e1.salary > e2.avg_sal;


    --case...when ... then... when ... then ... else ... end 
    --查询:若部门为10 查看工资的 1.1 倍,部门号为 20 工资的1.2倍,其余 1.3 倍
    select employee_id, last_name, salary, case department_id when 10 then salary * 1.1
                                                              when 20 then salary * 1.2
                                                              else salary * 1.3
                                                              end "new_salary"
    from employees;

    select employee_id, last_name, salary, decode(department_id, 10, salary * 1.1,
                                                                 20, salary * 1.2,
                                                                 salary * 1.3) "new_salary"
    from employees;


    --问题:显式员工的employee_id,last_name和location。其中,若员工
    --department_id与location_id为1800的department_id相同,则location为’Canada’,其余则为’USA’。
    select employee_id, last_name, case department_id when (
                        select department_id
                        from departments
                        where location_id = 1800
    ) then 'Canada' else 'USA' end "location"
    from employees;

    --问题:查询员工的employee_id,last_name,要求按照员工的department_name排序
    select employee_id, last_name
    from employees e1
    order by (
          select department_name
          from departments d1
          where e1.department_id = d1.department_id
    )

    -- SQL 优化:能使用 EXISTS 就不要使用 IN

    --问题:查询公司管理者的employee_id,last_name,job_id,department_id信息
    select employee_id, last_name, job_id, department_id
    from employees
    where employee_id in (
          select manager_id
          from employees
    )


    select employee_id, last_name, job_id, department_id
    from employees e1
    where exists (
          select 'x'
          from employees e2
          where e1.employee_id = e2.manager_id

    -- 问题:查询departments表中,不存在于employees表中的部门的department_id和department_name
    select department_id, department_name
    from departments d1
    where not exists (
          select 'x'
          from employees e1
          where e1.department_id = d1.department_id
    )

    --55. 更改 108 员工的信息: 使其工资变为所在部门中的最高工资, job 变为公司中平均工资最低的 job
        
    update employees e1
    set salary = (
        select max(salary)
        from employees e2
        where e1.department_id = e2.department_id
    ), job_id = (
       select job_id
       from employees
       group by job_id
       having avg(salary) = (
             select min(avg(salary))
             from employees
             group by job_id
       )
    )
    where employee_id = 108;
        
    --56. 删除 108 号员工所在部门中工资最低的那个员工.
    delete from employees e1
    where salary = (
          select min(salary)
          from employees
          where department_id = (
                select department_id
                from employees
                where employee_id = 108
          )
    )

    select * from employees where employee_id = 108;
    select * from employees where department_id = 100
    order by salary;

    rollback;

     

    常见的SQL面试题:经典50题

    ========================================================

    已知有如下4张表:

    学生表:student(学号,学生姓名,出生年月,性别)

    成绩表:score(学号,课程号,成绩)

    课程表:course(课程号,课程名称,教师号)

    教师表:teacher(教师号,教师姓名)

     

    根据以上信息按照下面要求写出对应的SQL语句。

    ps:这些题考察SQL的编写能力,对于这类型的题目,需要你先把4张表之间的关联关系搞清楚了,最好的办法是自己在草稿纸上画出关联图,然后再编写对应的SQL语句就比较容易了。下图是我画的这4张表的关系图,可以看出它们之间是通过哪些外键关联起来的:

     

    一、创建数据库和表

    为了演示题目的运行过程,我们先按下面语句在客户端navicat中创建数据库和表。

    (如何你还不懂什么是数据库,什么是客户端navicat,可以先学习这个:

    1.创建表

    1)创建学生表(student)

    按下图在客户端navicat里创建学生表

     

    学生表的“学号”列设置为主键约束,下图是每一列设置的数据类型和约束

    创建完表,点击“保存”

    2)创建成绩表(score)

    同样的步骤,创建"成绩表“。“课程表的“学号”和“课程号”一起设置为主键约束(联合主键),“成绩”这一列设置为数值类型(float,浮点数值)

    3)创建课程表(course)

    课程表的“课程号”设置为主键约束

    4)教师表(teacher)

    教师表的“教师号”列设置为主键约束,

    教师姓名这一列设置约束为“null”(红框的地方不勾选),表示这一列允许包含空值(null)

     

    2.向表中添加数据

    1)向学生表里添加数据

    添加数据的sql

    insert into student(学号,姓名,出生日期,性别) 
    values('0001' , '猴子' , '1989-01-01' , '男');
    
    insert into student(学号,姓名,出生日期,性别) 
    values('0002' , '猴子' , '1990-12-21' , '女');
    
    insert into student(学号,姓名,出生日期,性别) 
    values('0003' , '马云' , '1991-12-21' , '男');
    
    insert into student(学号,姓名,出生日期,性别) 
    values('0004' , '王思聪' , '1990-05-20' , '男');

    在客户端navicat里的操作

    2)成绩表(score)

    添加数据的sql

    insert into score(学号,课程号,成绩) 
    values('0001' , '0001' , 80);
    
    insert into score(学号,课程号,成绩) 
    values('0001' , '0002' , 90);
    
    insert into score(学号,课程号,成绩) 
    values('0001' , '0003' , 99);
    
    insert into score(学号,课程号,成绩) 
    values('0002' , '0002' , 60);
    
    insert into score(学号,课程号,成绩) 
    values('0002' , '0003' , 80);
    
    insert into score(学号,课程号,成绩) 
    values('0003' , '0001' , 80);
    
    insert into score(学号,课程号,成绩) 
    values('0003' , '0002' , 80);
    
    insert into score(学号,课程号,成绩) 
    values('0003' , '0003' , 80);

    客户端navicat里的操作

    3)课程表

    添加数据的sql

    insert into course(课程号,课程名称,教师号)
    values('0001' , '语文' , '0002');
    
    insert into course(课程号,课程名称,教师号)
    values('0002' , '数学' , '0001');
    
    insert into course(课程号,课程名称,教师号)
    values('0003' , '英语' , '0003');

    客户端navicat里的操作

    4)教师表里添加数据

    添加数据的sql

    -- 教师表:添加数据
    insert into teacher(教师号,教师姓名) 
    values('0001' , '孟扎扎');
    
    insert into teacher(教师号,教师姓名) 
    values('0002' , '马化腾');
    
    -- 这里的教师姓名是空值(null)
    insert into teacher(教师号,教师姓名) 
    values('0003' , null);
    
    -- 这里的教师姓名是空字符串('')
    insert into teacher(教师号,教师姓名) 
    values('0004' , '');

    客户端navicat里操作

    添加结果

     

    三、50道面试题

    为了方便学习,我将50道面试题进行了分类

     

    查询姓“猴”的学生名单

    查询姓“孟”老师的个数

    select count(教师号)
    from teacher
    where 教师姓名 like '孟%';

     

    2.汇总统计分组分析

    面试题:查询课程编号为“0002”的总成绩

    *
    分析思路
    select 查询结果 [总成绩:汇总函数sum]
    from 从哪张表中查找数据[成绩表score]
    where 查询条件 [课程号是0002]
    */
    select sum(成绩)
    from score
    where 课程号 = '0002';

    查询选了课程的学生人数

    /*
    这个题目翻译成大白话就是:查询有多少人选了课程
    select 学号,成绩表里学号有重复值需要去掉
    from 从课程表查找score;
    */
    select count(distinct 学号) as 学生人数 
    from score;

    查询各科成绩最高和最低的分, 以如下的形式显示:课程号,最高分,最低分

    /*
    分析思路
    select 查询结果 [课程ID:是课程号的别名,最高分:max(成绩) ,最低分:min(成绩)]
    from 从哪张表中查找数据 [成绩表score]
    where 查询条件 [没有]
    group by 分组 [各科成绩:也就是每门课程的成绩,需要按课程号分组];
    */
    select 课程号,max(成绩) as 最高分,min(成绩) as 最低分
    from score
    group by 课程号;

    查询每门课程被选修的学生数

    /*
    分析思路
    select 查询结果 [课程号,选修该课程的学生数:汇总函数count]
    from 从哪张表中查找数据 [成绩表score]
    where 查询条件 [没有]
    group by 分组 [每门课程:按课程号分组];
    */
    select 课程号, count(学号)
    from score
    group by 课程号;

    查询男生、女生人数

    /*
    分析思路
    select 查询结果 [性别,对应性别的人数:汇总函数count]
    from 从哪张表中查找数据 [性别在学生表中,所以查找的是学生表student]
    where 查询条件 [没有]
    group by 分组 [男生、女生人数:按性别分组]
    having 对分组结果指定条件 [没有]
    order by 对查询结果排序[没有];
    */
    select 性别,count(*)
    from student
    group by 性别;

    查询平均成绩大于60分学生的学号和平均成绩

    /* 
    题目翻译成大白话:
    平均成绩:展开来说就是计算每个学生的平均成绩
    这里涉及到“每个”就是要分组了
    平均成绩大于60分,就是对分组结果指定条件
    
    分析思路
    select 查询结果 [学号,平均成绩:汇总函数avg(成绩)]
    from 从哪张表中查找数据 [成绩在成绩表中,所以查找的是成绩表score]
    where 查询条件 [没有]
    group by 分组 [平均成绩:先按学号分组,再计算平均成绩]
    having 对分组结果指定条件 [平均成绩大于60分]
    */
    select 学号, avg(成绩)
    from score
    group by 学号
    having avg(成绩)>60;

    查询至少选修两门课程的学生学号

    /* 
    翻译成大白话:
    第1步,需要先计算出每个学生选修的课程数据,需要按学号分组
    第2步,至少选修两门课程:也就是每个学生选修课程数目>=2,对分组结果指定条件
    
    分析思路
    select 查询结果 [学号,每个学生选修课程数目:汇总函数count]
    from 从哪张表中查找数据 [课程的学生学号:课程表score]
    where 查询条件 [至少选修两门课程:需要先计算出每个学生选修了多少门课,需要用分组,所以这里没有where子句]
    group by 分组 [每个学生选修课程数目:按课程号分组,然后用汇总函数count计算出选修了多少门课]
    having 对分组结果指定条件 [至少选修两门课程:每个学生选修课程数目>=2]
    */
    select 学号, count(课程号) as 选修课程数目
    from score
    group by 学号
    having count(课程号)>=2;

    查询同名同性学生名单并统计同名人数

    /* 
    翻译成大白话,问题解析:
    1)查找出姓名相同的学生有谁,每个姓名相同学生的人数
    查询结果:姓名,人数
    条件:怎么算姓名相同?按姓名分组后人数大于等于2,因为同名的人数大于等于2
    分析思路
    select 查询结果 [姓名,人数:汇总函数count(*)]
    from 从哪张表中查找数据 [学生表student]
    where 查询条件 [没有]
    group by 分组 [姓名相同:按姓名分组]
    having 对分组结果指定条件 [姓名相同:count(*)>=2]
    order by 对查询结果排序[没有];
    */
    
    select 姓名,count(*) as 人数
    from student
    group by 姓名
    having count(*)>=2;

    查询不及格的课程并按课程号从大到小排列

    /* 
    分析思路
    select 查询结果 [课程号]
    from 从哪张表中查找数据 [成绩表score]
    where 查询条件 [不及格:成绩 <60]
    group by 分组 [没有]
    having 对分组结果指定条件 [没有]
    order by 对查询结果排序[课程号从大到小排列:降序desc];
    */
    select 课程号
    from score 
    where 成绩<60
    order by 课程号 desc;

    查询每门课程的平均成绩,结果按平均成绩升序排序,平均成绩相同时,按课程号降序排列

    /* 
    分析思路
    select 查询结果 [课程号,平均成绩:汇总函数avg(成绩)]
    from 从哪张表中查找数据 [成绩表score]
    where 查询条件 [没有]
    group by 分组 [每门课程:按课程号分组]
    having 对分组结果指定条件 [没有]
    order by 对查询结果排序[按平均成绩升序排序:asc,平均成绩相同时,按课程号降序排列:desc];
    */
    select 课程号, avg(成绩) as 平均成绩
    from score
    group by 课程号
    order by 平均成绩 asc,课程号 desc;

    检索课程编号为“0004”且分数小于60的学生学号,结果按按分数降序排列

    /* 
    分析思路
    select 查询结果 []
    from 从哪张表中查找数据 [成绩表score]
    where 查询条件 [课程编号为“04”且分数小于60]
    group by 分组 [没有]
    having 对分组结果指定条件 []
    order by 对查询结果排序[查询结果按按分数降序排列];
    */
    select 学号
    from score
    where 课程号='04' and 成绩 <60
    order by 成绩 desc;

    统计每门课程的学生选修人数(超过2人的课程才统计)

    要求输出课程号和选修人数,查询结果按人数降序排序,若人数相同,按课程号升序排序

    /* 
    分析思路
    select 查询结果 [要求输出课程号和选修人数]
    from 从哪张表中查找数据 []
    where 查询条件 []
    group by 分组 [每门课程:按课程号分组]
    having 对分组结果指定条件 [学生选修人数(超过2人的课程才统计):每门课程学生人数>2]
    order by 对查询结果排序[查询结果按人数降序排序,若人数相同,按课程号升序排序];
    */
    select 课程号, count(学号) as '选修人数'
    from score
    group by 课程号
    having count(学号)>2
    order by count(学号) desc,课程号 asc;

    查询两门以上不及格课程的同学的学号及其平均成绩

    /*
    分析思路
    先分解题目:
    1)[两门以上][不及格课程]限制条件
    2)[同学的学号及其平均成绩],也就是每个学生的平均成绩,显示学号,平均成绩
    分析过程:
    第1步:得到每个学生的平均成绩,显示学号,平均成绩
    第2步:再加上限制条件:
    1)不及格课程
    2)两门以上[不及格课程]:课程数目>2
    
    
    /* 
    第1步:得到每个学生的平均成绩,显示学号,平均成绩
    select 查询结果 [学号,平均成绩:汇总函数avg(成绩)]
    from 从哪张表中查找数据 [涉及到成绩:成绩表score]
    where 查询条件 [没有]
    group by 分组 [每个学生的平均:按学号分组]
    having 对分组结果指定条件 [没有]
    order by 对查询结果排序[没有];
    */
    select 学号, avg(成绩) as 平均成绩
    from score
    group by 学号;
    
    
    /* 
    第2步:再加上限制条件:
    1)不及格课程
    2)两门以上[不及格课程]
    select 查询结果 [学号,平均成绩:汇总函数avg(成绩)]
    from 从哪张表中查找数据 [涉及到成绩:成绩表score]
    where 查询条件 [限制条件:不及格课程,平均成绩<60]
    group by 分组 [每个学生的平均:按学号分组]
    having 对分组结果指定条件 [限制条件:课程数目>2,汇总函数count(课程号)>2]
    order by 对查询结果排序[没有];
    */
    select 学号, avg(成绩) as 平均成绩
    from score
    where 成绩 <60
    group by 学号
    having count(课程号)>=2;

    如果上面题目不会做,可以复习这部分涉及到的sql知识:

    3.复杂查询

    查询所有课程成绩小于60分学生的学号、姓名

    【知识点】子查询
    
    1.翻译成大白话
    1)查询结果:学生学号,姓名
    2)查询条件:所有课程成绩 < 60 的学生,需要从成绩表里查找,用到子查询
    
    第1步,写子查询(所有课程成绩 < 60 的学生)
    select 查询结果[学号]
    from 从哪张表中查找数据[成绩表:score]
    where 查询条件[成绩 < 60]
    group by 分组[没有]
    having 对分组结果指定条件[没有]
    order by 对查询结果排序[没有]
    limit 从查询结果中取出指定行[没有];
    
    select 学号 
    from score
    where 成绩 < 60;
    
    第2步,查询结果:学生学号,姓名,条件是前面1步查到的学号
    
    select 查询结果[学号,姓名]
    from 从哪张表中查找数据[学生表:student]
    where 查询条件[用到运算符in]
    group by 分组[没有]
    having 对分组结果指定条件[没有]
    order by 对查询结果排序[没有]
    limit 从查询结果中取出指定行[没有];
    */
    select 学号,姓名
    from student
    where  学号 in (
    select 学号 
    from score
    where 成绩 < 60
    );

    查询没有学全所有课的学生的学号、姓名|

    /*
    查找出学号,条件:没有学全所有课,也就是该学生选修的课程数 < 总的课程数
    【考察知识点】in,子查询
    */
    select 学号,姓名
    from student
    where 学号 in(
    select 学号 
    from score
    group by 学号
    having count(课程号) < (select count(课程号) from course)
    );

    查询出只选修了两门课程的全部学生的学号和姓名|

    select 学号,姓名
    from student
    where 学号 in(
    select 学号
    from score
    group by 学号
    having count(课程号)=2
    );

    1990年出生的学生名单

    /*
    查找1990年出生的学生名单
    学生表中出生日期列的类型是datetime
    */
    select 学号,姓名 
    from student 
    where year(出生日期)=1990; 
    

    查询各科成绩前两名的记录

    这类问题其实就是常见的:分组取每组最大值、最小值,每组最大的N条(top N)记录。

    sql面试题:topN问题

    工作中会经常遇到这样的业务问题:

    • 如何找到每个类别下用户最喜欢的产品是哪个?
    • 如果找到每个类别下用户点击最多的5个商品是什么?

     

    这类问题其实就是常见的:分组取每组最大值、最小值,每组最大的N条(top N)记录。

     

    面对该类问题,如何解决呢?

     

    下面我们通过成绩表的例子来给出答案。

     

    成绩表是学生的成绩,里面有学号(学生的学号),课程号(学生选修课程的课程号),成绩(学生选修该课程取得的成绩)

     

     

    • 分组取每组最大值

     

    案例:按课程号分组取成绩最大值所在行的数据

     

    我们可以使用分组(group by)和汇总函数得到每个组里的一个值(最大值,最小值,平均值等)。但是无法得到成绩最大值所在行的数据。

     

    select 课程号,max(成绩) as 最大成绩from score group by 课程号;

     

    我们可以使用关联子查询来实现:

     

    select * from score as a where 成绩 = (select max(成绩) from score as b where b.课程号 = a.课程号);

     

     

    上面查询结果课程号“0001”有2行数据,是因为最大成绩80有2个

     

    • 分组取每组最小值

     

    案例:按课程号分组取成绩最小值所在行的数据

     

    同样的使用关联子查询来实现

    select * from score as a where 成绩 = (select min(成绩) from score as b where b.课程号 = a.课程号);

     

     

     

    • 每组最大的N条记录

     

    案例:查询各科成绩前两名的记录

     

    第1步,查出有哪些组

    我们可以按课程号分组,查询出有哪些组,对应这个问题里就是有哪些课程号

    select 课程号,max(成绩) as 最大成绩from score group by 课程号;

     

     

    第2步:先使用order by子句按成绩降序排序(desc),然后使用limt子句返回topN(对应这个问题返回的成绩前两名)

    -- 课程号'0001' 这一组里成绩前2名select * from score where 课程号 = '0001' order by 成绩  desc limit 2;

    同样的,可以写出其他组的(其他课程号)取出成绩前2名的sql

     

    第3步,使用union all 将每组选出的数据合并到一起

    -- 左右滑动可以可拿到全部sql(select * from score where 课程号 = '0001' order by 成绩  desc limit 2)union all(select * from score where 课程号 = '0002' order by 成绩  desc limit 2)union all(select * from score where 课程号 = '0003' order by 成绩  desc limit 2);

     

     

    前面我们使用order by子句按某个列降序排序(desc)得到的是每组最大的N个记录。如果想要达到每组最小的N个记录,将order by子句按某个列升序排序(asc)即可。

     

    求topN的问题还可以使用自定义变量来实现,这个在后续再介绍。

     

    如果对多表合并还不了解的,可以看下我讲过的《从零学会SQL》的“多表查询”。

     

     

     

    • 总结

    常见面试题:分组取每组最大值、最小值,每组最大的N条(top N)记录。

    4.多表查询

    查询所有学生的学号、姓名、选课数、总成绩

    selecta.学号,a.姓名,count(b.课程号) as 选课数,sum(b.成绩) as 总成绩
    from student as a left join score as b
    on a.学号 = b.学号
    group by a.学号;

    查询平均成绩大于85的所有学生的学号、姓名和平均成绩

    select a.学号,a.姓名, avg(b.成绩) as 平均成绩
    from student as a left join score as b
    on a.学号 = b.学号
    group by a.学号
    having avg(b.成绩)>85;

    查询学生的选课情况:学号,姓名,课程号,课程名称

    select a.学号, a.姓名, c.课程号,c.课程名称
    from student a inner join score b on a.学号=b.学号
    inner join course c on b.课程号=c.课程号;

    查询出每门课程的及格人数和不及格人数

    -- 考察case表达式
    select 课程号,
    sum(case when 成绩>=60 then 1 
    	 else 0 
        end) as 及格人数,
    sum(case when 成绩 <  60 then 1 
    	 else 0 
        end) as 不及格人数
    from score
    group by 课程号;

    使用分段[100-85],[85-70],[70-60],[<60]来统计各科成绩,分别统计:各分数段人数,课程号和课程名称

    -- 考察case表达式
    select a.课程号,b.课程名称,
    sum(case when 成绩 between 85 and 100 
    	 then 1 else 0 end) as '[100-85]',
    sum(case when 成绩 >=70 and 成绩<85 
    	 then 1 else 0 end) as '[85-70]',
    sum(case when 成绩>=60 and 成绩<70  
    	 then 1 else 0 end) as '[70-60]',
    sum(case when 成绩<60 then 1 else 0 end) as '[<60]'
    from score as a right join course as b 
    on a.课程号=b.课程号
    group by a.课程号,b.课程名称;

    查询课程编号为0003且课程成绩在80分以上的学生的学号和姓名|

    select a.学号,a.姓名
    from student  as a inner join score as b on a.学号=b.学号
    where b.课程号='0003' and b.成绩>80;

    下面是学生的成绩表(表名score,列名:学号、课程号、成绩)

    使用sql实现将该表行转列为下面的表结构

    【面试题类型总结】这类题目属于行列如何互换,解题思路如下:

    【面试题】下面是学生的成绩表(表名score,列名:学号、课程号、成绩)

     

     

    使用sql实现将该表行转列为下面的表结构

     

     

    【解答】

     

    第1步,使用常量列输出目标表的结构

    可以看到查询结果已经和目标表非常接近了

     

    select 学号,'课程号0001','课程号0002','课程号0003'from score;

     

     

    第2步,使用case表达式,替换常量列为对应的成绩

    select 学号,(case 课程号 when '0001' then 成绩 else 0 end) as '课程号0001',(case 课程号 when '0002' then 成绩 else 0 end) as  '课程号0002',(case 课程号 when '0003' then 成绩 else 0 end) as '课程号0003'from score;

     

     

    在这个查询结果中,每一行表示了某个学生某一门课程的成绩。比如第一行是'学号0001'选修'课程号00001'的成绩,而其他两列的'课程号0002'和'课程号0003'成绩为0。

     

    每个学生选修某门课程的成绩在下图的每个方块内。我们可以通过分组,取出每门课程的成绩。

     

     

    第3关,分组

    分组,并使用最大值函数max取出上图每个方块里的最大值

    select 学号,max(case 课程号 when '0001' then 成绩 else 0 end) as '课程号0001',max(case 课程号 when '0002' then 成绩 else 0 end) as '课程号0002',max(case 课程号 when '0003' then 成绩 else 0 end) as '课程号0003'from scoregroup by 学号;

     

    这样我们就得到了目标表(行列互换)

     

    其他面试题:

    https://blog.csdn.net/u010565545/article/details/100786293

     

    展开全文
  • java面试题大全

    万次阅读 多人点赞 2018-02-05 17:55:40
    面试题部分! SSH框架面试题集锦 网易2017春招笔试真题编程题集合题解 面试进行曲之技术面试(项目经验) Java面试题-基础篇一 Java面试题-基础篇二 Java面试题-集合框架篇三
    展开全文
  • 消息中间件MQ与RabbitMQ面试题(2020最新版)

    万次阅读 多人点赞 2020-03-01 11:11:21
    文章目录为什么使用MQ?MQ的优点消息队列有什么优缺点?RabbitMQ有什么优缺点?你们公司生产环境用的是什么消息中间件?Kafka、ActiveMQ、RabbitMQ、RocketMQ 有什么优缺点?MQ 有哪些常见问题?...
  • 2020年前端面试题及答案

    万次阅读 多人点赞 2020-02-11 19:29:34
    前端面试汇总(2020年) 一 大纲 1、前言 2、前端工程化 3、前端设计模式 ...8、*前端基础知识点面试题 ...由于新冠肺炎疫情,现在成天呆在家里,加上也要准备面试,就在家里看面试题...
  • Spring Boot面试题(2020最新版)

    万次阅读 多人点赞 2020-02-19 17:48:42
    文章目录概述什么是 Spring Boot?Spring Boot 有哪些优点?Spring Boot 的核心注解是哪个?它主要由哪几个注解组成的?配置什么是 JavaConfig?Spring Boot 自动配置原理是什么?你如何理解 Spring Boot 配置加载...
  • SpringCloud面试题(一)

    万次阅读 多人点赞 2019-04-24 22:16:30
    SpringCloud面试题(一) 大家好,我是酷酷的韩~下面提供一些整理的springcloud面试题 一.微服务的优点缺点?说下开发项目中遇到的坑? 优点: 1.每个服务直接足够内聚,代码容易理解 2.开发效率高,一个服务只做一件事...
  • 最新Java面试题,常见面试题及答案汇总

    万次阅读 多人点赞 2019-07-12 08:56:55
    Java最新面试题面试题答案汇总
  • 计算机复试面试题总结

    万次阅读 多人点赞 2019-03-07 20:06:56
    面试问题之编程语言 1。C++的特点是什么? 封装,继承,多态。支持面向对象和面向过程的开发。 2.C++的异常处理机制? 抛出异常和捕捉异常进行处理。(实际开发) 3.c和c++,java的区别? c是纯过程,c++是对象...
  • 2020最新Java常见面试题及答案

    万次阅读 多人点赞 2019-10-26 15:53:35
    Java最新常见面试题 + 答案汇总 1、面试题模块汇总 面试题包括以下十九个模块:Java 基础、容器、多线程、反射、对象拷贝、Java Web 模块、异常、网络、设计模式、Spring/Spring MVC、Spring Boot/Spring Cloud、...
  • Spring常见面试题总结(超详细回答)

    万次阅读 多人点赞 2018-07-08 15:36:08
    1、Spring是什么? Spring是一个轻量级的IoC和AOP容器框架。是为Java应用程序提供基础性服务的一套框架,目的是用于简化企业应用程序的开发,它使得开发者只需要关心业务需求。常见的配置方式有三种:基于XML的配置...
  • Mybatis常见面试题总结

    万次阅读 多人点赞 2018-07-09 21:29:01
    1、什么是Mybatis? (1)Mybatis是一个半ORM(对象关系映射)框架,它内部封装了JDBC,开发时只需要关注SQL语句本身,不需要花费精力去处理加载驱动、创建连接、创建statement等繁杂的过程。程序员直接编写原生态...
  • Java 最常见的 200+ 面试题:面试必备

    万次阅读 多人点赞 2019-07-10 17:41:50
    这份面试清单是从我 2015 年做了 TeamLeader 之后开始收集的,一方面是给公司招聘用,另一方面是想用它来挖掘在 Java 技术栈中,还有那些知识点是我不知道的,我想找到这些技术盲点,然后修复它,以此来提高自己的...
  • 常见JVM面试题及答案整理

    万次阅读 多人点赞 2019-08-26 11:35:04
    总结了JVM一些经典面试题,分享出我自己的解题思路,希望对大家有帮助,有哪里你觉得不正确的话,欢迎指出,后续有空会更新。 1.什么情况下会发生栈内存溢出。 思路: 描述栈定义,再描述为什么会溢出,再说明一下...
  • 面试题总结 —— JAVA高级工程师

    万次阅读 多人点赞 2016-03-03 12:03:31
    面试题总结——JAVA高级工程师 近期考虑换工作的问题,于是投简历面试,面试5家公司的高级Java工程师,有4家给了我offer,想着总结一下面试经验,方便最近正在寻求机会的你们 一、无笔试题 不知道是不是职位...
  • Java面试题内容聚合

    万次阅读 多人点赞 2019-07-31 11:45:18
    为了不在面试中吃亏,面试前突击多看看面试题还是狠有必要的。这是一份常见Java面试题分类汇总,希望对大家有用! 初级面试题 Java面试题-基础篇一 Java面试题-基础篇二 Java面试题-集合框架篇三 Java面试...
  • Spring MVC面试题(2020最新版)

    万次阅读 多人点赞 2020-02-19 17:54:38
    文章目录概述什么是Spring MVC?简单介绍下你对Spring MVC的理解?Spring MVC的优点核心组件Spring MVC的主要组件?什么是DispatcherServlet什么是Spring MVC框架的控制器?Spring MVC的控制器是不是单例模式,如果是...
  • Java基础问题整理: 1.HashMap1.7与HashMap1.8的区别,从数据结构上、Hash值的计算上、链表数据的插入方法、内部Entry类的实现上分析? 2.Hash1.7是基于数组和链表实现的,为什么不用双链表?...

空空如也

1 2 3 4 5 ... 20
收藏数 276,746
精华内容 110,698
关键字:

面试题