欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页

2018 .03面试题整理(2018 .03 待更新 )

程序员文章站 2022-04-12 21:33:34
...

1.数据库存储大数据量(千万条记录级别)数据的考虑要点

分区
 将数据库分区可提高其性能并易于维护。通过将一个大表拆分成更小的单个表,只访问一小部分数据的查询可以执行得更快,因为需要扫描的数据较少。而且可以更快地执行维护任务(如重建索引或备份表)。

 实现分区操作时可以不拆分表,而将表物理地放置在个别的磁盘驱动器上。例如,将表放在某个物理驱动器上并将相关的表放在与之分离的驱动器上可提高查询性能,因为当执行涉及表之间联接的查询时,多个磁头同时读取数据。可以使用 Microsoft® SQL Server™ 2000 文件组指定将表放置在哪些磁盘上。

 

 硬件分区
 硬件分区将数据库设计为利用可用的硬件构架。硬件分区的示例包括:

 允许多线程执行的多处理器,使得可以同时执行许多查询。换句话说,在多处理器上可以同时执行查询的各个组件,因此使单个查询的速度更快。例如,查询内引用的每个表可同时由不同的线程扫描。


 RAID(独立磁盘冗余阵列)设备允许数据在多个磁盘驱动器中条带化,使更多的读/写磁头同时读取数据,因此可以更快地访问数据。在多个驱动器中条带化的表一般比存储在一个驱动器上的相同的表扫描速度要快。换句话说,将表与相关的表分开存储在不同的驱动器上可以显著提高联接那些表的查询的性能。


 水平分区
 水平分区将一个表分段为多个表,每个表包含相同数目的列和较少的行。例如,可以将一个包含十亿行的表水平分区成 12 个表,每个小表代表特定年份内一个月的数据。任何需要特定月份数据的查询只引用相应月份的表。

 具体如何将表进行水平分区取决于如何分析数据。将表进行分区是为了使查询引用尽可能少的表。否则,查询时须使用过多的 UNION 查询来逻辑合并表,而这会削弱查询性能。有关查询水平分区的表的更多信息,请参见视图使用方案。

 常用的方法是根据时期/使用对数据进行水平分区。例如,一个表可能包含最近五年的数据,但是只定期访问本年度的数据。在这种情况下,可考虑将数据分区成五个表,每个表只包含一年的数据。

 

 垂直分区
 垂直分区将一个表分段为多个表,每个表包含较少的列。垂直分区的两种类型是规范化和行拆分。

 规范化是个标准数据库进程,该进程从表中删除冗余列并将其放到次表中,次表按主键与外键的关系链接到主表。

 行拆分将原始表垂直分成多个只包含较少列的表。拆分的表内的每个逻辑行与其它表内的相同逻辑行匹配。例如,联接每个拆分的表内的第十行将重新创建原始行。

 与水平分区一样,垂直分区使查询得以扫描较少的数据,因此提高查询性能。例如有一个包含七列的表,通常只引用该表的前四列,那么将该表的后三列拆分到一个单独的表中可获得性能收益。

 应谨慎考虑垂直分区操作,因为分析多个分区内的数据需要有联接表的查询,而如果分区非常大将可能影响性能。

 

 使用分区视图

 

 

 

 

2.有多少种数据结构

 

  集合、线性结构、树形结构、图状结构(网状结构)树形结构、图状结构(网状结构)

3.算法

冒泡,选择,插入, 二分查找

 

4,Spring和spring mvc的区别

 

spring 是是一个开源框架,是为了解决企业应用程序开发,功能如下
◆目的:解决企业应用开发的复杂性
◆功能:使用基本的JavaBean代替EJB,并提供了更多的企业应用功能
◆范围:任何Java应用
简单来说,Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器框架。
◆轻量——从大小与开销两方面而言Spring都是轻量的。完整的Spring框架可以在一个大小只有1MB多的JAR文件里发布。并且Spring所需的处理开销也是微不足道的。此外,Spring是非侵入式的:典型地,Spring应用中的对象不依赖于Spring的特定类。
◆控制反转——Spring通过一种称作控制反转(IoC)的技术促进了松耦合。当应用了IoC,一个对象依赖的其它对象会通过被动的方式传递进来,而不是这个对象自己创建或者查找依赖对象。你可以认为IoC与JNDI相反——不是对象从容器中查找依赖,而是容器在对象初始化时不等对象请求就主动将依赖传递给它。
◆面向切面——Spring提供了面向切面编程的丰富支持,允许通过分离应用的业务逻辑与系统级服务(例如审计(auditing)和事务(transaction)管理)进行内聚性的开发。应用对象只实现它们应该做的——完成业务逻辑——仅此而已。它们并不负责(甚至是意识)其它的系统级关注点,例如日志或事务支持。
◆容器——Spring包含并管理应用对象的配置和生命周期,在这个意义上它是一种容器,你可以配置你的每个bean如何被创建——基于一个可配置原型(prototype),你的bean可以创建一个单独的实例或者每次需要时都生成一个新的实例——以及它们是如何相互关联的。然而,Spring不应该被混同于传统的重量级的EJB容器,它们经常是庞大与笨重的,难以使用。
◆框架——Spring可以将简单的组件配置、组合成为复杂的应用。在Spring中,应用对象被声明式地组合,典型地是在一个XML文件里。Spring也提供了很多基础功能(事务管理、持久化框架集成等等),将应用逻辑的开发留给了你。
所有Spring的这些特征使你能够编写更干净、更可管理、并且更易于测试的代码。它们也为Spring中的各种模块提供了基础支持。

Spring的两大核心AOP与IOC,可以单独用于任何应用,包括与Struts等MVC框架与Hibernate等ORM框架的集成,目前很多公司所谓的轻量级开发就是用 Spring + Struts(2)+Hibernate。
      Spring MVC就是一个MVC框架,个人觉得Spring MVC annotation式的开发比Struts2方便,可以直接代替上面的Struts(当然Struts的做为一个非常成熟的MVC,功能上感觉还是比Spring强一点,不过Spring MVC已经足够用了)。当然spring mvc的执行效率比struts高,是因为struts的值栈影响效率

spring mvc类似于struts的一个MVC开框架,其实都是属于spring,spring mvc需要有spring的架包作为支撑才能跑起来
◆目的:解决企业应用开发的复杂性
◆功能:使用基本的JavaBean代替EJB,并提供了更多的企业应用功能
◆范围:任何Java应用
简单来说,Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器框架。
◆轻量——从大小与开销两方面而言Spring都是轻量的。完整的Spring框架可以在一个大小只有1MB多的JAR文件里发布。并且Spring所需的处理开销也是微不足道的。此外,Spring是非侵入式的:典型地,Spring应用中的对象不依赖于Spring的特定类。
◆控制反转——Spring通过一种称作控制反转(IoC)的技术促进了松耦合。当应用了IoC,一个对象依赖的其它对象会通过被动的方式传递进来,而不是这个对象自己创建或者查找依赖对象。你可以认为IoC与JNDI相反——不是对象从容器中查找依赖,而是容器在对象初始化时不等对象请求就主动将依赖传递给它。
◆面向切面——Spring提供了面向切面编程的丰富支持,允许通过分离应用的业务逻辑与系统级服务(例如审计(auditing)和事务(transaction)管理)进行内聚性的开发。应用对象只实现它们应该做的——完成业务逻辑——仅此而已。它们并不负责(甚至是意识)其它的系统级关注点,例如日志或事务支持。
◆容器——Spring包含并管理应用对象的配置和生命周期,在这个意义上它是一种容器,你可以配置你的每个bean如何被创建——基于一个可配置原型(prototype),你的bean可以创建一个单独的实例或者每次需要时都生成一个新的实例——以及它们是如何相互关联的。然而,Spring不应该被混同于传统的重量级的EJB容器,它们经常是庞大与笨重的,难以使用。
◆框架——Spring可以将简单的组件配置、组合成为复杂的应用。在Spring中,应用对象被声明式地组合,典型地是在一个XML文件里。Spring也提供了很多基础功能(事务管理、持久化框架集成等等),将应用逻辑的开发留给了你。
所有Spring的这些特征使你能够编写更干净、更可管理、并且更易于测试的代码。它们也为Spring中的各种模块提供了基础支持。

Spring的两大核心AOP与IOC,可以单独用于任何应用,包括与Struts等MVC框架与Hibernate等ORM框架的集成,目前很多公司所谓的轻量级开发就是用 Spring + Struts(2)+Hibernate。
      Spring MVC就是一个MVC框架,个人觉得Spring MVC annotation式的开发比Struts2方便,可以直接代替上面的Struts(当然Struts的做为一个非常成熟的MVC,功能上感觉还是比Spring强一点,不过Spring MVC已经足够用了)。当然spring mvc的执行效率比struts高,是因为struts的值栈影响效率

spring mvc类似于struts的一个MVC开框架,其实都是属于spring,spring mvc需要有spring的架包作为支撑才能跑起来

 

5.介绍一下spring

 

 

简单地说,spring是用来管理你的类的框架,管理它们之间的互相调用和依赖关系,通过接口解藕,可以方便的更换使用多种不同的技术实现来完成你的系统。

核心:

a) IOC:Spring是开源框架,使用框架可以使我们减少工作量,提高工作效率并且它是分层结构,即相对应的层处理对应的业务逻辑,减少代码的耦合度。而spring的核心是IOC控制反转和AOP面向切面编程。IOC控制反转主要强调的是程序之间的关系是由容器控制的,容器控制对象,控制了对外部资源的获取。而反转即为,在传统的编程中都是由我们创建对象获取依赖对象,而在IOC中是容器帮我们创建对象并注入依赖对象,正是容器帮我们查找和注入对象,对象是被获取,所以叫反转。

b) AOP:面向切面编程,主要是管理系统层的业务,比如日志,权限,事物等。AOP是将封装好的对象剖开,找出其中对多个对象产生影响的公共行为,并将其封装为一个可重用的模块,这个模块被命名为切面(aspect),切面将那些与业务逻辑无关,却被业务模块共同调用的逻辑提取并封装起来,减少了系统中的重复代码,降低了模块间的耦合度,同时提高了系统的可维护性。

6,mysql 主从复制,oracle主从复制

 

  • 一主一从
  • 主主复制
  • 一主多从---扩展系统读取的性能,因为读是在从库读取的;
  • 多主一从---5.7开始支持
  • 联级复制---

mysql主从复制用途

  • 实时灾备,用于故障切换
  • 读写分离,提供查询服务
  • 备份,避免影响业务

 

主从部署必要条件:

  • 主库开启binlog日志(设置log-bin参数)
  • 主从server-id不同
  • 从库服务器能连通主库  

mysql主从复制原理

 2018 .03面试题整理(2018 .03 待更新 )

 

从库生成两个线程,一个I/O线程,一个SQL线程;

 

i/o线程去请求主库 的binlog,并将得到的binlog日志写到relay log(中继日志) 文件中;

主库会生成一个 log dump 线程,用来给从库 i/o线程传binlog;

 

SQL 线程,会读取relay log文件中的日志,并解析成具体操作,来实现主从的操作一致,而最终数据一致;

 

问题及解决方法


 

mysql主从复制存在的问题:

  • 主库宕机后,数据可能丢失
  • 从库只有一个sql Thread,主库写压力大,复制很可能延时

 

解决方法:

  • 半同步复制---解决数据丢失的问题
  • 并行复制----解决从库复制延迟的问题

7. dom4j和Sax的区别

 dom4j是一个Java的XML API,类似于jdom,用来读写XML文件的。dom4j是一个非常优秀的Java XML API,具有性能优异、功能强大和极端易用使用的特点,同时它也是一个开放源代码的软件。

SAX(simple API forXML)是一种XML解析的替代方法。相比于DOM,SAX是一种速度更快,更有效的方法。它逐行扫描文档,一边扫描一边解析。而且相比于DOM,SAX可以在解析文档的任意时刻停止解析,但任何事物都有其相反的一面,对于SAX来说就是操作复杂

8.创建存储过程,创建索引

创建存储过程:

 

create procedure print_std_info1
@name varchar(8)
as
select 学号,姓名,系别,出生日期 from student where 姓名aaa@qq.com
execute print_std_info1 '高春接'procedure print_std_info1
@name varchar(8)
as
select 学号,姓名,系别,出生日期 from student where 姓名aaa@qq.com
execute print_std_info1 '高春接'
创建索引:
CREATE INDEX index_name
ON table_name (column_name)

 

9.全局变量和局部变量存放位置和区别

 

9.1、局部变量:

       局部变量的定义:定义在方法中的变量都是局部变量(main方法也是方法,所以定义在main方法中的变量也是局                                      部变量)。

      生存时间:局部变量的生存时间和方法的生存时间一致,调用该方法声明该局部变量并初始化的时,该局部变量被创建并分配内存空间;直到该方法调用结束局部变量也就结束了;

     是否需要初始化:局部变量在使用前必须进行初始化,系统默认不会对局部变量进行初始化数据操作,如果局部                                       变量在使用前没有进行初始化则会在编译器报错;如果局部变量进行了声明没有进行初始化,                                     但是也一直没有被使用的话编译也是不会报错的;(局部变量使用前必须初始化话)

     创建位置: 局部变量是创建在栈内存中的;

  

2、全局变量:

    2.1 非静态全局变量

       非静态全局变量的定义:非静态全局变量都是定在类中,是类的成员变量或者说是成员属性属于类的一部分(或                                              者说是对象的一部分);

       生存时间:非静态全局变量加载在堆内存中,随着声明初始化而创建,随着对象消亡而消亡;

       是否需要初始化:全局变量都是不需要被强制初始化的,系统都会默认根据其数据类型进行默认赋值;但是建议                                     在声明时都进行初始化操作;

       创建位置:创建在堆内存中,因为非静态的全局变量数对象的成员变量是对象的一部分;

 

  2.2静态全局变量:

       静态全局变量的定义:静态的类成员变量;

       生存时间:静态全局变量随着类的字节码文件加载而加载产生,随着字节码文件的消失而消失,生存时间比类的                          对象还要长;

       是否初始化:凡是全局变量都是可以不要初始化的,静态变量也是一样,系统会自动根据其数据类型进行赋默认                               值,但是建议变量在声明时都进行初始化;

       创建位置:静态变量时存在于对内存中的,所以静态全局变量也是存在于堆内存中的;

 

10.hibernate和ibatis区别

 

hibernate中根据表生成对象实体,ibatis需要自己创建实体。hibernate不需要sql语句,ibatis需要。

 

11.spring配置事务。

 

<!-- 配置事务管理器, -->
<bean id="transactionManager" class="org.springframework.orm.hibernate5.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory" />
</bean>

 

12,网络安全包括的主要有几部分

 

(1)企业安全制度(最重要)
(2)、数据安全(防灾备份机制)
(3)、传输安全(路由热备份NATACL等)
(4)、服务器安全(包括冗余、DMZ区域等)
(5)、防火墙安全(硬件或软件实现、背靠背、DMZ等)
(6)、防病毒安全
(2)、数据安全(防灾备份机制)
(3)、传输安全(路由热备份NATACL等)
(4)、服务器安全(包括冗余、DMZ区域等)
(5)、防火墙安全(硬件或软件实现、背靠背、DMZ等)
(6)、防病毒安全
 

13.json和xml的优缺点比较

(1).可读性方面。
JSON和XML的数据可读性基本相同,JSON和XML的可读性可谓不相上下,一边是建议的语法,一边是规范的标签形式,XML可读性较好些。
(2).可扩展性方面。
XML天生有很好的扩展性,JSON当然也有,没有什么是XML能扩展,JSON不能的。
(3).编码难度方面。
XML有丰富的编码工具,比如Dom4j、JDom等,JSON也有json.org提供的工具,但是JSON的编码明显比XML容易许多,即使不借助工具也能写出JSON的代码,可是要写好XML就不太容易了。
(4).解码难度方面。
XML的解析得考虑子节点父节点,让人头昏眼花,而JSON的解析难度几乎为0。这一点XML输的真是没话说。
(5).流行度方面。
XML已经被业界广泛的使用,而JSON才刚刚开始,但是在Ajax这个特定的领域,未来的发展一定是XML让位于JSON。到时Ajax应该变成Ajaj(Asynchronous Javascript and JSON)了。
(6).解析手段方面。
JSON和XML同样拥有丰富的解析手段。
(7).数据体积方面。
JSON相对于XML来讲,数据的体积小,传递的速度更快些。
(8).数据交互方面。
JSON与JavaScript的交互更加方便,更容易解析处理,更好的数据交互。
(9).数据描述方面。
JSON对数据的描述性比XML较差。
(10).传输速度方面。
JSON的速度要远远快于XML。

14.怎么实现同步 (多线程)

一种是代码控制  synchronized由jvm实现, lock jdk实现

数据库锁实现   悲观锁,乐观锁

15.String,StringBuffer,StringBuilder优缺点

String定长不易扩展

StringBuffer线程安全,效率没有StringBuilder效率高

StringBuilder非线安全,适合单线程。效率高

17.HashMap,HashTable的区别

HashMap是支持null键和null值的,而HashTable在遇到null时,会抛出NullPointerException异常

HashMap线程不安全,HashTable线程安全

18.List和Set的比较

 

List特点:元素有放入顺序,元素可重复 ,Set特点:元素无放入顺序,元素不可重复(注意:元素虽然无放入顺序,但是元素在set中的位置是有该元素的HashCode决定的,其位置其实是固定的) 

List是一种数据结构,这种数据结构已经规定了其功能就是按照顺序排放数据的。这点是你我都无法改变的了。不过具体的顺序还有:顺序排放,链表排放等

19.Restful相比cxf有啥优势

rest轻量级,SOAP重量级;rest学习起来比较简单,容易上手,SOAP相对来说难些;rest能通过http形式的直接调用,基于JSON,SOAP通过XML传输;rest效率和速度来说相对快些,SOAP则稍逊一筹

20.消息队列

消息生产者,消息消费者。

 

  1.  // ConnectionFactory :连接工厂,JMS 用它创建连接  
  2.         ConnectionFactory connectionFactory; // Connection :JMS 客户端到JMS  
  3.         // Provider 的连接  
  4.         Connection connection = null// Session: 一个发送或接收消息的线程  
  5.         Session session; // Destination :消息的目的地;消息发送给谁.  
  6.         Destination destination; // MessageProducer:消息发送者  
  7.         MessageProducer producer; // TextMessage message;  
  8.         // 构造ConnectionFactory实例对象,此处采用ActiveMq的实现jar  
  9.         connectionFactory = new ActiveMQConnectionFactory(  
  10.                 ActiveMQConnection.DEFAULT_USER,  
  11.                 ActiveMQConnection.DEFAULT_PASSWORD, "tcp://localhost:61616");  
  12.         try { // 构造从工厂得到连接对象  
  13.             connection = connectionFactory.createConnection();  
  14.             // 启动  
  15.             connection.start();  
  16.             // 获取操作连接  
  17.             session = connection.createSession(Boolean.TRUE,  
  18.                     Session.AUTO_ACKNOWLEDGE);  
  19.             // 获取session注意参数值xingbo.xu-queue是一个服务器的queue,须在在ActiveMq的console配置  
  20.             destination = session.createQueue("FirstQueue");  
  21.             // 得到消息生成者【发送者】  
  22.             producer = session.createProducer(destination);  
  23.             // 设置不持久化,此处学习,实际根据项目决定  
  24.             producer.setDeliveryMode(DeliveryMode.NON_PERSISTENT);  
  25.             // 构造消息,此处写死,项目就是参数,或者方法获取  
  26.             sendMessage(session, producer);  
  27.             session.commit();  

21,线程池

 

1. newSingleThreadExecutor

创建一个单线程的线程池。这个线程池只有一个线程在工作,也就是相当于单线程串行执行所有任务。如果这个唯一的线程因为异常结束,那么会有一个新的线程来替代它。此线程池保证所有任务的执行顺序按照任务的提交顺序执行。

2.newFixedThreadPool

创建固定大小的线程池。每次提交一个任务就创建一个线程,直到线程达到线程池的最大大小。线程池的大小一旦达到最大值就会保持不变,如果某个线程因为执行异常而结束,那么线程池会补充一个新线程。

3. newCachedThreadPool

创建一个可缓存的线程池。如果线程池的大小超过了处理任务所需要的线程,

那么就会回收部分空闲(60秒不执行任务)的线程,当任务数增加时,此线程池又可以智能的添加新线程来处理任务。此线程池不会对线程池大小做限制,线程池大小完全依赖于操作系统(或者说JVM)能够创建的最大线程大小。

4.newScheduledThreadPool

创建一个大小无限的线程池。此线程池支持定时以及周期性执行任务的需求。

 

22.使用框架的好处

 

框架可以帮助我们减少代码冗余,提高运行速度,便于维护,规范编程运行速度,便于维护,规范编程
23,索引会失效么

一部分原因:

1) 没有查询条件,或者查询条件没有建立索引 

2) 在查询条件上没有使用引导列 
3) 查询的数量是大表的大部分,应该是30%以上。 
4) 索引本身失效 
5) 查询条件使用函数在索引列上
6) 对小表查询 
7) 提示不使用索引 

 

8) 统计数据不真实 

 

9)对索引列进行运算导致索引失效,我所指的对索引列进行运算包括(+,-,*,/,! 等) 

24.redis事务

 

  • 批量操作在发送 EXEC 命令前被放入队列缓存。
  • 收到 EXEC 命令后进入事务执行,事务中任意命令执行失败,其余的命令依然被执行。
  • 在事务执行过程,其他客户端提交的命令请求不会插入到事务执行命令序列中

25.redis发布订阅

 

Redis 发布订阅(pub/sub)是一种消息通信模式:发送者(pub)发送消息,订阅者(sub)接收消息。

Redis 客户端可以订阅任意数量的频道。

 

2018 .03面试题整理(2018 .03 待更新 )

 

下图展示了频道 channel1 , 以及订阅这个频道的三个客户端 —— client2 、 client5 和 client1 之间的关系:

2018 .03面试题整理(2018 .03 待更新 )

当有新消息通过 PUBLISH 命令发送给频道 channel1 时, 这个消息就会被发送给订阅它的三个客户端:

2018 .03面试题整理(2018 .03 待更新 )

2018 .03面试题整理(2018 .03 待更新 )

 

 

 

以下实例演示了发布订阅是如何工作的。在我们实例中我们创建了订阅频道名为 redisChat:

redis 127.0.0.1:6379> SUBSCRIBE redisChat

Reading messages... (press Ctrl-C to quit)
1) "subscribe"
2) "redisChat"
3) (integer) 1127.0.0.1:6379> SUBSCRIBE redisChat

Reading messages... (press Ctrl-C to quit)
1) "subscribe"
2) "redisChat"
3) (integer) 1

现在,我们先重新开启个 redis 客户端,然后在同一个频道 redisChat 发布两次消息,订阅者就能接收到消息。

redis 127.0.0.1:6379> PUBLISH redisChat "Redis is a great caching technique"

(integer) 1

redis 127.0.0.1:6379> PUBLISH redisChat "Learn redis by runoob.com"

(integer) 1

# 订阅者的客户端会显示如下消息
1) "message"
2) "redisChat"
3) "Redis is a great caching technique"
1) "message"
2) "redisChat"
3) "Learn redis by runoob.com"127.0.0.1:6379> PUBLISH redisChat "Redis is a great caching technique"

(integer) 1

redis 127.0.0.1:6379> PUBLISH redisChat "Learn redis by runoob.com"

(integer) 1

# 订阅者的客户端会显示如下消息
1) "message"
2) "redisChat"
3) "Redis is a great caching technique"
1) "message"
2) "redisChat"
3) "Learn redis by runoob.com"

25.nio和bio的区别

BIO:同步阻塞式IO,服务器实现模式为一个连接一个线程,即客户端有连接请求时服务器端就需要启动一个线程进行处理,如果这个连接不做任何事情会造成不必要的线程开销,当然可以通过线程池机制改善。 
NIO:同步非阻塞式IO,服务器实现模式为一个请求一个线程,即客户端发送的连接请求都会注册到多路复用器上,多路复用器轮询到连接有I/O请求时才启动一个线程进行处理。 
AIO(NIO.2):异步非阻塞式IO,服务器实现模式为一个有效请求一个线程,客户端的I/O请求都是由OS先完成了再通知服务器应用去启动线程进行处理。 
 

26.事务隔离级别

 

Read uncommitted

读未提交,顾名思义,就是一个事务可以读取另一个未提交事务的数据。

Read committed

读提交,顾名思义,就是一个事务要等另一个事务提交后才能读取数据。

Repeatable read

重复读,就是在开始读取数据(事务开启)时,不再允许修改操作

 

Serializable 序列化

Serializable 是最高的事务隔离级别,在该级别下,事务串行化顺序执行,可以避免脏读、不可重复读与幻读。但是这种事务隔离级别效率低下,比较耗数据库性能,一般不使用。

27.java中反射的作用

 

Java反射机制主要提供了以下功能: 在运行时判断任意一个对象所属的类;在运行时构造任意一个类的对象;在运行时判断任意一个类所具有的成员变量和方法;在运行时调用任意一个对象的方法;生成动态代理

 

执行某对象的方法
判断是否为某个类的实例

 

28.servlet的生命周期

 

Servlet 生命周期可被定义为从创建直到毁灭的整个过程。以下是 Servlet 遵循的过程:

  • Servlet 通过调用 init () 方法进行初始化。
  • Servlet 调用 service() 方法来处理客户端的请求。
  • Servlet 通过调用 destroy() 方法终止(结束)。
  • 最后,Servlet 是由 JVM 的垃圾回收器进行垃圾回收的。

servlet是非线程安全的

当Tomcat接收到Client的HTTP请求时,Tomcat从线程池中取出一个线程,之后找到该请求对应的Servlet对象。如果该Servlet还未被请求过,那么将进行Servlet初始化并调用Servlet并调用service()方法。否则,直接调用service()方法。要注意的是每一个Servlet对象再Tomcat容器中只有一个实例对象,即是单例模式。如果多个HTTP请求请求的是同一个Servlet,那么着两个HTTP请求对应的线程将并发调用Servlet的service()方法。

29.Map-reduce的理解

Map(映射): 把洋葱、番茄、辣椒和大蒜切碎,是各自作用在这些物体上的一个Map操作。所以你给Map一个洋葱,Map就会把洋葱切碎。 同样的,你把辣椒,大蒜和番茄一一地拿给Map,你也会得到各种碎块。 所以,当你在切像洋葱这样的蔬菜时,你执行就是一个Map操作。 Map操作适用于每一种蔬菜,它会相应地生产出一种或多种碎块,在我们的例子中生产的是蔬菜块。在Map操作中可能会出现有个洋葱坏掉了的情况,你只要把坏洋葱丢了就行了。所以,如果出现坏洋葱了,Map操作就会过滤掉坏洋葱而不会生产出任何的坏洋葱块。


Reduce(化简):在这一阶段,你将各种蔬菜碎都放入研磨机里进行研磨,你就可以得到一瓶辣椒酱了。这意味要制成一瓶辣椒酱,你得研磨所有的原料。因此,研磨机通常将map操作的蔬菜碎聚集在了一起。

 

29.ArrayList和linkedlist区别

1).ArrayList是实现了基于动态数组的数据结构,LinkedList基于链表的数据结构。 
     2).对于随机访问get和set,ArrayList觉得优于LinkedList,因为LinkedList要移动指针。 

     3).对于新增和删除操作add和remove,LinedList比较占优势,因为ArrayList要移动数据

 

30,Hashmap的扩容机制

 

  • Node<K,V>:链表节点,包含了key、value、hash、next指针四个元素
  • table:Node<K,V>类型的数组,里面的元素是链表,用于存放HashMap元素的实体
  • size:记录了放入HashMap的元素个数
  • loadFactor:负载因子
  • threshold:阈值,决定了HashMap何时扩容,以及扩容后的大小,一般等于table大小乘以loadFactor

HashMap使用的是懒加载,构造完HashMap对象后,只要不进行put 方法插入元素之前,HashMap并不会去初始化或者扩容table:

当添加完元素后,如果HashMap发现size(元素总数)大于threshold(阈值),则会调用resize方法进行扩容

 

若threshold(阈值)不为空,table的首次初始化大小为阈值,否则初始化为缺省值大小16

扩容或初始化完成后,resize方法返回新的table

 

31.spring 当中用到了那些设计模式

 

1).工厂模式,这个很明显,在各种BeanFactory以及ApplicationContext创建中都用到了;

2).模版模式,这个也很明显,在各种BeanFactory以及ApplicationContext实现中也都用到了;

3).代理模式,在Aop实现中用到了JDK的动态代理;

4).单例模式,这个比如在创建bean的时候。

 

5.Tomcat中有很多场景都使用到了外观模式,因为Tomcat中有很多不同的组件,每个组件需要相互通信,但又不能将自己内部数据过多地暴露给其他组件。用外观模式隔离数据是个很好的方法。

6.策略模式在Java中的应用,这个太明显了,因为Comparator这个接口简直就是为策略模式而生的。Comparable和Comparator的区别一文中,详细讲了Comparator的使用。比方说Collections里面有一个sort方法,因为集合里面的元素有可能是复合对象,复合对象并不像基本数据类型,可以根据大小排序,复合对象怎么排序呢?基于这个问题考虑,Java要求如果定义的复合对象要有排序的功能,就自行实现Comparable接口或Comparator接口.

7.原型模式:使用原型模式创建对象比直接new一个对象在性能上好得多,因为Object类的clone()方法是一个native方法,它直接操作内存中的二进制流,特别是复制大对象时,性能的差别非常明显。

8.迭代器模式:Iterable接口和Iterator接口 这两个都是迭代相关的接口,可以这么认为,实现了Iterable接口,则表示某个对象是可被迭代的;Iterator接口相当于是一个迭代器,实现了Iterator接口,等于具体定义了这个可被迭代的对象时如何进行迭代的

  32 对称加密算法和非对称加密算法

对称加密:des ,3des ,aes

非对称加密:rsa

33.简述java中的final、finally、finalize的差别

 

(1)final:可以作为修饰符修饰变量、方法和类,被final修饰的变量只能一次赋值;被final修饰的方法不能够在子类中被重写(override);被final修饰的类不能够被继承。

 

(2)finally用在异常处理中定义总是执行代码,无论try块中的代码是否引发异常,catch是否匹配成功,finally块中的代码总是被执行,除非JVM被关闭(System.exit(1)),通常用作释放外部资源(不会被垃圾回收器回收的资源)。

 

(3)finalize()方法是Object类中定义的方法,当垃圾回收器将无用对象从内存中清除时,该对象的finalize()方法被调用。由于该方法是protected方法,子类可以通过重写(override)该方法以整理资源或者执行其他的清理工作

 

34 java实现多态的机制是什么

 

方法的重写Overriding和重载Overloading是Java多态性的不同表现.

重写Overriding是父类与子类之间多态性的一种表现

重载Overloading是一个类中多态性的一种表现.

 

35.java集合类框架的基本接口有哪些

 

Collection:代表一组对象,每一个对象都是它的子元素

Set:不包括重复元素的Collection

List:有顺序的Collection,并且可以包含重复元素

Map:可以把键(key)映射到值(value)的对象,键不能重复

36,进程和线程的区别

 

线程是指进程内的一个执行单元,也是进程内的可调度实体.与进程的区别:(1)地址空间:进程内的一个执行单元;进程至少有一个线程;它们共享进程的地址空间;而进程有自己独立的地址空间;(2)进程是资源分配和拥有的单位,同一个进程内的线程共享进程的资源(3)线程是处理器调度的基本单位,但进程不是.(4)二者均可并发执行.

 37.jsp页面之间传递参数的方法

1)URL传值;
2)表单传值;
3)Cookie方法;

4)Session方法;

38.java创建对象的几种方法

1).使用new关键字:这是我们最常见的也是最简单的创建对象的方式,通过这种方式我们还可以调用任意的够赞函数(无参的和有参的)。比如:Student student = new Student();

2)使用Class类的newInstance方法:我们也可以使用Class类的newInstance方法创建对象,这个newInstance方法调用无参的构造器创建对象,如:Student student2 = (Student)Class.forName("根路径.Student").newInstance(); 或者:Student stu = Student.class.newInstance();

3)使用Constructor类的newInstance方法:本方法和Class类的newInstance方法很像,java.lang.relect.Constructor类里也有一个newInstance方法可以创建对象。我们可以通过这个newInstance方法调用有参数的和私有的构造函数。如: Constructor<Student> constructor = Student.class.getInstance(); Student stu = constructor.newInstance(); 这两种newInstance的方法就是大家所说的反射,事实上Class的newInstance方法内部调用Constructor的newInstance方法。这也是众多框架Spring、Hibernate、Struts等使用后者的原因。

4)使用Clone的方法:无论何时我们调用一个对象的clone方法,JVM就会创建一个新的对象,将前面的对象的内容全部拷贝进去,用clone方法创建对象并不会调用任何构造函数。要使用clone方法,我们必须先实现Cloneable接口并实现其定义的clone方法。如:Student stu2 = <Student>stu.clone();这也是原型模式的应用。

5)使用反序列化:当我们序列化和反序列化一个对象,JVM会给我们创建一个单独的对象,在反序列化时,JVM创建对象并不会调用任何构造函数。为了反序列化一个对象,我们需要让我们的类实现Serializable接口。如:ObjectInputStream in = new ObjectInputStream (new FileInputStream("data.obj")); Student stu3 = (Student)in.readObject();

39.数据库优化

1)使用索引

2)不要使用* 代替所有列名。

3)使用not exist 代替 not in

4)trancate 代替delete 

5)减少表的查询

40,exception 的父类

 

Exception extends Throwable

41.transient 关键字的意思

用transient关键字标记的成员变量不参与序列化过程

42. synchronized的用法:

synchronized修饰方法和synchronized修饰代码块。

 

43.jvm 配置参数

参数名称 含义 默认值  
-Xms 初始堆大小 物理内存的1/64(<1GB) 默认(MinHeapFreeRatio参数可以调整)空余堆内存小于40%时,JVM就会增大堆直到-Xmx的最大限制.
-Xmx 最大堆大小 物理内存的1/4(<1GB) 默认(MaxHeapFreeRatio参数可以调整)空余堆内存大于70%时,JVM会减少堆直到 -Xms的最小限制
-Xmn 年轻代大小(1.4or lator)   注意:此处的大小是(eden+ 2 survivor space).与jmap -heap中显示的New gen是不同的。
整个堆大小=年轻代大小 + 年老代大小 + 持久代大小.
增大年轻代后,将会减小年老代大小.此值对系统性能影响较大,Sun官方推荐配置为整个堆的3/8
-XX:NewSize 设置年轻代大小(for 1.3/1.4)    
-XX:MaxNewSize 年轻代最大值(for 1.3/1.4)    
-XX:PermSize 设置持久代(perm gen)初始值 物理内存的1/64  
-XX:MaxPermSize 设置持久代最大值 物理内存的1/4  
-Xss 每个线程的堆栈大小   JDK5.0以后每个线程堆栈大小为1M,以前每个线程堆栈大小为256K.更具应用的线程所需内存大小进行 调整.在相同物理内存下,减小这个值能生成更多的线程.但是操作系统对一个进程内的线程数还是有限制的,不能无限生成,经验值在3000~5000左右
一般小的应用, 如果栈不是很深, 应该是128k够用的 大的应用建议使用256k。这个选项对性能影响比较大,需要严格的测试。(校长)
和threadstacksize选项解释很类似,官方文档似乎没有解释,在论坛中有这样一句话:"”
-Xss is translated in a VM flag named ThreadStackSize”
一般设置这个值就可以了。
-XX:ThreadStackSize Thread Stack Size   (0 means use default stack size) [Sparc: 512; Solaris x86: 320 (was 256 prior in 5.0 and earlier); Sparc 64 bit: 1024; Linux amd64: 1024 (was 0 in 5.0 and earlier); all others 0.]
-XX:NewRatio 年轻代(包括Eden和两个Survivor区)与年老代的比值(除去持久代)   -XX:NewRatio=4表示年轻代与年老代所占比值为1:4,年轻代占整个堆栈的1/5
Xms=Xmx并且设置了Xmn的情况下,该参数不需要进行设置。
-XX:SurvivorRatio Eden区与Survivor区的大小比值   设置为8,则两个Survivor区与一个Eden区的比值为2:8,一个Survivor区占整个年轻代的1/10
-XX:LargePageSizeInBytes 内存页的大小不可设置过大, 会影响Perm的大小   =128m
-XX:+UseFastAccessorMethods 原始类型的快速优化    
-XX:+DisableExplicitGC 关闭System.gc()   这个参数需要严格的测试
-XX:MaxTenuringThreshold 垃圾最大年龄   如果设置为0的话,则年轻代对象不经过Survivor区,直接进入年老代. 对于年老代比较多的应用,可以提高效率.如果将此值设置为一个较大值,则年轻代对象会在Survivor区进行多次复制,这样可以增加对象再年轻代的存活 时间,增加在年轻代即被回收的概率
该参数只有在串行GC时才有效.
-XX:+AggressiveOpts 加快编译    
-XX:+UseBiasedLocking 锁机制的性能改善    
-Xnoclassgc 禁用垃圾回收    
-XX:SoftRefLRUPolicyMSPerMB 每兆堆空闲空间中SoftReference的存活时间 1s softly reachable objects will remain alive for some amount of time after the last time they were referenced. The default value is one second of lifetime per free megabyte in the heap
-XX:PretenureSizeThreshold 对象超过多大是直接在旧生代分配 0 单位字节 新生代采用Parallel Scavenge GC时无效
另一种直接在旧生代分配的情况是大的数组对象,且数组中无外部引用对象.
-XX:TLABWasteTargetPercent TLAB占eden区的百分比 1%  
-XX:+CollectGen0First FullGC时是否先YGC false  

并行收集器相关参数

-XX:+UseParallelGC Full GC采用parallel MSC
(此项待验证)
 

选择垃圾收集器为并行收集器.此配置仅对年轻代有效.即上述配置下,年轻代使用并发收集,而年老代仍旧使用串行收集.(此项待验证)

-XX:+UseParNewGC 设置年轻代为并行收集   可与CMS收集同时使用
JDK5.0以上,JVM会根据系统配置自行设置,所以无需再设置此值
-XX:ParallelGCThreads 并行收集器的线程数   此值最好配置与处理器数目相等 同样适用于CMS
-XX:+UseParallelOldGC 年老代垃圾收集方式为并行收集(Parallel Compacting)   这个是JAVA 6出现的参数选项
-XX:MaxGCPauseMillis 每次年轻代垃圾回收的最长时间(最大暂停时间)   如果无法满足此时间,JVM会自动调整年轻代大小,以满足此值.
-XX:+UseAdaptiveSizePolicy 自动选择年轻代区大小和相应的Survivor区比例   设置此选项后,并行收集器会自动选择年轻代区大小和相应的Survivor区比例,以达到目标系统规定的最低相应时间或者收集频率等,此值建议使用并行收集器时,一直打开.
-XX:GCTimeRatio 设置垃圾回收时间占程序运行时间的百分比   公式为1/(1+n)
-XX:+ScavengeBeforeFullGC Full GC前调用YGC true Do young generation GC prior to a full GC. (Introduced in 1.4.1.)

 

-

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

相关标签: 面试