当前位置:首页 > 开发 > 互联网 > 正文

java面试总结

发表于: 2015-07-05   作者:BlueSkator   来源:转载   浏览次数:
摘要: 1、object 的equals () 和 hashcode()  关于Object类的equals的特点,对于非空引用: 1.自反性:x.equals(x) return true ; 2.对称性:x.equals(y)为true,那么y.equals(x)也为true; 3.传递性:x.equals(y)为true,y.equals(z)为true,那么x.equals(z)

1、object 的equals () 和 hashcode() 

关于Object类的equals的特点,对于非空引用:

1.自反性:x.equals(x) return true ;

2.对称性:x.equals(y)为true,那么y.equals(x)也为true;

3.传递性:x.equals(y)为true,y.equals(z)为true,那么x.equals(z)也为true;

4.一致性:x.equals(y)的第一次调用为true,那么x.equals(y)的第二次,第三次,。。。,第n次调用也为true,前提条件是在比较之间没有修改x,也没有修改y。

5.x.equals(null)返回false。

 

当override equals方法时,同时需要重写hashCode方法,以保证相同对象的hashCode值相同。

 

关于Object类的hashCode方法的特点:

1.在java应用的一次执行过程当中,对于同一个对象的hashCode方法的多次调用,应该返回同样的值。(前提是该对象的信息没有发生改变);

2.对于两个对象来说,如果使用equals方法比较返回true,那么这两个对象的hashCode值一定是相同的;

3.对于两个对象来说,如果使用equals方法比较返回false,那么这两个对象的hashCode值不要求一定不同,也就是说可以相同,也可以不同。但是,如果不同,则可以提高应用的性能。

4.对于Object类来说,不同的Object对象的hashCode值是不同的(Object类的hashCode值表示的是对象的地址,其他类如果重写了hashCode()方法,那么hashCode值就不一定表示的是地址了)。

 

如果我们重写equals方法,那么有也要重写hashCode方法,反之依然。

 

集合增加时的原理:

 

    当使用HashSet时,hashCode()方法就会被调用,判断已经存储在集合中的对象的hashCode值是否与增加的对象的hashCode值一致;如果不一致,直接加进去;如果一致,再进行equals方法的比较,equals方法如果返回true,表示对象已经加进去了,就不会再增加新的对象,否则加进去。

String s1 = new String("a");
	String s2 = new String("a");
	System.out.println(s1..hashCode() == s2..hashCode());//返回true
	HashSet set = new HashSet();
	set.add(s1);
	set.add(s2);

 结果只会增加一个。因为String类重写了equals和hashCode方法,hashCode方法只是将字符串的内容通过一定的转换,转换成一个整数值。所以,String类的equals方法,只要两个字符串内容相同,则equals返回true。

另外一个例子:

首先,定义一个People类,未重写equals方法和hashCode方法。

public class People
{
	private String name;
        public People(String name)
	{
		super();
		this.name = name;
	}
	//省略get/set方法
}

 执行下面代码:

People p1 = new People("a");
		People p2 = new People("a");
		set.add(p1);
		set.add(p2);

 执行结果:

P1和P2都会加到set集合里面去,因为People类继承自Object类,Object类的hashCode()方法返回的值是地址的一种表现形式,因为P1和P2地址是不相同的,所以hashCode值也是不相同的,所以都会被加入到set集合里面。

2.StringBuffer 和 StringBulider

1)性能上讲:StringBuffer性能要低于StringBulider 

2)安全性讲:StringBuffer要高于StringBulider

新引入的StringBuilder类不是线程安全的,但其在单线程中的性能比StringBuffer高。StringBuffer 的方法都是synchronized的。

 

3.HashTable 和HashMap

HashTable和HashMap区别的就是支持线程同步保证线程安全而导致性能下降的问题。HashTable是线程安全的,很多方法都是synchronized方法,而HashMap不是线程安全的,但其在单线程程序中的性能比HashTable要高。

 

4.try {}里有一个return语句,那么紧跟在这个try后的finally {}里的code会不会被执行,什么时候被执行,在return前还是后?

try中的return语句调用的函数先于finally中调用的函数执行,也就是说return语句先执行,finally语句后执行,所以,返回的结果是2。Return并不是让函数马上返回,而是return语句执行后,将把返回结果放置进函数栈中,此时函数并不是马上返回,它要执行finally语句后才真正开始返回。

 

5.数据库事务

是指作为单个逻辑工作单元执行的一系列操作。事务处理可以确保除非事务性单元内的所有操作都成功完成,否则不会永久更新面向数据的资源。通过将一组相关操作组合为一个要么全部成功要么全部失败的单元,可以简化错误恢复并使应用程序更加可靠。一个逻辑工作单元要成为事务,必须满足所谓的ACID(原子性、一致性、隔离性和持久性)属性。 

 

如果没有锁定且多个用户同时访问一个数据库,则当他们的事务同时使用相同的数据时可能会发生问题。由于并发操作带来的数据不一致性包括:丢失数据修改、读”脏”数据(脏读)、不可重复读、产生幽灵数据。

 

 Hibernate数据库事务隔离级别

为了解决数据库事务并发运行时的各种问题数据库系统提供四种事务隔离级别:
1. Serializable 串行化
2. Repeatable Read 可重复读
3. Read Commited 可读已提交
4. Read Uncommited 可读未提交

 

6.Hibernate乐观锁与悲观锁

悲观锁,正如其名,它指的是对数据被外界(包括本系统当前的其他事务,以及来自外部系统的事务处理)修改持保守态度,因此,在整个数据处理过程中,将数据处于锁定状态。悲观锁的实现,往往依靠数据库提供的锁机制(也只有数据库层提供的锁机制才能真正保证数据访问的排他性,否则,即使在本系统中实现了加锁机制,也无法保证外部系统不会修改数据)。

使用乐观锁解决事务并发问题

  相对悲观锁而言,乐观锁机制采取了更加宽松的加锁机制。悲观锁大多数情况下依靠数据库的锁机制实现,以保证操作最大程度的独占性。但随之而来的就是数据库性能的大量开销,特别是对长事务而言,这样的开销往往无法承受。乐观锁机制在一定程度上解决了这个问题。乐观锁,大多是基于数据版本(Version)记录机制实现。何谓数据版本?即为数据增加一个版本标识,在基于数据库表的版本解决方案中,一般是通过为数据库表增加一个"version"字段来实现。
  乐观锁的工作原理:读取出数据时,将此版本号一同读出,之后更新时,对此版本号加一。此时,将提交数据的版本数据与数据库表对应记录的当前版本信息进行比对,如果提交的数据版本号大于数据库表当前版本号,则予以更新,否则认为是过期数据。

 Hibernate为乐观锁提供了3中实现:

1. 基于version

2. 基于timestamp

3. 为遗留项目添加添加乐观锁 

 

 7、java中Map,List与Set的区别

集合分类:
Collection :List、Set
Map:HashMap、HashTable
Collection是 最基本的集合接口 ,声明了适用于JAVA集合(只包括Set和List)的通用方法。 Set 和List 都继承了Conllection,Map。
1.1 Set(集合) 
Set是最简单的一种集合。集合中的对象不按特定的方式排序,并且没有重复对象。 Set接口主要实现了两个实现类:
  • HashSet: HashSet类按照哈希算法来存取集合中的对象,存取速度比较快 
  • TreeSet :TreeSet类实现了SortedSet接口,能够对集合中的对象进行排序。
  • Set : 存入Set的每个元素都必须是唯一的,因为Set不保存重复元素。加入Set的元素必须定义equals()方法以确保对象的唯一性。Set与Collection有完全一样的接口。Set接口不保证维护元素的次序。 

    HashSet:为快速查找设计的Set。存入HashSet的对象必须定义hashCode()。 

    TreeSet: 保存次序的Set, 底层为树结构。使用它可以从Set中提取有序的序列。 

    LinkedHashSet:具有HashSet的查询速度,且内部使用链表维护元素的顺序(插入的次序)。于是在使用迭代器遍历Set时,结果会按元素插入的次序显示。
  • 1.2 List
  • ArrayList :由数组实现的List。允许对元素进行快速随机访问,但是向List中间插入与移除元素的速度很慢。ListIterator只应该用来由后向前遍历 ArrayList,而不是用来插入和移除元素。因为那比LinkedList开销要大很多。 
  • LinkedList :对顺序访问进行了优化,向List中间插入与删除的开销并不大。随机访问则相对较慢。(使用ArrayList代替。)还具有下列方 法:addFirst(), addLast(), getFirst(), getLast(), removeFirst() 和 removeLast(), 这些方法 (没有在任何接口或基类中定义过)使得LinkedList可以当作堆栈、队列和双向队列使用。
    1.3 Map(映射)

    Map 是一种把键对象和值对象映射的集合,它的每一个元素都包含一对键对象和值对象。 Map没有继承于Collection接口 从Map集合中检索元素时,只要给出键对象,就会返回对应的值对象。

    HashMap就是使用对象的hashCode()进行快速查询的。此方法能够显着提高性能。 

    Map : 维护“键值对”的关联性,使你可以通过“键”查找“值”

    HashMap:Map基于散列表的实现。插入和查询“键值对”的开销是固定的。可以通过构造器设置容量capacity和负载因子load factor,以调整容器的性能。 

    LinkedHashMap: 类似于HashMap,但是迭代遍历它时,取得“键值对”的顺序是其插入次序,或者是最近最少使用(LRU)的次序。只比HashMap慢一点。而在迭代访问时发而更快,因为它使用链表维护内部次序。 

    TreeMap : 基于红黑树数据结构的实现。查看“键”或“键值对”时,它们会被排序(次序由Comparabel或Comparator决定)。TreeMap的特点在 于,你得到的结果是经过排序的。TreeMap是唯一的带有subMap()方法的Map,它可以返回一个子树。 

    1.4 区别
  • 1.4.1、Collection 和 Map 的区别 

    容器内每个为之所存储的元素个数不同。
    Collection类型者,每个位置只有一个元素。
    Map类型者,持有 key-value pair,像个小型数据库。

    1.4.2、各自旗下的子类关系

    Collection
         --List:将以特定次序存储元素。所以取出来的顺序可能和放入顺序不同。
               --ArrayList / LinkedList / Vector
         --Set : 不能含有重复的元素
               --HashSet / TreeSet
          Map
         --HashMap
         --HashTable
         --TreeMap

    1.4.3、其他特征

    List,Set,Map将持有对象一律视为Object型别。

    Collection、List、Set、Map都是接口,不能实例化。
        继承自它们的 ArrayList, Vector, HashTable, HashMap是具象class,这些才可被实例化。
    vector容器确切知道它所持有的对象隶属什么型别。vector不进行边界检查,线程安全,许多方法都是synchronized

    总结

    1. 如果涉及到堆栈,队列等操作,应该考虑用List,对于需要快速插入,删除元素,应该使用LinkedList,如果需要快速随机访问元素,应该使用ArrayList。
    2. 如果程序在单线程环境中,或者访问仅仅在一个线程中进行,考虑非同步的类,其效率较高,如果多个线程可能同时操作一个类,应该使用同步的类。
    3. 在除需要排序时使用TreeSet,TreeMap外,都应使用HashSet,HashMap,因为他们 的效率更高。
    4. 要特别注意对哈希表的操作,作为key的对象要正确复写equals和hashCode方法。
    5. 容器类仅能持有对象引用(指向对象的指针),而不是将对象信息copy一份至数列某位置。一旦将对象置入容器内,便损失了该对象的型别信息。
    6. 尽量返回接口而非实际的类型,如返回List而非ArrayList,这样如果以后需要将ArrayList换成LinkedList时,客户端代码不用改变。这就是针对抽象编程。

    7.Map的数据结构为一个Entry<K,V>,他的物理结构为一个数组和以这个数组中的每个元素为头指针的链表组成。

  8、多线程的实现

 

JAVA多线程实现方式主要有三种:继承Thread类、实现Runnable接口、使用ExecutorService、Callable、Future实现有返回结果的多线程。其中前两种方式线程执行完后都没有返回值,只有最后一种是带返回值的。

 

1、继承Thread类实现多线程
继承Thread类的方法尽管被我列为一种多线程实现方式,但Thread本质上也是实现了Runnable接口的一个实例,它代表一个线程的实例,并且,启动线程的唯一方法就是通过Thread类的start()实例方法。start()方法是一个native方法,它将启动一个新线程,并执行run()方法。这种方式实现多线程很简单,通过自己的类直接extend Thread,并复写run()方法,就可以启动新线程并执行自己定义的run()方法。

 

2、实现Runnable接口方式实现多线程
如果自己的类已经extends另一个类,就无法直接extends Thread,此时,必须实现一个Runnable接口,

3、实例化线程

1、如果是扩展java.lang.Thread类的线程,则直接new即可。

2、如果是实现了java.lang.Runnable接口的类,则用Thread的构造方法:

Thread(Runnable target) 
Thread(Runnable target, String name) 
Thread(ThreadGroup group, Runnable target) 
Thread(ThreadGroup group, Runnable target, String name) 
Thread(ThreadGroup group, Runnable target, String name, long stackSize)

 

3、使用ExecutorService、Callable、Future实现有返回结果的多线程
ExecutorService、Callable、Future这个对象实际上都是属于Executor框架中的功能类。

可返回值的任务必须实现Callable接口,类似的,无返回值的任务必须Runnable接口。执行Callable任务后,可以获取一个Future的对象,在该对象上调用get就可以获取到Callable任务返回的Object了,再结合线程池接口ExecutorService就可以实现传说中有返回结果的多线程了。

 Java中,线程指两件不同的事情:

1java.lang.Thread类的一个实例;

2、线程的执行。

使用java.lang.Thread类或者java.lang.Runnable接口编写代码来定义、实例化和启动新线程。

一个Thread类实例只是一个对象,像Java中的任何其他对象一样,具有变量和方法,生死于堆上。

Java中,每个线程都有一个调用栈,即使不在程序中创建任何新的线程,线程也在后台运行着。

一个Java应用总是从main()方法开始运行,mian()方法运行在一个线程内,它被称为主线程。

一旦创建一个新的线程,就产生一个新的调用栈。

线程总体分两类:用户线程和守候线程。

当所有用户线程执行完毕的时候,JVM自动关闭。但是守候线程却不独立于JVM,守候线程一般是由操作系统或者用户自己创建的

 

9.线程同步机制

4、 Java同步机制有4种实现方式:(部分引用网上资源) 
①    ThreadLocal ② synchronized( ) ③ wait() 与 notify() ④ volatile 
目的:都是为了解决多线程中的对同一变量的访问冲突 
ThreadLocal 
    ThreadLocal 保证不同线程拥有不同实例,相同线程一定拥有相同的实例,即为每一个使用该变量的线程提供一个该变量的副本,每一个线程都可以独立改变自己的副本,而不是与其它线程的副本冲突。

优势:提供了线程安全的共享对象 

与其它同步机制的区别:同步机制是为了同步多个线程对相同资源的并发访问,是为了多个线程之间进行通信;而 ThreadLocal 是隔离多个线程的数据共享,从根本上就不在多个线程之间共享资源,这样当然不需要多个线程进行同步了。

volatile 
     volatile 修饰的成员变量在每次被线程访问时,都强迫从共享内存中重读该成员变量的。而且,当成员变量发生变化时,强迫线程将变化;回写到共享内存。 
    优势:这样在任何时刻,两个不同的线程总是看到某个成员变量的同一个。 
    缘由:Java 语言规范中指出,为了获得最佳速度,允许线程保存共享成员变量的私有拷贝,而且只当线程进入或者离开同步代码块时才与共享成员变量的原始;对比。这样当多个线程同时与某个对象交互时,就必须要注意到要让线程及时的得到共享成员变量的变化。而 volatile 关键字就是提示 VM :对于这个成员变量不能保存它的私有拷贝,而应直接与共享成员变量交互。
     使用技巧:在两个或者更多的线程访问的成员变量上使用 volatile 。当要访问的变量已在 synchronized 代码块中,或者为常量时,不必使用。
        线程为了提高效率,将某成员变量(如A)拷贝了一份(如B),线程中对A的访问其实访问的是B。只在某些动作时才进行A和B的同步,因此存在A和B不一致的情况。volatile就是用来避免这种情况的。 volatile告诉jvm,它所修饰的变量不保留拷贝,直接访问主内存中的(读操作多时使用较好;线程间需要通信,本条做不到)

 Volatile 变量具有 synchronized 的可见性特性,但是不具备原子特性。这就是说线程能够自动发现 volatile 变量的最新。Volatile 变量可用于提供线程安全,但是只能应用于非常有限的一组用例:多个变量之间或者某个变量的当前;与修改后之间没有约束。
            您只能在有限的一些情形下使用 volatile 变量替代锁。要使 volatile 变量提供理想的线程安全,必须同时满足下面两个条件: 
对变量的写操作不依赖于当前;该变量没有包含在具有其他变量的不变式中。 

sleep() vs wait() 
sleep是线程类(Thread)的方法,导致此线程暂停执行指定时间,把执行机会给其他线程,但是监控状态依然保持,到时后会自动恢复。调用sleep不会释放对象锁。
wait是Object类的方法,对此对象调用wait方法导致本线程放弃对象锁,进入等待此对象的等待锁定池,只有针对此对象发出notify方法(或notifyAll)后本线程才进入对象锁定池准备获得对象锁进入运行状态。

(如果变量被声明为volatile,在每次访问时都会和主存一致;如果变量在同步方法或者同步块中被访问,当在方法或者块的入口处获得锁以及方法或者块退出时释放锁时变量被同步。)

 

10.servlet 生命周期

Tomcat容器其实就是servlet容器,管理项目中的定义的servlet ,当请求到来的时候通过servlet-mapping 找到对应的servlet,然后servlet 通过Service方法生成对应的servletRequest对象和servletResponse对象,最后调用对应的doGet,doPost方法,完成响应,servlet在整个生命周期只生成一次,即在web容器开启的时候,并且只销毁一次,在web容器关闭的时候。

 11.如何获取servlet上下文参数

通过servletConfig.getServletContext().getInitParameters();获取

12.spring的依赖注入

注入方式: 

接口注入 

属性注入[属性的SET/GET] 

构造注入[构造方法注入] 

使用构造函数依赖注入时,Spring保证所有一个对象所有依赖的对象先实例化后,才实例化这个对象。使用set方法依赖注入时,Spring首先实例化对象,然后才实例化所有依赖的对象。 

当设值注入与构造注入同时存在时,先执行设置注入,在执行构造注入。

13.HttpServletRequest类主要处理:

1.读取和写入HTTP头标

2.取得和设置cookies

3.取得路径信息

4.标识HTTP会话

14.SpringMVC 和 Struts2 的区别

  • spring mvc的入口是servlet,而struts2是fliter
  • spring mvc是基于方法的设计,而struts2是基于类的设计
  • struts2有以自己的interceptor机制,spring mvc用的是独立的AOP方式
  • spring mvc的方法之间基本上独立的,独享request response数据,struts2所有Action变量是共享的
    15.java 垃圾回收时机
    java提供了一个系统级的线程,即垃圾回收器线程。用来对每一个分配出去的内存空间进行跟踪。当JVM空闲时,自动回收每块可能被回收的内存,GC是完全自动的,不能被强制执行。程序员最多只能用System.gc()来建议执行垃圾回收器回收内存,但是具体的回收时间,是不可知的。 
    当对象的引用变量被赋值为null,可能被当成垃圾。
  • 16.List详解
  • |--List:元素是有序的(怎么存的就怎么取出来,顺序不会乱),元素可以重复(角标1上有个3,角标2上也可以有个3)因为该集合体系有索引,
      |-- ArrayList:底层的数据结构使用的是数组结构(数组长度是可变的百分之五十延长)(特点是查询很快,但增删较慢)线程不同步
      |-- LinkedList:底层的数据结构是链表结构(特点是查询较慢,增删较快)
      |-- Vector:底层是数组数据结构 线程同步(数组长度是可变的百分之百延长)(无论查询还是增删都很慢,被ArrayList替代了)
  • 17.线程池的管理机制
  • 18.spring JTA 实现机制
  • Spring 动态代理方式实现 ,一种是类代理,另外一种是接口代理,和Aop实现原理一致。
  • 19.线程池详解
  • http://www.ibm.com/developerworks/cn/java/j-jtp0730/

java面试总结

  • 0

    开心

    开心

  • 0

    板砖

    板砖

  • 0

    感动

    感动

  • 0

    有用

    有用

  • 0

    疑问

    疑问

  • 0

    难过

    难过

  • 0

    无聊

    无聊

  • 0

    震惊

    震惊

编辑推荐
标签: 面试 Java 代码查错: 1. abstract class Name { private String name; public abstract boo
标签: 面试 面向对象的特征 1. 抽象 :抽象就是忽略一个主题中与当前目标无关的那些方面,以便更充
标签: 面试 101 、 java 中会存在内存泄漏吗,请简单描述。 会。如: int i,i2; return (i-i2); //
标签: 面试 51 、垃圾回收的优点和原理。并考虑 2 种回收机制。 Java 语言中一个显著的特点就是引
今天去百度大厦面试,职位是测试开发工程师(暑期实习),面试官是一位漂亮、友善的JJ 第一道很简单
今天去百度大厦面试,职位是测试开发工程师(暑期实习),面试官是一位漂亮、友善的JJ 第一道很简单
今天去百度大厦面试,职位是测试开发工程师(暑期实习),面试官是一位漂亮、友善的JJ 第一道很简单
【背景说明】 情人节那天网投了16家公司,第二天下午一家邀约面试,今天面试完就拿到offer了,准备
今天周末,导师让我来实验室,帮他一起把数据从服务器上拷贝下来,然后做预处理,周一上午给出结果
今天周末,导师让我来实验室,帮他一起把数据从服务器上拷贝下来,然后做预处理,周一上午给出结果
版权所有 IT知识库 CopyRight © 2009-2015 IT知识库 IT610.com , All Rights Reserved. 京ICP备09083238号