回顾Java知识点，面试题汇总Day11（持续更新）

一、集合

1.1 Collection接口

Collection是集合框架中最基础的父接口，可以存储无序、不唯一的对象。

Iterable专门用来迭代，把集合中的元素全部取出来

Collection 中所有元素可以通过Iterator进行迭代（List、Set)

• Collection常用方法

1.2 Collection的子接口

使用其子接口

• List：存放有序、不唯一的元素
• Set:存放无序、唯一的元素
• Queue:队列接口

1.3 List接口

List接口在继承Collection接口的基础上进行了扩展，常用的扩展方法

1.4 List接口的实现类

ArrayList实现了长度可变的数组

优点：查找快，因为元素都是连续的，可以快速求出下标从而取出元素

缺点：增删慢，因为元素都是连续的，添加一个元素，就必须先将后续的元素依次后移一位，再把新元素加入，删除同理。

import java.util.ArrayList; public class Test5 { public static void main(String[] args) { ArrayList list = new ArrayList(); list.add("Hello"); list.add("World"); list.add("Love"); list.add("You"); System.out.println(list); } }

调用的是toString方法，源码如下：

public String toString() { Iterator<E> it = iterator(); if (! it.hasNext()) return "[]"; StringBuilder sb = new StringBuilder(); sb.append('['); for (;;) { E e = it.next(); sb.append(e == this ? "(this Collection)" : e); if (! it.hasNext()) return sb.append(']').toString(); sb.append(',').append(' '); } }

LinkedList 采用链表的形式来存储数据，和ArrayList恰好相反

优点：增删快

缺点：查询慢

地址指向，元素不连续。

import java.util.ArrayList; import java.util.LinkedList; public class Test5 { public static void main(String[] args) { LinkedList list = new LinkedList(); list.add("Hello"); //向集合中添加元素 list.add("World"); list.add("Java"); System.out.println(list); list.offer("JavaSE"); //向集合中添加元素，向后添加 list.offer("JavaEE"); System.out.println(list); list.push("JavaME"); //向集合中添加元素，从0开始添加 System.out.println(list); list.addFirst("JavaEE2");//从前开始添加元素 System.out.println(list); System.out.println(list.peekFirst());//获取集合中第一个元素 System.out.println(list.peekLast());//获取集合中最后一个元素 System.out.println(list); System.out.println(list.pollFirst()); //获取集合中第一个元素并删掉 System.out.println(list.pollLast());//获取集合中最后一个元素并删掉 System.out.println(list); } }

二、Spring

2.1 AOP

Aspect Oriented Programming 面向切面编程

Object Oriented Programming 面向对象编程

将程序中所有参与模块都抽象成对象，然后通过对象之间的相互调用完成特定的功能。

AOP是对OOP的一种补充，是在另外一个维度上抽象出对象，具体是指程序运行时动态将非业务代码切入到业务代码中，实现了业务代码和非业务代码的解耦合。

<dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>5.3.31</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-aop</artifactId> <version>5.3.31</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-aspects</artifactId> <version>5.3.31</version> </dependency>

package com.myspring.aop; public interface Cal { public int add(int num1, int num2); public int sub(int num1,int num2); public int mul(int num1,int num2); public int div(int num1,int num2); }

package com.myspring.aop; import org.springframework.stereotype.Component; @Component public class CalImpl implements Cal{ @Override public int add(int num1, int num2) { // System.out.println("add的参数是" + num1 + "," + num2); //非业务代码 int result = num1 + num2;//业务代码 // System.out.println("add方法的结果是" + result); //非业务代码 return result; } @Override public int sub(int num1, int num2) { int result = num1 - num2; return result; } @Override public int mul(int num1, int num2) { int result = num1 * num2; return result; } @Override public int div(int num1, int num2) { int result = num1 / num2; return result; } }

package com.myspring.aop; import org.aspectj.lang.JoinPoint; import org.aspectj.lang.annotation.AfterReturning; import org.aspectj.lang.annotation.Aspect; import org.aspectj.lang.annotation.Before; import org.springframework.context.annotation.EnableAspectJAutoProxy; import org.springframework.stereotype.Component; import java.util.Arrays; import java.util.Objects; @Component @Aspect @EnableAspectJAutoProxy //生成动态代理 public class LoggerAspect { /** * 参数日志 */ // @Before("execution(public int com.myspring.aop.CalImpl.add(..))") //此时只对add方法生效 @Before("execution(public int com.myspring.aop.CalImpl.*(..))") //此时CalImpl中所有方法皆可输出 public void before(JoinPoint joinPoint){ String name = joinPoint.getSignature().getName(); String args = Arrays.toString(joinPoint.getArgs()); System.out.println(name + "的参数是" + args); } /** * 结果日志 */ @AfterReturning(value = "execution(public int com.myspring.aop.CalImpl.*(..))",returning = "result") public void afterReturn(JoinPoint joinPoint, Object result){ String name = joinPoint.getSignature().getName(); System.out.println(name + "方法的结果是" + result); } }

package com.myspring.aop; import org.springframework.context.ApplicationContext; import org.springframework.context.annotation.AnnotationConfigApplicationContext; public class Test { public static void main(String[] args) { // Cal cal = new CalImpl(); // System.out.println(cal.add(10, 1)); ApplicationContext applicationContext = new AnnotationConfigApplicationContext("com.myspring.aop"); Cal cal = (Cal) applicationContext.getBean("calImpl"); System.out.println(cal.add(1, 1)); System.out.println(cal.sub(5, 2)); System.out.println(cal.mul(3, 8)); System.out.println(cal.div(10, 2)); } }

AOP基于IoC,将业务对象和切面对象分别注入到IoC中，同时业务对象只写业务代码，切面对象只写非业务代码，从而在代码层面实现业务代码和非业务代码的解耦合效果，通过IoC再将业务代码和非业务代码整合到一起即可，开发时解耦，运行时合并。

如何整合？

通过代理对象，将业务对象注入到IoC中，将切面对象也注入到IoC中，由IoC负责根据业务对象和切面对象创建出一个动态的代理对象，分别去完成业务代码和非业务代码的执行。

• 业务对象和切面对象必须注入到IoC中
• 切面对象需要添加切面注解以及动态代理注解 @Aspect @EnableAspectJAutoProxy

三、Spring MVC

Spring MVC是Spring全家桶的一款产品，对Java Web开发流程进行了封装，不需要再通过Servlet的方式来完成代码的开发，无论是代码量还是参数的接收，返回值等等各方面都做了优化。

Spring MVC是基于Spring框架的，基于IoC容器

Servlet：创建一个Servlet,接收客户端请求，完成相关的业务操作。

3.1 Spring MVC的使用

1.引入Spring MVC的依赖

<!--引入spring mvc的依赖--> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-webmvc</artifactId> <version>5.3.31</version> </dependency>

2.web.xml文件中配置springmvc

<!DOCTYPE web-app PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN" "http://java.sun.com/dtd/web-app_2_3.dtd" > <web-app> <display-name>Archetype Created Web Application</display-name> <!--Spring MVC的前端控制器--> <servlet> <servlet-name>springmvc</servlet-name> <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class> <init-param> <param-name>contextConfigLocation</param-name> <param-value>classpath:springmvc.xml</param-value> </init-param> </servlet> <servlet-mapping> <servlet-name>springmvc</servlet-name> <url-pattern>/</url-pattern> </servlet-mapping> </web-app>

3.创建springmvc配置文件

<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xmlns:mvc="http://www.springframework.org/schema/mvc" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd"> <!-- 启用注解驱动，必须要有。Spring MVC 的 @RequestMapping 注解。 需要 <mvc:annotation-driven/> 来启用注解驱动的处理器映射和适配器。 没有它，Spring 根本不认识你的 @Controller 和 @RequestMapping--> <mvc:annotation-driven /> <!-- 扫包 --> <context:component-scan base-package="com.myspring.controller"/> <!-- 视图解析器 --> <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"> <property name="prefix" value="/" /> <property name="suffix" value=".jsp" /> </bean> </beans>

4.创建控制器

package com.myspring.controller; import org.springframework.stereotype.Controller; import org.springframework.web.bind.annotation.RequestMapping; @Controller public class HelloController { @RequestMapping("/index") public String index(){ System.out.println("index......"); return "index"; } }

3.2 Spring MVC传参数

Spring MVC会自动对request中的参数进行解析，类型转换。开发者只需要在方法定义处声明需要的参数类型格式，Spring MVC会自动对参数进行解析和转换。

3.3 Spring MVC 返回

• 视图

定义方法返回值类型为String,返回视图名称，同时结合视图解析器，将真正的视图资源返回给调用者。

• JSON数据

需要在方法定义处添加@RequestBody,方法中直接返回数据即可。

返回试图是前后端不分离的单体架构，返回JSON数据前后端分离的架构。

3.4 单体架构

• 返回视图
• 将业务数据同时带到前端

package com.myspring.controller; import com.myspring.entity.User; import org.springframework.stereotype.Controller; import org.springframework.ui.Model; import org.springframework.web.bind.annotation.RequestMapping; @Controller public class HelloController { @RequestMapping("/index") public String index(Model model){ User user = new User(); user.setId(1); user.setName("李四"); model.addAttribute("name","张三"); // model.addAttribute("user","User"); //String 没有 id/name 属性 model.addAttribute("user",user); //正常访问 ${user.id} 和 ${user.name} return "index"; } }

<%@ page contentType="text/html;charset=UTF-8" language="java" %> <%@ page isELIgnored="false"%><!--可以把视图上的{name}转换成对应的值“张三”--> <html> <head> <title>Title</title> </head> <body> <h1>${name}</h1> <h2>${user.id}</h2> <h2>${user.name}</h2> </body> </html>

四、MyBatis

MyBatis是ORM框架

4.1 pom.xml

<dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>8.0.33</version> </dependency> <dependency> <groupId>org.mybatis</groupId> <artifactId>mybatis</artifactId> <version>3.4.5</version> </dependency>

4.2 config.xml

<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd"> <configuration> <!-- 配置项 --> <settings> <!--打印SQL--> <setting name="logImpl" value="STDOUT_LOGGING"/> </settings> <environments default="development"> <environment id="development"> <transactionManager type="JDBC"></transactionManager> <dataSource type="POOLED"> <!--MySQL 8.0 要用 com.mysql.cj.jdbc.Driver，不是 com.mysql.jdbc.Driver--> <property name="driver" value="com.mysql.cj.jdbc.Driver"/> <property name="url" value="jdbc:mysql://localhost:3306/car_rental_separate"/> <property name="username" value="root"/> <property name="password" value="123456"/> </dataSource> </environment> </environments> <mappers> <mapper resource="com/myspring/mapper/NewsMapper.xml"></mapper> </mappers> </configuration>

4.3 创建实体类

package com.myspring.entity; import lombok.Data; import java.util.Date; @Data public class News { private int id; private String title; private Date createtime; private String opername; private String content; }

4.4 创建Mapper接口

package com.myspring.mapper; import com.myspring.entity.News; public interface NewsMapper { public int add(News news); }

4.5 接口对应的mapper.xml文件

<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd"> <mapper namespace="com.myspring.mapper.NewsMapper"> <!-- 你的映射语句 --> <insert id="add" parameterType="com.myspring.entity.News"> insert into sys_news(title,content,createtime,opername) values (#{title},#{content},#{createtime},#{opername}) </insert> </mapper>

4.6 使用

package com.myspring; import com.myspring.entity.News; import com.myspring.mapper.NewsMapper; import org.apache.ibatis.session.SqlSession; import org.apache.ibatis.session.SqlSessionFactory; import org.apache.ibatis.session.SqlSessionFactoryBuilder; import java.io.InputStream; import java.util.Date; public class Test1 { public static void main(String[] args) { InputStream resourceAsStream = Test1.class.getClassLoader().getResourceAsStream("config.xml"); SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder(); SqlSessionFactory sqlSessionFactory = builder.build(resourceAsStream); SqlSession sqlSession = sqlSessionFactory.openSession(); //获取Mapper的代理对象 NewsMapper mapper = sqlSession.getMapper(NewsMapper.class); News news = new News(); news.setTitle("测试"); news.setCreatetime(new Date()); news.setOpername("admin"); news.setContent("测试测试测试"); int add = mapper.add(news); System.out.println(add); sqlSession.commit();//提交到数据库 } }

也可以将SQL直接添加到业务方法上

package com.myspring.mapper; import com.myspring.entity.News; import org.apache.ibatis.annotations.Insert; public interface NewsMapper { @Insert({"insert into sys_news(title,content,createtime,opername) values (#{title},#{content},#{createtime},#{opername})"}) public int add(News news); }