Java面试集锦

素颜马尾好姑娘i 2022-01-10 06:37 273阅读 0赞

**目录**

集合

Collection

List:

Set:

Vector:

Map,v>

HashMap

TreeMap

HashTable

Spring

IOC：控制反转

AOP：

spring 的优点？

什么是AOP？

SpringMvc

--------------------

# 集合 #

## `Collection<E>` ##

### `List:` ###

*  `List：` 线程不安全

特点:以线性方式存储，可以存放重复对象 , 有序【存入与取出顺序一致】

*  `ArrayList：`长度可变的数组 ，可以对元素进行随机的访问，向`ArrayList`中插入与删除元素的**(增删)速度慢，查询比较快**
 *  `LinkedList：`采用链表数据结构，插入和删除速度快，但访问速度慢

### `Set`: ###

*  `Set`： 线程不安全

特点：主要就是以map为基础 | 不可以存放重复对象 , 无序【存入与取出顺序不一致】

*  `HashSet` ：哈希算法来存取集合中的对象
 *  底层是HashMap
 *  存取速度比较快
 *  HashSet中采用的hash来确定是否是唯一元素
 *  我们想要让Set保证自定义元素的唯一性，就必须重写其hashCode和equals方法。也就是hashcode相同时，才会去调用equals

|– **`LinkedHashSet`** :是`HashSet`的子类，所以其保证元素的唯一性与父类一致，只不过实现方式是链表方式所以可以保证，存取的顺序一致

*  `TreeSet` *红黑树调整*
 *  底层是TreeMap
 *  `TreeSet`实现了`SortedSet`接口，能够对集合中的对象进行排序

### `Vector`: ###

`Vector：`线程安全

我们可以在HashMap的源码中看到这个单词的出现:
    
     int      initialCapacity,   // 代表的是  整数类型的  初始容量
     float    loadFactor         // 代表的是  浮点类型的  负载因子，也称之为加载因子

加载因子
    
        加载因子是表示Hsah表中元素的填满的程度.
    
                加载因子越大,填满的元素越多,
    
                       好处是,空间利用率高了
    
                       不好是,冲突的机会加大了.
    
               加载因子越小,填满的元素越少,
    
                       好处是:冲突的机会减小了,
    
                       不好是,空间浪费多了
    
    HashMap的加载因子：
    
    HashMap默认的加载因子是0.75，最大容量是16，因此可以得出HashMap的默认容量是：0.75*16=12。

## `Map<K,V>` ##

### `HashMap` ###

`HashMap:`

**特点**：基于散列表实现，其插入和查询`<K,V>`的开销是固定的

**底层**：

*  `HashMap`底层整体结构是一个数组，数组中的每个元素又是一个链表
 *  每次添加一个对象（put）时会产生一个链表对象（`Object`类型）
 *  非线程安全的；
 *  遍历使用的是Iterator迭代器

### `TreeMap` ###

`TreeMap`

特点：基于红黑树实现，查看`<K,V>`时，它们会被排序（原因：实现了`SortedMap`接口）

### `HashTable` ###

`HashTable:`

*   是线程安全的；
 *   无论是key还是value都不允许有null值的存在；在HashTable中调用Put方法时，如果key为null，直接抛出NullPointerException异常；
 *   遍历使用的是Enumeration列举；

--------------------

# Spring #

spring是一个非侵入式的轻量级框架，主要是采用Spring中的ioc和aop

spring主要用到的设计模式有**工厂**模式和**代理**模式。

IOC就是典型的工厂模式，比如采用SessionFactory或者是SqlSessionFactory去注入实例。

AOP就是典型的代理模式的体现。

## IOC：控制反转 ##

当调用者需要被调用者的协助完成某个操作时，通常由调用者来创建被调用者的实例对象。

但在spring里，创建被调用者的工作不再由调用者来完成，而是完全将创建实例工作交托给spring容器完成【以上环节称之为控制反转IOC】，然后注入给调用者，【以上环节称之为**依赖注入**（DI）】

举个栗子: 
    
          最初是由程序员进行手动实例化调用对象：
                    UserService userService = new  UserServiceImpl();
    
          当交托给spring时，即不再需要new对象了。只需要采用下方的三种注入方式中的一种即可。如：注解方式
        
            @AutoWired
            private UserService userService
    
           ------------------并且再applicationContext.xml中配置Bean对象-----------------------
    
            <bean id="userService" class="cn.javabs.ssm.service.impl.UserServiceImpl"></bean>

**DI：**全称为Dependency Injection，翻译为 **依赖注入**。

注入有三种方式：

*  构造器注入
 *  setter方法注入
 *  注解注入\{@Resource,@Autowired\}

## AOP： ##

AOP【面向切面编程】可以说是对OOP【面向对象】的补充和完善，

**AOP****简介**

在传统的业务处理代码中，通常都会进行事务处理、日志记录等操作。虽然使用OOP可以通过组合或者继承的方式来达到代码的重用，但如果要实现某个功能（如日志记录），同样的代码仍然会分散到各个方法中。这样，如果想要关闭某个功能，或者对其进行修改，就必须要修改所有的相关方法。这不但增加了开发人员的工作量，而且提高了代码的出错率。

为了解决这一问题，AOP思想随之产生。AOP采取横向抽取机制，将分散在各个方法中的重复代码提取出来，然后在程序编译或运行时，再将这些提取出来的代码应用到需要执行的地方。这种采用横向抽取机制的方式，采用传统的OOP思想显然是无法办到的，因为OOP只能实现父子关系的纵向的重用。虽然AOP是一种新的编程思想，但却不是OOP的替代品，它只是OOP的延伸和补充。

类与切面的关系：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9tcnlhbmcuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70][]

代理模式，分为静态代理和动态代理。

静态代理：代理的类在编译期就已经生成

动态代理：代理的类在运行时期才进行生成

Aop代理：属于动态代理。

动态代理

Jdk动态代理

Cglib动态代理

实现AOP的技术，主要分为两大类：

一是采用**动态代理**技术，利用截取消息的方式，对该消息进行装饰，以取代原有对象行为的执行；

二是采用**静态织入**的方式，引入特定的语法创建“切面”，从而使得编译器可以在**编译期**间织入有关“切面”的代码

--------------------

JDK动态代理 - 代码示例

## spring 的优点？ ##

1.降低了组件之间的耦合性 ，实现了软件各层之间的解耦   
2.可以使用容易提供的众多服务，如事务管理，消息服务等   
3.容器提供单例模式支持   
4.容器提供了AOP技术，利用它很容易实现如权限拦截，运行期监控等功能   
5.容器提供了众多的辅助类，能加快应用的开发   
6.spring对于主流的应用框架提供了集成支持，如hibernate，JPA，Struts等   
7.spring属于低侵入式设计，代码的污染极低   
8.独立于各种应用服务器   
9.spring的DI机制降低了业务对象替换的复杂性   
10.Spring的高度开放性，并不强制应用完全依赖于Spring，开发者可以自由选择spring的部分或全部

## 什么是AOP？  ##

面向切面编程（AOP）完善spring的依赖注入（DI），面向切面编程在spring中主要表现为两个方面   
1. 面向切面编程提供声明式事务管理   
2. spring支持用户自定义的切面

面向切面编程（aop）是对面向对象编程（oop）的补充和扩展

面向对象编程将程序分解成各个层次的对象，面向切面编程将程序运行过程分解成各个切面。   
AOP从程序运行角度考虑程序的结构，提取业务处理过程的切面，oop是静态的抽象，aop是动态的抽象，   
是对应用执行过程中的步骤进行抽象，，从而获得步骤之间的逻辑划分

--------------------

## SpringMvc ##

工作原理执行图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9tcnlhbmcuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 1][]

（1）用户发送请求至前端控制器DispatcherServlet；  
（2） DispatcherServlet收到请求后，调用HandlerMapping处理器映射器，请求获取Handle；  
（3）处理器映射器根据请求url找到具体的处理器，生成处理器对象及处理器拦截器(如果有则生成)一并返回给DispatcherServlet；  
（4）DispatcherServlet 调用 HandlerAdapter处理器适配器；  
（5）HandlerAdapter 经过适配调用 具体处理器(Handler，也叫后端控制器)；  
（6）Handler执行完成返回ModelAndView；  
（7）HandlerAdapter将Handler执行结果ModelAndView返回给DispatcherServlet；  
（8）DispatcherServlet将ModelAndView传给ViewResolver视图解析器进行解析；  
（9）ViewResolver解析后返回具体View；  
（10）DispatcherServlet对View进行渲染视图（即将模型数据填充至视图中）  
（11）DispatcherServlet响应用户。

**springMVC和struts2的区别有哪些?**

（1）springmvc的入口是一个servlet即前端控制器（DispatchServlet），

而struts2的入口是一个核心过虑器（StrutsPrepareAndExecuteFilter）。

（2）springmvc是**基于方法开发**(一个url对应一个方法)，请求参数传递到方法的形参，可以设计为单例或多例(建议**单例**)，

而struts2是**基于类开发**，传递参数是通过类的属性，只能设计为**多例**。

（3）Struts2采用值栈存储请求和响应的数据，通过OGNL存取数据，

springmvc通过参数解析器是将request请求内容解析，并给方法形参赋值，

将数据和视图封装成ModelAndView对象，最后又将ModelAndView中的模型数据通过reques域传输到页面。

Jsp视图解析器默认使用jstl（标准标签库）。

**SpringMvc的控制器是不是单例模式,如果是,有什么问题,怎么解决？**

SpringMvc是**单例**模式,所以在多线程访问的时候有线程安全问题,不要用同步,会影响性能的,解决方案是在控制器里面不能写字段。

**如果前台有很多个参数传入,并且这些参数都是一个对象的,那么怎么样快速得到这个对象？**

直接在方法中声明这个对象,SpringMvc就自动会把属性赋值到这个对象里面。

**SpringMvc中函数的返回值是什么？**

返回值可以有很多类型,有String, ModelAndView。ModelAndView类把视图和数据都合并的一起的，但一般用String比较好。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9tcnlhbmcuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70]: /images/20220109/a74317f792854e008e1fae51145343fb.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9tcnlhbmcuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 1]: /images/20220109/e3cafd8e751e42809fa3b43a64169de9.png