java 面试题

数据库 方面
一、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;

二、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 系统优化
1、sql 语句的优化：
一、不用(*)代替全部列名，
缘由：若是用*代替全部列名的话，oracle系统会出现动态解析的问题，好比须要到数据字典中来验证表和列的定义等。

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

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

四、用truncate 语句代替delete语句。
缘由：delete 删除数据的时候，oracle会使用撤销表空间来存放删除操做的信息，若是用户回滚，能够回到删除以前的状态，
而truncate不会这样作，数据不能回到删除以前的状态。

五、用 表链接 代替 嵌套查询 (表的屡次查询)。
缘由：若是用嵌套的查询，每次oracle内部会进行一系列的操做，这样会致使查询效率变低。

六、用exists代替in
缘由：in 操做符 用于检查值是否在一个列表中，所以须要进行全表扫描，而exists只是检查行是否存在，

七、用exists代替distinct
缘由：exists是用来检查子查询返回的行是否存在，而distinct是用来禁止重复行的显示。
可是distinct在禁止重复行显示以前须要排序检索到的行

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

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

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

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

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

一、索引列是上应该尽可能不使用‘非’操做符，如not，!<,not exists,no in 和not like. 由于使用非操做符会致使oracle对全表扫描。

二、惟一索引上不要使用null 值，
惟一索引是说列的值不能重复，可是多个null 值能够同时存在，由于oracle认为多个null 值不相等。
因此向惟一索引列上加null 值的时候，当where 子句 使用 is null 等非 操做符 对惟一索引列进行比较，oracle将会中止使用列上的惟一索引，oracle将会进行全表扫描。

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

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

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

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

四、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实例的初始化参数。

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

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

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

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


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

多线程方面的问题

一、如何实现多线程？
实现多线程有两种方式。一种是：继承Thread 类，另外一种是：实现Runnable 接口。
这两种方式其实均可以，区别不大，可是：由于java中 类的继承是单继承的，可是类能够实现多个接口。这一就说明，只要
继承了Thread 类，就不能够再继承其余类了。

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

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


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

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

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

二、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 工做流程：
一、浏览器发送http 请求，
二、请求被web.xml 中的 filterDispatcher 拦截
三、根据struts.xml 找处处理请求的Action
四、Action 进行逻辑处理，处理完之后返回一个 结果集
五、根据Strut2.xml 中的result 找到相应的页面
六、把处理结果返回到浏览器进行显示。



事务 方面：

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);
}
});

}

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

二、使用 Aop 声明事务控制
步骤：
一、配置事务管理器
<bean id = "transactionManager" class= "org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref = "dataSource"></property>
</bean>
二、配置事务加强 <tx:advice>,须要配置 事务加强的传播机制 7种传播机制
<tx id = "adviser" transaction-manager = "transactionManager">
<tx:attributes>
<tx:method name ="add*" propagation="REQUIRED"/>
</tx:attributes>
</tx>
三、配置切点、事务通知
<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 相似的操做。

一、事务的4个特性？
原子性 ：一个事务在执行的过程当中，要么所有执行，要么所有不执行。
一致性 ：数据不会由于事务的执行而遭到破坏。
隔离性 ：一个事务的执行不会影响其余事务的执行。
持久性 ：一个事务一旦提交，对数据库的影响是永久的。

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

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

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

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

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

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

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

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

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

八、依赖注入（DI） 和控制反转(Ioc)？
依赖注入是控制反转IOC 的一个方面，就是说只须要描述对象是如何建立的，不须要在代码里面实现。  控制反转是咱们不须要本身建立对象，而是把建立对象交给spring 容器，只须要告诉它如何建立，须要对象的时候直接从容器中获取就能够了。

控制反转是原则，依赖注入是实现的具体方式。
Spring的注入方式有哪些？
一、setter 注入
二、构造器注入
三、注解注入
@Component
@Service
@Controller
@Autowired ;默认是根据byName 去查找，而后是根据byType ，若是有多个 ，用@Qualifier("UserDao")
九、Spring 中 BeanFactory 和 ApplicationContext 做用？
BeanFactory:做用：用来 实例化，初始化，管理bean 的 ;建立bean 实例

十、Spring 中核心类有哪些？
BeanFactory ：产生新实例，能够实现单例模式Singeleton
ApplicationContext: 提供框架的实现，包含BeanFactory 中全部方法，

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

十二、使用Spring 有什么好处？什么是Spring?
Spring是轻量级的，Spring是一个容器框架，管理对象的生命周期和配置。包括  控制反转IOC和依赖注入DI;

　　一、控制反转；

　　二、面向切面编程AOP
1三、介绍一下Spring 中Bean 的生命周期？
1四、spring 注入？
1五、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 快。