01面试题----英斯特

英斯特笔试：

1.进程和线程的区别

一个程序下至少有一个进程，一个进程下至少有一个线程，一个进程下也可以有多个线程来增加程序的执行速度。

 

2.线程的生命周期，多线程并发会有什么影响

当线程被创建并启动以后，它既不是一启动就进入了执行状态，也不是一直处于执行状态。 
在线程的生命周期中，它要经过新建(New)、就绪（Runnable）、运行（Running）、阻塞 (Blocked)和死亡(Dead)5种状态。

多线程并发的影响：
多线程并发时会不安全，多线程同时操作对象的属性或者状态时，会因为线程之间的信息不同步，A线程读取到的状态已经过时，而A线程并不知道。

3.队列和栈的特性。在什么实际案例中见过？

堆栈的特性：先进后出，后进先出
队列的特性：先进先出，后进后出

　　

4.synchroized的作用，java中还有那些常用的锁？

synchronized 它可以把任意一个非 NULL 的对象当作锁。他属于独占式的悲观锁，同时属于可重入锁。
1. 作用于方法时，锁住的是对象的实例(this)；
2. 当作用于静态方法时，锁住的是Class实例， 会锁所有调用该方法的线程； 
3. synchronized 作用于一个对象实例时，锁住的是所有以该对象为锁的代码块。
Java中常见的锁还有乐观锁、悲观锁、自旋锁

5.synchronized 和 volatile 的区别是什么？

1.volatile本质是在告诉jvm当前变量在寄存器（工作内存）中的值是不确定的，需要从主存中读取； synchronized则是锁定当前变量，只有当前线程可以访问该变量，其他线程被阻塞住。
2.volatile仅能使用在变量级别；synchronized则可以使用在变量、方法、和类级别的
3.volatile仅能实现变量的修改可见性，不能保证原子性；而synchronized则可以保证变量的修改可见性和原子性
4.volatile不会造成线程的阻塞；synchronized可能会造成线程的阻塞。
5.volatile标记的变量不会被编译器优化；synchronized标记的变量可以被编译器优化

6.spring的Bean的作用域和生命周期

Bean的作用域:单例(singleton)、原型（prototype）、请求（request）、会话（session）、全局会话（global session）	
Bean的生命周期流程：
1.首先容器启动后，会对scope为singleton且非懒加载的bean进行实例化，
2.按照Bean定义信息配置信息，注入所有的属性，
3.如果Bean实现了BeanNameAware接口，会回调该接口的setBeanName()方法，传入该Bean的id，此时该Bean就获得了自己在配置文件中的id，
4.如果Bean实现了BeanFactoryAware接口,会回调该接口的setBeanFactory()方法，传入该Bean的BeanFactory，这样该Bean就获得了自己所在的BeanFactory，
5.如果Bean实现了ApplicationContextAware接口,会回调该接口的setApplicationContext()方法，传入该Bean的ApplicationContext，这样该Bean就获得了自己所在的ApplicationContext，
6.如果有Bean实现了BeanPostProcessor接口，则会回调该接口的postProcessBeforeInitialzation()方法，
7.如果Bean实现了InitializingBean接口，则会回调该接口的afterPropertiesSet()方法，
8.如果Bean配置了init-method方法，则会执行init-method配置的方法，
9.如果有Bean实现了BeanPostProcessor接口，则会回调该接口的postProcessAfterInitialization()方法，
10.经过流程9之后，就可以正式使用该Bean了,对于scope为singleton的Bean,Spring的ioc容器中会缓存一份该bean的实例，而对于scope为prototype的Bean,
   每次被调用都会new一个新的对象，期生命周期就交给调用方管理了，不再是Spring容器进行管理了
11.容器关闭后，如果Bean实现了DisposableBean接口，则会回调该接口的destroy()方法，
12.如果Bean配置了destroy-method方法，则会执行destroy-method配置的方法，至此，整个Bean的生命周期结束。4

7.spring常用的六个注解以及作用

@Component(value)
配置类，当使用该注解时，SpringIOC会将这个类自动扫描成一个bean实例
不写的时候，默认是类名，且首字母小写
@Autowired
自动装配，会根据类型寻找指定的Bean，required:表示假如说在bean目录下找不到指定的注解还需不需要注入，默认是true 修改为false时，表示假如说没有找到可以允许不注入。
@ImportResource({"classpath:xxx.xml"})
能够读取多个xml文件，这样就可以引入多个xml定义的bean
@Service
标注于业务层组件上表示定义一个bean，自动根据所标注的组件名称实例化一个首字母为小写的bean。
@RequestBody
用来传对象参数
@Resource
用来自动装配Bean，激活一个命名资源的依赖注入。@Resource属性name可以定义被自动装配Bean的名称

8.解释什么是事务，多线程事务并发会产生哪些问题，简述事务的四种隔离性

事务是应用程序中一系列严密的操作，所有操作必须成功完成，否则在每个操作中所作的所有更改都会被撤消。
也就是事务具有原子性，一个事务中的一系列的操作要么全部成功，要么一个都不做。 
事务的结束有两种，当事务中的所以步骤全部成功执行时，事务提交。如果其中一个步骤失败，将发生回滚操作，撤消撤消之前到事务开始时的所以操作。 

并发问题可归纳为以下几类: 
A.丢失更新
B.脏读
C.不可重复读
D. 覆盖更新
E.虚读（幻读）

事务的四种隔离性：
A.Serializable（串行化）：一个事务在执行过程中完全看不到其他事务对数据库所做的更新
（事务执行的时候不允许别的事务并发执行。事务串行化执行，事务只能一个接着一个地执行，而不能并发执行。）。
B.Repeatable Read（可重复读）：一个事务在执行过程中可以看到其他事务已经提交的新插入的记录，但是不能看到其他其他事务对已有记录的更新。
C.Read Commited（读已提交数据）：一个事务在执行过程中可以看到其他事务已经提交的新插入的记录，而且能看到其他事务已经提交的对已有记录的更新。
D.Read Uncommitted（读未提交数据）：一个事务在执行过程中可以看到其他事务没有提交的新插入的记录，而且能看到其他事务没有提交的对已有记录的更新。

9.什么是aop，spring的几种通知方式

aop是面向切面编程，在整个系统中，动态横向添加新的功能还不改变原来的业务流程的编程

spring的几种通知方式：
1.前置通知（方法调用前通知）
2.后置通知（方法调用后正常返回的时候通知，可以获取返回值，发生异常的时候不会执行）
3.最终通知（无论程序是否发生异常都会执行的）
4.异常通知（发生异常的执行）
5.环绕通知（方法执行的时候执行）

10.画出jvm的内存运行图并解释其作用

首先Java源代码文件(.java后缀)会被Java编译器编译为字节码文件(.class后缀)，
然后由JVM中的类加载器加载各个类的字节码文件，加载完毕之后，交由JVM执行引擎执行。
在整个程序执行过程中，JVM会用一段空间来存储程序执行期间需要用到的数据和相关信息，
这段空间一般被称作为Runtime Data Area（运行时数据区），也就是我们常说的JVM内存。
因此，在Java中我们常常说到的内存管理就是针对这段空间进行管理

　　

 

11.手写快速排序算法

StreamApi
第一种排序:sorted()，自然排序
 @Test
    public void test8() {
        List<String> list = Arrays.asList("aaa","bbb","ccc","ddd");
        list.stream().sorted().forEach(System.out::println);
    }

第二种排序:sorted(Comparator com)-定制排序
public void test8() {
        List<String> list = Arrays.asList("qqq","aaa","bbb","ccc","ddd");
        list.stream().sorted().forEach(System.out::println);
       	deptList.stream().sorted((x,y) -> {
           if(x.getDeptno().equals(y.getDeptno())) {
               return x.getDname().compareTo(y.getDname());
           }else {
               return x.getLoc().compareTo(y.getLoc());
           }
        });
    }
// 第三种按Map排序

//创建一个Map，并填入数据

Map<String, Integer> codes = new HashMap<>();
codes.put("United States", 1);
codes.put("Germany", 49);
codes.put("France", 33);
codes.put("China", 86);
codes.put("Pakistan", 92);

// 按照Map的键进行排序
Map<String, Integer> sortedMap = codes.entrySet().stream() 
　　　　　　　　.sorted(Map.Entry.comparingByKey())
　　　　　　　　.collect(
　　　　　　　　Collectors.toMap(
　　　　　　　　Map.Entry::getKey, 
　　　　　　　　Map.Entry::getValue,
　　　　　　　　(oldVal, newVal) -> oldVal,
　　　　　　　　LinkedHashMap::new
　　　　　　　　)
　　　　　　　　);

// 将排序后的Map打印
sortedMap.entrySet().forEach(System.out::println);
//按照value排序
　　Map<String, Integer> sortedMap2 = codes.entrySet().stream()
　　　　　　　　　　　　.sorted(Map.Entry.comparingByValue())
　　　　　　　　　　　　.collect(Collectors.toMap(
　　　　　　　　　　　　Map.Entry::getKey,
　　　　　　　　　　　　Map.Entry::getValue,
　　　　　　　　　　　　(oldVal, newVal) -> oldVal,
　　　　　　　　　　　　LinkedHashMap::new));

//排序以后打印

sortedMap2.entrySet().forEach(System.out::println);

　　

　　

12.手写线程安全的单例模式

　　

https://www.runoob.com/design-pattern/singleton-pattern.html

//懒汉式，线程安全
public class Singleton {  
    private static Singleton instance;  
    private Singleton (){}  
    public static synchronized Singleton getInstance() {  
    　　if (instance == null) {  
       　　instance = new Singleton();  
    　　}  
    return instance;  
    }  
}

//饿汉式
public class Singleton {  
    private static Singleton instance = new Singleton();  
    private Singleton (){}  
    public static Singleton getInstance() {  
    　　return instance;  
    }  
} 

//双检锁/双重校验锁（DCL，即double-checked locking），JDK1.5起
public class Singleton {  
    private volatile static Singleton singleton;  
    private Singleton (){}  
    public static Singleton getSingleton() {  
    if (singleton == null) {  
        synchronized (Singleton.class) {  
        　　if (singleton == null) {  
           　　singleton = new Singleton();  
        　　}  
        }  
    }  
    return singleton;  
    }  
}

//登记式/静态内部类
public class Singleton {  
    private static class SingletonHolder {  
    private static final Singleton INSTANCE = new Singleton();  
    }  
    private Singleton (){}  
    public static final Singleton getInstance() {  
    　　return SingletonHolder.INSTANCE;  
    }  
}

//枚举，JDK1.5起
public enum Singleton {  
    INSTANCE;  
    public void whateverMethod() {  
    }  
} 

经验之谈：一般情况下，不建议使用懒汉方式，建议使用饿汉方式。只有在要明确实现lazy loading 效果时，才会
使用登记方式。如果涉及到反序列化创建对象时，可以尝试使用枚举方式。如果有其他特殊的需求，可以考虑使用双检
锁方式。

13.设计一个秒杀的结构图

 

 

 

华为总部面试：
主要都是一些底层的东西，今天两个华为项目组，大概的题目是。
①基本数据类型和他们包装类之间（主要是有基本数据类型，为什么还要有包装类，基本数据类型和包装类在作为形参的时候有什么区别）
②jvm的内存模型【线程私有的线程共有的分别有哪些，分别存放什么，java8方法区改成了什么（改成了元数据区，又问他们有什么区别），什么又叫Java内存泄漏（怎么避免内存泄漏--主要是对象的引用类型）】，垃圾回收机制（新生代老年代的划分，他们分别用什么回收算法，常见的垃圾回收器，他们有什么特点，client和server模式下运行时他们的垃圾回收器是否相同（扯出来什么叫client，server模式，什么叫jit））。第二条很重要，两个项目组都问了
③hashmap 在1.7和1.8的底层实现有什么区别，这些改进有什么优点（以及引申出的桶排序（最快的排序，牺牲内存，保证性能），红黑树他的整体结构，四个规则）两个项目组都问了，第二个问的更深。
④spring通过bean创建对象时，怎么确保他的线程安全的
⑤由于我项目上写了websocket，http和https的区别（主要就是后者的加密，他的加密是基于什么的），当两个人之间通讯时，如何确保信息不会被伪造，篡改，截获（主要可逆加密中的对称加密和非对称加密，以及他们之间的配合使用），还有就是信任链当中的证书问题。
⑥抽象类和接口的区别
⑦你使用过哪些线程安全的类，为什么他们是线程安全的，如果给你一个线程不安全的类，你怎么将他改成线程安全的。
⑧构建一个大致的vue
⑨执行一个jar中的某个方法怎么执行。(主要是有一个MANIFEST.MF文件，在这里面配置main class.然后通过java -jar abc.jar)
⑩一台服务器近期cpu和内存突然使用率变高，怎么排查。
①说一下单点登录的具体实现
②我说我大学学过c和java，他问我java8有一个新特性叫lambda，他和c语言中的什么相似。

绿和：
1.几年工作经验？

2年

 

2.用的什么框架？

spring boot微服架构

 

3.是不是前后端分离

是前后端分离

 

4.用不用vue？用的话常用的指令有哪些？

用vue

v-if指令:是条件渲染指令，它根据表达式的真假来删除和插入元素
语法：v-if="expression"

v-show指令：显示内容 （同angular中的ng-show）

v-else指令：必须和v-if连用  不能单独使用  否则报错   模板编译错误

v-for指令：v-for指令基于一个数组渲染一个列表，它和JavaScript的遍历语法相似
语法：v-for="item in items"

v-bind指令： v-bind 指令可以在其名称后面带一个参数，中间放一个冒号隔开，这个参数通常是HTML元素的特性（attribute）
语法：v-bind:argument="expression"

v-model：v-model（表单元素设置了之后会忽略掉value，checked，selected），常用在表单 <input> 及 <textarea>，让表单元素和数据实现双向绑定（映射关系）

v-on指令：v-on 指令用于给监听DOM事件，它的用语法和v-bind是类似的，例如监听<a>元素的点击事件：<a v-on:click="doSomething">

v-text指令： v-text指令主要是防止页面首次加载时 {{}} 出现在页面上。将对象中数据变量值显示在绑定的标签内容上。
语法：v-text="expresstion"

 

5.js和jq熟悉吗

熟悉，两者区别如下
1、本质上的区别
jQuery是一个JavaScript函数库。jQuery就是基于JavaScript语言写出来的一个框架,实质上还是JavaScript而已。

2、代码书写的不同
jQuery 极大地简化了 JavaScript 编程，jQuery代码比沉重的JavaScript轻灵多了，jquery设计的初衷就是要用更少的代码，漂亮的完成更多的功能。

3、在使用方法上的不同
（1）使用JavaScript和jQuery分别加载DOM：
JavaScript只会执行一次，而jQuery会执行多次。
（2）使用JavaScript和jQuery获取class方法：
JavaScript没有默认的获取class的方法 ，而JQuery， 可以通过$('.className') 调用class的方法。

 

6.springmvc工作流程

工作原理：
1、  用户发送请求至前端控制器DispatcherServlet。

2、  DispatcherServlet收到请求调用HandlerMapping映射器。

3、  映射器找到具体的处理器(可以根据xml配置、注解进行查找)，生成对象及拦截器一并返回给DispatcherServlet。

4、  DispatcherServlet调用HandlerAdapter适配器。

5、  HandlerAdapter经过适配调用具体的处理器Controller（后端控制器)。

6、  Controller执行完成返回ModelAndView。

7、  HandlerAdapter将controller执行结果ModelAndView返回给DispatcherServlet。

8、  DispatcherServlet将ModelAndView传给ViewReslover视图解析器。

9、  ViewReslover解析后返回具体View。

10、DispatcherServlet根据View进行渲染视图（即将模型数据填充至视图中）。

11、 DispatcherServlet响应用户。

 

7.ArrayList和LinkedList的区别

共性：ArrayList与LinkedList都是List接口的实现类，因此都实现了List的所有未实现的方法，只是实现的方式有所不同。

区别：List接口的实现方式不同

ArrayList实现了List接口，以数组的方式来实现的，因此对于快速的随机取得对象的需求，使用ArrayList实现执行效率上会比较好。

LinkedList是采用链表的方式来实现List接口的，因此在进行insert和remove动作时效率要比ArrayList高。适合用来实现Stack(堆栈)与Queue(队列)。

 

8.redis支持的数据类型

Redis支持五种数据类型：string（字符串），hash（哈希），list（列表），set（集合）及zset(sorted set：有序集合)。

 

9.线程问题

概念：一个程序可以有多条执行线索同时执行，一个线程就是程序中的一条执行线索，
         独立运行的基本单位。

状态：
新建状态：执行new()方法
就绪状态：执行start()方法
运行状态：执行run()方法，获取CPU资源
阻塞状态：执行sleep()，让出CPU资源
死亡状态：可用stop()和destroy()强制终止

实现线程方式：继承Thread类，实现Runnable接口 ，实现Callable接口
  join()：线程插队 

sleep()和wait()区别：
sleep()是Thread类的方法，让出cpu,cpu去执行其他线程，会自动恢复。
wait()是Object类的方法，让出同步锁给等待此锁的线程，不会自动恢复。

run()和start()区别：
run()是让该线程所关联的执行代码（一个线程必须管理具体的执行代码）。
start()是启动一个线程，使线程就绪状态。

最佳线程数目=（（线程等待时间+线程CPU时间）/线程CPU时间）*CPU数目
（线程等待时间占比越高，需要越多线程，CPU时间占比越高，需要越少线程）

 

10.vue的路由

前端路由和后端路由：

后端路由：对于普通的网站，所有的超链接都是url地址，所有url都对应服务器上对应的资源
前端路由：对于单页面应用程序来说，主要通过url的hash（#）来实现不同页面的切换，同时hash还有一个特点HTTP请求中不会包含hash相关的内容，所以单页面程序中的页面跳转主要用hash实现
在单页面应用程序中这种通过hash来改变页面的方式称作前端路由区别于后端路由

 

11.为什么用elk+kafka

因为单纯的使用elk 日志收集，进行io读取，容易数据丢失，logstash太多了，扩展不好。非实时性。

 

12.mycat分了哪些表

1. 分库表
表示表的数据存放在多个实际的数据库中，按照一定的规则决定将某条数据存放在某一个数据库的表中；
添加数据时，根据分库规则决定添加到哪个实际数据库表中；
更新和删除数据时，首先定位到数据在哪个实际的数据库表中，然后再进行修改；
查询数据时，从映射的每个数据库中查询符合条件的记录，然后聚合以后返回结果；
存在分库规则，比如rule="auto-sharding-long"

2. 全局表
在每个数据库中都存放了该表的一个副本；
在添加和修改、删除数据时，在每个实际数据库表中都进行添加，操作完成后，每个数据库表的内容仍然相同；
在查询数据库表时，随机选择一个实际数据库表中的数据来返回；
用type="global"来标识。

3. 一对一映射表
一个mycat中的逻辑表映射到一个实际的数据库表，逻辑表与物理表之间是1对1映射的；

 

13.Rabbitmq怎么实现的

RabbitMQ使用以及原理解析

RabbitMQ是一个实现了AMQP（Advanced Message Queuing Protocol）高级消息队列协议的消息队列服务，用的是Erlang语言。
几个概念说明:
Broker:它提供一种传输服务,它的角色就是维护一条从生产者到消费者的路线，保证数据能按照指定的方式进行传输,
Exchange：消息交换机,它指定消息按什么规则,路由到哪个队列。
Queue:消息的载体,每个消息都会被投到一个或多个队列。
Binding:绑定，它的作用就是把exchange和queue按照路由规则绑定起来.
Routing Key:路由关键字,exchange根据这个关键字进行消息投递。
vhost:虚拟主机,一个broker里可以有多个vhost，用作不同用户的权限分离。
Producer:消息生产者,就是投递消息的程序.
Consumer:消息消费者,就是接受消息的程序.
Channel:消息通道,在客户端的每个连接里,可建立多个channel.

 

易九：
介绍项目
找一个模块的业务逻辑讲一下
介绍一下中台架构
Es是什么

拜客科技：
Final

修饰类，类不能被继承

修饰变量，变量变成常量，只能被赋值一次，一般会与public static共用

修饰方法，方法不能被重写

Final修饰对象，该对象不能再指向其他引用，换句话，该对象不能再接受new对象的赋值情况

　　

1.接口和抽象

(1)接口的特点：

 接口的关键字：interface

a.所有的方法都是用public abstract 修饰的。(不写也默认有)

b.接口不能实例化

c.实现类必须实现接口的所有方法

d.实现类可以实现多个接口（java中的"多继承"的关系）

e.所有的变量都是使用public static final 修饰的(静态常量)。

 

 (2)接口用的是什么协议

a.HTTP  超文本传输协议

b.HTTPS  安全超文本传输协议

c.FTP  文件传输协议( Xshell的文件拖拽)

d.TCP 网络控制协议

e.IP  互联网协议

f.UDP  用户数据协议

 

(3) java中抽象类的特点：

a.抽象类可以定义构造函数

b.抽象类可以声明和使用字段

c.如果一个类中有抽象方法，那么这个类一定是抽象类

d.抽象类中可以存在普通属性、方法、静态属性和静态方法

e.抽象类中不一定有抽象方法

f.抽象类中的抽象方法需要有子类实现，如果子类不实现，则子类也需要定义为抽象的

 

(4) 区别:

a.抽象类可以声明和使用字段；接口则不能，但是可以创建静态的final常量

b.抽象类可以定义构造函数，接口不能

c.抽象类中的方法可以是public、protected、private或者默认的package；接口的方法都是public（不管是否声明，接口都是公开的）

d.java接口中声明的变量默认都是final的，抽象类可以包含非final变量

e.抽象类可以在不提供接口方法实现的情况下实现接口

f.接口是绝对抽象的，不可以被实例化。抽象类也不可以被实例化，但是如果它包含main方法的话是可以被调用的

 

2.String能被继承吗，为什么

不能被继承，因为String类有final修饰符，而final修饰的类是不能被继承的。

3.流

1.按流向区分：输出流： OutputStream,Writer 基类
           输入流： InputSteam,Reader   基类
2.数据单元分：字节流： 字节输入流InputStream，字节输出流OutputStream
           字符流： 字符输入流Reader，字符输出流Writer

 

4.throws和throw的区别

throws：用来声明一个方法可能产生的所有异常，不做任何处理而是将异常往上传，谁调用我我就抛给谁。
  用在方法声明后面，跟的是异常类名
  可以跟多个异常类名，用逗号隔开
  表示抛出异常，由该方法的调用者来处理
  throws表示出现异常的一种可能性，并不一定会发生这些异常
throw：则是用来抛出一个具体的异常类型。
  用在方法体内，跟的是异常对象名
  只能抛出一个异常对象名
  表示抛出异常，由方法体内的语句处理
  throw则是抛出了异常，执行throw则一定抛出了某种异常  

5.事务的实现

（1）编程式事务管理对基于 POJO 的应用来说是唯一选择。我们需要在代码中调用beginTransaction()、commit()、rollback()等事务管理相关的方法，这就是编程式事务管理。
（2）基于 TransactionProxyFactoryBean的声明式事务管理
（3）基于 @Transactional 的声明式事务管理
（4）基于Aspectj AOP配置事务

 

6.Mybatis延时原理

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

 

7.数据库优化，回答了之后，他会问他就要在where中对字段进行null判断怎么解决

数据库优化：

1、在表中建立索引，优先考虑where、group by使用到的字段。

2、尽量避免使用select *，返回无用的字段会降低查询效率。如下：

SELECT * FROM t 

优化方式：使用具体的字段代替*，只返回使用到的字段。
 

3、尽量避免使用in 和not in，会导致数据库引擎放弃索引进行全表扫描。如下：

SELECT * FROM t WHERE id IN (2,3)

SELECT * FROM t1 WHERE username IN (SELECT username FROM t2)

优化方式：如果是连续数值，可以用between代替。如下：

SELECT * FROM t WHERE id BETWEEN 2 AND 3

如果是子查询，可以用exists代替。如下：

SELECT * FROM t1 WHERE EXISTS (SELECT * FROM t2 WHERE t1.username = t2.username)
 

4、尽量避免使用or，会导致数据库引擎放弃索引进行全表扫描。如下：

SELECT * FROM t WHERE id = 1 OR id = 3

优化方式：可以用union代替or。如下：

SELECT * FROM t WHERE id = 1
UNION
SELECT * FROM t WHERE id = 3

（PS：如果or两边的字段是同一个，如例子中这样。貌似两种方式效率差不多，即使union扫描的是索引，or扫描的是全表）

 

5、尽量避免在字段开头模糊查询，会导致数据库引擎放弃索引进行全表扫描。如下：

SELECT * FROM t WHERE username LIKE '%li%'

优化方式：尽量在字段后面使用模糊查询。如下：

SELECT * FROM t WHERE username LIKE 'li%'


6、尽量避免进行null值的判断，会导致数据库引擎放弃索引进行全表扫描。如下：------------------where中对字段进行null判断怎么解决？

SELECT * FROM t WHERE score IS NULL

优化方式：可以给字段添加默认值0，对0值进行判断。如下：

SELECT * FROM t WHERE score = 0

 

7、尽量避免在where条件中等号的左侧进行表达式、函数操作，会导致数据库引擎放弃索引进行全表扫描。如下：

SELECT * FROM t2 WHERE score/10 = 9

SELECT * FROM t2 WHERE SUBSTR(username,1,2) = 'li'

优化方式：可以将表达式、函数操作移动到等号右侧。如下：

SELECT * FROM t2 WHERE score = 10*9

SELECT * FROM t2 WHERE username LIKE 'li%'


8、当数据量大时，避免使用where 1=1的条件。通常为了方便拼装查询条件，我们会默认使用该条件，数据库引擎会放弃索引进行全表扫描。如下：

SELECT * FROM t WHERE 1=1

优化方式：用代码拼装sql时进行判断，没where加where，有where加and。

8.Dubbo功能

9.Dubbo怎么部署，几种方式

 

方式：
1、 使用web容器（Tomcat、Jetty等）启动dubbo服务 ：
增加端口管理复杂性， tomcat/jetty等都需要占用端口，dubbo服务也需要端口；浪费资源（内存），单独启动 tomcat，jetty占用内存大
运用：需要提供web服务的模块，一般dubbo client可以使用这种方式部署

2、使用自建Main方法类运行spring容器启动dubbo服务：Dobbo提供的优雅停机高级特性没用上，并且自已编写启动类可能会有缺陷
运用：在开发阶段测试dubbo server可以使用这种方式

3、使用Dubbo框架提供的Main方法类运行Spring容器启动服务：官方建议使用，dubbo框架本身提供启动类（com.alibaba.dubbo.container.Main），可实现优雅关机，打包的时候使用maven打成普通的jar包就可以了。
运用：生产上dubbo server可以用这种方式部署。
————————————————
版权声明：本文为CSDN博主「HsiunKao」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/growdane/article/details/84639182

 

10.Redis支持的数据类型，在什么情况下用
11.Reids的持久化，怎么实现
12.并行与并发的区别
13.什么是死锁
14.怎么防止死锁
15.同步关键字的实现原理
16.Springboot的注解，和里面包含的注解以及作用
17.Sleep和wait的区别
18.#{}和${}区别
19.Struts
20.自己设计一个shiro流程

一些笔试题：
1.有n个整数，使其前面各数顺序向后移m个位置，最后m个数变成最前面的m个数

 

import java.util.Scanner;
public class lianxi36 {
public static void main(String[] args) {
   int N =10;
   int[] a = new int[N];
   Scanner s = new Scanner(System.in);
   System.out.println("请输入10个整数：");
   for(int i=0; i<N; i++) {
    a[i] = s.nextInt();
   }
   System.out.print("你输入的数组为：");
   for(int i=0; i<N; i++) {
     System.out.print(a[i] + " ");
   }
   System.out.print("\n请输入向后移动的位数：");
   int m = s.nextInt();
   int[] b = new int[m];
   for(int i=0; i<m; i++) {
    b[i] = a[N-m+i];
   }
   for(int i=N-1; i>=m; i--) {
   a[i] = a[i-m];
   }
   for(int i=0; i<m; i++) {
    a[i] = b[i];
   }
System.out.print("位移后的数组是：");
   for(int i=0; i<N; i++) {
    System.out.print(a[i] + " ");
   }
}
}

 

 

 

2.给定一个整数N，按以下模式打印2*N行。如果N=4则
1
2*3
4*5*6
7*8*9*10
7*8*9*10
4*5*6
2*3
1
输入：n—>表示行数的整数
输出：按指定行数打印出该模式

public class printmatrix {

    public static int helper[] = new int[100];

    public static void calc(int n){
        if(n==1){
            helper[n]=1;
            return;
        }
        if(helper[n-1]==0)
            calc(n-1);
        helper[n] = helper[n-1]+n;
    }

    public static void printNum(int n){
        if(helper[n]==0){
            calc(n);
        }
        String[] strs = new String[n+1];
        int row = 1;
        for(;row<=n;row++){
            String str = new String();
            for(int i=helper[row-1]+1;i<=helper[row];i++){
                if(!str.equals(""))str+='*';
                str += i;
            }
            strs[row] = str;
        }
        for(String str : strs){
            if(str==null)continue;
            System.out.println(str);
        }
        for(int i=n;i>0;i--){
            System.out.println(strs[i]);
        }
    }
    public static void main(String[] args) {
        // TODO Auto-generated method stub

        printmatrix.printNum(4);
    }
}

3.谈谈你对webService的看法

WebService，顾名思义就是基于Web的服务。它使用Web(HTTP)方式，接收和响应外部系统的某种请求。从而实现远程调用

 

4.谈谈你对存储过程的看法

我理解的存储过程就是预先定义好的SQL语句，然后存储起来，等你用的时候再把自己所需要的匹配的SQL语句用Execute(即exec)调用就行！

5.已知表（Sales）

 

1>写出求每个Company的Amout的合计在10000以上的数据的SQL语句。
2>过滤掉Company、Amout重复的数据。只保留一条。以上述数据为例。执行结果应该为：

6.如下代码有错么？错在哪里？请说明情况。
List list=null；
System.out.println(list.length);

null没有 .size()
你可以 List<object> aa= new List<object>(); (C#语言，java类似）
就是意思是new一个list对象 这样.size()就可以用了

7.谈谈你对java集合类的看法。List，Set，Map是否继承自Collection接口？

Collection是最基本的集合接口，声明了适用于JAVA集合（只包括Set和List）的通用方法。 
Set 和List 都继承了Conllection；Set具有与Collection完全一样的接口，因此没有任何额外的功能，不像前面有两个不同的List。
实际上Set就是Collection,只 是行为不同。(这是继承与多态思想的典型应用：表现不同的行为。)Set不保存重复的元素(至于如何判断元素相同则较为负责) 
Map没有继承于Collection接口 从Map集合中检索元素时，只要给出键对象，就会返回对应的值对象。 

 

8.abstract class 和 interface有什么区别？

1. 抽象类可以有构造方法，接口不能有构造方法 
2. 抽象类中可以有普通成员变量，接口中没有普通成员变量 
3. 抽象类中可以包含非抽象的普通方法，接口中的所有方法必须是抽象的，不能有非抽象的普通方法 
4. 抽象类中抽象方法的访问类型可以是public，protected和默认类型虽然（eclipse下不报错，但应该也不行），但接口中的抽象方法只能是public类型，并且默认即为public abstract类型 
5. 抽象类中可以包含静态方法，接口中不能包含静态方法 
6. 抽象类和接口中都可以包含静态成员变量，抽象类中的静态成员变量的访问类型可以任意，但接口中定义的变量只能是public static final类型，并且默认即为public static final类型 
7. 一个类可以实现多个接口，但只能继承一个抽象类

9.启动一个线程使用run()还是start()？

启动线程肯定要用start()方法。当用start()开始一个线程后，线程就进入就绪状态，使线程所代表的虚拟处理机处于可运行状态，
这意味着它可以由JVM调度并执行。这并不意味着线程就会立即运行。当cpu分配给它时间时，才开始执行run()方法(如果有的话)。
start()是方法,它调用run()方法.而run()方法是你必须重写的. run()方法中包含的是线程的主体。 

10.应用服务器有哪些？

根据确定文档内容的时间，所有文档可以划分为静态Web文档、动态web文档和活动文档。常用的Web应用服务器有：nginx、Apache、Tomcat、WebLogic、Resin、Glassfish、JBoss、WebSphere等等。

11.如何理解transaction事务的概念？

事务（transaction）的概念与特性
    事务是一系列操作，这些操作组成了一个逻辑工作单元。这个逻辑工作
    单元中的操作作为一个整体，要么全部成功，要么全部失败。
    事务的特性（ACID）：
    1.原子性（Atomicity）：
      事务中的一系列操作作为一个原子性的逻辑工作单元，这个逻辑工作
      单元中的操作要么全部成功，要么全部失败。
    2.一致性（Consistency）：
      事务操作之前与操作之后数据库系统的数据状态是从一种一致性状态
      转换到另一种一致性状态。
    3.隔离性(Isolation)
      多个事务并发执行时，互相不能看到对方的操作过程。
    4.持久性（Durability）
      一旦事务执行成功，对数据库系统的影响是持久性的。

12.String时最基本的数据类型吗？String和StringBuffer的区别？

String不是基本的数据类型
（1）String:是对象不是原始类型.为不可变对象,一旦被创建,就不能修改它的值.对于已经存在的String对象的修改都是重新创建一个新的对象,然后把新的值保存进去.String 是final类,即不能被继承
（2）StringBuffer:是一个可变对象,当对他进行修改的时候不会像String那样重新建立对象。它只能通过构造函数来建立对象被建立以后,在内存中就会分配内存空间,并初始保存一个null.
　　 向StringBuffer中付值的时候可以通过它的append方法.

13.int 和 Integer有什么区别？

1、Integer是int的包装类，int则是java的一种基本数据类型 
2、Integer变量必须实例化后才能使用，而int变量不需要 
3、Integer实际是对象的引用，当new一个Integer时，实际上是生成一个指针指向此对象；而int则是直接存储数据值 
4、Integer的默认值是null，int的默认值是0

14.运行时异常与一般异常有何异同？

异常表示程序运行过程中可能出现的非正常状态，

运行时异常：表示虚拟机的通常操作中可能遇到的异常，是一种常见运行错误。java编译器要求方法必须声明抛出可能发生的非运行时异常，
但是并不要求必须声明抛出未被捕获的运行时异常。

一般异常：java编译器强制要求我们必需对出现的异常进行try…catch…处理的否则程序不能通过编译

15.说出Servlet的生命周期，并说出Servlet和CGI的区别？

Servlet的生命周期分为5个阶段:
实例化：Servlet容器创建Servlet类的实例。
初始化：该容器调用init()方法，通常会申请资源。
服务：由容器调用service()方法，（也就是doGet()和doPost()）。
破坏：在释放Servlet实例之前调用destroy()方法，通常会释放资源。
不可用：释放内存的实例。
CGI（Common Gateway Interface通用网关接口）程序来实现数据在Web上的传输，使用的是如Perl这样的语言编写的，它对于客户端作出的每个请求，
必须创建CGI程序的一个新实例，这样占用大量的内存资源。由此才引入了Servlet技术。
Servlet是一个用java编写的应用程序，在服务器上运行，处理请求信息并将其发送到客户端。对于客户端的请求，只需要创建Servlet的实例一次，因此节省了大量的内存资源。
Servlet在初始化后就保留在内存中，因此每次作出请求时无需加载。

16.说出ArrayList，Vector，LinkedList的存储性能和特性

ArrayList和Vector都是使用数组方式存储数据，此 数组元素数大于实际存储的数据以便增加和插入元素，它们都允许直接按序号索引元素，
但是插入元素要涉及数组元素移动等内存操作，所以索引数据快而插入数据 慢，Vector由于使用了synchronized方法（线程安全），通常性能上较ArrayList差，而LinkedList使用双向链表实现存储，
按序号索引数据需要进行前向或后向遍历，但是插入数据时只需要记录本项的前后项即可，所以插入速度较快。
一.同步性:Vector是线程安全的，也就是说是同步的，而ArrayList是线程序不安全的，不是同步的
二.数据增长:当需要增长时,Vector 默认增长为原来一培，而ArrayList却是原来的一半

17.条件：
学生表student：学号sno，姓名name
课程成绩表student_score：学号sno，学科stype，分数score
(1)查询所有同学的学生编号，学生姓名，选课总数，所有课程的总成绩
(2)检索“01”课程分数小于60，按分数降序排列的学生信息
(3)查询至少有一门课与学号为"01"的同学所学相同的同学的信息
编写新增学生信息的rest接口，包括用到的注解
(1).controller
(2).service
(3).dao
(4).xml,sql层

------------恢复内容结束------------

英斯特笔试：
1.进程和线程的区别

进程:是系统进行分配和管理资源的基本单位

线程:进程的一个执行单元, 是进程内调度的实体、是CPU调度和分派的基本单位, 是比进程更小的独立运行的基本单位。线程也被称为轻量级进程, 线程是程序执行的最小单位。

 一个程序至少一个进程, 一个进程至少一个线程。

 进程有自己的独立地址空间, 每启动一个进程, 系统就会为它分配地址空间, 建立数据表来维护代码段、堆栈段和数据段， 这种操作非常昂贵。

而线程是共享进程中的数据的, 使用相同的地址空间, 因此CPU切换一个线程的花费远比进程要小很多, 同时创建一个线程的开销啊也比进程要小很多。

 线程之间的通信更方便, 同一进程下的线程共享全局变量、静态变量等数据, 而进程之间的通信需要以通信的方式进行。

 如何处理好同步与互斥是编写多线程程序的难点。

 多进程程序更健壮, 进程有独立的地址空间, 一个进程崩溃后, 在保护模式下不会对其它进程产生影响,

而线程只是一个进程中的不同执行路径。线程有自己的堆栈和局部变量, 但线程之间没有独立的空间, 所以可能一个线程出现问题, 进而导致整个程序出现问题

 

2.线程的生命周期，多线程并发会有什么影响
3.队列和栈的特性。在什么实际案例中见过？
4.synchroized的作用，java中还有那些常用的锁？
5.synchronized 和 volatile 的区别是什么？
6.spring的Bean的作用域和生命周期
7.spring常用的六个注解以及作用
8.解释什么是事务，多线程事务并发会产生哪些问题，简述事务的四种隔离性
9.什么是aop，spring的几种通知方式
10.画出jvm的内存运行图并解释其作用
11.手写快速排序算法
12.手写线程安全的单例模式
13.设计一个秒杀的结构图

 

 

 

华为总部面试：
主要都是一些底层的东西，今天两个华为项目组，大概的题目是。
①基本数据类型和他们包装类之间（主要是有基本数据类型，为什么还要有包装类，基本数据类型和包装类在作为形参的时候有什么区别）
②jvm的内存模型【线程私有的线程共有的分别有哪些，分别存放什么，java8方法区改成了什么（改成了元数据区，又问他们有什么区别），什么又叫Java内存泄漏（怎么避免内存泄漏--主要是对象的引用类型）】，垃圾回收机制（新生代老年代的划分，他们分别用什么回收算法，常见的垃圾回收器，他们有什么特点，client和server模式下运行时他们的垃圾回收器是否相同（扯出来什么叫client，server模式，什么叫jit））。第二条很重要，两个项目组都问了
③hashmap 在1.7和1.8的底层实现有什么区别，这些改进有什么优点（以及引申出的桶排序（最快的排序，牺牲内存，保证性能），红黑树他的整体结构，四个规则）两个项目组都问了，第二个问的更深。
④spring通过bean创建对象时，怎么确保他的线程安全的
⑤由于我项目上写了websocket，http和https的区别（主要就是后者的加密，他的加密是基于什么的），当两个人之间通讯时，如何确保信息不会被伪造，篡改，截获（主要可逆加密中的对称加密和非对称加密，以及他们之间的配合使用），还有就是信任链当中的证书问题。
⑥抽象类和接口的区别
⑦你使用过哪些线程安全的类，为什么他们是线程安全的，如果给你一个线程不安全的类，你怎么将他改成线程安全的。
⑧构建一个大致的vue
⑨执行一个jar中的某个方法怎么执行。(主要是有一个MANIFEST.MF文件，在这里面配置main class.然后通过java -jar abc.jar)
⑩一台服务器近期cpu和内存突然使用率变高，怎么排查。
①说一下单点登录的具体实现
②我说我大学学过c和java，他问我java8有一个新特性叫lambda，他和c语言中的什么相似。

绿和：
1.几年工作经验？
2.用的什么框架？
3.是不是前后端分离
4.用不用vue？用的话常用的指令有哪些？
5.js和jq熟悉吗
6.springmvc工作流程
7.ArrayList和LinkedList的区别
8.redis支持的数据类型
9.线程问题
10.介绍一下项目
11.vue的路由
12.为什么用elk+kafka
13.mycat分了哪些表
14.Rabbitmq怎么实现的

易九：
介绍项目
找一个模块的业务逻辑讲一下
介绍一下中台架构
Es是什么

拜客科技：
Final
1.接口和抽象
2.String能被继承吗，为什么
3.流
4.异常和throw的区别
5.事务的实现
6.Mybatis延时原理
7.数据库优化，回答了之后，他会问他就要在where中对字段进行null判断怎么解决
8.Dubbo功能
9.Dubbo怎么部署，几种方式
10.Redis支持的数据类型，在什么情况下用
11.Reids的持久化，怎么实现
12.并行与并发的区别
13.什么是死锁
14.怎么防止死锁
15.同步关键字的实现原理
16.Springboot的注解，和里面包含的注解以及作用
17.Sleep和wait的区别
18.#{}和${}区别
19.Struts
20.自己设计一个shiro流程

一些笔试题：
1.有n个整数，使其前面各数顺序向后移m个位置，最后m个数变成最前面的m个数
2.给定一个整数N，按以下模式打印2*N行。如果N=4则
1
2*3
4*5*6
7*8*9*10
7*8*9*10
4*5*6
2*3
1
输入：n—>表示行数的整数
输出：按指定行数打印出该模式
3.谈谈你对webService的看法
4.谈谈你对存储过程的看法
5.已知表（Sales）

 

1>写出求每个Company的Amout的合计在10000以上的数据的SQL语句。
2>过滤掉Company、Amout重复的数据。只保留一条。以上述数据为例。执行结果应该为：

6.如下代码有错么？错在哪里？请说明情况。
List list=null；
System.out.println(list.length);
7.谈谈你对java集合类的看法。List，Set，Map是否继承自Collection接口？
8.abstract class 和 interface有什么区别？
9.启动一个线程使用run()还是start()？
10.应用服务器有哪些？
11.如何理解transaction事务的概念？
12.String时最基本的数据类型吗？String和StringBuffer的区别？
13.int 和 Integer有什么区别？
14.运行时异常与一般异常有何异同？
15.说出Servlet的生命周期，并说出Servlet和CGI的区别？
16.说出ArrayList，Vector，LinkedList的存储性能和特性
17.条件：
学生表student：学号sno，姓名name
课程成绩表student_score：学号sno，学科stype，分数score
(1)查询所有同学的学生编号，学生姓名，选课总数，所有课程的总成绩
(2)检索“01”课程分数小于60，按分数降序排列的学生信息
(3)查询至少有一门课与学号为"01"的同学所学相同的同学的信息
编写新增学生信息的rest接口，包括用到的注解
(1).controller
(2).service
(3).dao
(4).xml,sql层