java 面试题

Posted wanglichaoya

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了java 面试题相关的知识,希望对你有一定的参考价值。

数据库 方面
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 快。

















































































































































































































以上是关于java 面试题的主要内容,如果未能解决你的问题,请参考以下文章

面试基础题

2020 年最新版 Java 面试题大全(文末附参考答案)

2020年最新版Java面试题大全(文末附参考答案)

Java面试题,Java面试题及答案,2021最新的,都整理好了

IT JAVA 面试题真的那么重要吗,对记面试题我记了又忘,很烦!

java面试题