面试总结

1.arrayList底层实现、linkedList的底层实现、hashmap的底层实现 
ArrayList底层是数组

 public static void main(String[] args) {  
        List list=new ArrayList();  
        list.add("王利虎");  
        list.add("张三");  
        list.add("李四");  
        int size=list.size();  
        String[] array=new String[size];  
        for(int i=0;i<list.size();i++){  
            array[i]=(String)list.get(i);  
        }  
        for(int i=0;i<array.length;i++){  
            System.out.println(array[i]);  
        }  
    }  

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14

linkedList底层是链表

 private static class Node<E> {
　　　　//业务数据
        E item;
　　　　//指向下个node
        Node<E> next;
　　　　//指向上个node
        Node<E> prev;
        Node(Node<E> prev, E element, Node<E> next) {
            this.item = element;
            this.next = next;
            this.prev = prev;
        }
    }

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13

hashmap底层是数组+链表

import Collection.TestLinkedList;

/*
 * 自定义实现Map功能（底层：数组+链表）
 * Map:存放键值对，根据键找值
 * 目的仅为更加了解该结构、编码部分不考虑细节
 * 注意注释部分
 * */
class Entry<K, V> {
    K Key;
    V Value;

    public Entry(K key, V value) {
        super();
        Key = key;
        Value = value;
    }

}

public class RealizeMap<K, V, E> {
    @SuppressWarnings("unchecked")
    TestLinkedList<Entry<K, V>> arr[] = new TestLinkedList[165];
    int size;

    RealizeMap() {
        size = 0;
    }

    public void put(K key, V value) {
        // 注意不能漏了->处理键值覆盖
        Entry<K, V> e = new Entry<>(key, value);
        int hash = key.hashCode() % 165;
        if (arr[hash] == null) {
            TestLinkedList<Entry<K, V>> list = new TestLinkedList<>();
            arr[hash] = list;
            list.addLast(e);
        }else {
            for(int i=0;i<arr[hash].size;i++) {
                Entry<K, V> E = arr[hash].get(i);//由于E在此取义为该链表键对应节点的地址，所以直接改E即可覆盖之
                if(E.Key.equals(key)) {
                    E.Value = value;
                    return;
                }
            }
            arr[hash].addLast(e);
        }
    }

    public V get(K key) {
        int hash = key.hashCode();
        if (arr[hash] != null) {
            for (int i = 0; i < arr[hash].size; i++) {
                if (arr[hash].get(i).Key.equals(key))
                    return arr[hash].get(i).Value;
            }
        }
        return null;
    }

    public static void main(String[] args) {
        RealizeMap<String, String, Entry<String, String>> map = new RealizeMap<>();
        map.put("1", "张三");
        map.put("2", "李四");
        map.put("2", "黎明");
        map.put("3", "王五");
        map.put("4", "马六");
        System.out.println(map.get("2"));
    }

}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44
• 45
• 46
• 47
• 48
• 49
• 50
• 51
• 52
• 53
• 54
• 55
• 56
• 57
• 58
• 59
• 60
• 61
• 62
• 63
• 64
• 65
• 66
• 67
• 68
• 69
• 70
• 71

2.描述线程池搭建

2.1利用java.util.concurrent包提供了现成的线程池实现ThreadPoolExecutor

2.2Spring中的线程池是由ThreadPoolTaskExecutor类来实现的。该类的实现原理最终也是调 
用了java中的ThreadPoolExecutor类中的一些方法。具体的实现读者可以自己去翻阅 
Spring的源码，这里笔者就不罗列了。我们看下ThreadPoolTaskExecutor的初始化。 
ThreadPoolTaskExecutor有两种常用的有两种初始化方式：xml配置，java代码初始化 
xml配置：

<bean id="taskExecutor" 
class="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor">
<property name="corePoolSize" value="5" />
<property name="keepAliveSeconds" value="200" />
<property name="maxPoolSize" value="10" />
<property name="queueCapacity" value="20" />
<property name="rejectedExecutionHandler">
<bean class="java.util.concurrent.ThreadPoolExecutor$CallerRunsPolicy" />
</property>
</bean>

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10

看过上面的内容，读者应该很清楚上面的一些参数代表的意思了吧。笔

public MyThreadPoolTaskExecutor {
@Autowired
private ThreadPoolTaskExecutor taskExecutor;

　private void test(){
　　taskExecutor.execute(new Runnable(){
　　　　@Override
　　　　public void run() {
　　　　　//执行的代码
　　　　}});
　　}
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12

Java代码初始化：

private void test2(){
　　ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
　　executor.setCorePoolSize(10);
　　executor.setMaxPoolSize(15);
　　executor.setKeepAliveSeconds(1);
　　executor.setQueueCapacity(5);
　　executor.setRejectedExecutionHandler(new 

ThreadPoolExecutor.CallerRunsPolicy());
　　executor.initialize();
　　executor.execute(new Runnable(){
　　　　@Override
　　　　public void run() {
　　　　　　//执行的代码
　　　　}
　　});
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17

3.get与post的区别

3.1GET后退按钮/刷新无害，POST数据会被重新提交（浏览器应该告知用户数据会被重新提交）。 
3.2GET书签可收藏，POST为书签不可收藏。GET能被缓存，POST不能缓存 。GET编码类型application/x-www-form-url，POST编码类型encodedapplication/x-www-form-urlencoded 或 multipart/form-data。为二进制数据使用多重编码。 
3.3GET历史参数保留在浏览器历史中。POST参数不会保存在浏览器历史中。GET对数据长度有限制，当发送数据时GET 方法向 URL 添加数据；URL 的长度是受限制的（URL 的最大长度是 2048 个字符）。 
3.4POST无限制。GET只允许 ASCII 字符。POST没有限制。也允许二进制数据。 
3.5POST 相比，GET 的安全性较差。

4.ajax同步异步的关键字 
jquery的async:false,这个属性 
默认是true：异步，false：同步 
5.xml的头有什么作用 
ML文档必须以<?xml version="1.0"?>开头，否则XML解析器将无法识别该XML文档 
xml作用是用来spring xml配置 
6.线程安全 
ArrayList、Vector 
synchronized、volition 、lock 互斥锁 
8.创建线程几种方式

一、继承Thread类创建线程类
（1）定义Thread类的子类，并重写该类的run方法，该run方法的方法体就代表了线程要完
成的任务。因此把run()方法称为执行体。
（2）创建Thread子类的实例，即创建了线程对象。
（3）调用线程对象的start()方法来启动该
二、通过Runnable接口创建线程类
（1）定义runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样
是该线程的线程执行体。
（2）创建 Runnable实现类的实例，并依此实例作为Thread的target来创建Thread对象，
该Thread对象才是真正的线程对象。
（3）调用线程对象的start()方法来启动该线程。
三、通过Callable和Future创建线程
（1）创建Callable接口的实现类，并实现call()方法，该call()方法将作为线程执行体，
并且有返回值。
（2）创建Callable实现类的实例，使用FutureTask类来包装Callable对象，该FutureTask
对象封装了该Callable对象的call()方法的返回值。
（3）使用FutureTask对象作为Thread对象的target创建并启动新线程。
（4）调用FutureTask对象的get()方法来获得子线程执行结束后的返回值。

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18

9.mybatis的流程 
1.创建数据库 
2.配置mybatis配置文件xml 
3.创建model实体类以及mapper的xml 
4.创建回话工厂与sqlsession回话 
5.创建service与实现service接口的实现类 
调用sql语句进行映射对象、通过对象传参进行。 
或者数据或者对数据库进行增删改查。 
10.主从数据库的搭建叙述 
1.保证数据版本一样 
其中核心就是BINLOG需要开启 并设置serverID的值 
然后用cp命令将主数据库复制到从数据库、接着修改从数据库的my.cof增加serverID 制定 
复制用户 主数据库服务器id 短裤 用户名 密码 
启动进行验证 show salve status验证 
进行更新等操作验证数据库。 
11.单例模式 深层 
懒汉

比较懒、在类加载时、不创建实例、因此类加载速度快、但是运行时获取对象的速度慢 
饿汉 
在类加载时就完成来了初始化、所以类加载较慢、但获取对象的速度快 
内部静态类 枚举 双重校验锁 
如果线程安全选择 双重校验锁 
类加载机制 
java虚拟机把描述类的数据从Class文件加载到内存，并对数据进行校验、转换解析和初始 
化，最终形成可以被虚拟机直接使用的Java类型，这就是虚拟机的加载机制

12.rabbitMQ的实现原理与过程 
消息队列 生产者 mq相当于一个仓库 消费者 
先导入jar包、rabbitmq相关依赖、序列化相关依赖 
创建连接到rabbitmq 设置主机名 创建一个连接 创建一个频道 一个队列 
13.数据库函数 
BEGIN 
写SQL语句 
END 
14.gradle与maven区别 
maven使用者转投gradle的怀抱，和Gradle相比，ant显得冗余复杂，maven显得有些死板落 
后，而gradle基于DSL语法，特点明显：简洁、灵活、可读性强。 
16.mysql limit 从0开始的n 
17.spring mvc与spring boot的区别 
Spring Boot实现了自动配置，降低了项目搭建的复杂度 
Spring MVC提供了一种轻度耦合的方式来开发web应用、Spring MVC是Spring的一个模块， 
式一个web框架。通过Dispatcher Servlet, ModelAndView 和 View Resolver，开发web应 
用变得很容易。解决的问题领域是网站应用程序或者服务开发——URL路由、Session、模 
板引擎、静态Web资源等等 
Spring 是一个“引擎”； 
Spring MVC 是基于Spring的一个 MVC 框架 ； 
Spring Boot 是基于Spring4的条件注册的一套快速开发整合包； 
18.liunx 操作 ls cd mkdir cp rm locate q！回车 vim