博客主页： 明天会更好fjy
欢迎点赞 收藏 ⭐留言 欢迎讨论！
本文由 【明天会更好fjy】 原创，首发于 CSDN
由于博主是在学小白一枚，难免会有错误，有任何问题欢迎评论区留言指出，感激不尽！
P9:
1、为什么要使用Elasticsearch?1、横向可扩展性好、只需要增加服务器，简单配置，启动进程就可以并入集群；
2、提供更好的分布式特性、同一个索引分成多个分片（sharding）(勺儿定)，分而治提升处理效率
3、扩展性很强，各种规模的公司都可以选用，根据自己的数据规模选择集群的大小，并且有合理的分布式架构，单个计算节点宕机不会造成整体系统的崩溃
4、可以根据不同的需求方便地定制各类查询，使用简单或者高级的ranking(温儿根)策略；
第一步、客户写集群某节点写入数据，发送请求
第二步、协调节点收到请求后，确定所属分片，分配存储节点
第三步、存储节点写入成功后，请求副本分片节点，都写入成功之后，存储节点向协调节点报告成功，协调节点返回客户端成功
1、删除和更新也都是写 *** 作，但是 Elasticsearch 中的文档是不可变的，因此不
能被删除或者改动以展示其变更；
2、在文档被创建时，ES会为该文档指定一个版本号，当执行更新时，旧版本的文档在.del 文
*件中被标记为删除，新版本的文档被索引到一个新段。旧版本的文档依然能匹配查询，但是会在结果中被过滤掉。删除同理
1、搜索被执行成一个两阶段过程，我们称之为 Query Then Fetch(范迟)；
2、在初始查询阶段时，查询会广播到每个索引的主分片或者副本分片。搜索并构建一个优先队列。
3、每个分片返回各自优先队列中 所有文档的 ID 和排序值 给协调节点来合并结果列表。
4、协调节点将结果列表中的ID对应的文档取回，返回结果给客户端。
Elasticsearch 提供的首个近似聚合是 cardinality(康它耐了锤) 度量。它提供一个字段的基数，
即该字段的 distinct(地斯定次) 或者 unique(尤尼克) 值的数目。它是基于 HLL 算法的。HLL 会先对
我们的输入作哈希运算，然后根据哈希运算的结果中的 bits(遍斯) 做概率估算从而得到
基数。其特点是、可配置的精度，用来控制内存的使用（更精确 ＝ 更多内存）；
小的数据集精度是非常高的；我们可以通过配置参数，来设置去重需要的固定内
存使用量。无论数千还是数十亿的唯一值，内存使用量只与你配置的精确度相关。
整体使用版本号机制的乐观锁来控制；
对于写 *** 作，默认为只有当大多数分片可用时才允许写 *** 作。但即使大多数可用，也可能存在因为网络等原因导致写入副本失败，分片将会在一个不同的节点上重建直到成功。
对于读 *** 作，可以设置副本为同步状态(默认)，就是当主副分片都完成后才会返回；如果设置副本为异步时，也可以通过参数设置来只查询主分片，确定查询最新数据。
群集：是一个或多个节点（服务器）的集合，提供跨所有节点的联合索引和搜索功能。群集有唯一名称标识，其他节点根据这个名称加入集群
节点：是属于集群一部分的单个服务器。它存储数据并参与群集索引和搜索功能。
索引：相当于MySQL的“数据库”。可以设置分片以及副本信息。
类型：相当于MySQL的“表”，类型过多会导致索引混乱，ES7.0之后就不建议使用了，在ES8.0版本中会完全删除这个概念
文档：就相当一MySQL中的一行数据
分片是一个索引库的所有数据存放的存储空间，由于ES是分布式存储的，一个索引库的文档数据可以设置分布在许多分片中，而不是集中存在一起，同时每个分片还可以设置对应副本数来备份数据，保障整体数据高可用
1、ES的选主是 ZenDiscovery(然地克喂Z) 模块负责，首先配置每个节点是否可能成为master节点，当ZenDiscovery 通过ping发现多数节点认为当前没有master(迈斯特)的时候，发起选举
2、选举时，把所有能做master的节点根据节点id字典排序，选出第一个节点暂定为主节点
3、然后再发起投票，票数过半并且该节点自己也选举自己，那这个节点就是 master。
ls、查看当前目录文件
ll：可以显示当前目录的详细信息 比如创建修改时间 大小 类型等
Pwd、显示当前路径
cd、进入目录
mkdir、创建文件夹
touch、创建文件
rm、删除文件，删除文件夹需要加 -r
mv、剪切、重命名
cp、复制
clear、清除窗口信息
cat、查看文件内容
find、查找文件
1、通过top -c 命令找出当前的进程列表，接着按P（大写）可以按照CPU使用率排序，然后找到进程对应使用率高的进程ID
2、然后通过top -Hp 进程PID列举出当前进程的所有线程，按P（大写）排序，找到对应线程的PID，转为16进制备用
3、然后通过jstack(一斯达克) -l 线程PID > 文件，导出线程快照到这个文件里
4、然后通过grep命令查找文件中这个16进制线程PID的行为进行分析
systemctl status(斯达的斯) 服务名 某个服务的当前状态
systemctl start/stop/restart(喂斯到它)/reload(喂烙它) 服务名 启动/停止/重启/重新加载某个服务
systemctl is-enabled(恩尼博它) 服务名 查看服务是否被设为开机自启动
systemctl enable(恩尼博) 服务名 设置服务设为开机自启动
systemctl disable 服务名 设置服务设开机不自动启用
一般都是百度搜或者查看自己的博客。也可以使用 ‘man 命令名称’ 查看这个命令的使用手册，会有很详细的说明
1、通过 mvn package(潘根此)命令将web项目打包成war包，然后上传服务器。
2、war包项目，将文件传输到linux上的tomcat的webapps(宛博斯)文件夹，然后重启tomcat。
3、jar包项目，将文件传输到linux上之后，还需要通过nohup(诺胡普) java -jar 文件名.jar。来后台启动这个jar包
1、查看日志可以使用less(莱斯)命令，打开文件、 less 文件名，进入文件后，
输入冒号斜线、/ ，直接输入搜索的内容，回车即可。定位到内容可以按上下页查看附近的内容。
2、如果只是查看日志中是否存在某关键信息，使用grep '搜索的内容' --color(扣勒) 文件名称，可以输出到数据所在行
1、异步处理、有些业务不需要立即执行的，就可以把消息放入队列，然后在处理，这样可以不影响主线程运行
2、应用解耦
降低模块之间的耦合度，提升项目的扩展性。
3、流量削峰
应用可能会因为流量过大导致挂掉，所以一般这类前端请求都会加入消息队列。在秒杀场景中经常见到
1、持久化设置、 设置交换机持久化、队列持久化、 消息持久化
2、ACK确认机制、是消费端消费完成要通知服务端，服务端才把消息从内存删除。
3、设置集群镜像模式
4、消息补偿机制、根据状态字段进行补偿，发送完成和接收完成都要对状态做出变更，定时任务检测超时没有接收的或者接收失败的，重新发送。
1、rabbitmq中提供了事物和confirm(肯否儿)的机制，事物就类似于数据库的事物，开启，执行，提交，如果过程中发生任何异常，就会触发回滚机制，我们可以在回滚中加入一些逻辑处理，重新发送或者日志记录
2、配置生产者确认的机制，就是在消息发送之后，该消息会被指定唯一的ID，如果有消息成功被交换机转发到队列之后，mq会给生产者发送ack确认，如果没有队列接收消息，那么会发送错误回执消息给生产者，生产者可以尝试重试发送，或者日志记录
1、在消息生产时，MQ 内部针对每条生产者发送的消息生成一个 消息id，作为去重的依据，避免重复的消息进入队列；
2、在消息消费时，要求消息体中必须要有一个业务id作为去重的依据，避免同一条消息被重复消费。
优点： 解耦、异步、削峰
缺点：
1、需要保证高可用、MQ若是挂了，容易引起整个服务挂掉
2、系统复杂性增加、需要保证让消息可靠的传递、消息正确的被消费等问题
1、注册的时候，注册信息入库之后，即可返回前台成功，调用短信通知、邮件通知、其他初始化 *** 作的时候，都可以通过MQ异步通知对应服务进行 *** 作
2、秒杀的时候，用户请求后，生成唯一ID放到消息队列中即可，然后返回前台处理成功，请等待系统结果，秒杀系统通过MQ处理之后，短息通知用户，或者前台定时请求处理结果即可
发送消息的时候，会给消息指定routing(软定) key，可以理解为一个标识，每个队列也会有一个自己的routing key，交换机在收到消息后，会把消息发送给routing key匹配的队列中
常用的交换机主要分为一下三种、
fanout(范闹它)、如果交换器收到消息，会把消息发送给所有队列
direct(地软它)、如果routing key完全匹配相应的队列
topic(套呗k)、指定的routing key可以支持通配符，一个消息可以被发给多个匹配的队列
简单模式、工作模式、广播模式、路由模式、通配符模式
ActiveMQ(阿跌夫)基于jms协议，java开发，强在MQ领域所有想要的功能，基本都有，开箱即用。
rabbitMQ(软呗它)基于AMQP协议开发的，使用erlang(二兰)语言开发，重在基于内存，性能很高。
抽象、抽象是将一类对象的共同特征总结出来构造类的过程，包括数据抽象和行为抽象两方面。抽象只关注对象有哪些属性和行为，并不关注这些行为的细节是什么。
封装、通常认为封装是把数据和 *** 作数据的方法绑定起来，对数据的访问只能通过已定义的接口。
继承、继承是从已有类得到继承信息创建新类的过程。被继承的类被称为父类；继承的类被称为子类
多态、多态性是指允许不同子类的对象对同一行为作出不同的响应。
1、反射是指在运行状态中，可以获取任意一个类象的所有信息以及动态调用其中方法、构造器的机制。
2、一般都是使用Class clazz=Class.forName("类的全路径")这个方法，获取到class对象，然后通过该class对象获取到类中所有的method(迈斯的)方法、属性，调用Method的invoke(因否克)方法就可以执行该方法，但是如果是私有方法的话，必须通过getDeclaredMethod(甘它抠尔迈斯的)获取，还需要调用方法的setAccessible(艾克赛斯包)设置为true才可以执行。
List中有：
ArrayList:底层实现是数组，查询快，增删慢，线程不安全，效率高，每次扩容为当前容量的1.5倍+1；
Vector:底层实现是数组，查询快，增删慢，线程安全，效率低，扩容机制为翻倍；
linkedList:底层实现是双向链表，增删快，查询慢，线程不安全，效率高；
Set 中有：
HashSet:无序不可重复,底层使用Hash表实现，存取速度快。
linkedHashSet:采用hash表存储，使用双向链表记录插入顺序
Map中有：
HashMap、key重复则覆盖原有的value，底层使用数组+链表实现，jdk1.8以后加入了红黑树，线程不安全，key和value都允许为null
HashTable:key重复则覆盖原有的value，底层使用数组+链表实现，jdk1.8以后加入了红黑树，线程安全，key和value都不允许为null
一、Throwable(次了包)、
1、Error(诶而):重大的问题，我们处理不了。也不需要编写代码处理。比如说内存溢出。
2、Exception:一般性的错误，是需要我们编写代码进行处理的。
(1)RuntimeException(软它没):运行时异常。
(2)NullPointerException(培它) 空指针异常，最常遇到
(3)ArrayIndexOutOfBoundsException 下标越界异常
(4)IndexOutOfBoundsException 索引越界异常。当访问某个序列的索引值小于0或大于等于序列大小时，抛出该异常。
(5) SQLException sql异常 非常熟悉的错误信息就是Unknown(嗯闹) column xxx，这种错误的话，就是列名错了，还有就是 You have an error in your SQL syntax(森坦克斯),check(才克) xxxx near(尼而) xxx，这个错误就是sql语法错误，异常信息会指出来错误的具体地方
(6)检查异常/编译异常 、 对于检查的异常必须处理，可以采用捕获或抛出式解决
(7)ClassNotFoundException 类找不到异常
(8)FileNotFound 文件找不到异常，在文件 *** 作的时候，一不小心路径写错了，或者是windows切换linux的时候，因为路径格式不一致，经常会有这个错误
(9)ParseException(颇斯) 解析异常，一般当日期字符串解析时与指定格式不一致就是出现这个问题
1、乐观锁的话就是比较乐观，每次去拿数据的时候，认为别人不会修改，所以不会上锁，但是在更新的时候会判断一下在此期间别人有没有去更新这个数据，可以使用版本号机制或者CAS 算法实现。乐观锁在读 *** 作比较多的场景比较适用，这样可以提高吞吐量，就像数据库提供的write_condition(肯得森)机制，其实都是乐观锁
2、悲观锁的话就是每次去拿数据的时候，也认为别人会修改数据，这个时候就会加上锁，这就导致其他线程想拿数据的话，就会阻塞，直到这个线程修改完成才会释放锁，让其他线程获取数据。在数据库里的行级锁、表级锁都是在 *** 作之前就先锁住数据再 *** 作数据 ，都属于悲观锁。Java中的 synchronized(森克乃斯的) 和 ReentrantLock(喂安崔来克) 等独占锁就是悲观锁思想的实现
新建状态:
使用 new 关键字和 Thread 类或其子类建立一个线程对象后，该线程对象就处于新建状态。它保持这个状态直到程序 start() 这个线程。
就绪状态:
当线程对象调用了 start()方法之后，该线程就进入就绪状态。就绪状态的线程处于就绪队列中，要等待 JVM 里线程调度器的调度。
运行状态:
如果就绪状态的线程获取 CPU 资源，就可以执行 run()，此时线程便处于运行状态。处于运行状态的线程最为复杂，它可以变为阻塞状态、就绪状态和死亡状态。
阻塞状态:
如果一个线程执行了 sleep（睡眠）、suspend(谁斯般的)（挂起）等方法，失去所占用资源之后，该线程就从运行状态进入阻塞状态。在睡眠时间已到或获得设备资源后可以重新进入就绪状态。
死亡状态:
一个运行状态的线程完成任务或者其他终止条件发生时，该线程就切换到终止状态。TERMINATED(赤木内得它) 执行完成
- P8:
介绍下VUE常用指令及其含义
v-if 条件判断，条件true渲染标签，false不渲染标签
v-show 条件判断，标签会被渲染到浏览器，通过改变标签的display属性控制是否显示
v-for 循环指令，语法是 v-for=”(item,index) in list”
v-model 表单元素或者组件中的双向绑定指令
v-on 事件绑定指令，例如v-on:click绑定点击事件，可以用@代替，@click
v-bind 属性绑定指令，例如v-bind:title，绑定title，可以用冒号代替，:title
v-text/v-html 给标签内容赋值，v-text会以普通文本输入，v-html会渲染出对应格式，都可以解决插值闪烁问题
- 什么是插值闪烁，如何解决
使用插值表达式{{}}方式在网速较慢时会出现问题。
代码加载的时候先加载HTML，把插值语法当做HTML内容加载到页面上，当加载完js后才把插值语法替换掉。
在数据未加载完成时，页面会显示出原始的{{}}，加载完毕后才显示正确数据，我们称为插值闪烁
解决办法：使用v-cloak属性或者使用v-text、v-html进行数据填充
- vue生命周期以及对应钩子函数
vue实例从创建到销毁的过程就是vue的生命周期，这些过程中会伴随着一些函数的自调用。我们称这些函数为钩子函数。
beforeCreate
实例初始化之前
created
实例创建完成后，但是页面还没有渲染出来，一般用于加载后台数据
beforeMount
渲染开始之前被调用
mounted
页面渲染之后，一般用于调用第三方插件
beforeUpdate
页面更新前
updated
页面更新后
beforeDestroy
实例销毁前
destroyed
实例销毁后
- js数组中常用的方法
every()
判断数组的所有元素是否都满足指定的条件
都满足返回true，有一个不满足则返回false
some()
检测数组中是否存在符合指定条件的元素
存在返回 true，不存在返回 false
reduce()
对数组中的所有元素调用指定的回调函数，结果循环累计，最终返回一个结果
map()
对数组的每个元素调用指定的回调函数，并返回一个新的数组
filter()
返回数组中满足指定条件的所有元素，返回一个数组
push()
向数组中添加元素
splice(i,num)
删除数组内元素，从第i个删除，删除num个元素
- js 中 const，var，let 的区别
const 声明的是常量，不可以被修改，类似于Java的final
var 定义的变量可以修改，如果不初始化会输出 undefined，不会报错。
let 是块级作用域，函数内部使用 let 定义后，对函数外部无影响
- js中==和===的区别
==：两个等号称为等值符，当等号两边的值为相同类型时比较值是否相同，类型不同时会发生类型的自动转换，转换为相同的类型后再作比较
===：三个等号称为等同符，当等号两边的类型相同时，直接比较等号两边的值，值相同则返回 true，若等号两边的类型不同时直接返回 false
● let和const的引入
let声明局部变量，不会像var样造成变量污染；
const声明的是常量，不可以被修改，类似于Java的final
● 字符串模板
可以使用``符号来代替字符串的声明，不仅可以在换行的时候支持比较好的格式，而且还支持使用el表达式取值
● 箭头函数：简化了匿名函数的写法，直观、方便、易懂
● 解构表达式：可以通过大括号{}来快速解析对象内部的属性，很强大
跨域是浏览器对于javascript同源策略的限制。
发生在前端请求后台接口时，当前浏览器路径与请求的接口路径之间。
如果协议、域名、端口三者任何一个不同，都会发生跨域，浏览器会拦截请求结果，不允许使用
解决办法：CORS，跨域资源共享
原理：服务端提前设置好允许请求的源、允许请求的方式、允许携带的请求头、是否允许携带cookie等信息。
浏览器在发起请求时，首先发送一个预检请求，请求方式为option，询问服务端是否允许访问，如果服务端允许访问，浏览器才会发送真正的请求
可以通信，启动dubbo时，消费者会从zk拉取注册的生产者的地址接口等数据，缓存在本地。每次调用时，按照本地存储的地址进行调用；
注册中心集群中，（dangji）任意一台宕机后，将会切换到另一台；
注册中心全部宕机，服务的提供者和消费者仍能通过本地缓存通讯。
服务提供者集群中，任意一台宕机后，不影响使用；
服务提供者全部宕机，服务消费者会无法使用，并无限次重连等待服务者恢复；
如果要调用新的服务，缓存中没有新服务的地址信息，是调用不到的。
随机：按权重设置随机概率
轮循：轮流访问
最少活跃调用数：优先调用活跃数少的，相同活跃数的随机，让执行慢的提供者收到更少请求。
一致性Hash：相同参数的请求总是发到同一提供者
ZooKeeper是一个开源的分布式应用程序协调服务，是集群的管理者，监视着集群中各个节点的状态，根据节点提交的反馈进行下一步合理 *** 作 。
将简单易用的接口和性能高效、功能稳定的系统提供给用户。
读请求可以被集群中的任意一台机器处理 ，如果读请求在节点上注册了监听器，这个监听器也是由所连接的zookeeper机器来处理。
写请求，这些请求会同时发给其他 zookeeper 机器，并且达成一致后，请求才会返回成功 。
随着 zookeeper 的集群机器增多，读请求的吞吐会提高，但是写请求的吞吐会下降 。
● 服务提供者绑定指定端口并启动服务，同时连接注册中心，发送本机IP、端口、应用信息和服务信息到注册中心存储
● 消费者连接注册中心 ，并发送应用信息所请求的服务信息至注册中心，注册中心根据消费者所请求的服务信息来匹配对应的提供者列表发送至Consumer应用缓存。
● 消费者在发起远程调用时， 基于缓存的生产者列表选择一个发起调用。
● 服务提供者状态变更会实时通知注册中心、再由注册中心实时推送至Consumer
权限系统提的最多的就是RBAC（Role-based-Access-Control），基于角色的访问控制。
所谓角色，其实就是权限的集合，某个角色就是某几个权限的结合。
用户和角色进行绑定即可完成对用户的授权，其目的是为了简化授权和鉴权的过程。
- BCrypt简介
在用户模块，对于用户密码的保护，通常都会进行加密。
我们通常对密码进行加密，然后存放在数据库中，在用户进行登录的时候，将其输入的密码进行加密然后与数据库中存放的密文进行比较，以验证用户密码是否正确。
MD5和BCrypt比较流行。相对来说，BCrypt比MD5更安全。
● UUID
优点：
简单，代码方便；性能好，全球唯一
缺点：
没有排序，无法保证趋势递增。
UUID是36位字符串，查询的效率比较低，存储空间比较大
● Redis生成ID
优点：
不依赖于数据库，灵活方便，且性能优于数据库。
数字ID天然排序，对分页或者需要排序的结果很有帮助。
缺点：
如果系统中没有Redis，还需要引入Redis，增加系统复杂度。
需要编码和配置的工作量比较大。
● 雪花算法snowflake
snowflake是Twitter开源的分布式ID生成算法，结果是一个long型的ID。
其核心思想是：使用41bit作为毫秒数，10bit作为机器的ID，12bit作为毫秒内的流水号，最后还有一个符号位，永远是0，性能极好，使用简单。
- 用户注册的时候，对密码进行加盐加密处理之后，然后将盐值以及加密之后的密码等数据存入数据库，数据库不存储明文密码。
- 登录的时候，服务端接收到用户名密码之后，先根据用户名去数据库查询，如果查询到了，在把用户输入的密码结合查询出来的用户的盐值进行相同的加密处理，然后跟查询出来的密码进行对比，如果一致，则登录成功，否则登录失败
Spring Security 是 Spring 家族中的一个安全管理框架，提供了一套 Web 应用安全性的完整解决方案。
在用户认证方面，Spring Security 框架支持主流的认证方式。
在用户授权方面，Spring Security 提供了基于角色的访问控制和访问控制列表（Access Control List，ACL），可以对应用中的领域对象进行细粒度的控制
核心功能主要包括：
1、认证 （你是谁）
2、授权 （你能干什么）
3、攻击防护 （防止伪造身份）
● 首先是认证，即用户登陆，会被 Au then tication Processing Filter 拦截
调用认证管理器的实现类
认证管理器会调用 Provider Manager来获取用户验证信息
如果验证通过后会将用户的权限信息封装一个 User 放到 spring 的全局缓存 Security Context Holder 中，以备后面访问资源时使用。
● 其次是授权，即访问资源，在访问 url 时，会通过 Ab stract Security Interceptor 拦截器拦截，它会调用对应方法来获取被拦截url所需的全部权限
再调用授权管理器，这个授权管理器会通过spring的全局缓存Security Context Holder来获取用户的权限信息，还会获取该url信息以及访问该 url 所需的全部权限
然后根据所配的策略，如果权限足够，则返回通过，权限不够则报错并调用权限不足页面。
● Quartz 块s： 是一个完全由 Java 编写的开源任务调度的框架。通过触发器设置 job 定时运行规则，控制 job 的运行时间。
● Timer 太ma：JDK原生的工具。使用非常简单，不过这个工具功能有限，只能简单的周期性执行任务，而且所有任务都是由一个线程来调度，所有任务都是串行执行的，上一个任务执行情况会影响下一个任务。
● Sche saqi duled 丢类的 Executor 课T Service：定时执行的线程池。也是只能执行一些简单的周期性任务，比如每秒执行一次。通过它每一个被调度的任务都会被线程池中的一个线程去执行，因此任务可以并发执行，而且相互之间不受影响。
● spring-task： spring3.0 之后自带，它可以看做是轻量级的Quartz。可以指定 cron 表达式，也可以固定频率或者固定延迟执行。但是需要用在spring 项目中。
Spring3.0以后自主开发的定时任务工具。
spring-task：可以将它比作一个轻量级的实现定时任务的框架，而且使用起来很简单，除spring相关的包外不需要额外的包。
而且支持注解和配置文件两种形式。
SpringTask 默认是单线程的，多个定时任务使用的都是同一个线程；
在实际开发中，不希望所有的任务都运行在一个线程中，想要改成多线程，给SpringTask提供一个多线程的Task Sche duler。
装箱就是：自动将基本数据类型转换为包装类型；
拆箱就是：自动将包装类型转换为基本数据类型；
在定义变量的时候，比如Integer num = 1;就会自动装箱成Integer对象 *** 作，int num2 = num;就会进行自动拆箱 *** 作
在比较的时候，也会会发生拆箱和装箱 *** 作
● 无论如何，Integer与new Integer不会相等，不会经历拆箱过程。
● 两个都是非new出来的Integer，如果数在-128到127之间，则是true,否则为false。
● 两个都是new出来的,都为false。
● int和Integer或者new Integer比较，都为true，因为会把Integer自动拆箱为int再去比。
值传递就是传递的过程中，传递的是值，对值 *** 作之后，不会影响原有变量的值。
引用传递就是传递的过程中，传递的是引用， *** 作引用之后，会影响原有变量的值。
● 在传递的过程中，如果传递的是基本数据类型以及String，那么都是值传递，不会改变原有变量。
● 在传递的过程中，如果传递的是对象，如果修改了属性的值，那么会直接改动原有对象，会影响外面的值。
spring容器可以管理 singleton 作用域 Bean 的生命周期。
在此作用域下，Spring 能够精确地知道该 Bean 何时被创建，何时初始化完成，以及何时被销毁。
Per
而对于 prototype 作用域的 Bean，Spring 只负责创建，当容器创建了 Bean 的实例后，Bean 的实例就交给客户端代码管理，Spring 容器将不再跟踪其生命周期。每次客户端请求 prototype 作用域的 Bean 时，Spring 容器都会创建一个新的实例。
● 读未提交：允许另外一个事务可以看到这个事务未提交的数据，最低级别，任何情况都无法保证。
● 读已提交：保证一个事务修改的数据提交后才能被另一事务读取，而且能看到该事务对已有记录的更新，可避免脏读的发生。
● 可重复读：保证一个事务修改的数据提交后才能被另一事务读取，但是不能看到该事务对已有记录的更新，可避免脏读、不可重复读的发生。
● 串行化：一个事务在执行的过程中完全看不到其他事务对数据库所做的更新，可避免脏读、不可重复读、幻读的发生。
（1）工厂模式：BeanFactory就是简单工厂模式的体现，用来创建对象的实例。
（2）单例模式：Bean默认为单例模式。
（3）代理模式：Spring的AOP功能用到了JDK的动态代理和CGLIB字节码生成技术。
（4）模板方法：用来解决代码重复的问题。比如JmsTemplate。
● 定时删除：在设置key的过期时间的同时，为该key创建一个定时器，让定时器在key的过期时间来临时，对key进行删除。
● 惰性删除：key过期的时候不删除，每次从数据库获取key的时候去检查是否过期，若过期，则删除，返回null。
● 定期删除：每隔一段时间执行一次删除过期key *** 作。
Redis默认过期策略是：定期删除+惰性删除。
缓存预热就是系统上线后，提前将相关的缓存数据直接加载到缓存系统。
避免在用户请求的时候，先查询数据库，然后再将数据缓存的问题！
用户直接查询事先被预热的缓存数据！
缓存预热解决方案：
（1）直接写个缓存刷新页面，上线时手工 *** 作下。
（2）数据量不大，可以在项目启动的时候自动进行加载。
当访问量剧增、服务出现问题，比如响应时间慢或不响应，或者非核心服务影响到核心流程的性能时，仍然需要保证服务还是可用的，即使是有问题的服务。
redis可以帮助系统实现数据降级载体，系统可以根据一些关键数据进行自动降级，也可以配置开关实现人工降级。
降级的最终目的是：保证核心服务可用，即使是有损的。
mysql数据可能会发生变动，那么redis就要跟数据库的数据保持一致。
我们实际去使用的时候，是在数据发生变动的地方。
比如增删改的时候，新起一个线程，然后将变动的数据更新到redis中，根据不同的场景需求，也可以在数据变动时，把redis里的数据删掉。
下一次用户查询的时候，发现redis中没有数据，就会重新去数据库加载一遍，这样也可以实现同步的效果。
redis 是单线程,线程安全。
因为 Redis 是基于内存的 *** 作，CPU 不是 Redis 的瓶颈，Redis 的瓶颈最有可能是机器内存的大小或者网络宽带。
redis 实际上是采用了线程封闭的观念，把任务封闭在一个线程，自然避免了线程安全问题。
不过对于需要依赖多个 redis *** 作的复合 *** 作来说，依然需要锁，而且有可能是分布式锁。
P7:
1 HashMap底层原理在jdk1.8中 底层是数组 链表 红黑树实现
在Hashmap中，初始化长度为16，当用put方法存储数据时，传入key及value值，此时将key值进行hash运算后的hash值作为entry（嗯吹）键值对在数组中的索引位置，确定位置之后，首先判断该位置是否为空，如果为空，就将entry值放在该位置，否则将entry以链表的方式存在数组中，当链表长度超过8位之后，会将链表转换为红黑树继续存储entry
2 Java类的加载机制加载
Classloader（楼得）通过完全限定名查找字节码文件，并利用字节码文件创建一个class对象.
验证
确保class文件所包含的字节流信息符合当前虚拟机的要求，不会对虚拟机造成自身安全，主要包括四种验证 字节码 元数据 符号引用 文件格式验证
准备
在方法区中为类变量分配内存并设置初始值。实例变量不会在这里分配初始化，而是随着对象分配到Java堆中。给静态变量分配内存空间
解析
将常量池中的符号引用替换成直接引用
初始化
如果有父类就对父类进行初始化 给静态变量和静态代码库进行初始化工作
·3 hashmap和hashtable的区别？相同点：
1、都是key-value 的双列集合；
2、都是数组+链表的底层原理；
3.都实现了Map 接口。
不同点：
1、继承的父类不同
Hashtable 继承Dictionary （迪克神奶瑞）类，而HashMap 继承Abstract（俺木死拽特） Map类。
2、线程安全性不同
hashMap 允许null 键和null 值，线程不同步，不安全，效率高，hashtable 不允许null 键和null 值，线程同步，安全，效率低。
在java 开发中常用的是HashMap 类，比如(抗卡润特)ConcurrentHashMap，可以实现线程安全，Hashtable 和vector 一样成为了废弃类
4 Java中ArrayList和linkedlist区别？相同点：
1、都是List 接口的实现类，具有元素可重复，存取有序特点；
2、都是线程不安全，效率高；
不同点：
1、数据结构：ArrayList底层是动态数组，linkedList底层是双向链表；
2、随机访问效率：ArrayList效率优先于linkedList ，因为linkedList 是线性的数据存储方式，指针从前往后依次查询。
3、增加和删除效率：linkedList效率优先于ArrayList ，因为ArrayList 增删 *** 作要影响数组内的其他数据的下标。
5 final finally finalize的区别final:修饰符，可以 修饰类，类不能被继承，，修饰方法，方法不能被重写，修饰变量，变量变常量，只能被赋值一次
finally:是异常处理的一部分，用于释放资源，一般来说，代码肯定会执行，特殊情况：在执行到finally之前JVM提前退出
finalize:是Object类的一个方法，用于垃圾回收
·6 ConcurrentHashMap jdk1.8有什么优化？取消segments(赛格门磁,核算)字段，直接采用transient(锤森特) volatile（外咯太傲） HashEntry（恩吹）
在table数组＋单向链表的数据结构，添加了红黑树的结构。当链表长度大于8时，链表
将转变为红黑树的结构，那么可以降低查询的时间复杂度，可以改进性能。
·7并发编程的三要素是那些？你是怎么理解的？原子性
原子性是指一个或多个 *** 作 要么全部执行 并且在执行的过程中不对其他 *** 作打断 要么全部都不执行
可见性
多个线程 *** 作一个共享变量时 其中一个线程对变量进行了修改 其他线程可以立即看到修改后的结果
有序性
程序的执行顺序按照代码的先后顺序来执行
8 Java线程具有五中基本状态是那些？新建状态
使用new关键字或thread(斯瑞德)类和子类创建一个线程对象后，该线程对象处于新建状态，并保持这个状态直到程序start这个线程
就绪状态
当线程对象调用了start方法之后 线程进入就绪状态 在就绪队列中等待jvm线程调度器的调度
运行状态
如果就绪状态线程获得cpu资源后 就可以执行run方法 然后线程就进入运行状态 处于运行状态的线程及其复杂 它可以变为 阻塞状态 死亡状态 就绪状态
阻塞状态
如果一个线程执行了sleep suspend(瑟斯喷)方法 失去所有资源后 线程进入阻塞状态 时间过了之后 获得设备资源的线程可重新进入就绪状态
死亡状态
一个运行状态的线程完成任务或终止条件发生 线程进入死亡状态 terminated(特美内忒的)执行完成
1.2 MySql数据库
·9 mysql搜索引擎知道哪些？有什么区别？默认搜索引擎是什么？InnoDB 存储引擎:
支持自增长列（auto_increment），支持外键（foreign key），支持事务回滚以及系统崩溃的修复能力，并且支持mvcc行级锁。缺点是读写效率较差，占用的数据空间相对较大。
MyISAM 存储引擎:
不支持事务、支持表级锁，支持全文搜索，缓冲池只缓存索引文件，
mysql-5.1版本之前默认搜索引擎是MyISAM，之后是innoDB
10数据库中count(*)和count(1)有什么区别,关于count（*）查询百万数据量速度慢如何优化？
从执行结果来看count(*)和count(1)没有区别，因为他们都不过滤空值
从执行效率来看MySQL会对count（*）做优化
（1）如果列为主键，count(列名)效率优于count(1)
（2）如果列不为主键，count(1)效率优于count(列名)
（3）如果表中存在主键，count(主键列名)效率最优
（4）如果表中只有一列，则count(*)效率最优
·11 mysql查询语句的优化？
避免全表扫描，首先应考虑在 where 及 order by 涉及的列上建立索引
避免在 where子句中使用!=， <>
避免对字段进行 null 值判断，可以设置默认值为0使用where！=0来判断
避免用or做链接条件,可以使用union(有俺) all
避免以%开头的模糊查询，in 和 not in可以替换为between and
避免对字段进行表达式和函数的 *** 作，否则将会导致引擎放弃使用索引而进行全表扫描。
·12 mysql批量插入5000条数据如何优化？
• 第一种方法：
合并sql插入语句，作用是：日志量减少，从而提高效率，同时也能减少SQL语句解析的次数，和网络传输的io
• 第二种方法；
在同一个事务中进行插入处理,这是因为进行一个INSERT *** 作时，MySQL内部会建立一个事务，在事务内才进行真正插入处理 *** 作。并且插入都在执行后才统一进行提交 *** 作。
13 主键索引和唯一索引有啥区别？
主键是一种约束，唯一索引是一种索引，两者在本质上是不同的。
主键创建后一定包含一个唯一索引，唯一索引并不一定就是主键。
主键列在创建时，已经默认为空值 + 唯一索引了。
主键可以被其他表引用为外键，而唯一索引不能。
主键更适合那些不容易更改的唯一标识，如自动递增列、身份z号等。
一个表最多只能创建一个主键，但可以创建多个唯一索引
在 RBO 模式下，主键的执行优先级要高于唯一索引。两者可以提高查询的速度
唯一索引列允许空值，而主键列不允许为空值。
14 #{}和${}的区别是什么？
#{}是占位符，${}是连接符。
Mybatis在处理#{}时，会将sql中的#{}替换为?号，调用PreparedStatement的set方法来赋值；
Mybatis在处理${}时，就是把${}替换成变量的值。
使用#{}可以有效的防止SQL注入，提高系统安全性。
15 当实体类中的属性名和表中的字段名不一样，怎么办？
第一种方法：通过在查询的sql语句中定义字段名的别名，让字段名的别名和实体类的属性名一致；
第二种方法：通过
第三种方法：在实体类通过@Column(可乐门)注解也可以实现；
16 Mybatis有哪些动态sql？
Mybatis动态sql是指：可以在Xml映射文件内，以标签的形式编写动态sql。执行原理是：根据表达式的值完成逻辑判断并动态拼接sql的功能。
Mybatis提供了9种动态sql标签：
、where、 if 、foreach、choose、when 、otherwise、 set 、trim 、bind(结合)
17在mapper中如何传递多个参数?
第一种：在对应的xml中，使用#{0}代表接收的是dao层中的第一个参数，#{1}代表dao层中第二参数，更多参数一致往后加即可。
第二种：使用 @param 注解:
18 resultMap和resultType
MyBatis中在进行查询映射的时候，返回类型为resultType（锐赛特泰普）或resultMap，resultType表示直接返回类型，而resultMap则是对外部ResultMap的引用，并且 resultType与resultMap不能同时存在。
在进行查询映射时，查询出的每一个属性都放在一个对应的Map里，其中键是属性名，值则是其对应的值，返回类型都是ResultMap，
当提供的返回类型属性是resultType时，会自动的把对应的值赋给resultType所指定对象的属性。
当提供的返回类型是resultMap时，需要转化为对应的对象，因为Map不能很好的表示领域模型，这常常用在复杂查询中。
19一对一关联查询使用什么标签?一对多关联查询使用什么标签?
MyBatis中使用collection(科莱克森)标签解决一对多的关联查询，可用的属性如下：
property（怕不理）:集合属性的值
ofType（欧服退铺）:集合中元素的类型.
column（卡乐木）:对应的外键字段名称.
select:使用另一个查询封装的结果.
MyBatis中使用association(额嗖西诶森)标签解决一对一的关联查询，可用的属性如下：
property:对象属性的名称. javaType:对象属性的类型.
column:对应的外键字段名称. select:使用另一个查询封装的结果！
20 接口绑定有几种实现方式,分别是怎么实现的?
接口绑定有两种实现方式,一种是通过注解绑定,就是在接口的方法上面加上
@Select@Update 等注解里面包含 Sql 语句来绑定,
另外一种就是通过 xml 里面写 SQL 来绑定,在这种情况下,要指定 xml 映射文件中的 namespace 需要的接口全路径名.
1.4 spring
21 spring有哪些核心组件?
Spring Core(核心)：核心类库，提供 IOC 服务；
Spring Context 提供了框架式的bean的访问方式以及企业级功能如JNDI定时任务等。
Spring AOP：AOP 服务；
Spring ORM: 对现有ORM框架的支持。
Spring DAO：对 JDBC 的抽象，简化了数据访问异常的处理；
Spring Web：提供了基本的面向 Web 的特性 例如多方文件上传；
Spring MVC：提供面向 Web 应用的 Model-View-Controller 实现。
22 Spring中的设计模式有那些？。
工厂模式：BeanFactory 就是简单工厂模式的体现，用来创建对象的实例；
单例模式：Bean 默认为单例模式。
模板方法：用来解决代码重复的问题。
代理模式：Spring 的 AOP 功能用到了 JDK 的动态代理和 CGLIB 字节码生成术；
观察者模式：定义对象键一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知被制动更新.
23简单介绍一下Spring bean 的生命周期？
就是从创建到销毁的过程，通过构造方法或者工厂方法，实例化bean对象，并通过依赖注入，设置对象的属性。将Bean实例传递给Bean的前置处理器，调用Bean的初始化方法，再将Bean实例传递给Bean的后置处理器的，然后使用Bean。容器关闭之前，调用Bean的销毁方法销毁实例
24 Spring中有哪些不同的通知类型
1.前置通知：链接点执行之前执行通过@before注解
2.返回之后通知：链接点指向完成以后执行，用来绑定返回值形式使用@returning注解
3.抛出（异常）后执行通知：执行过程中抛出异常后通知 使用@throwing注解
4.后置通知:连接点执行结束后执行使用@after注解
5.环绕通知 ：方法执行前，执行后，抛出异常时都会通知，使用@around注解
25 谈谈你对IOC的理解
IOC（控制反转）是一种设计思想，将对象的生命周期和依赖关系交给ioc容器来管理，只需要配置好配置文件和注解，就可以动态注入依赖对象，并放到容器中，降低开发难度，增加了项目的可维护性
26 BeanFactory和FactoryBean的区别
BeanFactory和FactoryBean都是接口，区别在于
BeanFactory是个Factory，是IOC容器或对象工厂，提供了IOC容器最基本的形式，和实现规范。
FactoryBean是一个由bean工厂管理的bean。它是一个能生产或者修饰对象生成工厂的Bean,实现方式与工厂模式和修饰器模式类似
27 JDK动态代理与CGLib动态代理的区别
JDK动态代理只能对实现了接口的类生成代理，而不能针对类
CGLib是针对类实现代理，主要是对指定的类生成一个子类，覆盖其中的方法（继承）
当Bean实现接口时，Spring就会用JDK的动态代理
当Bean没有实现接口时，Spring可以强制使用CGLib来实现
在JDK1.6之前CGLib比JDK性能要高，因为CGLib 底层采用 ASM 字节码生成框架。JDK1.6之后JDK动态代理性能比CGlib快20%，CGLib 是通过继承方式实现的动态代理，所以不能代理被final修饰的类或方法。
28 Spring 事务底层原理
区分处理单元IOC：设置事务管理器，设置事务的传播特性及隔离机制。
AOP对需要事务处理的类进行拦截，并且实现了Spring声明式事务处理模块
对事务处理实现：事务的生成、提交、回滚、挂起
结合：目的是为了形成一个Spring声明式事务处理的设计体系。
29 springmvc的执行流程
1)客户端提交请求到前端控制器DispatcherServlet
2)由前端控制器查询一个或多个处理器映射器HandlerMapping，找到处理请求的Controller
3)前端控制器将请求提交到Controller（也称为Handler）
4)Controller调用业务逻辑处理后，返回模型视图数据(ModelAndView)
5)前端控制器查询一个或多个视图解析器（ViewResoler），找到ModelAndView指定的视图
6)视图负责将结果显示到客户端
30 springmvc如何处理异常?
Spring MVC处理异常有3种方式：
使用Spring MVC提供的简单异常处理器
（2）实现Spring的异常处理接口，并自定义异常处理器；
（3）使用@ExceptionHandler(艾克斯撒普森憨的了)注解
31 Springmvc 中拦截器如何使用
preHandle ：进入 Handler方法之前执行身份认证、授权，若不正确此方法会进行拦截不能向下执行
postHandle：进入Handler方法之后，在返回modelAndView之前执行，应用场景从modelAndView出发。
After(阿福特) Completion(康姆普雷森) 完成后：执行Handler后执行此方法，适用于异常，日志的统一处理
32如何开启注解处理器和适配器？
在springmvc.xml 配置文件中通过开启
33如何解决 get 和 post 乱码问题？
解决 post 请求乱码:在 web.xml 里边配置一个Filter 过滤器并设置编码为 utf-8即可。
解决 get 请求乱码:修改 tomcat 配置文件添加编码与工程编码一致。对参数进行重新编码
34 springmvc有哪些常用的注解
@RequestMapping
@GetMapping
@PostMapping
@RequestParam
@RequestBody
@ResponseBody
35 什么是MVC模式
MVC是一种架构型模式，能更好的开发和维护效率。
在MVC模式中，应用程序被划分成了Model(包含了应用程序的业务逻辑和业务数据)、View(封装了应用程序的页面)和Controller(负责协调模型和视图)三个部分。MVC模式的这三个部分分职明确，而且每个部分都可以独立的改变，不影响其他部分，提高了应用的灵活性。
36当一个方法向AJAX返回特殊对象,譬如Object,List等,需要做什么处理？
在方法上加@ResponseBody注解，表示该方法的返回值不管是什么类型，都会返回JSON格式的数据。
把原来Controller类上的@Controller注解替换为@RestController注解。@RestController = @Controller + @ResponseBody，表明该Controller类所有带有@RequestMapping的方法都返回JSON格式的数据。
37 SpringMVC用什么对象从后台向前台传递数据的？
1.使用Map、Model和ModelMap的方式，这种方式存储的数据是在request域中
2.使用request的方式
3.使用ModelAndView
38 对于一个多模块项目，如果管理项目依赖的版本
通过在父模块中声明dependencyManagement和(普拉根)pluginManagement， 然后让子模块通过
39 Maven常用命令
clean：删除项目中已经编译好的信息
test：使用合适的单元，测试框架运行。
package：将编译好的代码打包成可分发的格式
install：将安装包放在本地仓库，并在项目作为依赖使用。
Deploy(地普捞A)：复制最终的包到远程仓库，并共享
40 Maven的生命周期
maven有三套生命周期，分别为：Clean 周期：默认周期，site周期。主要阶段包含:验证 - 验证项目是否正确。编译 - 编译项目的源代码。测试test：使用合适的单元，测试框架运行。打包- package：将编译好的代码打包成可分发的格式。安装install：将安装包放在本地仓库，并在项目作为依赖使用。部署deploy(地普捞A)：复制最终的包到远程仓库，并共享
p6:
- String中常用的方法有哪些(最少10个)
split()：把字符串分割成字符串数组
indexOf()：从指定字符提取索引位置
trim()：去除字符串两端空格
replace()：替换
hashCode()：返回此字符串的哈希码
subString()：截取字符串
equals()：比较两个字符串的值
length()：获取字符串的长度
valueOf()：转换为字符串
concat()：将指定字符串连接到此字符串的结尾
- 重载重写的区别
重载： 发生在同一个类中，方法名必须相同，参数类型不同，个数不同，顺序不同，与方法的修饰符和返回值无关
重写： 发生在父子类中，方法名.参数列表必须相同，返回值范围小于等于父类，抛出的异常范围小于等于父类
==号在比较基本数据类型时比较的是值，而用==号比较两个对象时比较的是两个对象的地址值；
equals()方法，默认效果和==号的效果一样，也是比较的地址值，然而，Java 提供的所有类中，绝大多数类都重写了 equals()方法，比如 string，integer 等，重写后的 equals()方法一般都是比较两个对象的值 。
相同点：三个类都是处理字符串的类；
不同点：
从安全上来说，
String 中的对象是不可变的，也就可以理解为常量
StringBuffer 对方法加了同步锁，所以是线程安全的，效率比较低，适合多线程。
StringBuilder 并没有对方法进行加同步锁，线程不安全的，效率高适合单线程。
maven是一个项目管理工具，可以对项目的整个生命周期进行管理，并且可以对项目的依赖jar包进行管理。
Maven的生命周期包括：清理、编译、测试、打包、安装、部署,对应命令如下：
清理 mvn clean 将会删除 target 目录及内容
编译 mvn compile 将java文件编译为 class 文件输出到 target 目录下
测试 mvn test 执行单元测试类
打包 mvn package 把项目打包到项目的target目录
安装 mvn install 包含package，且将项目打包安装到本地仓库
部署 mvn deploy 包含install，且将项目上传到远程仓库
6、maven的jar包冲突，如何解决？由于maven对jar有隐性的依赖，所以可能会导致项目中jar包版本冲突。
maven自带两种方式：
路径就近原则：依赖传递过来的路径近的优先。
优先声明原则：在 pom 文件定义依赖，先声明的依赖为准。
手动配置两种方式：
排除法：通过exclusion标签排除依赖
锁定版本：通过dependencyManagement 直接锁定版本。
7、final、finally、finalize的区别Final是一个安全修饰符,用final修饰的类不能被继承,用final声明的方法不能被重写,用final声明的变量就相当于常量,不能被修改。
Finally是在异常里经常用到的，就是try和catch里的代码执行完以后，必须要执行的方法，我们经常在finally里写一些关闭资源的方法，关闭IO流什么的，就算是try和catch里有return代码，也会执行finally里的内容的，除非在try catch里遇到System.exit代码，整个主线程就停掉了，才不会执行finally里的代码
Finalize是Object类的一个方法，在垃圾回收的时候,调用被回收对象的此方法，回收对象
1、抽象类只能被单继承，但是接口可以多实现；
2、抽象类中有构造方法，接口中没有构造方法。
3、抽象类中即可以有普通成员变量也可以有常量；接口中变量全是常量，默认修饰符 public static final；
4、抽象类中既可以有抽象方法，也可以有普通方法，但是有有抽象方法的类必须定义为抽象类；接口中的方法只能定义为抽象方法，默认修饰符 public abstract。
Java的类型分为四类八种
四类为：整型，浮点型，布尔型，字符型
基本数据类型有8种，分别是`byte、short、int、long 、float、double、char、boolean`，
对应包类Byte,Short,Integer,Long,Float,Double,Character,Boolean
1.新增lamda表达式这块，遍历集合以及定义匿名函数
2.switch中的变量可以是string类型，之前只能是基本数据类型
3.增加流式编程，让我们用stream的方式，可以非常方便的对集合里的数据 *** 作
4.新的时间类，LocalDate、LocalTime、LocalDateTime这几个类，让我们 *** 作日期的时候非常方便
5.Java 8允许我们给接口添加一个非抽象的方法实现，只需要使用 default关键字就行了
1.NullPointException空指针异常，一般都是调用空对象的方法了
2.FileNotFoundException异常，文件找不到异常，文件不存在或加载不到。
3.ClassCastException类转换异常，类型转换失败导致
4.SQLException， sql语法错误或者sql语句书写错误导致
12、Java里常见的集合有什么特点java 中的集合分为，单列集合Collection,双列集合Map。
Collection 分为：List 、 Set
List有序可重复 分为ArrayList、Vector、linkedList：
ArrayList:底层实现是数组，查询快，增删慢，线程不安全，效率高，每次扩容为当前容量的1.5倍+1；
Vector:底层实现是数组，查询快，增删慢，线程安全，效率低，扩容机制为翻倍；
linkedList:底层实现是双向链表，增删快，查询慢，线程不安全，效率高；
Set
HashSet:无序不可重复,底层使用Hash表实现，存取速度快。
linkedHashSet:采用hash表存储，使用双向链表记录插入顺序
Map分为：HashMap、HashTable
HashMap：key重复则覆盖原有的value，底层使用数组+链表实现，jdk1.8以后加入了红黑树，线程不安全，key和value都允许为null
HashTable:key重复则覆盖原有的value，底层使用数组+链表实现，jdk1.8以后加入了红黑树，线程安全，key和value都不允许为null
13、HashMap底层原理在jdk1.8之前，底层是通过数组+链表实现的，当我们创建hashmap时会先创建一个数组。
当我们用put方法存数据时，先根据key的hashcode值计算出hash值，然后用这个哈希值确定在数组中的位置，再把value值放进去，如果这个位置本来没放东西，就会直接放进去；如果之前就有，就会生成一个链表，把新放入的值放在头部。
当用get方法取值时，会先根据key的hashcode值计算出hash值，确定位置，再根据equals方法从该位置上的链表中取出该value值。
当容量超过当前容量的0.75倍之后，就会自动扩容为原来容量的2倍。这个0.75就是负载因子。
但是在jdk1.8之后，最大的不同就是其由 数组+链表+ 红黑树组成。因为在1.7的时候，这个链表的长度不固定，所以如果key的hashcode重复之后，那么对应的链表的数据的长度就无法控制了，get数据的时间复杂度就取决于链表的长度了，为了提高这一部分的性能，加入了红黑树，如果链表的长度超过8位之后，会将链表转换为红黑树，极大的降低了时间复杂度
HashMap 线程不安全，有多个线程同时 HashMap，可能会导致数据的不一致。如果需要满足线程安全，可以使用 ConcurrentHashMap。
ConcurrentHashMap是线程安全的HashMap，内部采用了的"分段锁"策略，它的主干是个Segment数组，通过继承ReentrantLock 来进行加锁。所以每次锁住的是一个 segment，这样只要保证每个 Segment 是线程安全的，也就实现了全局的线程安全。一个Segment就是一个子哈希表，默认有16 个 Segment。所以理论上，只要它们的 *** 作分别分布在不同的 Segment 上，最多可以同时支持 16 个线程并发写。
15、创建线程的方式1.继承Thread类，或者直接实现Runnable接口，然后再重写下run方法就行了。启动线程的方式就是调用类里边的 start方法。
2.实现 Callable 接口，他的执行代码的方法是call方法，可以有返回值
3.通过线程池来实现，线程池就是事先将多个线程对象放到一个容器中，当使用的时候就不用 new 线程而是直接去池中拿线程即可。节省了开辟子线程的时间，提高代码执行效率。
wait方法呢就是线程等待，调用这个方法之后，线程进入等待状态，只有等待通知notify或者notifyAll才会继续执行，会释放锁，释放cpu资源。
sleep线程睡眠，让当前线程休眠，此时线程处于阻塞的状态，时间到了之后，线程继续向下执行，不会释放锁，不会解除cpu占用
yield线程让步，意思是释放CPU资源，让其他线程抢夺CPU资源
join线程插队，就是让当前线程先运行，其他线程先等待
interrupt线程中断，就是中断当前线程的意思
notify唤醒线程，notifyAll唤醒所有线程
17、线程池的原理线程池主要由4个部分组成，
- 线程池管理器：用于创建并管理线程池
- 工作线程：线程池中的线程
- 任务接口：每个任务，必须实现的接口，用于工作线程调度运行
- 任务队列：用于存放待处理的任务，提供一种缓冲机制
线程池做的工作主要是控制运行的线程的数量；处理过程中将任务放入队列，然后在线程创建后启动这些任务，如果线程数量超过了最大数量，超出数量的线程排队等候；等其它线程执行完毕，再从队列中取出任务来执行。他的主要特点为：线程复用；控制最大并发数；管理线程。
ConcurrentHashMap是线程安全的HashMap，内部采用了的"分段锁"策略，它的主干是个Segment数组，通过继承ReentrantLock 来进行加锁。所以每次锁住的是一个 segment，这样只要保证每个 Segment 是线程安全的，也就实现了全局的线程安全。一个Segment就是一个子哈希表，默认有16 个 Segment。所以理论上，只要它们的 *** 作分别分布在不同的 Segment 上，最多可以同时支持 16 个线程并发写。
JVM主要包括：类加载器、执行引擎、本地接口、运行时数据区
类加载器：加载类文件到内存。只管加载，只要符合文件结构就加载
执行引擎：负责解释命令
本地接口：本地接口的作用是融合不同的语言为java所用。
JVM的运行时数据区分为五个区域：堆、栈、本地方法栈、方法区、计数器。
计数器：这里记录了线程执行的字节码的行号。
栈：每个方法执行的时候都会创建一个栈，用于存放 局部变量表、动态链接。
本地方法栈：与栈类似，是执行本地方法。
堆：堆就是存放对象实例，几乎所有的对象实例都在这里分配内存。
方法区：用于存储Java虚拟机加载的类信息、常量、静态变量、以及编译器编译后的代码等数据。
类的加载分为五个阶段：加载-》检查-》准备-》解析-》初始化
加载：根据查找路径找到相应的 class 文件然后导入；
检查：检查加载的 class 文件的正确性；
准备：给类中的静态变量分配内存空间；
解析：将常量池中的符号引用替换成直接引用。
符号引用就理解为一个标示，而直接引用是直接指向内存中的地址；
初始化：对静态变量和静态代码块执行初始化工作。
一般有两种方法来判断：
引用计数器算法：对象中添加一个引用计数器，如果引用计数器为0则表示没有其它地方在引用它。如果有一个地方引用就+1，引用失效时就-1。它有一个缺点不能解决循环引用的问题。
可达性分析算法：这种算法可以有效地避免对象循环引用的情况，整个对象实例以一个树的形式呈现，从根节点开始向下搜索，搜索所走过的路径称为引用链。当一个对象到跟节点没有任何引用链相连时，则证明此对象是可以被回收的。
jdk1.7中的堆的情况分为：
年轻代
年轻代区域被划分为三部分，Eden区和两个大小严格相同的Survivor区，在Eden区间变满的时候，GC就会将存活的对象移到空闲的Survivor区间中。
年老代
老年代主要保存生命周期长的对象，根据JVM的策略，在经过15次垃圾收集后，仍然存活于Survivor的对象被移动到老年代。
永久代
永久代主要保存 类，方法，文件对象，这部分的空间如果使用不当，就会造成内存溢出，比如一次性加载了很多的类，
虚拟区
最大内存和初始内存的差值，就是虚拟区
1、Redis是基于C语言开发的key-value形式的nosql数据库，数据存储在内存中，有string hash list set zset 五种数据类型
2、由于数据存储在内存中，为防止服务器宕机数据丢失，支持RDB和 AOF 俩种持久化方式。
RDB: 默认开启，把内存快照的形式把内存中的数据持久化到本地磁盘文件。
AOF: 默认不开启，需要手动开启，设置appendonly 值为yes；aof是把写或删除的 *** 作（命令）日志以追加的方式保存磁盘文件
24、说下对Redis缓存使用的了解？1、Redis缓存使用，首先查询数据时先从Redis缓存中查询，如果缓存中有数据，直接返回数据。如果查询不到，再去数据库中查询，查到数据添加到Redis缓存，返回查询的数据。
2、Redis缓存涉及到数据同步问题：
当数据库数据发生变化时，Redis缓存中的数据也需要同步，否则导致数据不一致。
所以，数据新增、修改、删除时，把Redis缓存的数据清空。当再次查询时，先从数据库查询，然后把数据缓存到Redis中；这样就保证了数据的同步。
数据发生变化时，Redis缓存中的数据也需要同步，否则导致数据不一致。
25、介绍下Redis缓存雪崩？缓存雪崩造成因素有2个：
1、Redis服务器宕机
2、同一时间Redis中缓存的数据大量过期，原本该去缓存查询的大量请求，有缓存出现问题，全都去数据查询，导致数据压力太大，系统崩溃。
解决方案：
可以给key的过期时间+随机数（让key的过期时间尽可能的分散）
26、介绍下Redis缓存穿透？缓存穿透是指用户查询数据，在数据库没有，自然在缓存中也不会有。这样就导致用户查询的时候，在缓存中找不到，每次都要去数据库再查询一遍，然后返回空（相当于进行了两次无用的查询）。这样请求就绕过缓存直接查数据库。
解决方案：
查询数据库如果没有，也要在Redis缓存一个空数据（key的value值：空字符串）。
但是有可能出现缓存同步问题：
解决方案： key设置一个很短的过期时间。key过期以后，Redis会清空这个key ,下次去查询时候，Redis中查不到，就会去查数据库，如果数据库查到值，就可以缓存到Redis，从而保证数据的同步。
27、说下你对ActiveMQ的了解？ActiveMQ是一个消息中间件，主要用于应用解耦。有两个角色：生产者和消费者。有5种消息类型：
· TextMessage：一个字符串对象
· MapMessage：键-值对对象
· ObjectMessage：序列化的 Java 对象
· BytesMessage：字节对象
· StreamMessage ：Java 原始数据流
常见有两种消息模式:
点对点：发送消息时没有消费者，消息会保存到队列中，有多个消费者时，消息只能被一个消费者读取，先到先得。
发布订阅：发送消息时，生产值需要提前订阅，消息不会保存到队列，多个消费者订阅都会接收到消息。
28、说下Linux常用命令（至少10个）？cd：进入某个目录
pwd：查看当前目录
ls：查看当前目录下有哪些文件
mkdir：创建一个目录
cp：复制文件
mv： 文件移动
rm -rf：递归强制删除
tar -xzvf：解压缩
tail -200f 文件名：动态输出日志最后200行
kill -9 进程pid：强制杀死进程
ps -ef|grep tomcat：查看tomcat进程pid
29、共享锁和独占锁独占锁：独占锁也叫排他锁,是指该锁一次只能被一个线程所持有。如果线程对数据A加上排他锁后，则其他线程不能再对A加任何类型的锁。获得排它锁的线程即能读数据又能修改数据。
共享锁：共享锁是指该锁可被多个线程所持有。如果线程对数据A加上共享锁后，则其他线程只能对A再加共享锁，不能加排它锁。获得共享锁的线程只能读数据，不能修改数据。
区别大致分了三个方面
wait方法呢就是线程等待，调用这个方法之后，线程进入等待状态，只有等待通知notify或者notifyAll才会继续执行，会释放锁，释放cpu资源。
sleep线程睡眠，让当前线程休眠，此时线程处于阻塞的状态，时间到了之后，线程继续向下执行，不会释放锁，不会解除cpu占用
p5:
1.什么是mybatis?
Mybatis 是一个半 ORM（对象关系映射）框架，它内部封装了 JDBC，开发时只需要关注 SQL 语句本身，不需要花费精力去处理加载驱动、创建连接、创建 statement 等繁杂的过程。程序员直接编写原生态 sql，可以严格控制 sql 执行性能，灵活度高。
2.MyBaits运行原理？
1.加载核心配置文件
2.创建 sqlSessionFactory
3.创建 sqlSession
4.由 sqlSession 调执行器
5.输入参数
6.执行 sql
7.返回结果
3.简述mybatis中 #{}和${}的区别？
#{}:占位符，使用 #{} 格式的语法会导致 MyBatis 创建 PreparedStatement 参数并安全地设置参数（就像使用 ? 一样）；
${}:连接符，不对参数做任何解析，直接拼接 sql 语句，相当于 statment，有 sql 注入风险，一般需要使用 group by ,order by 必须使用列名时才使用;
4.mybatis中使用mapper开发有什么规范？
接口名称必须和 xml 文件名称一致 接口中方法名称必须是
xml 文件中的 sql 标签中的 id 的值
xml 文件中 namespace 的值必须是接口的全类路径名
参数类型一致
返回值类型一致
5.Mybatis原生 *** 作返回selectOne和selectList的区别？
动态代理对象调用sqlSession.selectOne()和sqlSession.selectList()是根据mapper接口方法的返回值决定，如果返回list则调用selectList方法，如果返回单个对象则调用selectOne方法。
6.mybatis和hibernate的区别？
Mybatis 它不完全是一个 ORM（关系数据模型） 框架，因为 MyBatis 需要程序员自己编写 Sql 语句。可以严格控制 sql 执行性能，灵活度高，非常适合对关系数据模型要求不高的软件开发。
Hibernate 对象/关系映射能力强，数据库无关性好，对于关系模型要求高的软件，如果用 hibernate 开发可以节省很多代码，提高效率
7.mybatis的核心文件SqlMapConfig.xml 中配置有哪些内容（至少3个）？
properties（属性） settings（配置） typeAliases（类型别名） typeHandlers（类型处理器） objectFactory（对象工厂） plugins（插件） environments（环境集合属性对象） environment（环境子属性对象） mappers（映射器）
8.列举 mybatis 中至少 3 个常用标签及其作用？
If:判断标签
where：条件标签，
Foreach：循环标签
Sql：动态sql，将通用的sql抽取成公用的
choose, when, otherwise 标签: 有时我们不想应用到所有的条件语句，而只想从中择其一项。针对这种情况，MyBatis 提供 了 choose 元素，它有点像 Java 中的 switch 语句。
9.mybatis的一对一 和一对多标签和怎么进行配置？
一对一映射：
一对一的关系 ：property: 指的是集合属性的值, javaType：指的是集合中元素的类型
一对多映射：
一对多的关系 ：property: 指的是集合属性的值, ofType：指的是集合中元素的类型
10.mybatis中的延迟加载作用和使用场景？
作用：
当需要查询关联信息时再去数据库查询，默认不去关联查询，提高数据库性能。
只有使用resultMap支持延迟加载设置。
场合：
当只有部分记录需要关联查询其它信息时，此时可按需延迟加载，需要关联查询时再向数据库发出sql，以提高数据库性能。
当全部需要关联查询信息时，此时不用延迟加载，直接将关联查询信息全部返回即可，可使用resultType或resultMap完成映射。
11.介绍 mybatis 的一级缓存和二级缓存？
一级缓存：mybatis默认开启
是一个sqlSession范围（从sqlSession的创建到 sqlSession的销毁）
执行commit（）是清空一级缓存
二级缓存：手动开启
可以跨sqlSession (一个namespace范围 共享sqlSession )
执行commit（）是清空二级缓存
12.spring框架的优势？
1.方便解耦，简化开发
2.AOP编程的支持
3.声明式事务的支持
4.方便程序的测试
5.方便集成各种优秀框架
6.降低Java EE API的使用难度
13.说出你对spring两大核心ioc和aop的理解？
IOC 就是控制反转，原来我们需要创建对象的，必须自己 new，但是现在有了 spring 容器，我们不需要再自己 new 了，有两个好处，解耦，因为对象自己 new 完之后，无法更改,如果依赖对象发生异常，则会对我们自己的类造成 影响。 springIOC，用户只需要进行配置，容器会在容器中自动实例化依赖对象，并且是单例模式，直接通过@autowired 直接注入即可。
AOP，一般称为面向切面，作为面向对象的一种补充，用于将那些与业务无关，但却对多个对象产生影响的公共 行为和逻辑，抽取并封装为一个可重用的模块，这个模块被命名为“切面”（Aspect），减少系统中的重复代码， 降低了模块间的耦合度，同时提高了系统的可维护性。可用于权限认证、日志、事务处理。AOP 实现的关键在于 代理模式，AOP 代理主要分为静态代理和动态代理。静态代理的代表为 AspectJ；动态代理则以 Spring AOP 为代表。
14.spring为什么被称为一站式框架？
spring在javaee三层结构中，每一层都提供不同的解决技术
- web层：springMVC
- service层：spring的ioc
- dao层：spring的jdbcTemplate
15.springIOC底层原理？
（1）xml配置文件
（2）dom4j解析xml
（3）工厂设计模式
（4）反射方式创建对象
16.springbean实例化的三种方式？
1、构造器实例化bean
2、静态工厂实例化bean
3、实例工厂实例化bean
17.springbean的作用域范围？
1）singleton：默认，每个容器中只有一个bean的实例
2）prototype：为每一个bean请求提供一个实例
3）request：为每一个网络请求创建一个实例
4）session：与request范围类似，确保每个session中有一个bean的实例，在session过期后，bean会随之失效。
5) global-session：global-session和Portlet应用相关
18.属性注入的方式有哪些？
(1)构造器注入：通过构造方法初始化
(2)setter注入：通过setter方法初始化注入
(3)接口注入
19.什么是IOC？什么是DI？二者有什么关系？
（1）IOC: 控制反转，把对象创建交给spring进行配置
（2）DI: 依赖注入，向类里面的属性中设置值
（3）关系：依赖注入不能单独存在，需要在ioc基础之上完成 *** 作
20.Spring提供了哪几种集合类的配置元素？
: 该标签用来装配可重复的list值。
21.spring中标注项目分层注解？
控制层：controller
业务层：service
持久层：respository
以上三个注解由一个注解衍生@component
22.注解的概念？
通过指定的符号和关键字在类，方法，属性上完成特定功能
23.@Resource注解和@Autowired注解有什么区别？
两个注解都是为类中的属性赋值
@Autowired注解可以自动为类中的属性赋值值，既可以通过类型注入也可以通过名称注入
@Resource(name="XXX")这个注解有个属性name，name的值必须写UserDao里@Component的值；因为Resource是通过引用的方式注入的，引用的就是UserDao里@Component表示的对象
24.介绍一下 spring 中 AOP 的概念以及作用？
AOP，一般称为面向切面，作为面向对象的一种补充，用于将那些与业务无关，但却对多个对象产生影响的公共 行为和逻辑，抽取并封装为一个可重用的模块，这个模块被命名为“切面”（Aspect），减少系统中的重复代码， 降低了模块间的耦合度，同时提高了系统的可维护性。可用于权限认证、日志、事务处理。AOP 实现的关键在于 代理模式，AOP 代理主要分为静态代理和动态代理。静态代理的代表为 AspectJ；动态代理则以 Spring AOP 为代表。
25.aop增强方式？
前置增强
后置增强
环绕增强
异常增强
最终增强
26.Springmvc 的运行原理？ (画图也可以)
- 基本步骤：
- 客户端请求提交到DispatcherServlet（前端控制器）
- 由DispatcherServlet控制器查询一个或多个HandlerMapping（处理器映射器），找到处理请求的Controller
- DispatcherServlet将请求提交到Controller（也称为Handler）
- Controller调用业务逻辑处理后，返回ModelAndView(模型视图数据)
- DispatcherServlet查询一个或多个ViewResoler（视图解析器），找到ModelAndView指定的视图
- 视图负责将结果显示到客户端
27.Springmvc 的三大组建及作用？
处理器映射器 解析xml或者注解等 返回请求的处理器(handler)
处理器适配器 执行处理器(handler) 返回ModelAndView
视图解析器 解析视图返回 view
28.Spring MVC的主要组件和作用？
（1）前端控制器 DispatcherServlet（不需要程序员开发）
作用：接收请求、响应结果 相当于转发器，有了DispatcherServlet 就减少了其它组件之间的耦合度。
（2）处理器映射器HandlerMapping（不需要程序员开发）
作用：根据请求的URL来查找Handler
（3）处理器适配器HandlerAdapter
注意：在编写Handler的时候要按照HandlerAdapter要求的规则去编写，这样适配器HandlerAdapter才可以正确的去执行Handler。
（4）处理器Handler（需要程序员开发）
（5）视图解析器 ViewResolver（不需要程序员开发）
作用：进行视图的解析 根据视图逻辑名解析成真正的视图（view）
29.springmvc处理方法返回值类型？
ModelAndView
Void
String
JSON
30.列举出 springmvc 的常用注解，至少 3 个及其作用？
@controller 主要负责处理前端控制器(DispatcherServlet )发过来的请求
@RequestMapping 是一个用来处理请求地址映射的注解
@RequestParam 是从 Request 里获取参数值
@Service 用于标注业务层
@Autowired，自动装配
@Resource 通过 name 属性去匹配 bean
@ResponseBody ，会直接返回 json 或者 xml 数据。
@RequestBody 接收json或xml数据
31.springmvc处理器转发和重定向关键字区别？
转发：forward: 一次请求一次响应 可以携带参数 只能转发到本项目
重定向：redirect:两次请求两次响应 不可以携带 参数 能重定向到别的项目
32.如何解决get和post乱码问题？
解决post请求乱码：我们可以在web.xml里边配置一个CharacterEncodingFilter 过滤器。设置为utf-8。
解决get请求乱码有两种方法个：
1）修改tomcat配置文件添加编码和工程编码一致；
2) 另一种方法对请求参数进行重新编码；
33.SpringMVC常用的注解有哪些？
@RequestMapping:用于请求url映射。
@RequestBody：注解实现接收http请求的json数据，将json转换为java对象。
@ResponseBody：注解实现将conreoller方法返回对象转化为json对象响应给客户
34.springMVC是线程安全的吗？
springMVC是线程安全的，因为springmvc是基于方法拦截处理请求，参数的变量全
部是局部变量，并且spring中的bean也是单例模式，所以一般情况下不会产生安全问题。
35.SpringMVC和Struts的区别？
- springmvc框架是基于过滤器，通过servlet分发请求，而struts框架是通过拦截器实现的
- springmvc框架是通过方法实现，是单例 但是struts框架是多例的用成员变量接收参数
36.单例模式有什么特点？
(1)单例类确保自己只有一个实例。
(2)单例类必须自己创建自己的实例。
(3)单例类必须为其他对象提供唯一的实例
37.简述事务四大特性：
原子性：事务中的 *** 作要么全部成功要么全部失败
隔离性：并发访问数据库时不能互相干扰
一致性：事务前后数据的完整性保持一致
持久性：事务一旦提交，数据永久发生改变
38.spring的设计模式？
1)工厂模式，BeanFactory用来创建对象的实例。
2) 代理模式，在Aop实现中用到了JDK的动态代理。
3) 单例模式，这个比如在创建bean的时候。
4) 模板方法，用来解决代码重复的问题。比如. RestTemplate, JmsTemplate, JpaTemplate。
39.Java连接数据的四大参数
//加载驱动
Class.forName("com.mysql.jdbc.Driver");
//设置数据库路径
String url = "jdbc:mysql://localhost:端口号/库名";
//用户名
String username ="root";
//密码
String password ="123";
- 常见的五个响应状态码？
200 成功
302 重定向
- 前台提交的数据类型和后台需要的不一致
- 提交路径错误
500 服务器端的错误
P4:
第一天：7题
1：什么是html？
用来描述网页的一种超文本标记语言。
2：html的作用
html就是用于展示信息的
3：html的书写规范
1.由尖括号包围的关键词。
2.通常是成对出现的。标签对第一个标中的签是开始标签，第二个标签是结束标签。
3.大多数标签是可以嵌套的。
4：html中input标签的类型及功能
1. 定义单行的输入字段，用户可在其中输入文本。
2.定义密码字段。该字段中的字符被掩码.
3.定义单选按钮
4. 定义复选框。
5.按钮；定义可点击按钮
6：get和post请求的区别 从哪提交多少数据 安全吗
1.get:通过地址栏提交数据，不安全，数据大小有限制
2.post：通过请求体提交数据，安全，数据大小没有限制
7：img标签的属性有哪些，及作用
1.src:用于设定要引入的图片的url
2.alt:用于设定图像的替代文字（有些浏览器不兼容）如果图片不显示，将显示alt的内容；
3.title：文字提示（鼠标放到图片上时显示）
4.width:用于设定图片的宽度
5.height:用于设定图片的高度
第二天：10题
1：css的含义和作用：
含义：层叠样式表
作用：
1.样式表解决了html的内容与表现分离
2.使用样式表极大的提高了工作效率
2：css与html结合的3种方式是什么？
1.内联式
2.内部式
3.外联式
3：css基本选择器分别有哪些？格式是什么？优先级是什么？
选择器和格式：
1.id选择器。格式：#id
2.class选择器。格式：.class
3.元素选择器。格式：标签名
优先级：
优先级由高到低：id选择器、class选择器、标签选择器
5：js和java的相同点区别
相同之处包括：
1.它们的语法和 C 语言都很相似；
2.它们都是面向对象的（虽然实现的方式略有不同）；
3.Javascript 在设计时参照了 Java 的命名规则；
不同之处包括：
1.Javascript 是动态类型语言，而 Java 是静态类型语言；
2.Javascript 是弱类型的，Java 属于强类型；
3.Javascript 的面向对象是基于原型的（prototype-based）实现的，Java 是基于类（class-based）的；
4.Javascript 除了长得和 Java 比较像之外，语言风格相去甚远。Javascript 在设计时所参考的对象不包括 Java，而包括了像 Self 和 Scheme 这样的语言。
6:js的五种原始类型
1.number：整数/小数/NaN
2.string：字符串
3.boolean：true/false
4. null：空
5.undefined：变量未定义或者未初始化
7.Js中=、==、=== 的区别
=：赋值 var a =10;
==：比较值是否相等
===：比较是数据类型和值 是否相同（"25" 和25 比较结果为false）
8.js的组成
a.ECMA：语法规则；
b.DOM对象
c.BOM对象 （获取浏览器信息）
9. js中创建数组的三种方式？
new Array();// 空数组
new Array(size);// 期望数组的长度，每个元素都是undefined
//创建数组，并初始化指定的值
var arr = [element0, element1, ..., elementn]
10.js中数组的注意事项
1.js中数组长度可以改变
2.js中数组可以存储不同类型的元素；
3.当访问超过索引最大值的元素时没有索引越界异常；
第三天：8题
1.Js中函数的定义格式
方式一：function 函数名(参数列表){
函数体;
return 返回值;(可选项)}
注意：函数需要返回值，就直接用return 返回结果即可。
方式二：var 函数名称 = function(参数列表){
函数体;
return 返回值;}
方式三(了解)：var 函数名称 = new Function(参数列表,函数体);
2.js中全局变量和局部变量定义。
全局变量：在Javascript标签里定义一个变量，在js部分有效
局部变量：在方法里面定义，只有在方法里面使用有效
3.URL和URI的含义。
URI的定义是：统一资源标识符；
URL的定义是：统一资源定位符。
换句话说，URI属于父类，而URL属于URI的子类。URL是URI的一个子集。
4.关于js中的重载问题。
1.js中不存在重载；
2.定义多个同名方法时，会执行最后一个
5.js中Math类常用的方法有。
Abs绝对值
ceil 向上取整
floor向下取整
round四舍五入
random:0到1之间任意值 包括0不包括1
6.请写出document对象中常用的三个获取的方法。
1.getElementById(); (非常重要)返回带有指定id的一个对象(标签对象)
2.getElementsByName();返回带有指定名称的数组，切记返回的是数组；
3.getElementsByTagName();返回带有指定标签名的集合
7.列举BOM 里常用的至少 4 个对象，并列举 window 对象的常用方法至少 5 个
BOM的对象：
Navigator： 浏览器对象
Screen：屏幕信息
History：历史记录
Location：地址栏信息
Window对象：代表一个浏览器窗口
Window对象方法
1.alert() 显示带有一段消息和一个确认按钮的警告框。
2.confirm(参数) 显示带有一段消息以及确认按钮和取消按钮的对话框。
3.prompt() 显示可提示用户输入的对话框。
4.open() 打开一个新的浏览器窗口或查找一个已命名的窗口。
5.close() 关闭浏览器窗口。
8.document对象常用的方法有？
1.write();
2.getElementById();
3.getElementsByName();
4.getElementsByTagName();
第四天：10题
1.Servlet的优缺点：
缺点：不适合设置html响应体，需要大量的response.getWriter().print("")。
优点：动态资源，可以编程 java代码。
2.html的优缺点：
缺点：html是静态页面，不能包含动态信息。
优点：不用为输出html标签而发愁。
3.jsp和Servlet的分工：
JSP：
作为请求发起页面，例如显示表单、超链接。
作为请求结束页面，例如显示数据。
Servlet：
作为请求中处理数据的环节。
4.Jsp的组成
jsp = jsp标签(指令)+html + java脚本
5.jsp原理
本质：jsp其实是一种特殊的Servlet
当jsp页面第一次被访问时，服务器会把jsp编译成java文件（这个java其实是一个servlet类）
然后再把java编译成.class
然后创建该类对象
最后调用它的service()方法
第二次请求同一jsp时，直接调用service()方法。
6.jsp三大指令
page:设置页面属性
include：包含其它页面
talib:引入jstl标签库
7.Jsp9大内置对象
request，response，session，application，config，exception，page，out，pageContext
8.jsp页面中书写java代码的三种方式
<% %>
<%= %>
<%! %>
9.EL表达式的作用
1.输出字符串
2.输出变量值
3.输出对象的属性值
4.输出集合和数组
10.EL表达式(${})的11个内置对象
pageScope
requestScope
sessionScope
applicationScope
param；
paramValues；
header；
headerValues；
initParam；
cookie；
pageContext；
第五天到第七天：4题
1.什么是MVC
M：model模型
V：view视图
C: controller 控制器
2.三层架构含义
1.WEB层：包含JSP和Servlet等；
2.业务层：它只关心业务逻辑；
3.数据层：封装了对数据库访问；
3.ResultSetHandler的各个实现类：
1.ArrayHandler：
2.ArrayListHandler：
3.BeanHandler：
4.BeanListHandler：
5.MapHandler：
6.MapListHandler：
7.ColumnListHandler：
8.KeyedHandler(name)：
9.ScalarHandler
4.分页的好处
提高了速度
减轻了服务器的压力
在不影响用户阅读的前提下，增强了用户体验
第八天：6题
1.:Filter和Servlet的共同点及区别
共同点：
1：都是JavaWeb三大组件
2：都是单例的
3：都需要在web.xml中，或者通过注解进行配置
区别：
1：初始化时机不同，过滤器是在服务器启动时，Servlet是在第一次访问Servlet时
2：作用不同，Filter是拦截和过滤请求，Servlet是接收请求转发请求和完成响应
2.Servlet为什么是单例的？
这东西是服务器创建的，初始化加载一次或者第一次访问只创建一次
3：请说出三个监听器
ServletContext—Listener：上下文文本域监听器
HttpSession—Listener：会话域监听器
ServletRequest—Listener：请求域监听器
4.过滤器(filter)的生命周期：
1：启动服务器是加载过滤器的实例，并调用init()方法来初始化实例 只执行一次
2：每次请求都会调用doFilter()方法 每请求一次执行一次
3：关闭服务器时调用destory()方法来销毁实例。只执行一次
5.过滤器的四种拦截方式
①request 默认是拦请求
②forword 拦转发
③include 拦包含
④error 拦错误
6.javaWeb的三大组件
①servlet
②Filter
③Listener
第九天到第十一天：7题
1.文件上传对页面的要求
1.必须使用表单，而不能是超链接；
2.表单的method必须是POST，而不能是GET；
3.表单的enctype必须是multipart/form-data；
4.在表单中添加file表单字段
3:Jquery三种基本选择器
1.id选择器
2.class选择器
3.标签选择器
4:Jquery常用的方法
val():获取value值
text()：获取标签之间的文本内容
html()：获取标签之间的所有内容
attr(“属性名称”):获取属性
5:Jquery常用的事件
click（）:点击事件
submit（）：表单提交事件
blur（）：失去焦点事件
change（）：改变事件
6:JQuery下封装的ajax三种形式
$.get(“访问路径”，function(data){});
$.post(“访问路劲”，{“name”：“张三”}，function(data){})
$.ajax({
Type:”get”,
Url:”路径”，
data:{ },
success:function(data){
使用data数据
}}
)
7:ajax的优缺点
优点：
增强了用户的体验！
因为服务器无需再响应整个页面，只需要响应部份内容！
缺点：
ajax虽然提高了用户体验，但无形中向服务器发送的请求次数增多了，导致服务器压力增大
第十二天和第十三天：8题
1.xml的简介
xml是可扩展的标记语言。XML的标签是可以由用户自定义的。
2.xml的用途
1. 数据交换：不同语言之间用来交换数据；(qq的收发消息)
2. 小型数据库：用来当数据库存储数据。(存储国家城市信息)
3. 程序的配置文件
3.请写出xml元素命名规则
1.xml代码区分大小写
2. Xml中标签不能以数字和下划线开头
3. xml当中标签不能以xml、XML、Xml等开头；
4.xml的标签不能包含空格和冒号
4.xml两种解析方式和各自优缺点
DOM解析：将整个xml文档加载到内存中，形成文档树，可以对文档树进行增删改查。
优点：可以对文档进行增删改查 *** 作。
缺点：文件过大可能造成内存溢出。
SAX解析：基于事件驱动，边读边解析。
优点：不会造成内容溢出。
缺点：不能对文档进行增删改 *** 作。
6:什么叫做json
用来存储数据的，类似xml，但是json比较方便解析
它是js提供的一种数据交换格式！
7:json的语法
一个对象以 {左括号 开始， }右括号 结束。
每个“名称”后跟一个 :冒号 ；“‘名称/值’ 对”之间使用 ,逗号 分隔
格式：{"key1":obj,"key2":obj,"key3":obj...}
8:json与xml比较
1.可读性：XML胜出
2.解析难度：JSON本身就是JS对象，所以简单很多
3.流行度：XML已经流行好多年，但在AJAX领域，JSON更受欢迎。
第十四天：5
1：请写出事务的概念和事务的sql实现形式
概念：把一系列的sql语句当成一个整体，要么全部成功，要么全部失败。
Sql实现形式：
开启 start transaction
回滚 rollback
提交Commit:
2：事务的隔离等级有哪四个
1.串行化
2.可重复读
3.读已提交数据
4.读未提交数据
3：并发事务不隔离可能出现的问题有哪三个
1.脏读
2.不可重复读
3.幻读
4：事务的四大特性是什么
1.一致性
2.原子性
3.隔离性
4.持久性
5.cookies和session的相同点和区别
相同点：都是跟踪会话的技术
不同点：
1、数据存放位置不同：cookie数据存放在浏览器上，session数据放在服务器上。
2、安全程度不同：
cookie不是很安全，考虑到安全应当使用session。
3、性能使用程度不同：
session会在一定时间内保存在服务器上。当访问增多，会比较占用你服务器的性能,考虑到减轻服务器性能方面，应当使用cookie。
4、数据存储大小不同：
单个cookie保存的数据不能超过4K，浏览器对其没有限制。
P3:
- +聊一聊你对三层架构的理解：
三层架构既是MVC,
M是model，代表模型层，主要用于访问数据库，封装数据。
V 是view,代表视图层，一般指页面，用于展示数据
C 是controller，代表控制层，负责接收前端数据，处理请求并响应
- Tomcat的目录结构
- bin目录：该目录下存放的是二进制可执行文件，如果startup.bat是用来启动tomcat的，shutdown.bat是用来关闭tomcat的。
- Conf目录：用来放配置文件的
- lib目录：Tomcat的类库，存放的是jar包
- logs目录：存放的是日志文件
- temp目录：存放Tomcat的临时文件
- webapps目录：部署web项目的目录
- work目录：运行的文件都在这里（项目运行时生成的文件）
- 说一下sql攻击
SQL攻击也叫sql注入，即是指web应用程序对用户输入数据的合法性没有判断或过滤不严，攻击者可以在web应用程序中事先定义好的查询语句的结尾上添加额外的SQL语句，在管理员不知情的情况下实现非法 *** 作，以此来实现欺骗数据库服务器执行非授权的任意查询。所以一般情况下用preparedStatement。
4、JDBC的核心类以及使用preparedStatement的好处
核心类有：
DriverManage：驱动管理器
Connection：链接对象
Statement：语句发送器对象
ResultSet：结果集（查询时才有）
preparedStatement的好处
①Sql语句执行效率高
②增强代码的可读性和可维护性
③提高了安全性，防止sql注入、
5、说一下exist的使用
exists后跟子查询，子查询有结果是为True，没有结果时为False。为True时外层执行，为False外层不执行。
6、请求转发与重定向的区别
- ：转发是一次请求 重定向是两次请求
- ：转发可以携带数据 重定向不可以
③：转发只能在本项目内转发 所以转发是不用写项目名称。
重定向可以重定向到项目以外的资源，路径必须包含项目名称。
④：转发时地址栏不发生改变，重定向时地址栏发生改变。
7、什么是索引，索引的优缺点
索引(Index)是帮助MySQL高效获取数据的数据结构。
优点：
1、所有的列都可以被设置索引
2、大大加快数据的查询速度
缺点：
1、耗时
2、占空间
8、聊一聊mysql的约束以及其使用场景
1. NOT NULL ：非空约束，用于保证该字段的值不能为空，比如姓名，学号等
2. DEFAULT ：默认约束，用于保证该字段有默认值，比如性别
3. PRIMARY KEY ：主键约束，用于保证该字段的值具有唯一性，并且非空，比如学号，员工编号等
4. UNIQUE : 唯一约束，用于保证该字段的值具有唯一性，可以为空，比如座位号
5.FOREIGN KEY ：外键约束，用于限制两个表的关系，用于保证该字段的值必须来自于主表的关联列的值，在从表中添加外键约束，用于引用主表中某列的值，比如学生表的专业编号，员工表的部门编号，员工表的工种编号
9、sql执行慢的原因
1.硬件问题。如网络速度慢，内存不足，I/O吞吐量小，磁盘空间满了等。
2.没有索引或者索引失效。
3.数据过多（可以通过分库分表解决）
10、什么是视图，视图的好处以及创建视图时需要注意什么？
视图是一种虚拟的表，是从数据库中一个或多个表中导出来的表
视图的作用
1.使 *** 作简单化
2.增加数据的安全性
3.提高表的逻辑独立性
创建视图时需要注意以下几点：
①定义视图的用户必须对所参照的表或视图有查询权限，即可执行SELECT语句。
②不能使用COMPUTE或COMPUTE BY子句。
③不能使用ORDER BY子句。
④不能使用INTO子句。
⑤不能在临时表或表变量上创建视图。
11、说一说连接池的概念以及你知道的链接池
我知道的有dbcp链接池，c3p0链接池，druid链接池。他们用来统一管理连接。连接池可以提高的连接的使用效率，Close()方法不再是关闭连接，而是归还连接给连接池。
- 常见的响应码有哪些？
2xx：响应成功。代表：200
3xx： 代表：302(重定向)，304(访问缓存)
4xx：客户端错误。
404（请求路径没有对应的资源）
405：请求方式没有对应的doXxx方法
5xx：服务器端错误。代表：500(服务器内部出现异常)
13、Servlet和html的优缺点对比？
Servlet
缺点：不适合设置html响应体
优点：动态资源，可以编程 java代码。
html：
缺点：html是静态页面，不能包含动态信息
优点：不用为输出html标签而发愁
14、说说怎么解决乱码问题
请求时乱码：request.setCharacterEncoding("utf-8");
响应时乱码：Resonse.setContextType(“text/html;charset=utf-8”)
- json的作用
a、json现在多用于存储和交换文本信息的语法
b、进行数据的传输
c、json比 XML 更小、更快，更易解析。
16、servlet的生命周期
Init()出生的方法
创建servlet的对象时调用
就一次
Service()服务的方法
浏览器访问servlet时调用
访问一次就调用一次
Destrory()销毁的方法
销毁servlet对象之前调用
一次
P2
1.String是基本数据类型吗？基本数据类型有哪些？
不是。基本数据类型有：byte,short,int,long,char,double,float,boolean
2.switch后的表达式的数据类型
byte,short,int,char,String,枚举
3.请问数组和String有没有length()这个方法或length的属性
数组没有length()这个方法，但有length的属性。String有length()这个方法
4.基本数据类型对应的包装类
byte:Byte float:Float
short:Short double:Double
int:Integer char:Character
long:Long boolean:Boolean
5.Math类中方法有哪些？Math.round(11.5)等於多少? Math.round(-11.5)等於多少?
abs()：求绝对值
max()：求最大值
min()：求最小值
round()：四舍五入
Math.round(11.5)等于12.
Math.round(-11.5)等于-11
Ceil 向上取整
Floor 向下取整
6.Java中继承的特点：
只支持单继承，不支持多继承；支持多层继承
7.接口和抽象类的区别
构造方法：
接口：没有构造方法
抽象类：有构造方法，用于子类访问父类成员时给父类成员初始化。
成员方法：
接口：只能有抽象方法,1.8以后可以有默认方法
抽象类：可以由抽象方法和普通方法
成员变量：
接口：只能是静态常量
抽象类：可以是常量，也可以是变量
8.静态代码块，构造代码块，构造方法执行顺序
静态代码块，构造代码块，构造方法，静态代码块只加载一次
9.方法重写和重载的区别？
重写：子类中出现和父类声明一模一样的方法
重载：同一个类中，出现方法名相同，参数列表不同的方法
10.集合和数组的区别
1）数组的长度不可改变，集合的长度可变
2）数组只能存放相同数据类型的元素，集合可以存放不同类型的元素
3）数组可以存放基本数据类型，也可以存放引用数据类型，集合只能存放引用数据类型
11.构造方法的作用：
创建对象并给成员变量赋值
12.是否可以从一个static方法内部发出对非static方法的调用
不可以，静态只能访问静态
13.String中常用的方法：至少说5个
split()：分割
toString()：获取出字符串的内容
charAt()：获取指定索引处的字符
equals():判断两个字符串内容是否相等
substring():截取
getBytes():将字符串转成字节数组
valueOf():将数据转成字符串
trim():去除两端空格
compareTo():按照字典顺序比较字符串
1.==和equals的区别
==比较基本数据类型的值是否相等，比较引用数据类型的地址值是否相等。
equals本来是比较引用数据类型的地址，可以重写此方法比较对象的属性是否相等。
2.将日期转成字符串和字符串转日期的方法方别是什么？
日期转字符串：
public String format(Date )
字符串转日期：
public Date parse(String)
3.String s1 = "hello" ,s1 += "world"，最原始的s1变了没？
没有，因为String是不可改变的字符序列，一旦创建则不可改变。
4.String s = new String("hello");与String s2 = "hello"有区别吗？
有区别：前者创建了两个对象，后者创建了一个对象
5.StringBuilder和StringBuffer的区别
StringBuilder是长度可变的字符序列，线程不安全，效率高。
StringBuffer是长度可变的字符序列，线程安全，效率低。
6.什么叫自动拆装箱？
自动拆装箱是jdk1.5的新特性。
自动拆箱：
自动的把包装类转换成对应的基本数据类型
自动装箱：
自动的把基本数据类型转换成对应的包装类。
7.画出Collection集合的继承体系
Collection
List Set
ArrayList HashSet
linkedList linkedHashSet
Vector TreeSet
8.泛型的好处。
A:把运行时期的异常提前到了编译期间
B:避免了强制类型转换
C:优化了程序设计，解决了黄色警告线
9.ArrayList遍历方法三种分别是什么？
for循环
增强for循环
迭代器遍历
10. 写出List的子类及特征
ArrayList：底层是数组，查询快，增删慢，线程不安全，效率高。
linkedList：底层是链表，查询慢，增删快，线程不安全，效率高。
Vector：底层是数组，查询快，增删慢，线程安全，效率低。
11.Collection和Collections的区别
Collection是单列集合的根接口
Collections是 *** 作单列集合的工具类。
12.对List集合进行排序有哪些方式？
1）自然排序，实现Comparable接口。需要排序的类实现此接口。
2）比较器排序，实现Comparator接口。一般在sort方法的参数用用匿名内部类去使用。
13.如不指定泛型：集合中存放的数据默认为什么类型的
Object类型的
14.Map集合的遍历方式
1）通过键找值的方式。使用keySet方法获取所有的键存储到set集合中，遍历set集合，使用get方法通过键获取值。
2）通过键值对对象的方式。使用entrySet方法获取所有的键值对对象存储到set集合中，遍历set集合，通过键值对对象获取键和值。
15.HashMap和Hashtable的区别
Hashtable，1.0版本出现，线程是安全的，效率低。不允许null作为键或者值。
HashMap，1.2版本出现，线程是不安全的，效率高。允许null作为键或者值。
16.List，set和map的特点及区别
List特点：有序，有索引，元素可重复
Map特点：元素按键值对存储，无序，键唯一
Set特点：没有索引，元素不可重复
17.Error和Exception的区别
Error 爱要思22:非常严重的错误，程序不必处理，比如内存溢出
Exception: 表示异常，说明程序发成不正常的情况从而导致jvm停止运行的现象。
就是指程序中出现非正常的情况从而导致jvm停止运行的
现象。
18.异常的分类及区别
编译时异常
程序员必须去处理，否则编译不能通过
运行时异常
可以不用处理，一般由于 *** 作不当造成。
19.处理异常的两种方式
1）使用throws关键字声明异常，在方法的声明后，由调用者处理
2）使用try..catch来捕获异常，在方法体中，自己处理
20.Java 中，throw 和 throws 有什么区别
throw用在方法体中，只能抛出一个异常，一定会抛出。
throws用在方法声明上，可以抛出多个，可能会抛出。
21.捕获异常的三种情况
try{
}catch(异常类型 e){
}
try{
}catch(异常类型 e){
}finally{
}
try{
}finally{
}
22.final和finally和finalize的区别
final
是最终的，不可变的。修饰类，该类不能被继承，修饰
方法，方法不能被重写，修饰变量，变量变成常量。
finally
try..catch的异常处理中，里面是必定会执行的代码，一般
用于资源释放。
finalize
是Object类中的一个方法，当垃圾回收器确定不存在
对该对象的更多引用时，由对象的垃圾回收器调用此方法。
23.并发和并行
并发：在同一个时间段内同时运行。
并行：在同一个时间点同时运行。
（记忆：并发是并行的假象）
24.Thread类中start()和run()方法的区别
start()方法被用来启动新创建的线程，而且start()内部调用了run()方法
run()方法的时候，只会是在原来的线程中调用，没有新的线程启动
25.创建多线程的两种方式
1）继承Thread类，重写run方法，run方法中是线程要执行的代码。
创建子类对象，调用start方法开启线程。
2）实现Runnable接口，重写run方法，run方法中是线程要执行的代码，
创建Thread的对象，把Runnable接口的实现类对象作为构造方法的参数，
调用start方法开启线程。
26.怎样解决线程安全问题？
1）同步代码块，
synchronized(任意锁对象){
可能会产生线程安全问题的代码}
2）同步方法
public synchronized void method(){
可能会产生线程安全问题的代码
}
3）Lock锁
- public void lock() :加同步锁。
- public void unlock() :释放同步锁
27.Lock锁和synchronized的区别
lock锁需要手动释放：lock.unlock();
synchronized修饰的锁产生异常时会自动释放
28.线程生命周期图
新建：new
可运行：run
被终止：Teminated
锁阻塞：Blocked
无限等待：Waiting
计时等待：TimedWaiting
29.进程和线程的区别
进程是运行中的程序。
线程是进程的一个执行单元，没有自己独立的内存空间。
30.sleep(),wait()方法的区别?
sleep() 属于Thread类，wait() 属于Object类
sleep()执行后不会释放对象锁，wait()会释放对象锁
31.Lambda表达式的格式及省略规则
格式：
()->{}
省略规则：
1.抽象方法中参数的类型可以省略。
2.当抽象方法的参数只有一个的时候，小括号可以省略。
3.当大括号中语句只有一条的时候，大括号，语句后面
的分号和return关键字都可以省略。
32.绝对路径和相对路径
绝对路径：
以磁盘为起点的路径。
相对路径：
以项目所在路径的根目录作为起点的路径。
33.什么是递归？
递归就是方法自己本身调用自己的现象。
递归分为直接递归和间接递归。
34.递归的注意事项
1）递归要有结束条件，否则，栈内存溢出。
2）递归的次数不能过多，否则，栈内存溢出。
3）构造方法不能递归。
35.io流的分类
根据流向：
输入流
输出流
根据传输的数据类型：
字节流
字符流
36.IO流中顶级的父类们是？
字节输入流：InputStream
字节输出流：OutputStream
字符输入流：Reader
字符输出流：Writer
37.写出四个高效流（缓冲流）的类
缓冲字节输入流：BufferedInputStream
缓冲字节输出流：BufferedOutputStream
缓冲字符输入流：BufferedReader
缓冲字符输出流：BufferedWriter
38.常见的软件结构分为
C/S结构：客户端与服务器结构
B/S结构：浏览器与服务器结构
39.网络通信的三要素：
协议
ip地址
端口号
40.TCP协议和UDP协议的区别
TCP协议：可靠，需要建立连接，效率低
UDP协议：不可靠，不需要建立连接，效率高
--------------------------------------------------------------------------------------------
补充知识点：
1.什么是死锁现象
指的是两个或两个以上的线程执行过程中，为争夺资源出现相互等待的现象
2.反射中获取Class对象的三种方式
第一种：对象名.getClass()
第二种：类名.class
第三种：Class.forName()
3.反射的理解
就是把java类中的各种成分映射成一个个的Java对象
4.JDK1.5有什么新特性?
(1)静态导入 (2)可变参数 (3)增强for循环
(4)自动装箱和拆箱 (5)枚举 (6)泛型
5.单例模式有什么特点？
单例类自己只有一个实例，必须自己创建自己的实例，必须为其他对象提供唯一的实例
6.Java中Runnable和Callable有什么不同？
Runnable从JDK1.0开始就有了，Runnable的run()方法没有返回值
Callable是在JDK1.5增加的，Callable的 call() 方法可以返回值
- 类加载机制
加载，连接，初始化
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）