2018百度秋招一面/二面/三面

1.int和integer所占字节，int 、new integer、integer区别，大于128的时候有什么区别。
int、integer所占字节为4字节。
1. int 和Integer在进行比较的时候，Integer会进行拆箱，转为int值与int进行比较。
2. Integer与Integer比较的时候，由于直接赋值的时候会进行自动的装箱，那么这里就需要注意两个问题，一个是-128<= x<=127的整数，将会直接缓存在IntegerCache中，那么当赋值在这个区间的时候，不会创建新的Integer对象，而是从缓存中获取已经创建好的Integer对象。二：当大于这个范围的时候，直接new Integer来创建Integer对象。
3. new Integer(1) 和Integer a = 1不同，前者会创建对象，存储在堆中，而后者因为在-128到127的范围内，不会创建新的对象，而是从IntegerCache中获取的。那么Integer a = 128, 大于该范围的话才会直接通过new Integer（128）创建对象，进行装箱。

    public static void main(String[] args) {
        int i = 128;
        Integer i2 = 128;
        Integer i3 = new Integer(128);
        //Integer会自动拆箱为int，所以为true
        System.out.println(i == i2);//true
        System.out.println(i == i3);//true
        System.out.println(i2==i3);//false
        Integer i5 = 127;//java在编译的时候,被翻译成-> Integer i5 = Integer.valueOf(127);
        Integer i6 = 127;
        System.out.println(i5 == i6);//-128—127直接，直接在缓存中取值。true
        Integer ii5 = new Integer(127);
        System.out.println(i5 == ii5); //false
        Integer ii7 = 128;
        Integer ii8 = 128;
        System.out.println(ii7 == ii8);//false，大于等于128，相当于两个对象相比较
        Integer i7 = new Integer(128);
        Integer i8 = new Integer(128);
        System.out.println(i7 == i8);  //false
    }

2.string，stringbuff，stringbuild的区别，执行效率。
1.三者在执行速度方面的比较：StringBuilder > StringBuffer > String
2. String：字符串常量,StringBuffer：字符创变量，StringBuilder：字符创变量
3. 　StringBuilder：线程非安全的，StringBuffer：线程安全的
4. 1.如果要操作少量的数据用 = String; 2.单线程操作字符串缓冲区 下操作大量数据 = StringBuilder; 3.多线程操作字符串缓冲区 下操作大量数据 = StringBuffer
3.final(变量、方法、类) finally finalize
final：Java中的关键字，修饰符。
1.如果一个类被声明为final，就意味着它不能再派生出新的子类，不能作为父类被继承。因此，一个类不能同时被声明为absrtact抽象类的和final的类。
2.如果将变量或者方法声明为final，可以保证它们在使用中不被改变.
2.1 被声明为final的变量必须在声明时给定初值，而在以后的引用中只能读取，不可修改。
2.2被声明final的方法只能使用，不能重载
finally：java的一种异常处理机制。
finally是对Java 异常处理模型的最佳补充。finally 结构使代码总会执行，而不管有无异常发生。使用 finally 可以维护对象的内部状态，并可以清理非内存资源。特别是在关闭数据库连接这方面，如果程序员把数据库连接的close()方法放到finally中，就会大大降低程序出错的几率。
finally()一定会执行，除非jvm停止运行。
finalize：Java中的一个方法名。
Java技术使用finalize()方法在垃圾收集器将对象从内存中清除出去前，做必要的清理工作。这个方法是由垃圾收集器在确定这个对象没有被引用时对这个对象调用的。
3.可变长参数
只要在一个形参的“类型”与“参数名”之间加上三个连续的“.”（即“…”，英文里的句中省略号），就可以让它和不确定个实参相匹配。而一个带有这样的形参的方法，就是一个实参个数可变的方法。
private static int sumUp(int… values) {
}
http://www.cnblogs.com/uptownBoy/articles/1698335.html
4.Java集合，ArrayList和 LinkedList
http://blog.csdn.net/qq_23211905/article/details/72824261
http://blog.csdn.net/qq_23211905/article/details/72884818
http://blog.csdn.net/qq_23211905/article/details/72885139
5.hashMap原理，hash碰撞解决方法，扩容机制，线程不安全怎么解决
http://blog.csdn.net/qq_23211905/article/details/72592134
线程不安全怎么解决：hashtable，Map map = Collections.synchronizedMap(new HashMap()); ConcurrentHashMap
6.ConcurrentHashMap原理，get和计算size的方法，ConcurrentHashMap哪些操作效率低
java 1.7 http://ifeve.com/concurrenthashmap/
http://blog.csdn.net/qq_23211905/article/details/72804144
7.线程不安全处理的关键字和方法
voliate，synchronized，threadlocal，lock。
8.synchronized和lock区别
1)synchronized使用object对象本身的notify,wait,notifyAll调度机制，lock使用condition进行线程间的调度
2）用法不同，synchronized用在需要同步的对象，方法，代码块，其中括号表示需要锁的对象。Lock有显示的指定起始和终止位置。
3）性能不一样。Lock接口的实现类ReentrantLock。拥有和synchronized相同的并发性和内存语义，还多了投票锁、定时锁、等候和中断锁。在竞争激烈的情况下synchronized性能弱ReetrantLock，当竞争不激烈时synchronized性能较好。
4)机制不一样，synchronized获得锁和释放的方式都在快结构中，当获取多个锁时候，释放的顺序相反。Lock需要开发人员主动释放，必须放在finally中，否则会发生死锁，tryLock是非阻塞的
9.voliate原理和synchronized区别
1)关键字 volatile是线程同步轻量级实现，性能比synchronized好，但是volatitle只能修饰变量，synchronized可以修饰方法，代码块。
2）多线程访问synchronized会阻塞，而volatile不会。
3）volatile能保证数据可见性，但是不能保证原子性。synchronized能够保证原子性，同时保证线程可见性，因为它是将私有内存和共有内存中的数据进行通报。
4)关键字volatile是解决变量在多线程间的可见性，而synchronized是解决多个线程间访问资源的同步性。
10. ThreadLocal原理
Synchronized实现内存共享，ThreadLocal为每个线程维护一个本地变量。
ThreadLocal类中维护一个Map，用于存储每一个线程的变量副本，Map中元素的键为线程对象，而值为对应线程的变量副本。
ThreadLocal在spring中发挥着巨大的作用，在管理Request作用域中的Bean、事务管理、任务调度、AOP等模块都出现了它的身影。
ThreadLocal类中有一个Map，用于存储每一个线程的变量的副本。
11.聚簇索引和非聚集索引
聚簇索引是对磁盘上实际数据重新组织以按指定的一个或多个列的值排序的算法。特点是存储数据的顺序和索引顺序一致。
一般情况下主键会默认创建聚簇索引，且一张表只允许存在一个聚簇索引。
聚簇索引的叶子节点就是数据节点，而非聚簇索引的叶子节点仍然是索引节点，只不过有指向对应数据块的指针。
建立聚簇索引使用CREATE INDEX语句，格式为：CREATE CLUSTER INDEX index_name ON table_name(column_name1,column_name2,…)
非聚集索引。表数据存储顺序与索引顺序无关。对于非聚集索引，叶结点包含索引字段值及指向数据页数据行的逻辑指针，其行数量与数据表行数据量一致。
http://blog.csdn.net/qq_23211905/article/details/73381852
http://www.cnblogs.com/aspnethot/articles/1504082.html
12.索引的优缺点
优点：
第一， 通过创建唯一性索引，可以保证数据库表中每一行数据的唯一性。
第二， 可以大大加快数据的检索速度，这也是创建索引的最主要的原因。
第三， 可以加速表和表之间的连接，特别是在实现数据的参考完整性方面特别有意义。
第四， 在使用分组和排序子句进行数据检索时，同样可以显著减少查询中分组和排序的时间。
第五， 通过使用索引，可以在查询的过程中，使用优化隐藏器，提高系统的性能。
缺点：
第一， 创建索引和维护索引要耗费时间，这种时间随着数据量的增加而增加。
第二， 索引需要占物理空间，除了数据表占数据空间之外，每一个索引还要占一定的物理空间，如果要建立聚簇索引，那么需要的空间就会更大。
第三， 当对表中的数据进行增加、删除和修改的时候，索引也要动态的维护，这样就降低了数据的维护速度。
13.哪些操作会使索引失效
1.如果条件中有or，即使其中有条件带索引也不会使用(这也是为什么尽量少用or的原因)
2.对于多列索引，不是使用的第一部分，则不会使用索引
3.like查询是以%开头
4.如果列类型是字符串，那一定要在条件中将数据使用引号引用起来,否则不使用索引
5.如果mysql估计使用全表扫描要比使用索引快,则不使用索引
6.使用函数会使得索引失效。
14.联合索引结构，怎么使用
当b+树的数据项是复合的数据结构，比如(name,age,sex)的时候，b+数是按照从左到右的顺序来建立搜索树的，比如当(张三,20,F)这样的数据来检索的时候，b+树会优先比较name来确定下一步的所搜方向，如果name相同再依次比较age和sex，最后得到检索的数据；但当(20,F)这样的没有name的数据来的时候，b+树就不知道下一步该查哪个节点，因为建立搜索树的时候name就是第一个比较因子，必须要先根据name来搜索才能知道下一步去哪里查询。比如当(张三,F)这样的数据来检索时，b+树可以用name来指定搜索方向，但下一个字段age的缺失，所以只能把名字等于张三的数据都找到，然后再匹配性别是F的数据了， 这个是非常重要的性质，即索引的最左匹配特性。
15.explain解释
http://blog.csdn.net/qq_23211905/article/details/72259034
16.数据库的事物，ACID解释，数据库传播特性
原子性：原子性是指事务是一个不可再分割的工作单位，事务中的操作要么都发生，要么都不发生。
一致性：一致性是指在事务开始之前和事务结束以后，数据库的完整性约束没有被破坏。这是说数据库事务不能破坏关系数据的完整性以及业务逻辑上的一致性。
隔离性：多个事务并发访问时，事务之间是隔离的，一个事务不应该影响其它事务运行效果。
持久性：持久性意味着一旦事务执行成功，在系统中产生的所有变化将是永久的。
http://blog.csdn.net/qq_23211905/article/details/72356609
17.数据库左连接，右连接，内连接
内连接：把两个表中数据对应的数据查出来
外连接：以某个表为基础把对应数据查出来
内连接 inner join（查找条件中对应的数据，no4没有数据不列出来）
左连接（左表中所有数据，右表中对应数据）
右连接（右表中所有数据，左表中对应数据）
18.spring注解，获取前端注解
1、@Component
是所有受Spring 管理组件的通用形式，@Component注解可以放在类的头上，@Component不推荐使用
2、@Controller
@Controller对应表现层的Bean，也就是Action
3、@ Service
@Service对应的是业务层Bean
4、@ Repository
@Repository对应数据访问层Bean
5.@Autowired
@Autowired顾名思义，就是自动装配，其作用是为了消除代码Java代码里面的getter/setter与bean属性中的property。当然，getter看个人需求，如果私有属性需要对外提供的话，应当予以保留。
@Autowired默认按类型匹配的方式，在容器查找匹配的Bean，当有且仅有一个匹配的Bean时，Spring将其注入@Autowired标注的变量中。
6.resource
@Resource注解与@Autowired注解作用非常相似
7.springMvc
@RequestMapping，@ModelAttribute和 @SessionAttributes，@requestParam
http://www.cnblogs.com/leskang/p/5445698.html
19.spring的ioc和aop
许多应用都是通过彼此间的相互合作来实现业务逻辑的，如类A要调用类B的方法，以前我们都是在类A中，通过自身new一个类B，然后在调用类B的方法，现在我们把new类B的事情交给spring来做，在我们调用的时候，容器会为我们实例化。
资源定位，即定义bean的xml-------》载入--------》IOC容器注册，注册beanDefinition。
3. 三种注入方式，构造器、接口、set注入，我们常用的是set注入
4. bean是如何创建— 工厂模式
5. 数据是如何注入-------反射
面向切面编程，在我们的应用中，经常需要做一些事情，但是这些事情与核心业务无关，比如，要记录所有update*方法的执行时间时间，操作人等等信息，记录到日志。
http://www.cnblogs.com/yanbincn/archive/2012/06/01/2530377.html
http://outofmemory.cn/code-snippet/3762/Spring-AOP-learn-example
20.mybatis的占位符
1.#{}占位符用来设置参数，参数的类型可以有3种，基本类型，自定义类型，map基本类型作为参数，参数与占位符中的名称无关。
2.${}占位符是字符串连接符，可以用来动态设置表明，列名，排序名
21.git和svn
1.最核心的区别Git是分布式的，而Svn不是分布的。但Git更倾向于分布式开发，因为每一个开发人员的电脑上都有一个Local Repository,所以即使没有网络也一样可以Commit，查看历史版本记录，创建项 目分支等操作，等网络再次连接上Push到Server端。
2.Git把内容按元数据方式存储，而SVN是按文件：因为,.git目录是处于你的机器上的一个克隆版的版本库，它拥有中心版本库上所有的东西，例如标签，分支，版本记录等。.git目录的体积大小跟.svn比较，你会发现它们差距很大。
3.Git没有一个全局版本号，而SVN有：目前为止这是跟SVN相比Git缺少的最大的一个特征。
4.Git的内容的完整性要优于SVN: GIT的内容存储使用的是SHA-1哈希算法。这能确保代码内容的完整性，确保在遇到磁盘故障和网络问题时降低对版本库的破坏。
svn切分支：http://www.cnblogs.com/andy2simple/p/5386256.html
22.linux基本命令，文件排序
http://blog.csdn.net/qq_23211905/article/details/75529843
获取文件前几行: head -n filename
获取文件最后几行：tail -n filename
排序用 sort:
http://www.cnblogs.com/51linux/archive/2012/05/23/2515299.html
23.Java垃圾回收机制
http://blog.csdn.net/qq_23211905/article/details/72614591
24.设计模式
http://blog.csdn.net/qq_23211905/article/details/76247769
25.单例模式讲解
26.算法，数组a和大小n返回找出重复的值。
27.快速排序
28.dubbo原理
29.restful原理好处
30.java是值传递还是引用传递
java中只存在值传递，只存在值传递！！！ 然而我们经常看到对于对象（数组，类，接口）的传递似乎有点像引用传递，可以改变对象中某个属性的值。但是不要被这个假象所蒙蔽，实际上这个传入函数的值是对象引用的拷贝，即传递的是引用的地址值，所以还是按值传递。
http://blog.csdn.net/zzp_403184692/article/details/8184751

/******二面/
二面回答的不好，目测已挂！！
1.介绍项目，项目中的难点。
2. activeMq原理，怎么保证消息发送方发送的消息不丢失？
3. 线程和进程的区别？
进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动,进程是系统进行资源分配和调度的一个独立单位.
线程是进程的一个实体,是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位.

1. 简而言之,一个程序至少有一个进程,一个进程至少有一个线程.
2. 线程的划分尺度小于进程，使得多线程程序的并发性高。
3. 另外，进程在执行过程中拥有独立的内存单元，而多个线程共享内存，从而极大地提高了程序的运行效率。
4. 线程在执行过程中与进程还是有区别的。每个独立的线程有一个程序运行的入口、顺序执行序列和程序的出口。但是线程不能够独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制。
5. 从逻辑角度来看，多线程的意义在于一个应用程序中，有多个执行部分可以同时执行。但操作系统并没有将多个线程看做多个独立的应用，来实现进程的调度和管理以及资源分配。这就是进程和线程的重要区别。

4. 数据库事物的隔离级别？
5. 数据库的索引结构和用处？
6. 返回查找索引会不会失效？索引的使用情况？
7. NIO原理？
8. 二叉树的广度收索？
9. 分布式事物一致性怎么保证？CAP？
10. restful的好处及缺点？
    （1）每一个URI代表一种资源，独一无二；
    （2）客户端和服务器之间，传递这种资源的某种表现层；
    （3）客户端通过四个HTTP动词，对服务器端资源进行操作，实现”表现层状态转化”。
    REST最大的几个特点为：资源、统一接口、URI和无状态。
    ● URL具有很强可读性的，具有自描述性；
    ● 资源描述与视图的松耦合；
    ● 可提供OpenAPI，便于第三方系统集成，提高互操作性；
    ● 如果提供无状态的服务接口，可提高应用的水平扩展性；
    ● 透明性，暴露资源存在。
    充分利用 HTTP 协议本身语义。
    无状态，这点非常重要。在调用一个接口（访问、操作资源）的时候，可以不用考虑上下文，不用考虑当前状态，极大的降低了复杂度
    HTTP 本身提供了丰富的内容协商手段，无论是缓存，还是资源修改的乐观并发控制，都可以以业务无关的中间件来实现。
    http://blog.csdn.net/qq_23211905/article/details/76572949
    http://www.infoq.com/cn/articles/understanding-restful-style/
    缺点：
    一个适用于简单操作的接口规范而已，无规矩不成方圆，复杂操作并不适用，还是看业务发展需求的
    适合CRUD并且只适合CRUD，有的浏览器可能不支持POST、GET之外的提交方式，要特殊处理，API容易给让误解中能进行增、删、查、改等操作

/3*/

1. restful的好处及缺点？
2. 讲解推荐算法？
   http://blog.csdn.net/u014605728/article/details/51274814
   美团推荐实践：http://www.csdn.net/article/2015-01-30/2823783
3. 冷启动怎么解决？
4. 推荐系统为什么要评估召回率？
   查准率＝检索出的相关信息量 / 检索出的信息总量
   查全率＝检索出的相关信息量 / 系统中的相关信息总量
   准确率定义为系统的推荐列表中用户喜欢的产品和所有被推荐产品的比率:，准确率表示用户对一个被推荐产品感兴趣的可能性。
   召回率定义为推荐列表中用户喜欢的产品与系统中用户喜欢的所有产品的比率，召回率表示一个用户喜欢的产品被推荐的概率。
5. 电商系统中的召回率能评估的出来吗？
6. 项目中结算部门怎么做的？
7. 项目中转账是怎么实现的？
8. 有一张学生成绩表，有三列，学号，学科，成绩；我想统计 学生总分大于200分的学生学号和总分？
9. 我 还有一张学生基础信息表，这里面有所有学生的信息；学生成绩表里呢 学生信息不全，可能有的学生没有参加考试 就没有成绩；我现在想统计 所有学生的 总成绩，没参加考试的 按0分记
   学生基础信息表里 有 学号，姓名；我最终要的 是 学号，姓名，总成绩 这三列。
   select u.uid,u.name ,ifnull(sum(s.score),0)score from user u left join user_score s on u.uid=s.uid group by u.uid
   10.我写过的比较复杂的代码给他发了一份。
   11.List aList = {“a”,“b”,“a”,“c”}
   List bList = {“a”,“c”,“d”}
   比如 我有上面两个列表；我想把两个列表中重复的 元素去掉。

//面试官数有错误，我也没太明白
    public  static  void remove1(List<String> alist,List<String> blist){
        if(alist==null&&blist==null){
            return ;
        }else if(alist==null&&blist!=null){
            blist=new ArrayList<>(new HashSet<>(blist));
        }else if(alist!=null&&blist==null){
            alist=new ArrayList<>(new HashSet<>(alist));
        }else {
            Set<String> set1 = new HashSet<>(alist);
            set1.addAll(blist);
            Set<String> set2 = new HashSet<>(set1);
            set1.removeAll(alist);
            set2.removeAll(blist);
            blist = new ArrayList<>(set1);
            alist = new ArrayList<>(set2);
        }
    }
 //迭代器删除
     public  static  void   remove2(List<String> alist,List<String> blist){
        if(alist==null&&blist==null){
            return;
        }else if(alist==null&&blist!=null){
            blist=new ArrayList<>(new HashSet<>(blist));
        }else if(alist!=null&&blist==null){
            alist=new ArrayList<>(new HashSet<>(alist));
        }else {
            Set<String> set1 = new HashSet<>(alist);
            set1.addAll(blist);
            Set<String> set2 = new HashSet<>(set1);
            Iterator<String> it1 = set1.iterator();
            while (it1.hasNext()){
                String next = it1.next();
                if(alist.contains(next)){
                    it1.remove();
                }
            }
            Iterator<String> it2 = set2.iterator();
            while (it2.hasNext()){
                String next = it2.next();
                if(blist.contains(next)){
                    it2.remove();
                }
            }
            blist = new ArrayList<>(set1);
            alist = new ArrayList<>(set2);
        }
        System.out.println(alist+","+blist);
    }