JAVA中高级面试整理2018

一.基础知识：
1）集合类：List和Set比较，各自的子类比较（ArrayList，Vector，LinkedList；HashSet，TreeSet）；
   1.list 有序可重复,set 无序不可重复
   2.list 可以根据索引获得元素，set不可以
   ArrayXxx:底层数据结构是数组，查询快，增删慢
   LinkedXxx:底层数据结构是链表，查询慢，增删快
   HashXxx:底层数据结构是哈希表。依赖两个方法：hashCode()和equals()
   TreeXxx:底层数据结构是二叉树。两种方式排序：自然排序和比较器排序

2）HashMap的底层实现，之后会问ConcurrentHashMap的底层实现；

在JDK1.6，JDK1.7中，HashMap采用位桶+链表实现，即使用链表处理冲突，同一hash值的链表都存储在一个链表里。但是当位于一个桶中的元素较多，即hash值相等的元素较多时，通过key值依次查找的效率较低。而JDK1.8中，HashMap采用位桶+链表+红黑树实现，当链表长度超过阈值（8）时，将链表转换为红黑树，这样大大减少了查找时间

实现原理：
首先有一个每个元素都是链表（可能表述不准确）的数组，当添加一个元素（key-value）时，就首先计算元素key的hash值，以此确定插入数组中的位置，但是可能存在同一hash值的元素已经被放在数组同一位置了，这时就添加到同一hash值的元素的后面，他们在数组的同一位置，但是形成了链表，同一各链表上的Hash值是相同的，所以说数组存放的是链表。而当链表长度太长时，链表就转换为红黑树，这样大大提高了查找的效率。当链表数组的容量超过初始容量的0.75时，再散列将链表数组扩大2倍，把原链表数组的搬移到新的数组中
ConcurrentHashMap:
    ConcurrentHashMap在1.8中的实现，相比于1.7的版本基本上全部都变掉了。首先，取消了Segment分段锁的数据结构，取而代之的是数组+链表（红黑树）的结构。而对于锁的粒度，调整为对每个数组元素加锁（Node）。然后是定位节点的hash算法被简化了，这样带来的弊端是Hash冲突会加剧。因此在链表节点数量大于8时，会将链表转化为红黑树进行存储。这样一来，查询的时间复杂度就会由原先的O(n)变为O(logN)。
代码中加锁片段用的是synchronized关键字，而不是像1.7中的ReentrantLock。这一点也说明了，synchronized在新版本的JDK中优化的程度和ReentrantLock差不多了。
3）如何实现HashMap顺序存储：可以参考LinkedHashMap的底层实现；

LinkedHashMap用双向链表的结构，把所有存储在HashMap中的数据连接起来

桶（桶的概念就是数组的一个存储节点，比如说arr[0]是一个桶，arr[1]也是一个桶）中的链表和这个双向链表是两个概念，以下是我总结的区别：①桶中的链表是散列表结构的一部分；而双向链表是LinkedHashMap的额外引入；②桶中的链表只做数据存储，没有存储顺序的概念；双向链表的核心就是控制数据存储顺序（存储顺序是LinkedHashMap的核心）;③桶中的链表产生是因为发生了hash碰撞，导致数据散落在一个桶中，用链表给予存储，所以这个链表控制了一个桶；双向链表是要串连所有的数据，也就是说有桶中的数据都是会被这个双向链表管理。

4）HashTable和ConcurrentHashMap的区别；
hashTable容器在竞争激烈的并发环境下表现出效率低下的原因是因为所有访问HashTable的线程都必须竞争同一把锁，假如容器里有多把锁，每一把锁用于锁容器其中一部分数据，那么当多线程访问容器里不同数据段的数据时，线程间就不会存在锁竞争，从而可以有效提高并发访问效率，这就是ConcurrentHashMap所使用的锁分段技术。首先将数据分成一段一段地存储，然后给每一段数据配一把锁，当一个线程占用锁访问其中一个段数据的时候，其他段的数据也能被其他线程访问。
5）String,StringBuffer和StringBuilder的区别；

在线程安全上，StringBuilder是线程不安全的，而StringBuffer是线程安全的

        String：适用于少量的字符串操作的情况

       StringBuilder：适用于单线程下在字符缓冲区进行大量操作的情况

       StringBuffer：适用多线程下在字符缓冲区进行大量操作的情况

6）Object的方法有哪些：比如有wait方法，为什么会有；
   Object是所有类的直接类或间接类，如果一个类在声明时未继承任何基类，Java就默认其基类是Object，所以Object被称作根类或基类。该类位于java.lang包中
   protected Object   clone()创建并返回此对象的一个副本。   
   boolean   equals(Object obj)指示其他某个对象是否与此对象“相等”。   
   protected void   finalize()当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。   
   Class<?>   getClass()返回此 Object 的运行时类。   
   int   hashCode()返回该对象的哈希码值。   
   void   notify()唤醒在此对象监视器上等待的单个线程。   
   void   notifyAll()唤醒在此对象监视器上等待的所有线程。   
   String   toString()返回该对象的字符串表示。   
   void   wait()在其他线程调用此对象的 notify() 方法或 notifyAll() 方法前，导致当前线程等待。   
   void   wait(long timeout)在其他线程调用此对象的 notify() 方法或 notifyAll() 方法，或者超过指定的时间量前，导致当前线程等待。   
   void   wait(long timeout, int nanos)在其他线程调用此对象的 notify() 方法或 notifyAll() 方法，或者其他某个线程中断当前线程，或者已超过某个实际时间量前，导致当前线程等待。

7）wait和sleep的区别，必须理解；
wait()是Object类的方法，当一个线程执行到wait方法时，它就进入到一个和该对象相关的等待池，同时释放对象的机锁，使得其他线程能够访问，可以通过notify，notifyAll方法来唤醒等待的线程

sleep() 方法是线程类（Thread）的静态方法，让调用线程进入睡眠状态，让出执行机会给其他线程，等到休眠时间结束后，线程进入就绪状态和其他线程一起竞争cpu的执行时间。 
因为sleep() 是static静态的方法，他不能改变对象的机锁，当一个synchronized块中调用了sleep() 方法，线程虽然进入休眠，但是对象的机锁没有被释放，其他线程依然无法访问这个对象。

sleep() 和 wait() 的区别就是 调用sleep方法的线程不会释放对象锁，而调用wait() 方法会释放对象锁

8）JVM的内存结构，JVM的算法；
https://blog.csdn.net/bluetjs/article/details/52874852

9）强引用，软引用和弱引用的区别；
强引用： 
String str = “abc”; 
list.add(str); 
软引用： 
如果弱引用对象回收完之后，内存还是报警，继续回收软引用对象 
弱引用： 
如果虚引用对象回收完之后，内存还是报警，继续回收弱引用对象 
虚引用： 
虚拟机的内存不够使用，开始报警，这时候垃圾回收机制开始执行System.gc(); String s = “abc”;如果没有对象回收了， 就回收没虚引用的对象


10）数组在内存中如何分配；
A：每一个new出来的东西都有地址值；
B：每个变量都有默认值
            byte，short, int ,long    0
        float, double,  0.0
        char  ' u0000'   ----空字符
        boolean       false
        引用类型  null
C：使用完毕后就变成了垃圾，但是并没有立即回收。会在垃圾回收器空闲时回收。

11）用过哪些设计模式，手写一个（除单例）；

12）springmvc的核心是什么，请求的流程是怎么处理的，控制反转怎么实现的；
1 ，用户发送请求至前端控制器DispatcherServlet
 2、DispatcherServlet收到请求调用HandlerMapping处理器映射器
 3，处理器（过滤器）如果有，返回DispatcherServlet处理，没有则返回404页面
 4，DispatcherServlet调用 handlerAdapter 处理器
 5，handlerAdapter 适配处理器（controller） 后端处理器
 6，controller 处理完成返回你modelView
 7，hendlerAdapter 将controller 返回的结果
返回给DispatcherServlet
 8，DispatcherServlet 将modelAndView传给viewReslover
 9，ViewReslover 解析返回具体的view
 10，DispatcherServlet响应用户

13）spring里面的aop的原理是什么；
实现AOP的技术，主要分为两大类：一是采用动态代理技术，利用截取消息的方式，对该消息进行装饰，以取代原有对象行为的执行；二是采用静态织入的方式，引入特定的语法创建“方面”，从而使得编译器可以在编译期间织入有关“方面”的代码。

14）mybatis如何处理结果集：反射，建议看看源码；

15）java的多态表现在哪里；
重载重写

16）接口有什么用；
从程序角度，简单理解，接口就是函数声明，类就是函数实现。需要注意的是同一个声明可能有很多种实现。
17）说说http,https协议；
    1、https协议需要到ca申请证书，一般免费证书较少，因而需要一定费用。
    2、http是超文本传输协议，信息是明文传输，https则是具有安全性的ssl加密传输协议。
    3、http和https使用的是完全不同的连接方式，用的端口也不一样，前者是80，后者是443。
    4、http的连接很简单，是无状态的；HTTPS协议是由SSL+HTTP协议构建的可进行加密传输、身份认证的网络协议，比http协议安全。
18）tcp/ip协议簇；
19）osi五层网络协议；
应用层
传输层
网络层
数据链路层
物理层
物理层：中继器、集线器、还有我们通常说的双绞线也工作在物理层
数据链路层：网桥（现已很少使用）、以太网交换机（二层交换机）、网卡（其实网卡是一半工作在物理层、一半工作在数据链路层）
网络层：路由器、三层交换机
传输层：四层交换机、也有工作在四层的路由器

20）tcp，udp区别；
TCP (Transmission Control Protocol)和UDP(User Datagram Protocol)协议属于传输层协议。其中TCP提供IP环境下的数据可靠传输，它提供的服务包括数据流传送、可靠性、有效流控、全双工操作和多路复 用。通过面向连接、端到端和可靠的数据包发送。通俗说，它是事先为所发送的数据开辟出连接好的通道，然后再进行数据发送；而UDP则不为IP提供可靠性、 流控或差错恢复功能。一般来说，TCP对应的是可靠性要求高的应用，而UDP对应的则是可靠性要求低、传输经济的应用。TCP支持的应用协议主要 有：Telnet、FTP、SMTP等；UDP支持的应用层协议主要有：NFS（网络文件系统）、SNMP（简单网络管理协议）、DNS（主域名称系 统）、TFTP（通用文件传输协议）等.
TCP/IP协议与低层的数据链路层和物理层无关，这也是TCP/IP的重要特点

21）用过哪些加密算法：对称加密，非对称加密算法；
对称加密算法的特点是算法公开、计算量小、加密速度快、加密效率高。
不足之处是，交易双方都使用同样钥匙，安全性得不到保证
DES算法，3DES算法，TDEA算法，Blowfish算法，RC5算法，IDEA算法。
加密和解密花费时间长、速度慢，只适合对少量数据进行加密。比如RSA就是最常用的非对称加密算法

22）说说tcp三次握手，四次挥手；
  A-b(syn) b-A(ack+syn) A-b(ack)
  A-b(ack+fin) b-a(ack) b-a(fin+ack) a-b(ack)
23）cookie和session的区别，分布式环境怎么保存用户状态；
具体来说cookie机制采用的是在客户端保持状态的方案，而session机制采用的是在服务器端保持状态的方案。同时我们也看到，由于在服务器端保持状态的方案在客户端也需要保存一个标识，所以session机制可能需要借助于cookie机制来达到保存标识的目的，但实际上还有其他选择。
24）git，svn区别；
25）请写一段栈溢出、堆溢出的代码；
public class Test {  
    public void testHeap(){  
        for(;;){  
              ArrayList list = new ArrayList (2000);  
          }  
    }  
    int num=1;  
    public void testStack(){  
        num++;  
        this.testStack();  
     }  
      
    public static void main(String[] args){  
        Test  t  = new Test ();  
        t.testHeap();  
        t.testStack();     
    }  
}  
26）ThreadLocal可以用来共享数据吗；
线程范围内共享多个变量，可以将多个变量封装为一个对象
二.IO:
1）bio，nio，aio的区别；
bio 同步阻塞
nio 同步非阻塞
aio 异步非阻塞


2）nio框架：dubbo的实现原理；
Apache Mina
jboss netty
sun grizzl
3）京东内部的jsf是使用的什么协议通讯：可参见dubbo的协议；
协议：JSF（默认）/SAF(dubbo)/HTTP/Telnet/HTTP2

三.算法：

1）java中常说的堆和栈，分别是什么数据结构；另外，为什么要分为堆和栈来存储数据。

2）TreeMap如何插入数据：二叉树的左旋，右旋，双旋；

3）一个排序之后的数组，插入数据，可以使用什么方法？答：二分法；问：时间复杂度是多少？

4）平衡二叉树的时间复杂度；

5）Hash算法和二叉树算法分别什么时候用；


6）图的广度优先算法和深度优先算法：详见jvm中垃圾回收实现；

三.多线程相关：

1）说说阻塞队列的实现：可以参考ArrayBlockingQueue的底层实现（锁和同步都行）；

2）进程通讯的方式：消息队列，共享内存，信号量，socket通讯等；

3）用过并发包的哪些类；

4）什么地方用了多线程；

5）Excutors可以产生哪些线程池；
     创建固定数目线程的线程池。
      public static ExecutorService newFixedThreadPool(int nThreads)
     创建一个可缓存的线程池，调用 execute 将重用以前构造的线程（如果线程可用）。如果现有线程没有可用的，则创建一个新线程并添加到池中。终止并从缓存中移除那些已有 60 秒钟未被使用的线程。
public static ExecutorService newCachedThreadPool()
创建一个单线程化的 Executor。
public static ExecutorService newSingleThreadExecutor()
创建一个支持定时及周期性的任务执行的线程池，多数情况下可用来替代 Timer 类。
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)

6）为什么要用线程池；
1.减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务。
2.可以根据系统的承受能力，调整线程池中工作线线程的数目，防止因为消耗过多的内存，而把服务器累趴下(每个线程需要大约1MB内存，线程开的越多，消耗的内存也就越大，最后死机)。
Java里面线程池的顶级接口是Executor，但是严格意义上讲Executor并不是一个线程池，而只是一个执行线程的工具。真正的线程池接口是ExecutorService。
7）volatile关键字的用法：使多线程中的变量可见；
四.数据库相关（mysql）：
1）msyql优化经验：
2）mysql的语句优化，使用什么工具；
  explain
  profiling
3）mysql的索引分类：B+，hash；什么情况用什么索引；
1. Hash索引仅仅能满足"=","IN"和"<=>"查询，不能使用范围查询。因为经过相应的Hash算法处理之后的Hash值的大小关系，并不能保证和Hash运算前完全一样；
   2. Hash索引无法被用来避免数据的排序操作。因为Hash值的大小关系并不一定和Hash运算前的键值完全一样；

   3. Hash索引不能利用部分索引键查询。对于组合索引，Hash索引在计算Hash值的时候是组合索引键合并后再一起计算Hash值，而不是单独计算Hash值，所以通过组合索引的前面一个或几个索引键进行查询的时候，Hash索引也无法被利用；

   4. Hash索引在任何时候都不能避免表扫描。由于不同索引键存在相同Hash值，所以即使取满足某个Hash键值的数据的记录条数，也无法从Hash索引中直接完成查询，还是要回表查询数据；


   5. Hash索引遇到大量Hash值相等的情况后性能并不一定就会比B+树索引高。


4）mysql的存储引擎有哪些，区别是什么；
    MyISAM引擎的主要特点就是快，没有事务处理操作，也不支持外键操作。适合于多读取插入，少更新删除的操作表。存储数据分成三个文件：.frm(存储表定义) .MYD(存储数据)  .MYI(存储索引)
    InnoDB  ：是新版本mysql的默认引擎，支持事务处理和外键，但是其缺点几就是慢了些。存储方式分为两种：1.共享表空间存储。[.frm(表结构) 和 innodb_data_home(数据)和innodb_data_file_path(索引)]   2.多表空间存储。 [.frm(表结构) 和 .idb（数据）  ]。

    适用于对于事务由较高要求的表的创建。

    MEMORY： 数据访问非常快的引擎，存储格式同一放在内存中的一个磁盘文件中格式是.frm 。默认使用hash索引。一旦服务器关闭表中的数据就会丢失。数据大小有限制。

    MERGE：本身是融合的意思，实质是MyISUM表的融合，这些融合的表必须结构完全相同。MERGE本身是没有数据的。插入操作可以是first或者是last。删除只是删除MERGE表定义，并不删除真正表的数据。存储方式：.frm(文件存储表定义信息)  .MRG(描述组合表的信息，比如由哪些表组成，插入时的依据)。
    适用于：将一系列等同的MyISAM表逻辑方式组合在一起，作为一个对象引用它们。
5）说说事务的特性和隔离级别；
  
   事务特性分为四个：原子性（Atomicity）、一致性（Consistency）、隔离性（Isolation）、持续性（Durability）简称ACID
   read uncommited（读未提交）、read commited（读提交）、read repeatable（读重复）、serializable（序列化），这四个级别可以逐个解决脏读、不可重复读、幻读这几类问题。
6）悲观锁和乐观锁的区别，怎么实现；
       悲观锁：总是假设最坏的情况，每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁，这样别人想拿这个数据就会阻塞直到它拿到锁。传统的关系型数据库里边就用到了很多这种锁机制，比如行锁，表锁等，读锁，写锁等，都是在做操作之前先上锁。再比如Java里面的同步原语synchronized关键字的实现也是悲观锁。
       乐观锁：顾名思义，就是很乐观，每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断一下在此期间别人有没有去更新这个数据，可以使用版本号等机制。乐观锁适用于多读的应用类型，这样可以提高吞吐量，像数据库提供的类似于write_condition机制，其实都是提供的乐观锁。在Java中java.util.concurrent.atomic包下面的原子变量类就是使用了乐观锁的一种实现方式CAS实现的。

五.mq：

1）mq的原理是什么：有点大。。都可以说；

消息队列为构造以同步或异步方式实现的分布式应用提供了松耦合方法。消息队列的API调用被嵌入到新的或现存的应用中，通过消息发送到内存或基于磁盘的队列或从它读出而提供信息交换。消息队列可用在应用中以执行多种功能，比如要求服务、交换信息或异步处理等。

2）mq如何保证实时性；

3）mq的持久化是怎么做的；

六.nosql相关（主要是redis）:

1）redis和memcache的区别；
>>Memcached
Memcached的优点：
Memcached可以利用多核优势，单实例吞吐量极高，可以达到几十万QPS（取决于key、value的字节大小以及服务器硬件性能，日常环境中QPS高峰大约在4-6w左右）。适用于最大程度扛量。
支持直接配置为session handle。
Memcached的局限性：
只支持简单的key/value数据结构，不像Redis可以支持丰富的数据类型。
无法进行持久化，数据不能备份，只能用于缓存使用，且重启后数据全部丢失。
无法进行数据同步，不能将MC中的数据迁移到其他MC实例中。
Memcached内存分配采用Slab Allocation机制管理内存，value大小分布差异较大时会造成内存利用率降低，并引发低利用率时依然出现踢出等问题。需要用户注重value设计。
>>Redis
Redis的优点：
支持多种数据结构，如 string（字符串）、 list(双向链表)、dict(hash表)、set(集合）、zset(排序set)、hyperloglog（基数估算）
支持持久化操作，可以进行aof及rdb数据持久化到磁盘，从而进行数据备份或数据恢复等操作，较好的防止数据丢失的手段。
支持通过Replication进行数据复制，通过master-slave机制，可以实时进行数据的同步复制，支持多级复制和增量复制，master-slave机制是Redis进行HA的重要手段。
单线程请求，所有命令串行执行，并发情况下不需要考虑数据一致性问题。
支持pub/sub消息订阅机制，可以用来进行消息订阅与通知。
支持简单的事务需求，但业界使用场景很少，并不成熟。


Redis的局限性：
Redis只能使用单线程，性能受限于CPU性能，故单实例CPU最高才可能达到5-6wQPS每秒（取决于数据结构，数据大小以及服务器硬件性能，日常环境中QPS高峰大约在1-2w左右）。
支持简单的事务需求，但业界使用场景很少，并不成熟，既是优点也是缺点。
Redis在string类型上会消耗较多内存，可以使用dict（hash表）压缩存储以降低内存耗用。
Mc和Redis都是Key-Value类型，不适合在不同数据集之间建立关系，也不适合进行查询搜索。比如redis的keys pattern这种匹配操作，对redis的性能是灾难。
>>mongoDB 
mongoDB 是一种文档性的数据库。先解释一下文档的数据库，即可以存放xml、json、bson类型系那个的数据。
这些数据具备自述性（self-describing），呈现分层的树状数据结构。redis可以用hash存放简单关系型数据。
mongoDB 存放json格式数据。
适合场景：事件记录、内容管理或者博客平台，比如评论系统。
1.mongodb持久化原理
mongodb与mysql不同，mysql的每一次更新操作都会直接写入硬盘，但是mongo不会，做为内存型数据库，数据操作会先写入内存，然后再会持久化到硬盘中去，那么mongo是如何持久化的呢
mongodb在启动时，专门初始化一个线程不断循环（除非应用crash掉），用于在一定时间周期内来从defer队列中获取要持久化的数据并写入到磁盘的journal(日志)和mongofile(数据)处，当然因为它不是在用户添加记录时就写到磁盘上，所以按mongodb开发者说，它不会造成性能上的损耗，因为看过代码发现，当进行CUD操作时，记录(Record类型)都被放入到defer队列中以供延时批量（groupcommit）提交写入，但相信其中时间周期参数是个要认真考量的参数，系统为90毫秒，如果该值更低的话，可能会造成频繁磁盘操作，过高又会造成系统宕机时数据丢失过。

2.什么是NoSQL数据库？NoSQL和RDBMS有什么区别？在哪些情况下使用和不使用NoSQL数据库？
NoSQL是非关系型数据库，NoSQL = Not Only SQL。
关系型数据库采用的结构化的数据，NoSQL采用的是键值对的方式存储数据。
在处理非结构化/半结构化的大数据时；在水平方向上进行扩展时；随时应对动态增加的数据项时可以优先考虑使用NoSQL数据库。
在考虑数据库的成熟度；支持；分析和商业智能；管理及专业性等问题时，应优先考虑关系型数据库。
3.MySQL和MongoDB之间最基本的区别是什么？
关系型数据库与非关系型数据库的区别，即数据存储结构的不同。
4.MongoDB的特点是什么？

（1）面向文档（2）高性能（3）高可用（4）易扩展（5）丰富的查询语言

5.MongoDB支持存储过程吗？如果支持的话，怎么用？
MongoDB支持存储过程，它是javascript写的，保存在db.system.js表中

6.如何理解MongoDB中的GridFS机制，MongoDB为何使用GridFS来存储文件？
GridFS是一种将大型文件存储在MongoDB中的文件规范。使用GridFS可以将大文件分隔成多个小文档存放，这样我们能够有效的保存大文档，而且解决了BSON对象有限制的问题。

7.为什么MongoDB的数据文件很大？
MongoDB采用的预分配空间的方式来防止文件碎片。

8.当更新一个正在被迁移的块（Chunk）上的文档时会发生什么？
更新操作会立即发生在旧的块（Chunk）上，然后更改才会在所有权转移前复制到新的分片上。

9.MongoDB在A:{B,C}上建立索引，查询A:{B,C}和A:{C,B}都会使用索引吗？
不会，只会在A:{B,C}上使用索引。
10.如果一个分片（Shard）停止或很慢的时候，发起一个查询会怎样？
如果一个分片停止了，除非查询设置了“Partial”选项，否则查询会返回一个错误。如果一个分片响应很慢，MongoDB会等待它的响应。
>>Redis、Memcache和MongoDB的区别
从以下几个维度，对redis、memcache、mongoDB 做了对比，
1、性能
都比较高，性能对我们来说应该都不是瓶颈
总体来讲，TPS方面redis和memcache差不多，要大于mongodb
2、操作的便利性
memcache数据结构单一
redis丰富一些，数据操作方面，redis更好一些，较少的网络IO次数
mongodb支持丰富的数据表达，索引，最类似关系型数据库，支持的查询语言非常丰富
3、内存空间的大小和数据量的大小
redis在2.0版本后增加了自己的VM特性，突破物理内存的限制；可以对key value设置过期时间（类似memcache）
memcache可以修改最大可用内存,采用LRU算法
mongoDB适合大数据量的存储，依赖操作系统VM做内存管理，吃内存也比较厉害，服务不要和别的服务在一起
4、可用性（单点问题）
对于单点问题，
redis，依赖客户端来实现分布式读写；主从复制时，每次从节点重新连接主节点都要依赖整个快照,无增量复制，因性能和效率问题，所以单点问题比较复杂；不支持自动sharding,需要依赖程序设定一致hash 机制。一种替代方案是，不用redis本身的复制机制，采用自己做主动复制（多份存储），或者改成增量复制的方式（需要自己实现），一致性问题和性能的权衡
Memcache本身没有数据冗余机制，也没必要；对于故障预防，采用依赖成熟的hash或者环状的算法，解决单点故障引起的抖动问题。
mongoDB支持master-slave,replicaset（内部采用paxos选举算法，自动故障恢复）,auto sharding机制，对客户端屏蔽了故障转移和切分机制。
5、可靠性（持久化）
对于数据持久化和数据恢复，
redis支持（快照、AOF）：依赖快照进行持久化，aof增强了可靠性的同时，对性能有所影响
memcache不支持，通常用在做缓存,提升性能；
MongoDB从1.8版本开始采用binlog方式支持持久化的可靠性
6、数据一致性（事务支持）
Memcache 在并发场景下，用cas保证一致性
redis事务支持比较弱，只能保证事务中的每个操作连续执行
mongoDB不支持事务
7、数据分析
mongoDB内置了数据分析的功能(mapreduce),其他不支持
8、应用场景
redis：数据量较小的更性能操作和运算上
memcache：用于在动态系统中减少数据库负载，提升性能;做缓存，提高性能（适合读多写少，对于数据量比较大，可以采用sharding）
MongoDB:主要解决海量数据的访问效率问题

2）用redis做过什么；

有关商品，热销，推荐排序的队列，通常存放在Redis之中，期间也包扩Storm对于Redis列表的读取和更新。

3）redis是如何持久化的：rdb和aof；
RDB每次进行快照方式会重新记录整个数据集的所有信息。RDB在恢复数据时更快，可以最大化redis性能，子进程对父进程无任何性能影响。
AOF有序的记录了redis的命令操作。意外情况下数据丢失甚少。他不断地对aof文件添加操作日志记录，你可能会说，这样的文件得多么庞大呀。是的，的确会变得庞大，但redis会有优化的策略，比如你对一个key1键的操作，set key1 001 ,  set key1 002, set key1 003。那优化的结果就是将前两条去掉咯，那具体优化的配置在配置文件中对应的是 
前者是指超过上一次aof重写aof文件大小的百分之多少，会再次优化，如果没有重写过，则以启动时为主。后者是限制了允许重写的最小aof文件大小。bgrewriteaof命令是手动重写命令，会fork子进程，在临时文件中重建数据库状态，对原aof无任何影响，当重建旧的状态后，也会把fork发生后的一段时间内的数据一并追加到临时文件，最后替换原有aof文件，新的命令继续向新的aof文件中追加。
4）redis集群如何同步；
过程：
    1：当一个从数据库启动时，会向主数据库发送sync命令，
    2：主数据库接收到sync命令后会开始在后台保存快照（执行rdb操作），并将保存期间接收到的命令缓存起来
    3：当快照完成后，redis会将快照文件和所有缓存的命令发送给从数据库。
    4：从数据库收到后，会载入快照文件并执行收到的缓存的命令。

5）redis的数据添加过程是怎样的：哈希槽；
Redis 集群中内置了 16384 个哈希槽，当需要在 Redis 集群中放置一个 key-value时，redis 先对 key 使用 crc16 算法算出一个结果，然后把结果对 16384 取模， 这样每个 key 都会对应一个编号在 0-16383 之间的哈希槽，redis 会根据节点数量大
致均等的将哈希槽映射到不同的节点。
6）redis的淘汰策略有哪些；
    volatile-lru：从已设置过期时间的数据集（server.db[i].expires）中挑选最近最少使用的数据淘汰
    volatile-ttl：从已设置过期时间的数据集（server.db[i].expires）中挑选将要过期的数据淘汰
    volatile-random：从已设置过期时间的数据集（server.db[i].expires）中任意选择数据淘汰
    allkeys-lru：从数据集（server.db[i].dict）中挑选最近最少使用的数据淘汰
    allkeys-random：从数据集（server.db[i].dict）中任意选择数据淘汰
    no-enviction（驱逐）：禁止驱逐数据
7）redis有哪些数据结构；
  string ,hash,list,set,sortedset,Pub/Sub
七.zookeeper:
1）zookeeper是什么；
2）zookeeper哪里用到；
3）zookeeper的选主过程；
4）zookeeper集群之间如何通讯；
5）你们的zookeeper的节点加密是用的什么方式；
6）分布式锁的实现过程；
进程需要访问共享数据时, 就在"/locks"节点下创建一个sequence类型的子节点, 称为thisPath. 当thisPath在所有子节点中最小时, 说明该进程获得了锁. 进程获得锁之后, 就可以访问共享资源了. 访问完成后, 需要将thisPath删除. 锁由新的最小的子节点获得.
有了清晰的思路之后, 还需要补充一些细节. 进程如何知道thisPath是所有子节点中最小的呢? 可以在创建的时候, 通过getChildren方法获取子节点列表, 然后在列表中找到排名比thisPath前1位的节点, 称为waitPath, 然后在waitPath上注册监听, 当waitPath被删除后, 进程获得通知, 此时说明该进程获得了锁.

八.linux相关：

1）linux常用的命令有哪些；

2）如何获取java进程的pid；

3）如何获取某个进程的网络端口号；

4）如何实时打印日志；

5）如何统计某个字符串行数；

九.设计与思想：

1）重构过代码没有？说说经验；

2）一千万的用户实时排名如何实现；

3）五万人并发抢票怎么实现；

最后

以上就是细心冰棍为你收集整理的JAVA中高级面试整理2018的全部内容，希望文章能够帮你解决JAVA中高级面试整理2018所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。