常见面试问题总结

【Java】

 1. 容器

   1）队列(queue): 若Blocking:阻塞put/take  offer/peek poll 异常element/remove

    a. PriorityQueue:comparator  堆排序

                b. Deque：双向队列  linkedList  addFirst()

                c. DelayQueue：类似timeTask，延迟期满才能提取元素

                d. ConcurrentLinkedQueue：线程安全

   2）数组(Array):注意左右边界校验，如arr!=null&&arr.length>1;

   3）List：有序可重复，可接受null，索引方便，.subList（）视图。

     a. LinkedList,  ArrayList

                 b. CopyOnWriteArrayList:读写分离，写时复制加锁。开辟新空间，内存消耗多

扫描二维码关注公众号，回复： 3153458 查看本文章

   4）Set：去重，必须实现equals方法。

     a.hashSet，LinkedHashSet：快速查找，后者则是为了保证次序

                 b.SortedSet：如treeSet，底层实现的红黑树，保证有序

                 c. Collections.newSetFromMap：实现线程安全

   5）Map：hashCode 数组 + equals linkedList put get

     a. HashMap,LinkedHashMap:后者是为了保证次序

                 b.sortedMap:如treeMap，key保持排序状态

                 c. ConcurrentHashMap：锁分段技术，读写分析，写的时候，Segment加锁保护其名下的HashEntry，读的时候不加锁。

   6）遍历：Iterator：指向第一个元素前一个，故要next。Foreach，实现Iterator即可用，单不可增删，会引起modCount变化，抛异常。

      Comparablet内比较器  comparator 外比较器 策略模式

                 

 2. 并发

   1）线程实现方法：Thread  runnable接口  callable接口

   2）线程池：减少损耗（一开始就创建好），好管理

      类别：newSiggleThreadPool(),newFixedThreadPool(workQueue长度不可控),newCachedThreadPool(线程数不可控),newScheduledThreadPool()，

                  内部：ThreadPoolExecutor(corePoolSize,maximumPoolSize,keepAliveTime,unit,workQueue(直接/有界/无界),ThreadFactory(worker线程),handler(DiscardPolicy/CallerRunPolicy))

                  方法：execute/submit Future.get FutureTask   shutdown/shutdownNow

   3）常见类：ThreadLocal，内部ThradLocalMap，CountDownLatch, CyclicBarrier, Semaphore

   4）Synchronized和Lock的区别

      Lock：AQS AbstractQueuedSynchronized   jdk类，可冲入，不可中断，非公平

                  Synchronized: object final 1. jvm关键字 可冲入，可判断锁状态，可公平，大量同步，finally要释放锁。在不断优化，锁消除，锁粗化，monitorenter,monitorexist映射在内核上，影响开销

   5）性能调优：

     Atomic原子类，免锁容器，ConcurrentHashMap在java8使用CAS无锁算法，ReentrantReadWriteLock读写锁，  CAS，冲突检测，数据更新

                 

 3. IO

    1. 字节流：OutputStream/InputStream,直接IO， 字符流：Writer/Reader,间接IO，需flush  字符字节转换，需要指定编码格式

                2. 基本概念：while((read=inputStream.read(byteArr))>0) 硬盘-（阻塞）-> 内核  -（同步）-> 用户

                3. FileLock Charset

                4. IO和NIO的区别：观察者模式--> 事件机制 --> reactor设计模式 --> nio --> netty对nio进行了简单封装  jetty或tomcat

                   面向缓冲：ByteBuffer等，稍后处理，可移动，灵活  mark position limit capacity

                   非阻塞：FileChannel（阻塞）无法和Selcetor使用；ServerSocketChannel中设置,可配合Selcetor。Reactor模式

                   选择器 Selector selector = Selector.open()， register(selector, SelectionKey.OP_ACCPECT)

    5. 实现案例：Netty EventLoopGroup ServerBootstrap group channel childHandler

               

 4. 内存管理&JVM

    1）GC内存模型：堆(新生代/老年代) 调整-Xms  方法区：永久代 j8用元空间代替； 栈：JVM栈（引用类型） Native栈

                2）JVM内存模型：volatile 不能保证原子性，可以保证可见性，有序性  主内存，工作内存

                3）清理：引用计数法，GCRoot：标记-清除  标记-复制  标记-整理 

                4）性能：JDK工具jconsole Jps Jstack Jmap;  内存泄露：jmeter+jps+MAT  CPU冲高：ps -ef | grep   jstack pid  top-Hp pid

               

 5. 反射

    1）反射：getClass .class Class.forName，getFields(); 提高性能，反射+缓存

                2）双亲委派模型：BootStrap lib Extension lib\ext Application \lib  自定义

    3）类加载器：classLoader  findClass  defineClass loadClass  代理增强

                   Apache tomcat  OSGI  javaAgent探针，main之前拦截  Java字节码  热部署等

               

 6. Java8

   1）lamada闭包：

       匿名函数捕获一个外部变量（自由变量），那么它就是一个closure。

                   闭包是自带运行环境的函数final，当一个函数在定义它的作用域意外的地方被调用时，他访问的依然是定义它时的作用域。这种现象称之为闭包

   2）Stream API:

      Java8中的Stream是对集合（Collection）对象功能的增强，它专注于对集合对象进行各种非常便利、高效的聚合操作（aggregate operation）,或者大批量数据操作（bulk data operation）

      借助于lamada表达式 java.util.stream，函数式语言+多核时代

      .stream().parallelStream().map().readuce()，对stream的使用就是实现一个filter-map-reduce过程，产生一个最终结果

       Stream.of("one","two","three","for"),filter(e->e.length()>3).peek(e->System.out.println("Filtered value:"+e)).map(String::toUpperCase).peek(e->System.out.pringtln("Mapped value:"+e)).collect(Collectors.toList());

                  

 【设计模式】

 1. 代理模式

    真实类在代理类里注册，代理类根据注册new一个真实类Object并运转

 2. 观察者模式

    当对象间存在一对多关系时，使用观察者模式。比如，当一个对象呗修改，则会自动通知它的依赖对象。行为型模式

                client->Subjec（被观察者state容器注册，notifyUpdate）->Observer abstract ->o1,o2,o3(update方法)

 3. 适配器模式

 4. 装饰器模式

 【框架】

 1. Spring

    IOC：主业务，自动注入而非自己维护 DI和DL（JNDI）

                 动态工厂Bean/静态工厂bean Bean的作用域 单例，原型 Bean后处理器（采用动态代理，对bean增强）。

                  2. Spring的IOC和DI

    1）bean的装配：动态工厂：factory-bean="someFactory"   factory-method="getSomeService"     静态工厂：class=""  factory-method="getSomeService"

    2）bean的作用域：singleton  prototype

    3）bean后处理器：对bean创建的前后对bean进行增强

    4）bean的生命周期  构造方法-> set值 -> BeanNameAware -> beanFactoryAware -> 执行后护理器前 -> InitializingBean-afterPropertiesSet -> initPost --> 执行后处理器后 -> 执行方法 --> DisposableBean-destroy -> destroy

    5）xml方式

       property/constructor-arg  name  value/ref

       array/list/set/map/props

       autowire

       parent

    6）注解方式

       <context:compont-sacn base-package="com.huawei.ztj.di01">

      @Compont

      @Scope

      @Value   @Resource

      MyJavaConfig   @Configuration   @Bean  构造器

                AOP：系统业务，织入而非混入

                 1. Proxy代理  java.lang.reflect.Proxy  使用：ISomeService target = new SomeServiceImpl(); ISomeService proxy = Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), new InvocationHander(){

   @Override

   public Object invoke(Object proxy, Method method, Object[] args) throwable {

      ..;  Object result = method.invoke(target, args);  ..;

   }

});

                2. 代理设计模式 ： 代理类和目标类实现同一接口，代理类是对目标类的增强（仍包含目标类的逻辑）。好处：控制目标对象的访问，增强目标对象的功能。区别于：适配器模式（改变），装饰器模式（增强，方式不一样）。

                3. AOP

                                1. 通知Advice 增强的系统功能  MethodBeforeAdvice AfterReturningAdvice  MethodInterceptor(aopalliance中的包)  ThrowsAdvice   CGLIB  无实现InvocationHandler

        2. 顾问Advisor  切入点

        <bean id="afterAdvisor" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">  NameMatchMethodPointcutAdvisor

           <property name="advice" ref="beforeAdvice"/>

           <property name="patterns" value=".*Sec.*/.*T.*">  mappedName

        </bean>

       3.配置

    <bean id="serviceProxy" class="org.springframework.aop.framework.ProxyFactoryBean">     <bean class="org.springframework.aop.framework.autoproxy.advisorAutoProxyCreator"/>

       <property name="target" ref="someService"/>

       <property name="interfaces" value="com.huawei.ztj.di01.ISomeService"/>

       <property name="interceptorNames" value="beforeAdvice"/>

    </bean>

    4. AspectJ

    注解："execution(" * *..ISomeService.doSome(..)")"   通知+顾问

    XML：<aop:config>

             <aop:pointcut expression="execution(* *..ISomeService.doSome(..))" id="doSomePointcut"/>

                 <aop:aspect ref="myAspect">

                       <aop:before method="myBefore" pointcut-ref="doSomePointcut"/>

                 </aop:aspect>

             </aop:aspect>

         </aop:config>

    1. spring-aop包源码解读

          外层：  Advice各个接口

     support包：  Advisor 切入点，如NameMatchMethodPointcutAdvisor、RegexpMethodPointcutAdvisor

   framework包：  拦截器

                1）autoproxy：DefaultAdvisorAutoProxyCreator、BeanNameAutoProxyCreator

                2）ProxyFactoryBean

                3）JdkDynamicAopProxy、CglibAopProxyFactory  重点

   下一步计划：core beans context    aspectJ aop:config  aop:pointcut  aop:aspect  aop:before  pointcut-ref  <aop:pointcut expression="execution(* *..ISomeService.doSome(..))" id="doSomePointcut"/>

  

 2. SpringMVC

   DispatcherServlet--> 映射处理器  处理适配器ModelAndView  视图解析（view）  视图渲染（Model）

   1、DispatcherServlet前端控制器接收发过来的请求，交给HandlerMapping处理器映射器

   2、HandlerMapping处理器映射器，根据请求路径找到相应的HandlerAdapter处理器适配器（处理器适配器就是那些拦截器或Controller）

   3、HandlerAdapter处理器适配器，处理一些功能请求，返回一个ModelAndView对象（包括模型数据、逻辑视图名）

   4、ViewResolver视图解析器，先根据ModelAndView中设置的View解析具体视图

   5、然后再将Model模型中的数据渲染到View上

 3. MyBatis

  

 4. OSGI

 5. SOA架构

    1. RMI：https://www.cnblogs.com/ygj0930/p/6542811.html   学习参考：http://www.blogjava.net/zhenyu33154/articles/320245.html

   RMI:stub  skeleton  接口Remote  注册：java.rmi.Naming.rebind("rmi://10.74.226.146:11099/demoService", demoService);  rmic生成桩和框架 JVM  rmiregistry注册程序运行

                                                                       调用：IHello hello = (IHello) Naming.lookup("rmi://localhost:1099/hello");

   RPC:系统网络服务，客户端和服务端句柄。

   JNDI：Java Naming and Directory Interface 是一个应用程序设计的API 

   采用java的序列化   头疼的防火墙渗透

                2. Spring HttpInvoker  它基于HTTP之上提供RPC,同时又使用了Java的对象序列化机制。

   学习参考：https://www.cnblogs.com/lpc-xx/p/8556827.html

                3. Hessian：Hessian是一个轻量级的remoting onhttp工具，使用简单的方法提供了RMI的功能   二进制

   web.xml注册   <servlet-class>com.caucho.hessian.server.HessianServlet</servlet-class>

   调用：HessianProxyFactory factory = new HessianProxyFactory();  HessianService hs = (HessianService)factory.create(HessianService.class, url);

   私有的序列化机制  解决防火墙问题

                4. Burlap：https://www.cnblogs.com/javalouvre/p/3730597.html  集中远程服务的区别   https://www.cnblogs.com/maybo/p/5190012.html 

   私有的序列化机制  解决防火墙问题

                5. Http服务和RFC服务的区别：https://blog.csdn.net/wangyunpeng0319/article/details/78651998  看下客户端请求是否有http打头

                6. 使用和发布web服务： https://blog.csdn.net/gray_li/article/details/78460213 

                7. 使用Spring MVC创建Rest API：

     1) 【Spring集成】-SpringMVC创建REST API https://blog.csdn.net/fxkcsdn/article/details/80932349  n

 【MySQL】

   1）参考：https://blog.csdn.net/zhugewendu/article/details/73550414

   2）

   SQL和索引优化

   优化数据库对象

   优化InnoDB

   磁盘优化

 【TCP/IP】

 【消息通知】

      ActiveMQ:java， java系统配合默契  基于STOMP协议 Simple Text Orientated Message Protocol

                  RabbitMQ:Erlang  性能更强  基于AMQP(Advanced Message Queue Protocol)  而“语言中立”则意味着只要遵循 AMQP 的协议，任何一种语言都可以开发消息组件乃至中间件本身

                           基于Erlang,支持多种协议的消息Broker，通过插件支持STOMP协议   admin/Changeme_123   jms

      HornetQ:基于JBoss

               

  1. 整体架构

     private int getCalledTimes(long minTime) {

                                int i = 0;

                                List<Long> removeList = new ArrayList<Long>();

                                for (int k = callTimes.size() - 1; k > 0; k--)

                                {

                                    Long time = callTimes.get(k);

                                                if (time > minTime)

                                                {

                                                                i++;

                                                }

                                                else

                                                {

                                                    removeList.add(time);

                                                }

                                               

                                }

                                callTimes.removeAll(removeList);

                                return i;

                }

  【途径】

  1. 书：Java编程思想，Java并发编程实战，effective java, Spring实战,

  2. 网络： MOOC课程，Java技术栈， ImportNew