【总结】Java面试题

部分转自 https://blog.csdn.net/junchi_/article/details/79754032

一、String特性。StringBuffer 和 StringBuilder 区别

问:String a = “str”; String b = new String(“str”);问 a == b , a.equals(b) 的值是true还是false? 

答:false ; true
这里涉及到 == 与 equals 的区别:

  ==和squals在比较基本数据类型时都比的是数值,但在比较引用数据类型时都比较的是地址。
  而String类内部重写了equals()方法,所以比较的是内容是否相同。

   String a = “str”; ,”str” 存到方法区的字符串常量池。而String b = new String(“str”);,new String() 只要是new出来的就存到堆中,再指向常量池的”str”。用 == 时,a指向的是字符串常量池地址,而b指向的是 new String() 堆中存放地址。所以必然false。而String 的equals 是比较内容,他们的内容都是”str”。所以是 true。

    关于String要知道它是被final修饰的不可变类。频繁修改最好用 StringBuffer 或 StringBuilder。二者的区别,StringBuilder效率高,线程不安全。StringBuffer线程安全。

  String:字符常量,保存在常量池中。依赖一个私有字符常量表实现的

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {
    /** The value is used for character storage. */
    private final char value[];

  AbstractStringBuilder :StringBuffer类与StringBuilder类都继承了AbstractStringBuilder,然而AbstractStringBuilder类是依赖一个字符变量表实现的;

abstract class AbstractStringBuilder implements Appendable, CharSequence {
    /**
     * The value is used for character storage.
     */
    char[] value;

  StringBuilder:自己重写了方法之后,全都在方法内super.function(),未做任何扩展。同时从类名语义上来说String构建者,所以没有subString方法看来也合情合理; 
  StringBuffer:在重写方法的同时,几乎所有方法都添加了synchronized同步关键字;

 

二、ArrayList 和 LinkedList 原理、区别以及底层数据结构

     区别:  
  ArrayList是实现了基于动态数组的数据结构,LinkedList基于链表的数据结构。 
  对于随机访问get和set,ArrayList觉得优于LinkedList,因为LinkedList要移动指针。 
  对于新增和删除操作add和remove,LinedList比较占优势,因为ArrayList要移动数据。 
     知道这些还不够,最好看一遍源码。了解一下存在这些区别的原因。以第三点为例,为什么新增删除 ArrayList占优势呢?看了源码就会了解到。 ArrayList 底层结构是数组,首先数组是不可变的,新增要检查数组大小是否满足,不满足需要扩容,扩容就需要新建数组,然后将原数组copy到新数组,再制空原数组,在新数组新增。删除时,ArrayList会将后面部分的元素依次往上挪一个位置(就是copy)。其他方法不再描述,具体需要先熟悉一下源码。有时候会问到怎么保证ArrayList 线程安全。用Collections.synchronizedList()或改用 Vector。原理是方法前加入了synchronize关键字实现加锁。

1.Vector与ArrayList:相同点:有序,不唯一,底层数组存值。
(1)Vector采用同步处理方式,效率低,线程安全,扩容采用原容量2倍扩增。
(2)ArrayList采用异步处理方式,效率高,线程不安全,扩容采用原容量1.5倍扩增。

 

三、HashMap、HashTable、ConcurrentHashMap 原理、源码、数据结构,线程是否安全

    HashMap是数组加链表结构(哈希表)。

  存入一个Key-Value对象,Key调用hashCode()生成一个哈希码,根据哈希码算出要存入数组中的位置i,判断位置i是否有值,如果没值直接将Key-Value存入位置i,如果位置i上有值,调用equals()将Key与位置i上已有的值一个一个比较,如果有重复,Key不插入,Value要将之前值覆盖,如果无重复,接着存入位置i,并以链表的方式连接。

    HashTable和HashMap区别,属于线程安全,key value 不能为 null。

   ConcurrentHashMap也是线程安全,结构可理解成 分裂数组+HashTable。效率比HashTable高,因为HashTable是整个Map加锁,ConcurrentHashMap是把锁加到 各个分裂数组上。

 

四、Lock 和 synchronize 实现原理与区别。简述乐观锁悲观锁。分布式锁实现方式

    synchronized是托管给JVM执行的,而lock是java写的控制锁的代码。synchronized在锁定时如果方法块抛出异常,JVM 会自动将锁释放掉,不会因为出了异常没有释放锁造成线程死锁。但是 Lock 的话就享受不到 JVM 带来自动的功能,出现异常时必须在 finally 将锁释放掉,否则将会引起死锁。在资源竞争不是很激烈的情况下,偶尔会有同步的情形下,synchronized是很合适的。原因在于,编译程序通常会尽可能的进行优化synchronize。 

锁:解决并发问题

   1).悲观锁: 很悲观,修改数据的时候总会认为别人也会修改,所以要加锁,利用的数据库锁机制实现

    1)数据库中实现:select * from t_user where id = 10 for update

    2)Hibernate实现 1)session.get(User.calss,10,LockOptions.UPGRADE);

  2).乐观锁很乐观,修改数据的时候总会认为别人不会修改,所以不加锁,利用版本号机制实现

    1)Hibernate怎么实现

      a)在实体类中添加version(该属性Hibernate会帮我们维护)

      b)在表中也添加version字段

      c)在映射文件中建立关系

    2)原理

      a)提交的时候先判断版本号是否一致

        1)如果一致就提交,版本号自增

        2)如果不一致就不让提交,说明数据已经被其他事务修改。

    分布式锁实现方式:基于数据库实现,基于缓存(Redis,memcached,tair)实现,基于Zookeeper实现。

 

五、SpringMVC流程。常用注解。Spring的IOC和AOP

SpringMVC流程:

用户发送请求至前端控制器DispatcherServlet。
DispatcherServlet收到请求调用HandlerMapping处理器映射器。
处理器映射器找到具体的处理器(可以根据xml配置、注解进行查找),生成处理器对象及处理器拦截器(如果有则生成)一并返回给DispatcherServlet。
DispatcherServlet调用HandlerAdapter处理器适配器。
HandlerAdapter经过适配调用具体的处理器(Controller,也叫后端控制器)。
Controller执行完成返回ModelAndView。
HandlerAdapter将controller执行结果ModelAndView返回给DispatcherServlet。
DispatcherServlet将ModelAndView传给ViewReslover视图解析器。
ViewReslover解析后返回具体View。
DispatcherServlet根据View进行渲染视图(即将模型数据填充至视图中)。
DispatcherServlet响应用户。

 

六、微服务架构Spring Boot ,Spring Cloud

1.微服务的优势 

  首先,分解巨大单体应用为多个微服务,解决了单体应用的复杂性问题。每个服务都有一个定义清楚的边界,通过 RPC- 或者消息驱动API与外接沟通,这样单个微服务相比单体应用更容易开发和维护。

  其次,微服务架构使得每个服务都可以由专门的开发团队来开发。开发者可以自由选择开发技术,同时也意味着开发者不需要被迫使用旧项目采用的过时技术。即使重写单个微服务也不会太困难,相比重写整个单体应用容易多了。

  第三,微服务架构使得每个微服务独立部署,开发者不再需要协调其它服务部署对本服务的影响。这种改变可以加快部署速度,使得持续化部署成为可能。

  最后,微服务架构使得每个服务可以独立扩展。

2.Spring Cloud 五大神兽:(要知道实现原理,Eureka 是重点)

服务发现——Netflix Eureka
客服端负载均衡——Netflix Ribbon
断路器——Netflix Hystrix
服务网关——Netflix Zuul
分布式配置——Spring Cloud Config

七、多线程与高并发

多线程要了解线程常用方法。线程池的实现方式。如何避免死锁。生命周期。

  线程的生命周期:

    新建状态:线程刚New出来时。

    就绪状态:线程调用start()。

    运行状态:处于就绪状态的线程,抢到了资源时调用run(),就处于运行状态。

    阻塞状态:当线程调用sleep(),或yield()时。

    终止状态:当线程执行结束或者调用stop()。

  避免死锁:

  1. 加锁顺序(线程按照一定的顺序加锁)
  2. 加锁时限(线程尝试获取锁的时候加上一定的时限,超过时限则放弃对该锁的请求,并释放自己占有的锁)
  3. 死锁检测

并发包扩常用类原理和应用场景:计数器CountdownLatch,栅栏CyclicBarrier,信号量semaphore,交换。

 

八、事务相关

项目中事务处理方案。

4种事务特性:
  原子性 (atomicity):强调事务的不可分割. 同一个事务中sql语句要么一起执行成功,要么一起执行失败。
  一致性 (consistency):事务的执行的前后数据的完整性保持一致. 
  隔离性 (isolation):事务在执行的过程中互不干扰。
  持久性(durability) :事务中的数据一旦提交或者回滚,数据修改是永久的。、

5种隔离级别:

  DEFAULT 这是一个PlatfromTransactionManager默认的隔离级别,使用数据库默认的事务隔离级别
  未提交读(read uncommited) :脏读,不可重复读,虚读都有可能发生 
  已提交读 (read commited):避免脏读。但是不可重复读和虚读有可能发生 
  可重复读 (repeatable read) :避免脏读和不可重复读.但是虚读有可能发生
  串行化的 (serializable) :避免以上所有读问题

7种传播行为:

    保证同一个事务中 

PROPAGATION_REQUIRED 支持当前事务,如果不存在 就新建一个(默认) 
PROPAGATION_SUPPORTS 支持当前事务,如果不存在,就不使用事务 
PROPAGATION_MANDATORY 支持当前事务,如果不存在,抛出异常 
   保证没有在同一个事务中 
PROPAGATION_REQUIRES_NEW 如果有事务存在,挂起当前事务,创建一个新的事务 
PROPAGATION_NOT_SUPPORTED 以非事务方式运行,如果有事务存在,挂起当前事务 
PROPAGATION_NEVER 以非事务方式运行,如果有事务存在,抛出异常 
PROPAGATION_NESTED 如果当前事务存在,则嵌套事务执行
分布式事务处理方案(XA,TCC等,也可以了解一下阿里最近推出的 GTS)

 

九、常用那些设计模式,说出原理,以及框架中用到哪些。单例的几种写法

    23种设计模式至少要了解Spring框架用到的一些设计模式。bean单例 beanfactory工厂 AOP动态代理等。

    单例有饿汉式,懒汉式,静态内部类等方式。这些方式并非真正安全,可以用反射拿到,用枚举可以避免。

饿汉式:

	/*//饿汉式,在系统加载类是就创建了对象,占用资源,但在多线程中安全
	private static Boss boss=new Boss("罗嘉", 18);
	
	//提供一个对外的接口,专门用来供外界调用这个对象
	public static Boss getBoss() {
		return boss;
	}*/

  懒汉式:

	//懒汉式,在系统加载类时不会创建对象,在用对象时才会创建节约资源,但在多线程中有安全隐患,要加个同步锁
	private static Boss boss;
	//提供一个对外的接口,专门用来供外界调用这个对象
	public synchronized static Boss getBoss() {
		if (boss==null) {
				boss=new Boss("罗嘉", 18);
		}
		return boss;
	}

spring中用到的设计模式:

  1.工厂模式,在各种BeanFactory以及ApplicationContext创建中都用到了;实质:由一个工厂类根据传入的参数,动态决定应该创建哪一个产品类

  2.模版模式,在各种BeanFactory以及ApplicationContext实现中也都用到了;

  3.代理模式,在Aop实现中用到了JDK的动态代理;spring优先支持实现接口的方式,如果没有接口则使用cglib方式

    实现原理: 切面在应用运行的时刻被织入。一般情况下,在织入切面时,AOP容器会为目标对象创建动态的创建一个代理对象。SpringAOP就是以这种方式织入切面的。 

  4.策略模式,第一个地方,加载资源文件的方式,使用了不同的方法,比如:ClassPathResourece,FileSystemResource,ServletContextResource,UrlResource但他们都有共同的借口Resource;第二个地方就是在Aop的实现中,采用了两种不同的方式,JDK动态代理和CGLIB代理;

  5.单例模式,这个比如在创建bean的时候。

  6. 适配器模式

    实现方式:SpringMVC中的适配器HandlerAdatper。

    实现原理:HandlerAdatper根据Handler规则执行不同的Handler。

 

十、常用中间件RabbitMQ,kafka等,原理、区别、优缺点

中间件的应用场景。

RabbitMQ是一个AMQP实现,传统的messaging queue系统实现,基于Erlang。老牌MQ产品了。AMQP协议更多用在企业系统内,对数据一致性、稳定性和可靠性要求很高的场景,对性能和吞吐量还在其次。

Kafka是linkedin开源的MQ系统,主要特点是基于Pull的模式来处理消息消费,追求高吞吐量,一开始的目的就是用于日志收集和传输,0.8开始支持复制,不支持事务,适合产生大量数据的互联网服务的数据收集业务。

 

十一、缓存:Redis原理,数据结构,集群几种方式。和memcache区别

 

十二、HTTP协议,RPC协议,Socket协议

 

十三、Nginx实现负载均衡的几种方式

    轮询,随机,哈希,加权轮询,加权随机,最小连接数等。

 

十四、java1.8新特性

 

十五、关于jvm调优

    原文作者:秀得水乱流
    原文地址: http://www.cnblogs.com/wlb509727985/archive/2018/11/04/9904255.html
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞