java 面试题

Posted 2021-01-19 wanglichaoya

数据库 方面
1、Oracle 数据库分为：内连接和外连接。
内连接：一般就是等值连连接。
例如： select * from A a ,B b where A.c = B.c;
或者：
select * from A inner join B on A.c = B.c;
这两种查询方式我认为是等效的。 内连接的特点就是：只查询两张表匹配的记录，匹配不到的记录是查不出来的。
外连接：分为：左外连接 和 右外连接。特点就是：有一些关联信息查询不出来的时候，使用外连接。 主表可以查询出来。
左外连接 ： 以 left outer join 前面的表为主表。
left outer join
右外连接: 以 right outer join 前面的表为主表。
right outer join

例如 ：要进行部门表和员工表进行关联查询，并且查询所有的部门信息。有可能一些部门没有员工，这样会有一些信息是
无法匹配到的，这个时候可以用左外连接或者右外连接。
select * from dept left outer join employment on dept.deptid = employment.deptid;

全连接：
full join
全连接查询：左外连接和右外连接 查询的并集。
select * from dept full join employment where 1 = 1;

2、oracle 中常用的函数都有哪些？
日期处理函数：例如：month_between,add_month
转换函数：to_number,to_data,to_char
字符处理函数：substr,replace,trim,concat,upper等
逻辑函数：nvl2(E1,E2,E3):如果E1 为 null,返回E3,否则返回E2.
聚合函数：sum,avg,max,min


oracle 系统优化
一、sql 语句的优化：
1、不用(*)代替所有列名，
原因：如果用*代替所有列名的话，oracle系统会出现动态解析的问题，比如需要到数据字典中来验证表和列的定义等。

2、在能够确保数据完整性的前提下，多使用commit来进行提交。
原因：这样可以释放：程序语句获得的锁，以及回滚段上的数据操纵信息，还有oracle系统管理所需要的其他开销等

3、用where 语句代替having 语句。
原因：having是先进行分组，然后再对分组后的结果进行筛选，而where是直接对条件进行筛选。

4、用truncate 语句代替delete语句。
原因：delete 删除数据的时候，oracle会使用撤销表空间来存放删除操作的信息，如果用户回滚，可以回到删除之前的状态，
而truncate不会这样做，数据不能回到删除之前的状态。

5、用 表连接 代替 嵌套查询 (表的多次查询)。
原因：如果用嵌套的查询，每次oracle内部会进行一系列的操作，这样会导致查询效率变低。

6、用exists代替in
原因：in 操作符 用于检查值是否在一个列表中，因此需要进行全表扫描，而exists只是检查行是否存在，

7、用exists代替distinct
原因：exists是用来检查子查询返回的行是否存在，而distinct是用来禁止重复行的显示。
但是distinct在禁止重复行显示之前需要排序检索到的行

8、用<=代替< 号
原因：
例如 查询emp.empno<=9901 的时候，oracle是直接把数据定位到9901。
而 emp.empno<9901 的时候，oracle会把数据定位到9901，然后查找比9901小的值。

9、多张表查询的时候，有歧义的列要给表起一个别名，这样可以消除歧义，加快查询效率。

二、表连接的优化
1、from后面表的顺序
从查询的角度来看，表与表之间的先后顺序没有区别，但是从查询效率上来看，是有区别的。
原因：
oracle的解析器是按照从右到左 的树勋处理from后面的表，所以，from后面指定的表中，最后面的表先被处理，作为驱动表
，并对该表排序，再扫描倒数第二张表，将第二张表的数据和第一张表的数据进行合并。
所以，要把数据量最小的表放到最后，作为驱动表，这样可以提高执行的效率

三、合理使用索引
索引：是一个和表或视图有关的磁盘结构，可以加快从表或者视图中检索行的速度，是提高检索效率的有效手段。

条件：
表数据在5000条以上
一个表中可以建立多个索引，但是不能太多，太多的话会加大系统维护的开销。
频繁修改的列不能作为索引列
经常出现在where子句或连接条件中的列作为索引关键字。

1、索引列是上应该尽量不使用‘非’操作符，如not，!<,not exists,no in 和not like. 因为使用非操作符会导致oracle对全表扫描。

2、唯一索引上不要使用null 值，
唯一索引是说列的值不能重复，但是多个null 值可以同时存在，因为oracle认为多个null 值不相等。
所以向唯一索引列上加null 值的时候，当where 子句 使用 is null 等非 操作符 对唯一索引列进行比较，oracle将会停止使用列上的唯一索引，oracle将会进行全表扫描。

四：如何在程序中调用存储过程？
使用jdbc 的方式：
CallableStatement c = conn.prepareCall(“{call insertPro(?,?,?)}”);

java 方面
-------servlet 方面 ------------
1、servlet 生命周期
加载，实例化，初始化，服务，销毁 五个阶段。
初始化是：javax.servlet.Servlet.init 方法表达
服务： javax.servlet.Servlet.server
销毁： javax.servlet.Servlet.destroy

2、servlet 的转发和重定向 区别和定义？
转发：是服务器端的跳转，在浏览器上是看不到地址的变化。比较高效
重定向：是完全跳转，在浏览器中是可以看到地址的变化。
转发：
request.getRequestDispatcher("1.html").forward(request,response);
重定向：
response.Redirect("1.html");

3、request.getAttribute() 和 request.getParameter() 方法的区别？
request.getAttribute() 是 jsp 页面通过request.setAttribute() 方法设定的值
request.getParameter() 是 获取http请求 传递过来的参数。

4、jsp 的内置对象：
request 客户端发送请求，包括 来自get/post 的请求参数，HttpServletRequest 对象
response 网页传递给客户端的回应，响应 ，HttpServletResponse 对象
application 正在执行的内容，只要浏览器不关闭，都可以获取到
page ：jsp 页面本身：表示从该页面产生的一个servlet 实例
exception ：针对错误的网页，未捕捉的例外

session ：会话，与请求相关的回话期，session 表示一个请求的javax.servlet.http.HttpSession 对象

pageContext ：页面属性的配置在这里配置
out ： 用来传送后台传送的输出。
config ：servlet 的构建部分。表示一个javax.servlet.ServletConfig对象。该对象用于存取servlet实例的初始化参数。

5、页面间对象传递的方法？
request,session,cookie,application

6、jsp 和 servlet 的区别？
jsp 主要侧重于 数据的展示，视图。jsp 编译后是’类servlet‘
servlet :主要是侧重于逻辑的处理。

7、java的基本数据类型都有哪些？
int :
short
double
char
byte
float
boolean

8、java 中垃圾回收？
垃圾回收是：java中 长时间不使用的对象，是无用的对象，这些对象将会被丢弃回收。


9、静态内部类 和静态类的区别？
静态内部是是 声明 为static 的内部类，不需要当 外部类实例 化以后才能实例化。
静态类 ：是需要外部类实例化后才能被实例化。

多线程方面的问题

1、如何实现多线程？
实现多线程有两种方式。一种是：继承Thread 类，另一种是：实现Runnable 接口。
这两种方式其实都可以，区别不大，但是：因为java中 类的继承是单继承的，但是类可以实现多个接口。这一就说明，只要
继承了Thread 类，就不可以再继承其他类了。

启动一个线程,start()方法
run()方法里面写 方法的实现之类的内容。

2、sleep() 和wait() 方法有什么区别？
sleep 是 Thread 的方法，是让线程暂停 指定时间，把线程执行的机会给其他线程，到指定时间以后会继续执行，调用sleep()不会释放对象锁。
wait(): 是Object 类的方法，调用wait()方法会导致本线程放弃对象锁，进入等待此对象的等待锁定池，只有调用了notify()或者 notifyAll()，对象才会进入对象锁定池重新获取对象锁，进入运行状态。


3、同步和异步 的区别？在什么情况下使用？
如果数据在线程间共享，比如：正在写的数据 可能会被另一个线程读取，或者正在读取的数据已经被另一个线程写过了，那么这些数据是共享数据，必须同步存取。
异步：当应用程序调用一个需要比较长的时间才能返回值的方法，并且不想让程序等待时间太长，就应该使用异步编程。

Ajax 方面
Json格式
[{"11","33"}]

数据结构方面
1、说出ArrayList ,Vector,LinkList 区别？
ArrayList 和Vector 都是用数组方式来储存数据，数组元素数大于实际存储的数据方便插入数据，都允许直接按序号索引元素，但是插入数据的时候
会涉及数组元素移动等内存操作，索引查询快而插入，删除数据比较慢。Vector是线程安全的，同步，实现了Synchronized方法，但是性能上没有ArrayList 好。
LinkList 采用的双向链表实现存储，新增，删除比较快，查询慢。

2、Collection 与Collections 区别？
Collection 是集合类的上层接口。继承Collection 接口的 主要有：List 和 Set
Collections 是一个 集合的帮助类。里面有各种静态的集合操作方法，例如：排序（Collections.sort()方法）



框架方面
Struts
在web.xml 需要配置
<filter>
<filter-name>struts</filter-name>
<filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
<filter>
<filter-mapping>
<filter-name>struts2</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>

struts2 工作流程：
1、浏览器发送http 请求，
2、请求被web.xml 中的 filterDispatcher 拦截
3、根据struts.xml 找到处理请求的Action
4、Action 进行逻辑处理，处理完以后返回一个 结果集
5、根据Strut2.xml 中的result 找到相应的页面
6、把处理结果返回到浏览器进行显示。



事务 方面：

Spring 是如何实现事务控制的？
答： Spring 提供了对 事务 的支持。在spring 中有两种方式实现：声明式事务 和 编程式事务。

编程式事务：通过编写代码来达到对事务的控制。
步骤：
在spring 中需要 配置 数据源，事务管理器 DataSourceTransactionManager, 使用ref 引用 数据源 dataSource,有了事务管理对事务的控制还是比较麻烦，Spring 提供了 事务管理器模板，transactionTemplate,配置事务管理器模板，引用事务管理器。
编码：
spring 中的配置：
<!--配置 数据源-->
<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName">
<value>${db.driver}</value>
</property>
<property name="url">
<value>${db.url}</value>
</property>
<property name="username">
<value>${db.username}</value>
</property>
<property name="password">
<value>123456</value>
</property>
</bean>

<bean id="dao" class="co
<!--配置事务管理器-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"></property>

</bean>
<!--事务管理器模板 方便使用事务-->
<bean id="transactionTemplate" class="org.springframework.transaction.support.TransactionTemplate">
<property name="transactionManager" ref="transactionManager"></property>
</bean>

在 service 业务层实现类 中：
@Component
public class AccountServiceImpl implements AccountServiceIter {
@Autowired
private AccountDaoInter adi;
@Autowired
private TransactionTemplate tt;
//转账方法，由out向in转money元
@Override
public void transfer(final String out, final String in, final double money) {
// TODO Auto-generated method stub

//使用事务管理器模板进行事务控制
tt.execute(new TransactionCallbackWithoutResult() {

@Override
protected void doInTransactionWithoutResult(TransactionStatus status) {
// TODO Auto-generated method stub
adi.outMoney(out, money);
//一个异常，使用了事务控制，在出现了异常之后，事务会回滚
int i = 1 / 0;
adi.inMoney(in, money);
}
});

}

}
-------------------------------------------------------------------------
声明是事务
1、使用 @Transactional 注解
使用 @Transactional 注解 需要在 配置文件中 开启对这个注解的扫描。 <tx:annotation-driven transaction-manager = "transactionManager"/>，引用事务管理，这样就可以使用
@Transactional 注解了。 @Transactional 可以用在类上表示对所有的方法都起作用；可以用在方法上表示只对指定方法起作用。

2、使用 Aop 声明事务控制
步骤：
1、配置事务管理器
<bean id = "transactionManager" class= "org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref = "dataSource"></property>
</bean>
2、配置事务增强 <tx:advice>,需要配置 事务增强的传播机制 7种传播机制
<tx id = "adviser" transaction-manager = "transactionManager">
<tx:attributes>
<tx:method name ="add*" propagation="REQUIRED"/>
</tx:attributes>
</tx>
3、配置切点、事务通知
<aop:config>
<aop:pointcut id = "myPointcut" expression = "execution(* com.service.SerImpl.*.*(..))"/>
<aop:advisor id = "adviser" pointcut-ref = "myPointcut"/>
</aop:config>
Spring 优先级？

Spring 传播机制： 7个
support :支持当前事务
never : 以非事务方式执行，如果当前存在事务，则抛出异常。
Not_Supported: 以非事务方式执行，如果当前存在事务，则把当前事务挂起
Required: 如果当前没有事务，则创建一个事务；如果当前有事务，则加入到这个事务中
Required_New :新建事务，如果当前有事务，就把当啊亲事务挂起
manadator: 使用当前事务，如果当前没有事务，则抛出异常。
NESTED ：如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行 与 PROPAGATION_REQUIRED 类似的操作。

 1）、<tx:method name="*" propagation="REQUIRED" /> 如果当前没有事务，就新建一个事务；如果已存在一个事务，就加入到这个事务中。

    2）、<tx:method name="*" propagation="SUPPORTS" /> 支持当前事务，如果当前没有事务，以非事务方式执行。

    3）、<tx:method name="*" propagation="MANDATORY" />使用当前事务，如果当前没有事务，则抛出异常。

    4）、<tx:method name="*" propagation="REQUIRES_NEW" />新建事务，如果当前存在事务，则把当前事务挂起。

    5）、<tx:method name="*" propagation="NOT_SUPPORTED" />以非事务方式执行，如果当前存在事务，则把当前事务挂起。

    6）、<tx:method name="*" propagation="NEVER" />以非事务方式执行，如果当前存在事务，则抛出异常。

     7）、<tx:method name="*" propagation="NESTED" />如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行         与 PROPAGATION_REQUIRED 类似的操作。

1、事务的4个特性？
原子性 ：一个事务在执行的过程中，要么全部执行，要么全部不执行。
一致性 ：数据不会因为事务的执行而遭到破坏。
隔离性 ：一个事务的执行不会影响其他事务的执行。
持久性 ：一个事务一旦提交，对数据库的影响是永久的。

2、事务的实现：
声明式事务 和 编程式声明。

基于Aop 技术实现的事务，本质就是在方法执行之前或者执行之后对方法进行拦截，然后 目标方法执行之前创建并加入事务，根据执行结果来确定回滚或者提交。
声明式事务有另种方式：
基于xml 配置
@transactional 注解，把事务 规则应用到业务逻辑中。

3、事务的隔离机制
Read committed 读提交
Read Uncommitted 读未提交。最低级别。
RepeaTable read :可重复读。 可避免脏读，不可重复读的发生。
Serializable 串行化 。可避免：脏读，不可重复读，幻读的发生。

脏读： 是一个事务在修改某个数据但未提交，这时，另一个事务也来访问该数据，
这时就会造成两个事务得到的数据不一致，
比如，A 向 B 转 100元，这时 B 发现钱确实到账了，但只要 A 不提交该事务，所有的事务都将回滚， B 会发现 钱没能到账

不可重复读是： 指事务1在读取某一数据，而事务2立马修改了这个数据并提交给事务给数据库，
当事务1再次读取该数据就会得到不同的结果，

幻读： 事务非独立执行时发生的一种现象。
比如：事务1对一个表中的所有行的某个数据项进行修改操作如从 1 修改成2，这时事务2又对这个表中插入了一行数据，并且在这个数据项的数据为 1 时就提交给数据库。如果事务1的操作用户查看刚刚修改的数据，会发现还有一行没有修改，其实这一行是事务2添加的，这就是 幻读

4、Spring 工作原理
Spring 最核心的就是 ioc(控制反转) Aop(面向切面编程)。 IOC 控制反转 使一个 对象不用new ,可以自动生产，在程序运行的时候动态的创建，调用对象。把创建对象的权利交给Spring 容器来进行创建。
Aop 是面向切面编程，可以为某一类对象的方法在执行前后去调用指定模块。
5、为什么要用spring?

6、介绍一下spring 的事务管理？
声明式事务 和 编程式事务

7、在spring 中如何定义 hibernate mapping？

8、依赖注入（DI） 和控制反转(Ioc)？

Spring的注入方式有哪些？
1、setter 注入
2、构造器注入
3、注解注入
@Component
@Service
@Controller
@Autowired ;默认是根据byName 去查找，然后是根据byType ，如果有多个 ，用@Qualifier("UserDao")
9、Spring 中 BeanFactory 和 ApplicationContext 作用？
BeanFactory:作用：用来 实例化，初始化，管理bean 的 ;创建bean 实例

10、Spring 中核心类有哪些？
BeanFactory ：产生新实例，可以实现单例模式Singeleton
ApplicationContext: 提供框架的实现，包含BeanFactory 中所有方法，

11、什么是Aop？作用是什么？
Aop：面向切面编程。
最大的好处就是可以 提高代码复用率。 比如：在实际的开发中需要记录日志，好多地方都用到了记录日志这个方法，可以把记录日志的这些代码抽取出来，放到代理的方法中，这样就可以当需要记录日志的时候调用代理类的记录日志方法实现。
Aop 可以完善 OOP 面向对象思想，以前是：定义一个抽象类 中记录 日志的方法，在需要记录日志的类中 继承这个抽象类来实现，但是这种方式会有重复代码。

12、使用Spring 有什么好处？什么是Spring?

13、介绍一下Spring 中Bean 的生命周期？
14、spring 注入？
15、Aop 名词：
切面Aspect
连接点：joinpoint
通知：Advice
切入点：pointcut
引入：introduction
目标对象 ：target Object
Aop代理： Aop Prox
织入 weaving
通知类型：
前置通知：before advice
返回后通知 After return advice
抛出异常后通知：After throwing advice
后通知： After advice
环绕通知： around Advice

版本控制工具

git 和 svn 区别？ 、
svn :是’集中式‘ 版本控制工具；
git :是’分布式‘ 版本控制工具。
所谓 分布式 和 集中式 也就是 他们保存的地方不一样。
svn 是 集中保存 在 远程服务器上，如果服务器完蛋了，那么就不能再进行回退和看历史版本了。每次需要先进行更新，然后再把有变动的代码进行提交。
git 是 保存在本地 或者 远程服务器 ，这样是比较安全的。其次是 一般 git 的速度要比 svn 快。