Java初中级程序员面试题宝典

Java基础部分

&与&&区别？

&和&&都是逻辑运算符，都是判断两边同时真则为真，不然为假；可是&&当第一个条件不成以后，后面的条件都不执行了，而&则仍是继续执行，直到整个条件语句执行完为止。

使用 final 关键字修饰一个变量时，是引用不能变，仍是引用的对象不能变？

使用 final 关键字修饰一个变量时，是指引用变量不能变，引用变量所指向的对象中的内容 仍是能够改变的。

静态变量和实例变量的区别？

在语法定义上的区别：

静态变量前要加 static 关键字，而实例变量前则不加。

在程序运行时的区别：实例变量属于某个对象的属性，必须建立了实例对象，其中的实例变 量才会被分配空间，才能使用这个实例变量。

静态变量不属于某个实例对象，而是属于类， 因此也称为类变量，只要程序加载了类的字节码，不用建立任何实例对象，静态变量就会被分配空间，静态变量就能够被使用了。

总之，实例变量必须建立对象后才能够经过这个对象 来使用，静态变量则能够直接使用类名来引用。

静态变量使用时,经过类名.名称,实例变量必需要初始化后才能使用。实例变量是实例化后才会分配空间,而静态变量当类加载时会分配空间。

是否能够从一个 static 方法内部发出对非 static 方法的调用？

不能够。由于非 static 方法是要与对象关联在一块儿的，必须建立一个对象后，才能够在该对 象上进行方法调用，而 static 方法调用时不须要建立对象，能够直接调用。也就是说，当一 个 static 方法被调用时，可能尚未建立任何实例对象，若是从一个 static 方法中发出对非 static 方法的调用，那个非 static 方法是关联到哪一个对象上的呢？这个逻辑没法成立，因此， 一个 static 方法内部发出对非 static 方法的调用。

非static方法能够访问static方法.

static方法不能访问非static方法

"=="和 equals 方法究竟有什么区别？

  ==若是判断值类型的话，判断内容是否相同。若是判断引用类型则是判断内存地址是否相同

Equals判断值内容是否相等

Integer 与 int 的区别

Integer 是引用类型,默认值是null。而int是是值类型默认值是0

请说出做用域 public， private， protected，以及不写时的区别

这四个做用域的可见范围以下表所示。

说明：若是在修饰的元素上面没有写任何访问修饰符，则表示 friendly。

做用域 当前类 同一包（ package） 子孙类 其余包（ package）

public     √              √                                      √                 √

protected √            √                                      √                 ×

friendly     √             √                                      ×                ×

private      √              ×                                   ×                  ×

重载与重写区别？

重载是同一个类中，方法名称相同， 可是参数或个数不一样。与返回值没有关系。

重写是在多个类中， 产生继承关系。父类与子类的方法方法必须相同。

接口与抽象类的区别？

区别:定义接口的关键字是：interface 而定义抽象类的关键字是：abstract。

接口中成员不能有私有， 抽象类能够。

接口中定义的成员， 是finl public static 类型， 抽象类没有。

接口中的不能有普通方法， 抽象类中能够。

相同：

两个都不new

可是 接口与抽象类是面向对象必备知识，设计模式、重构代码有必然做用

final, finally, finalize 的区别。

final 用于声明属性，方法和类，分别表示属性不可变，方法不可覆盖，类不可继承。

内部类要访问局部变量，局部变量必须定义成 final 类型，例如，一段代码……

finally 是异常处理语句结构的一部分，表示老是执行。

finalize 是 Object 类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法，可

以覆盖此方法提供垃圾收集时的其余资源回收，例如关闭文件等。 JVM 不保证此方法总被

调用

String、StringBuffer与StringBuilder的区别

String 字符串常量

StringBuffer 字符串变量（线程安全）

StringBuilder 字符串变量（非线程安全）

接口和抽象类的区别

接口中不能有构造方法，抽象类中能够有

抽象类中能够包含普通方法，接口中的方法都被隐式指定为public abstract方法而且只能是public abstract的、

抽象类能够有普通的成员变量，接口中的成员变量必须是public static final 的

抽象类中的方法的访问能够是public ，protected和默认类型

抽象类中能够包含静态方法，接口中不能包含静态方法

一个类能够实现多个接口，可是只能继承一个抽象类

 

数据类型转换

自动数据类型转换

Byte>short>char>int>long>float>double>long

运算中数据类型转换

一类型                                二类型       转换后的类型

Byte，short，char                      int             int

Byte，short，char，int                 long            long

Byte，short，char，int，long           float           float

Byte，short，char，int，long,float     double          double

 

全部的类都继承于object类，你用过的object类的直接子类有哪些，object类经常使用的方法有哪些

1．clone方法

保护方法，实现对象的浅复制，只有实现了Cloneable接口才能够调用该方法，不然抛出CloneNotSupportedException异常。

2．getClass方法

final方法，得到运行时类型。

3．toString方法

该方法用得比较多，通常子类都有覆盖。

4．finalize方法

该方法用于释放资源。由于没法肯定该方法何时被调用，不多使用。

5．equals方法

该方法是很是重要的一个方法。通常equals和==是不同的，可是在Object中二者是同样的。子类通常都要重写这个方法。

6.数组有没有length()这个方法? String有没有length()这个方法？

答：数组没有length()这个方法，有length的属性。String有有length()这个方法。

 

7．hashCode方法

该方法用于哈希查找，重写了equals方法通常都要重写hashCode方法。这个方法在一些具备哈希功能的Collection中用到。

通常必须知足obj1.equals(obj2)==true。能够推出obj1.hash- Code()==obj2.hashCode()，可是hashCode相等不必定就知足equals。不过为了提升效率，应该尽可能使上面两个条件接近等价。

7．wait方法

wait方法就是使当前线程等待该对象的锁，当前线程必须是该对象的拥有者，也就是具备该对象的锁。wait()方法一直等待，直到得到锁或者被中断。wait(long timeout)设定一个超时间隔，若是在规定时间内没有得到锁就返回。

调用该方法后当前线程进入睡眠状态，直到如下事件发生。

（1）其余线程调用了该对象的notify方法。

（2）其余线程调用了该对象的notifyAll方法。

（3）其余线程调用了interrupt中断该线程。

（4）时间间隔到了。

此时该线程就能够被调度了，若是是被中断的话就抛出一个InterruptedException异常。

8．notify方法

该方法唤醒在该对象上等待的某个线程。

9．notifyAll方法

该方法唤醒在该对象上等待的全部线程

反射的优缺点？

反射：就是正在运行动态读取这个类的完整信息。

优势：java的反射机制就是增长程序的灵活性、

缺点：缺点：（1）性能问题：使用反射基本上是一种解释操做，

用于字段和方法接入时要远慢于直接代码。所以反射机制主要应用在对灵活性和扩展性要求很高的系统框架上，普通程序不建议使用。

（2）使用反射会模糊程序内内部逻辑：程序员但愿在源代码中看到程序的逻辑，反射等绕过了源代码的技术，于是会带来维护问题。反射代码比相应的直接代码更复杂。

那些地方用到了反射？

例如: jdbc、Java经常使用框架、jdk的动态代理、android的加载布局文件

java  中有几种类型的流？JDK 为每种类型的流提供了一些抽象类以供继承， 为每种类型的流提供了一些抽象类以供继承，请说出他们分别是哪些类？ 

   字节流，字符流。字节流继承于 InputStream OutputStream，字符流继承于

InputStreamReaderOutputStreamWriter。在 java.io 包中还有许多其余的流，主要是为了提

高性能和使用方便。

多线程部分

什么是多线程？

在一个应用程序中,同时，有多个不一样的执行路径。

说一下多线程的好处？

提供程序效率。

线程和进程有什么区别？

线程是进程的一条执行路径，而进程是线程的集合。

什么是线程同步、异步？

线程同步表示，当前线程执行完后下一个线程接着执行。

线程异步表示,  在一个应用程序中,同时，有多个不一样的执行路径。例如 javaweb ajax android handler

线程之间如何同步

线程之间同步使用 synchronized、wait 与 notify

什么是线程不安全？如何解决？（重点）

就是在多个线程共享同一个数据会受到其余线程的干扰。如何解决:使用线程同步技术， 用上锁(synchronized)。 让一个线程执行完了，在让另外一个线程执行。

如何建立一个线程？有几种方法？

继承thread类， 重写run方法、实现Runnalbe接口，从新run方法 ， 启动一个线程用start();

是使用Runnalbe接口好？仍是继承Thread类好？

 是实现Runnalbe接口好，由于实现的接口还能够继续继承。若是继承了Thread类不能在继承。

sleep()和 wait()有什么区别?

a、sleep是让当前线程指定休眠时间，而后继续工做  不释放锁

  b、让当前线程wait则是等待，直到有线程通知notify（）唤醒他才会从新工做。释放锁

 

集合相关面试题

 

 

说一下数据结构中的4

什么是数组？什么是链表？

所谓数组，是相同数据类型的元素按必定顺序排列的集合

数组：存储区间是连续的，占用内存严重，故空间复杂的很大。但数组的二分查找时间复杂度小，为O(1)；数组的特色是：寻址容易，插入和删除困难；

所谓链表，链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是经过链表中的指针连接次序实现的。链表由一系列结点（链表中每个元素称为结点）组成，结点能够在运行时动态生成。每一个结点包括两个部分：一个是存储数据元素的数据域，另外一个是存储下一个结点地址的指针域。 相比于线性表顺序结构，操做复杂。因为没必要须按顺序存储，链表在插入的时候能够达到O(1)的复杂度，比另外一种线性表顺序表快得多，可是查找一个节点或者访问特定编号的节点则须要O(n)的时间，而线性表和顺序表相应的时间复杂度分别是O(logn)和O(1)。

链表:链表存储区间离散，占用内存比较宽松，故空间复杂度很小，但时间复杂度很大，达O（N）。链表的特色是：寻址困难，插入和删除容易。

说一下什么是哈希表

那么咱们能不能综合二者的特性，作出一种寻址容易，插入删除也容易的数据结构？答案是确定的，这就是咱们要提起的哈希表。哈希表（(Hash table）既知足了数据的查找方便，同时不占用太多的内容空间，使用也十分方便。

  哈希表有多种不一样的实现方法，我接下来解释的是最经常使用的一种方法—— 拉链法，咱们能够理解为“链表的数组” ，如图：

 

 

 

说一下ArrayList底层实现方式？

①ArrayList经过数组实现，一旦咱们实例化ArrayList无参数构造函数默认为数组初始化长度为10

②add方法底层实现若是增长的元素个数超过了10个，那么ArrayList底层会新生成一个数组，长度为原数组的1.5倍+1，而后将原数组的内容复制到新数组当中，而且后续增长的内容都会放到新数组当中。当新数组没法容纳增长的元素时，重复该过程。是一旦数组超出长度，就开始扩容数组。扩容数组调用的方法 Arrays.copyOf(objArr, objArr.length + 1);

说一下LinkedList底层实现方式？

LinkedList底层的数据结构是基于双向循环链表的，且头结点中不存放数据,以下：

 

 

既然是双向链表，那么一定存在一种数据结构——咱们能够称之为节点，节点实例保存业务数据，前一个节点的位置信息和后一个节点位置信息，以下图所示：

 

 

说一下HashMap底层实现方式？

HashMap是由数组+链表组成

put方法底层实现:

经过key的hash值%Entry[].length获得该存储的下标位置，若是多个key的hash值%Entry[].length 值相同话就就会存储到该链表的后面。

ArrayList 和 Vector 的区别

这两个类都实现了 List 接口(List 接口继承了Collection 接口),他们都是有序集合,即存储在这两个集合中的元素的位置都是有顺序的,至关于一种动态的数组,咱们之后能够按位置索引号取出某个元素,而且其中的数据是容许重复的,

ArrayList 与 Vector 的区别,这主要包括两个方面:.

(1)同步性:

Vector 是线程安全的,也就是说是它的方法之间是线程同步的,而 ArrayList 是线程序不安全的,它的方法之间是线程不一样步的。若是只有一个线程会访问到集合,那最好是使用 ArrayList,由于它不考虑线程安全,效率会高些;若是有多个线程会访问到集合,那最好是使用 Vector,由于不须要咱们本身再去考虑和编写线程安全的代码。

(2)数据增加:

ArrayList 与 Vector 都有一个初始的容量大小,当存储进它们里面的元素的个数超过了容量时,就须要增长 ArrayList 与 Vector 的存储空间,每次要增长存储空间时,不是只增长一个存储单元,而是增长多个存储单元,每次增长的存储单元的个数在内存空间利用与程序效率之间要取得必定的平衡。Vector 默认增加为原来两倍,而 ArrayList 的增加策略在文档中没有明确规定(从源代码看到的是增加为原来的1.5倍)。

ArrayList 与 Vector 均可以设置初始的空间大小,Vector 还能够设置增加的空间大小,而 ArrayList 没有提供设置增加空间的方法。

HashMap 和 Hashtable 的区别

 

总结：

hashmap	线程不安全	容许有null的键和值	效率高一点、	方法不是Synchronize的要提供外同步	有containsvalue和containsKey方法	HashMap 是Java1.2 引进的Map interface 的一个实现	HashMap是Hashtable的轻量级实现
hashtable	线程安全	不容许有null的键和值	效率稍低、	方法是是Synchronize的	有contains方法方法	、Hashtable 继承于Dictionary 类	Hashtable 比HashMap 要旧

 

List 和Set、Map 区别?

Java中的集合包括三大类，它们是Set、List和Map，它们都处于java.util包中，Set、List和Map都是接口，它们有各自的实现类。Set的实现类主要有HashSet和TreeSet，List的实现类主要有ArrayList，Map的实现类主要有HashMap和TreeMap。

  Set中的对象不按特定方式排序，而且没有重复对象。但它的有些实现类能对集合中的对象按特定方式排序，例如TreeSet类，它能够按照默认排序，也能够经过实现java.util.Comparator<Type>接口来自定义排序方式。

  List中的对象按照索引位置排序，能够有重复对象，容许按照对象在集合中的索引位置检索对象，如经过list.get(i)方式来得到List集合中的元素。

  Map中的每个元素包含一个键对象和值对象，它们成对出现。键对象不能重复，值对象能够重复。

List、Map、Set 三个接口,存取元素时,各有什么特色?

list：存储： 有序的 可重复的

访问：能够for循环，foreach循环，iterator迭代器 迭代。

set：存储：无序的 不重复的

访问：能够foreach循环，iterator迭代器 迭代

map：存储：存储的是一对一对的映射 ”key=value“，key值 是无序，不重复的。value值可重复

访问：能够map中key值转为为set存储，而后迭代这个set，用map.get(key)获取value

也能够 转换为entry对象 用迭代器迭代

说出 ArrayList,Vector, LinkedList 的存储性能和特性

ArrayList和Vector都是使用数组方式存储数据，此数组元素数大于实际存储的数据以便增长和插入元素，它们都容许直接按序号索引元素，可是插入元素要涉及数组元素移动等内存操做，因此索引数据快而插入数据慢，Vector因为使用了synchronized方法（线程安全），一般性能上较ArrayList差，而LinkedList使用双向链表实现存储，按序号索引数据须要进行前向或后向遍历，可是插入数据时只须要记录本项的先后项便可，因此插入速度较快。

去掉一个 Vector 集合中重复的元素

经过Vector.contains（）方法判断是否包含该元素，若是没有包含就添加到新的集合当中，适用于数据较小的状况下。

Collection 和 Collections 的区别。

Collection是集合类的上级接口，继承于它的接口主要有Set和List。 Collections是针对集合类的一个帮助类，它提供了一系列静态方法实现了对各类集合的排序，搜索和线程安全等操做。

Set 里的元素是不能重复的,那么用什么方法来区分重复与否呢?是用==仍是equals()?它们有何区别?

set里的元素是不能重复的，用iterator()方法来区分重复与否。

equals 方法（是String类从它的超类Object中继承的）被用来检测两个对象是否相等，即两个对象的内容是否相等。

==用于比较引用和比较基本数据类型时具备不一样的功能：

比较基本数据类型，若是两个值相同，则结果为true

而在比较引用时，若是引用指向内存中的同一对象，结果为true

HashMap面试题

HashMap的工做原理是近年来常见的Java面试题。几乎每一个Java程序员都知道HashMap，都知道哪里要用HashMap，知道Hashtable和HashMap之间的区别，那么为什么这道面试题如此特殊呢？是由于这道题考察的深度很深。这题常常出如今高级或中高级面试中。投资银行更喜欢问这个问题，甚至会要求你实现HashMap来考察你的编程能力。ConcurrentHashMap和其它同步集合的引入让这道题变得更加复杂。让咱们开始探索的旅程吧！

先来些简单的问题

“你用过HashMap吗？” “什么是HashMap？你为何用到它？”

几乎每一个人都会回答“是的”，而后回答HashMap的一些特性，譬如HashMap能够接受null键值和值，而Hashtable则不能；HashMap是非synchronized;HashMap很快；以及HashMap储存的是键值对等等。这显示出你已经用过HashMap，并且对它至关的熟悉。可是面试官来个急转直下，今后刻开始问出一些刁钻的问题，关于HashMap的更多基础的细节。面试官可能会问出下面的问题：

“你知道HashMap的工做原理吗？” “你知道HashMap的get()方法的工做原理吗？”

你也许会回答“我没有详查标准的Java API，你能够看看Java源代码或者Open JDK。”“我能够用Google找到答案。”

但一些面试者可能能够给出答案，“HashMap是基于hashing的原理，咱们使用put(key, value)存储对象到HashMap中，使用get(key)从HashMap中获取对象。当咱们给put()方法传递键和值时，咱们先对键调用hashCode()方法，返回的hashCode用于找到bucket位置来储存Entry对象。”这里关键点在于指出，HashMap是在bucket中储存键对象和值对象，做为Map.Entry。这一点有助于理解获取对象的逻辑。若是你没有意识到这一点，或者错误的认为仅仅只在bucket中存储值的话，你将不会回答如何从HashMap中获取对象的逻辑。这个答案至关的正确，也显示出面试者确实知道hashing以及HashMap的工做原理。可是这仅仅是故事的开始，当面试官加入一些Java程序员天天要碰到的实际场景的时候，错误的答案频现。下个问题多是关于HashMap中的碰撞探测(collision detection)以及碰撞的解决方法：

“当两个对象的hashcode相同会发生什么？” 从这里开始，真正的困惑开始了，一些面试者会回答由于hashcode相同，因此两个对象是相等的，HashMap将会抛出异常，或者不会存储它们。而后面试官可能会提醒他们有equals()和hashCode()两个方法，并告诉他们两个对象就算hashcode相同，可是它们可能并不相等。一些面试者可能就此放弃，而另一些还能继续挺进，他们回答“由于hashcode相同，因此它们的bucket位置相同，‘碰撞’会发生。由于HashMap使用链表存储对象，这个Entry(包含有键值对的Map.Entry对象)会存储在链表中。”这个答案很是的合理，虽然有不少种处理碰撞的方法，这种方法是最简单的，也正是HashMap的处理方法。但故事尚未完结，面试官会继续问：

“若是两个键的hashcode相同，你如何获取值对象？” 面试者会回答：当咱们调用get()方法，HashMap会使用键对象的hashcode找到bucket位置，而后获取值对象。面试官提醒他若是有两个值对象储存在同一个bucket，他给出答案:将会遍历链表直到找到值对象。面试官会问由于你并无值对象去比较，你是如何肯定肯定找到值对象的？除非面试者直到HashMap在链表中存储的是键值对，不然他们不可能回答出这一题。

其中一些记得这个重要知识点的面试者会说，找到bucket位置以后，会调用keys.equals()方法去找到链表中正确的节点，最终找到要找的值对象。完美的答案！

许多状况下，面试者会在这个环节中出错，由于他们混淆了hashCode()和equals()方法。由于在此以前hashCode()屡屡出现，而equals()方法仅仅在获取值对象的时候才出现。一些优秀的开发者会指出使用不可变的、声明做final的对象，而且采用合适的equals()和hashCode()方法的话，将会减小碰撞的发生，提升效率。不可变性使得可以缓存不一样键的hashcode，这将提升整个获取对象的速度，使用String，Interger这样的wrapper类做为键是很是好的选择。

若是你认为到这里已经完结了，那么听到下面这个问题的时候，你会大吃一惊。“若是HashMap的大小超过了负载因子(load factor)定义的容量，怎么办？”除非你真正知道HashMap的工做原理，不然你将回答不出这道题。默认的负载因子大小为0.75，也就是说，当一个map填满了75%的bucket时候，和其它集合类(如ArrayList等)同样，将会建立原来HashMap大小的两倍的bucket数组，来从新调整map的大小，并将原来的对象放入新的bucket数组中。这个过程叫做rehashing，由于它调用hash方法找到新的bucket位置。

若是你可以回答这道问题，下面的问题来了：“你了解从新调整HashMap大小存在什么问题吗？”你可能回答不上来，这时面试官会提醒你当多线程的状况下，可能产生条件竞争(race condition)。

当从新调整HashMap大小的时候，确实存在条件竞争，由于若是两个线程都发现HashMap须要从新调整大小了，它们会同时试着调整大小。在调整大小的过程当中，存储在链表中的元素的次序会反过来，由于移动到新的bucket位置的时候，HashMap并不会将元素放在链表的尾部，而是放在头部，这是为了不尾部遍历(tail traversing)。若是条件竞争发生了，那么就死循环了。这个时候，你能够质问面试官，为何这么奇怪，要在多线程的环境下使用HashMap呢？：）

热心的读者贡献了更多的关于HashMap的问题：

为何String, Interger这样的wrapper类适合做为键？ String, Interger这样的wrapper类做为HashMap的键是再适合不过了，并且String最为经常使用。由于String是不可变的，也是final的，并且已经重写了equals()和hashCode()方法了。其余的wrapper类也有这个特色。不可变性是必要的，由于为了要计算hashCode()，就要防止键值改变，若是键值在放入时和获取时返回不一样的hashcode的话，那么就不能从HashMap中找到你想要的对象。不可变性还有其余的优势如线程安全。若是你能够仅仅经过将某个field声明成final就能保证hashCode是不变的，那么请这么作吧。由于获取对象的时候要用到equals()和hashCode()方法，那么键对象正确的重写这两个方法是很是重要的。若是两个不相等的对象返回不一样的hashcode的话，那么碰撞的概率就会小些，这样就能提升HashMap的性能。

咱们可使用自定义的对象做为键吗？ 这是前一个问题的延伸。固然你可能使用任何对象做为键，只要它遵照了equals()和hashCode()方法的定义规则，而且当对象插入到Map中以后将不会再改变了。若是这个自定义对象时不可变的，那么它已经知足了做为键的条件，由于当它建立以后就已经不能改变了。

咱们可使用CocurrentHashMap来代替Hashtable吗？这是另一个很热门的面试题，由于ConcurrentHashMap愈来愈多人用了。咱们知道Hashtable是synchronized的，可是ConcurrentHashMap同步性能更好，由于它仅仅根据同步级别对map的一部分进行上锁。ConcurrentHashMap固然能够代替HashTable，可是HashTable提供更强的线程安全性。看看这篇博客查看Hashtable和ConcurrentHashMap的区别。

我我的很喜欢这个问题，由于这个问题的深度和广度，也不直接的涉及到不一样的概念。让咱们再来看看这些问题设计哪些知识点：

hashing的概念

HashMap中解决碰撞的方法

equals()和hashCode()的应用，以及它们在HashMap中的重要性

不可变对象的好处

HashMap多线程的条件竞争

从新调整HashMap的大小

总结

HashMap的工做原理

HashMap基于hashing原理，咱们经过put()和get()方法储存和获取对象。当咱们将键值对传递给put()方法时，它调用键对象的hashCode()方法来计算hashcode，让后找到bucket位置来储存值对象。当获取对象时，经过键对象的equals()方法找到正确的键值对，而后返回值对象。HashMap使用链表来解决碰撞问题，当发生碰撞了，对象将会储存在链表的下一个节点中。 HashMap在每一个链表节点中储存键值对对象。

当两个不一样的键对象的hashcode相同时会发生什么？ 它们会储存在同一个bucket位置的链表中。键对象的equals()方法用来找到键值对。

由于HashMap的好处很是多，我曾经在电子商务的应用中使用HashMap做为缓存。由于金融领域很是多的运用Java，也出于性能的考虑，咱们会常常用到HashMap和ConcurrentHashMap。你能够查看更多的关于HashMap的文章:

请讲下Java里面的容器

 分两大类，Map和Collection。而Collection又有子接口List(数据存储顺序和插入顺序是同样的)、Set(里面的元素具备惟一性)

 Map是存储键值对的,里面的健不能够重复,但值能够重复

a. 对于List主要有ArrayList和LinkedList两种实现。实现的数据结构不一样，因此主要的区别也都是和数据结构相关的。 ArrayList基于数组，随机访问快，而对于中间元素的插入删除效率比较低，并且须要考虑扩容问题。LinkedList，则 基于链表，和ArrayList提到的正相反，随机访问慢，但对于中间元素的插入和删除更有效率。

Set也是一种Collection，和List比起来主要体如今元素惟一性。

请说下Iterator的做用

 迭代器能够实现Collection接口的方法，能够一个一个地获取集合中的元素

在遍历集合时 可判断是否有下一个元素

说下ArrayList和LinkedList的区别和联系，并说明什么状况下用它们

 区别:ArrayList用于对象的随机访问速度快,没有顺序

LinkedList实现机制是链表式的,和顺序有关,速度比ArrayList慢

联系:ArrayList和LinkedList都是List接口的实现类

当要快速获取一个值时,用ArrayList,用于顺序插入操做时,用LinkedList.

说下List，Set，Map三种集合各有什么特征

List集合中的元素能够重复,

Set集合中的元素不能够重复

Map集合用键-值映射存放对象,Map容器中的键对象不能重复,值对象能够重复

HashSet和TreeSet有什么区别，何时用它们

 区别:HashSet中的元素不能重复,没有顺序

TreeSet中的元素不能重复,但有顺序

当集合中的元素须要排序时,用TreeSet

通常状况下用HashSet,由于不须要排序,速度比TreeSet快

什么是泛型，怎么使用的，有什么好处？

答案

 定义一个集合时，能够知道里面定义的是什么类型

使用:在集合类型后面加< 数据类型 >

使用泛型后,从集合中取得元素后就不用再用强转

什么是for each循环，它能够循环那些数据类型

答案

 也能够叫加强型循环，经过对象拿到集合里的值，由于扩展性比较强，建议多使用

能够用来循环集合和数组

比较下集合和数组的优缺点

 集合是多个对象的容器,能够将不一样数据类型的多个对象组织在一块儿

数组类型是有相同数据类型的数据集合,数组是不少语言都支持的底层数据结构,性能上是最高的

HashMap与LinkedHashMap,和TreeMap的区别。

共同点：HashMap,LinkedHashMap,TreeMap都属于Map的实现类.

不一样点: 1.HashMap里面存入的键值对在取出的时候是随机的,

2.TreeMap取出来的是排序后的键值对。但若是您要按天然顺序或自定义顺序遍历键，那么TreeMap会更好。

3. LinkedHashMap 是HashMap的一个子类，若是须要输出的顺序和输入的相同,那么用LinkedHashMap能够实现.

在List里面怎么去掉重复的数？

经过把List里面的数据放入HashSet能够去除重复

HashMap和ArrayList是否是都是线程不安全的？

ArrayList是线程不安全的；HashMap是线程不安全的；还有咱们常见的一些JAVA集合都是线程不安全,这样作是为了提升性能

在JDK5之后提供了线程安全的并发包java.util.concurrent并发包,譬如里面的类CopyOnWriteArrayList,CopyOnWriteArraySet,ConcurrentHashMap等

ArrayList集合加入1万条数据，应该怎么提升效率

由于ArrayList的底层是数组实现,而且数组的默认值是10,若是插入10000条要不断的扩容,耗费时间,因此咱们调用ArrayList的指定容量的构造器方法ArrayList(int size) 就能够实现不扩容,就提升了性能

 

网路通信部分

 

 

Xml与JSON区别

数据交换格式

区别:

xml是重量级、json是轻量级

xml比较占带宽、json占带宽小,易于压缩

json在webservice 用的比较少、xml用的较多

相同：

二者都用在项目交互下  例如  移动app接口用的就是json、在web项目中与其余项目对接用xml较多。

json经常使用解析方法 gson、jsonobject、jackson等 xml dom sax pull 解析

 

TCP与UDP区别？

  udp:  a、是面向无链接, 将数据及源的封装成数据包中,不须要创建创建链接

      b、每一个数据报的大小在限制64k内

      c、因无链接,是不可靠协议

       d、不须要创建链接,速度快

tcp：  a、建议链接，造成传输数据的通道.

     b、在链接中进行大数据量传输，以字节流方式

     c 经过三次握手完成链接,是可靠协议

     d 必须创建链接m效率会稍低

     聊天、网络视频会议、桌面共享用的就是  udp

 

说说三次握手?

 1）第一次握手：创建链接时，客户端A发送SYN包（SYN=j）到服务器B，并进入SYN_SEND状态，等待服务器B确认。

（2）第二次握手：服务器B收到SYN包，必须确认客户A的SYN（ACK=j+1），同时本身也发送一个SYN包（SYN=k），即SYN+ACK包，此时服务器B进入SYN_RECV状态。

（3）第三次握手：客户端A收到服务器B的SYN＋ACK包，向服务器B发送确认包ACK（ACK=k+1），此包发送完毕，客户端A和服务器B进入ESTABLISHED状态，完成三次握手。

完成三次握手，客户端与服务器开始传送数据。

什么是Webserivce?

Webservice就是提供不一样的平台相互通信，基于Soap协议。

Web service 就是一个应用程序，它向外界暴露出一个可以经过Web进行调用的API。

SOAP是一种简单基于xml的轻量协议，用户web上交换结构化信息和类型信息。

soap请求是HTTP POST的一个专用版本，遵循一种特殊的xml消息格式Content-type设置为: text/xml任何数据均可以xml化。

WebService实现原理是？

HTTP协议+XML

说一下什么是Http协议？

对器客户端和 服务器端之间数据传输的格式规范，格式简称为“超文本传输协议”。

什么是Http协议无状态协议？怎么解决Http协议无状态协议？（曾经去某创业公司问到）

一、无状态协议对于事务处理没有记忆能力。缺乏状态意味着若是后续处理须要前面的信息

二、无状态协议解决办法： 经过一、Cookie 二、经过Session会话保存。

说一下Http协议中302状态(阿里常常问)

http协议中，返回状态码302表示重定向。

这种状况下，服务器返回的头部信息中会包含一个 Location 字段，内容是重定向到的url

Http协议有什么组成？

请求报文包含三部分：

a、请求行：包含请求方法、URI、HTTP版本信息

b、请求首部字段

c、请求内容实体

响应报文包含三部分：

a、状态行：包含HTTP版本、状态码、状态码的缘由短语

b、响应首部字段

c、响应内容实体

Http协议中有那些请求方式？

GET： 用于请求访问已经被URI（统一资源标识符）识别的资源，能够经过URL传参给服务器

POST：用于传输信息给服务器，主要功能与GET方法相似，但通常推荐使用POST方式。

PUT： 传输文件，报文主体中包含文件内容，保存到对应URI位置。

HEAD： 得到报文首部，与GET方法相似，只是不返回报文主体，通常用于验证URI是否有效。

DELETE：删除文件，与PUT方法相反，删除对应URI位置的文件。

OPTIONS：查询相应URI支持的HTTP方法。

Http协议中Http1.0与1.1区别？

在http1.0中，当创建链接后，客户端发送一个请求，服务器端返回一个信息后就关闭链接，当浏览器下次请求的时候又要创建链接，显然这种不断创建链接的方式，会形成不少问题。

5.在http1.1中，引入了持续链接的概念，经过这种链接，浏览器能够创建一个链接以后，发送请求并获得返回信息，而后继续发送请求再次等到返回信息，也就是说客户端能够连续发送多个请求，而不用等待每个响应的到来。

Http协议实现原理机制？

    2.一、整个流程步骤

               

 

  2.二、域名解析过程

               

 

 2.三、三次握手过程

     2.四、发起HTTP请求

     2.五、响应HTTP请求并获得HTML代码

     2.六、浏览器解析HTML代码

     2.七、浏览器对页面进行渲染呈现给用户

get与post请求区别？（初级程序员必备问题）

区别一：

  get重点在从服务器上获取资源，post重点在向服务器发送数据；

区别二：

   get传输数据是经过URL请求，以field（字段）= value的形式，置于URL后，并用"?"链接，多个请求数据间用"&"链接，如http://127.0.0.1/Test/login.action?name=admin&password=admin，这个过程用户是可见的；

post传输数据经过Http的post机制，将字段与对应值封存在请求实体中发送给服务器，这个过程对用户是不可见的；

区别三：

   Get传输的数据量小，由于受URL长度限制，但效率较高；

Post能够传输大量数据，因此上传文件时只能用Post方式；

区别四：

   get是不安全的，由于URL是可见的，可能会泄露私密信息，如密码等；

post较get安全性较高；

区别五：

   get方式只能支持ASCII字符，向服务器传的中文字符可能会乱码。

post支持标准字符集，能够正确传递中文字符。

九、Http请求报文与响应报文格式？

请求报文包含三部分：

a、请求行：包含请求方法、URI、HTTP版本信息

b、请求首部字段

c、请求内容实体

响应报文包含三部分：

a、状态行：包含HTTP版本、状态码、状态码的缘由短语

b、响应首部字段

c、响应内容实体

十、常见Http协议状态？

200：请求被正常处理

204：请求被受理但没有资源能够返回

206：客户端只是请求资源的一部分，服务器只对请求的部分资源执行GET方法，相应报文中经过Content-Range指定范围的资源。

301：永久性重定向

302：临时重定向

303：与302状态码有类似功能，只是它但愿客户端在请求一个URI的时候，能经过GET方法重定向到另外一个URI上

304：发送附带条件的请求时，条件不知足时返回，与重定向无关

307：临时重定向，与302相似，只是强制要求使用POST方法

400：请求报文语法有误，服务器没法识别

401：请求须要认证

403：请求的对应资源禁止被访问

404：服务器没法找到对应资源

500：服务器内部错误

503：服务器正忙

Http协议首部字段？

a、通用首部字段（请求报文与响应报文都会使用的首部字段）

Date：建立报文时间

Connection：链接的管理

Cache-Control：缓存的控制

Transfer-Encoding：报文主体的传输编码方式

b、请求首部字段（请求报文会使用的首部字段）

Host：请求资源所在服务器

Accept：可处理的媒体类型

Accept-Charset：可接收的字符集

Accept-Encoding：可接受的内容编码

Accept-Language：可接受的天然语言

c、响应首部字段（响应报文会使用的首部字段）

Accept-Ranges：可接受的字节范围

Location：令客户端从新定向到的URI

Server：HTTP服务器的安装信息

d、实体首部字段（请求报文与响应报文的的实体部分使用的首部字段）

Allow：资源可支持的HTTP方法

Content-Type：实体主类的类型

Content-Encoding：实体主体适用的编码方式

Content-Language：实体主体的天然语言

Content-Length：实体主体的的字节数

Content-Range：实体主体的位置范围，通常用于发出部分请求时使用

Http与Https优缺点？

a、通讯使用明文不加密，内容可能被窃听，也就是被抓包分析。

b、不验证通讯方身份，可能遭到假装

c、没法验证报文完整性，可能被篡改

HTTPS就是HTTP加上加密处理（通常是SSL安全通讯线路）+认证+完整性保护

Http优化

利用负载均衡优化和加速HTTP应用

利用HTTP Cache来优化网站

Http协议有那些特征？

一、支持客户/服务器模式；二、简单快速；三、灵活；四、无链接；五、无状态；

若是你还对Http协议不熟悉的话，请参考Http协议http://www.itmayiedu.com/front/articleinfo/49.html文章

JavaWeb基础部分

讲下Servlet的执行流程。doGet和doPost的区别

  Servlet的执行流程也就是servlet的生命周期，当服务器启动的时候生命周期开始，而后经过init()《启动顺序根据web.xml里的startup-on-load来肯定加载顺序》方法初始化servlet，再根据不一样请求调用doGet或doPost方法，最后再经过destroy()方法进行销毁。

doGet和doPost都是接受用户请求的方法，doGet处理get请求，doPost处理post请求，doGet用于地址栏提交，doPost用于表单提交，在页面提交数据时，get的数据大小有限制4k，post没有限制，get请求提交的数据会在地址栏显示，post不显示，因此post比get安全.

当service有一个实例变量，doGet和doPost去调用这个变量，会出现什么问题，你是如何解决的。

会出现线程不安全问题。不管是doGet仍是doPost去调用，服务器端处理的过程都是同样的，那么咱们能够把处理过程单独写在另一个方法handle里，让两个方法都去调用handle，根据不一样请求去调用不一样的方法。

如何处理servlet的线程不安全问题

线程安全就是多线程操做同一个对象不会有问题，线程同步通常来保护线程安全，因此能够在Servlet的线程里面加上同步方法或同步块。（Synchronized）能够保证在同一时间只有一个线程访问，（使用同步块会致使性能变差，最好不去使用实例变量）

Jsp的重定向和转发的流程有什么区别

重定向是客户端行为，转发是服务器端行为

重定向时服务器产生两次请求，转发产生一次请求，重定向时能够转发到项目之外的任何网址，转发只能在当前项目里转发

重定向会致使request对象信息丢失。转发则不会

转发的url不会变,request.getRequestDispatch（）。forward()

重定向的url会改变,response.getRedirect();

Jsp和servlet的区别

jsp的可读性强，容易维护，而且jsp在最后会编译成servlet

servlet容易调试

Jsp的九大内置对象，三大指令，七大动做的具体功能

JSP九大内置对象:

pageContext ：只对当前jsp页面有效，里面封装了基本的request和session的对象
Request ：对当前请求进行封装
Session ：浏览器会话对象，浏览器范围内有效
Application ：应用程序对象，对整个web工程都有效
Out ：页面打印对象，在jsp页面打印字符串
Response ：返回服务器端信息给用户
Config ：单个servlet的配置对象，至关于servletConfig对象
Page ：当前页面对象，也就是this
Exception ：错误页面的exception对象，若是指定的是错误页面，这个就是异常对象

三大指令：

Page ：指令是针对当前页面的指令
Include ：用于指定如何包含另外一个页面
Taglib ：用于定义和指定自定义标签

七大动做：

Forward，执行页面跳转，将请求的处理转发到另外一个页面
Param ：用于传递参数
Include ：用于动态引入一个jsp页面
Plugin ：用于下载javaBean或applet到客户端执行
useBean ：使用javaBean
setProperty ：修改javaBean实例的属性值
getProperty ：获取javaBean实例的属性值

获取页面的元素和值有几种方式，分别说一下

request.getParameter() 返回客户端的请求参数与值

request.getParameterNames() 返回全部可用属性名的枚举

request.getParameterValues() 返回包含参数的全部值的数组

servlet和javaScript的区别，他们分别是什么做用

一个是服务端，一个是客户端

Servlet是独立于平台和协议的服务器端的java应用程序，能够动态生成web页面，并采用响应--请求的模式提供web服务

javaScript是一种解释性语言，用于向html页面提供交互行为，一般被直接嵌入在html页面中

servlet是java语言编写的web应用

js是基于html上的一种解释语言

会话跟踪有哪些，他们的区别是什么

Cookie，session和application，
Cookie是http对象，客户端与服务端均可以操纵

cookie是在客户端保持状态，session是在服务器端保持状态，因为cookie是保存在客户端本地的，因此数据很容易被窃取，当访问量不少时，使用session则会下降服务器的性能，application的做用域是整个工程里只有一个，能够在不一样浏览器之间共享数据，全部人均可以共享，所以application也是不安全的

说说jsp的隐藏对象有哪些

Request,out,response , pageContext , session , application , config , page , exception，也即jsp的九大内置对象

request ，response，session 和 application是怎么用的

Request是客户端向服务端发送请求

Response是服务端对客户端请求作出响应

Session在servlet中不能直接使用，须要经过getSession()建立，若是没有设定它的生命周期，或者经过invildate()方法销毁，关闭浏览器session就会消失

Application不能直接建立，存在于服务器的内存中，由服务器建立和销毁

jsp页面跳转

Jsp页面跳转有两种方式，forward和redirect（转发和重定向）

Forward只能在当前项目里跳转，只产生一次请求，request保存的变量不会丢失，url地址不会改变

Redirect可跳转到项目之外的任何页面，产生两次请求，request保存的变量会所有丢失，url地址会发生改变，变化为第二个请求的地址

话跟踪

若是建立servlet实例不用构造方法，怎么建立一个servlet实例

Web容器会自动为servlet写一个无参的构造器，它使用class.forName("").newInstance()反射来建立servlet实例的

Servlet是安全的吗？当service有一个实例变量，doGet和doPost去调用这个变量，会出现什么问题，你是如何解决的

是线程不安全的，由于servlet是单例模式，当多个客户端共同访问的时候线程不安全。

尽可能用局部变量，同步块，若是当前字段是不会改变的，用final修饰

 

Java框架部分

说说Spring？

Spring的核心是控制反转、依赖注入,Aop（面向切面）至关于把每一个bean与bean之间的关系交给第 三方容器进行管理.

说SpringIOC、SpringAOP?

SpringIOC ,其实就是依赖注入、控制反转。至关于把每一个bean与bean之间的关系交给第三方容器管理。而这个容器就是spring

SpringAOP 面向切面的编程，或AOP，是一种编程技术，容许程序模块化横向切割关注点，或横切典型的责任划分，如日志和事务管理。 SpringAop 就是用 Javva的动态代理

 

Spring的底层实现机制是什么？

使用Demo4j（解析XML）+Java反射机制

Demo4j 其实就是解析XML。使用反射机制实例化bean。

 

SpringAOP用到了什么代理？

JDK动态代理:对实现了接口的类生成代理

CGLib代理机制:对类生成代理

动态代理与静态代理区别？

静态代理：由程序员建立或特定工具自动生成源代码，再对其编译。在程序运行前，代理类的.class文件就已经存在了。
动态代理：在程序运行时，运用反射机制动态建立而成。

Spring注入有那些方式？

Set注入

构造器注入

静态工厂的方法注入

实例工厂的方法注入

Spring有那些注解？

@Autowired(按类型注入)

@Service(标示为注入为服务层)

@Resource(按名称注入)

@Controller(标识控制器bean id)

@RequestMapping（表示映射URL路径）

简述Spring的优缺点？

  Spring 的优势？?

  1.下降了组件之间的耦合性 ，实现了软件各层之间的解耦

  2.可使用容易提供的众多服务，如事务管理，消息服务等

  3.容器提供单例模式支持

  4.容器提供了AOP技术，利用它很容易实现如权限拦截，运行期监控等功能

  5.容器提供了众多的辅助类，能加快应用的开发

  6.spring对于主流的应用框架提供了集成支持，如hibernate，JPA，Struts等

  7.spring属于低侵入式设计，代码的污染极低

  8.独立于各类应用服务器

  9.spring的DI机制下降了业务对象替换的复杂性

  10.Spring的高度开放性，并不强制应用彻底依赖于Spring，开发者能够自由选择spring的部分或所有

缺点:

使用到了大量反射机制。反射机制很是占内存，

SpringMVC工程流程

1. 用户向服务器发送请求，请求被Spring 前端控制Servelt DispatcherServlet捕获；

2. DispatcherServlet对请求URL进行解析，获得请求资源标识符（URI）。而后根据该URI，调用HandlerMapping得到该Handler配置的全部相关的对象（包括Handler对象以及Handler对象对应的拦截器），最后以HandlerExecutionChain对象的形式返回；

3. DispatcherServlet 根据得到的Handler，选择一个合适的HandlerAdapter。（附注：若是成功得到HandlerAdapter后，此时将开始执行拦截器的preHandler(...)方法）

4.  提取Request中的模型数据，填充Handler入参，开始执行Handler（Controller)。 在填充Handler的入参过程当中，根据你的配置，Spring将帮你作一些额外的工做：

      HttpMessageConveter： 将请求消息（如Json、xml等数据）转换成一个对象，将对象转换为指定的响应信息

      数据转换：对请求消息进行数据转换。如String转换成Integer、Double等

      数据根式化：对请求消息进行数据格式化。 如将字符串转换成格式化数字或格式化日期等

      数据验证： 验证数据的有效性（长度、格式等），验证结果存储到BindingResult或Error中

5.  Handler执行完成后，向DispatcherServlet 返回一个ModelAndView对象；

6.  根据返回的ModelAndView，选择一个适合的ViewResolver（必须是已经注册到Spring容器中的ViewResolver)返回给DispatcherServlet ；

7. ViewResolver 结合Model和View，来渲染视图

8. 将渲染结果返回给客户端。

 

SpringMVC工做流程描述

 为何SpringMVC只使用一个Servlet(DispatcherServlet)来处理全部请求？

详细见J2EE设计模式-前端控制模式

Spring为何要结合使用HandlerMapping以及HandlerAdapter来处理Handler?

符合面向对象中的单一职责原则，代码架构清晰，便于维护，最重要的是代码可复用性高。如HandlerAdapter可能会被用于处理多种Handler。

 

Hibernate面试题

什么是Hibernate？

hibernate是一个基于ORM持久框架,可让程序员以面向对象的思想操做数据库,提升生产效率.

什么是ORM？

orm不过是一种思想，对象关系映射。是对象关系模型，如hibernate,让你以面向对象的方式去编程。封装了JDBC.

 

说一下orm与jdbc的区别？

jdbc只是一个java操做数据库的规范接口而已

orm不过是一种思想，对象关系映射。

ORM：是对象关系模型，如hibernate,让你以面向对象的方式去编程。封装了JDBC.

JDBC：是从底层访问数据库服务器。通常银行，金融行业为了安全起见，直接用JDBC访问

Hibernate中get和load有什么不一样之处?

load ：找不到数据的话会抛出org.hibernate.ObjectNotFoundException异常。此时hibernate会使用延迟加载加载机制

 get找不到的话会返回null。

若是查询不到数据，get 会返回 null,可是不会报错, load 若是查询不到数据，则报错ObjectNotFoundException

使用get 去查询数据，(先到一级/二级)会当即向db发出查询请求(select ...), 若是你使用的是 load查询数据，(先到一级、二级))即便查询到对象，返回的是一个代理对象,若是后面没有使用查询结果，它不会真的向数据库发select ,当程序员使用查询结果的时候才真的发出select ,这个现象咱们称为懒加载(lazy)

hibernate的三种状态？

在Hibernate中，对象有三种状态：临 时状态(Transient)、持久状态(Persistent)和游离状态(Detached)。

处于持久态的对象也称为 PO(PersistenceObject),临时对象和游离对象也称为VO(ValueObject).

 

hibernate的懒加载？ 有几种禁用方法

在Hibernate框架中，当咱们要访问的数据量过大时，明显用缓存不太合适， 由于内存容量有限 ，为了减小并发量，减小系统资源的消耗，这时Hibernate用懒加载机制来弥补这种缺陷，可是这只是弥补而不是用了懒加载整体性能就提升了。

咱们所说的懒加载也被称为延迟加载，它在查询的时候不会马上访问数据库，而是返回代理对象，当真正去使用对象的时候才会访问数据库。

1.使用代理对象：Hibernate.initialize("代理对象");

2.在须要禁用懒加载的映射文件中显示的加入lazy = "false"

3.使用openSessionInView【须要借助于过滤器】 须要在web.xml文件中配置

hibernate有几种查询方式？

一、 属性查询二、 参数查询、命名参数查询三、 关联查询四、 分页查询五、 统计函数

Hibernate的优缺点？

1.Hibernate的优缺点：
优势：一、程序更加面向对象；
二、提升了生产率；
三、方便移植（修改配置文件）；
四、无侵入性。
缺点：
一、效率比JDBC略差；
二、不适合批量操做。

Hibernate的缓存机制

Hibernate缓存包括两大类：Hibernate一级缓存和Hibernate二级缓存。

1.Hibernate一级缓存又称为“Session的缓存”。

Session内置不能被卸载，Session的缓存是事务范围的缓存（Session对象的生命周期一般对应一个数据库事务或者一个应用事务）。

一级缓存中，持久化类的每一个实例都具备惟一的OID。

2.Hibernate二级缓存又称为“SessionFactory的缓存”。

因为SessionFactory对象的生命周期和应用程序的整个过程对应，所以Hibernate二级缓存是进程范围或者集群范围的缓存，有可能出现并发问题，所以须要采用适当的并发访问策略，该策略为被缓存的数据提供了事务隔离级别。

第二级缓存是可选的，是一个可配置的插件，默认下SessionFactory不会启用这个插件。

Hibernate提供了org.hibernate.cache.CacheProvider接口,它充当缓存插件与Hibernate之间的适配器。

Hibernate延迟加载？

1) Hibernate2延迟加载实现：a)实体对象 b)集合（Collection）

2) Hibernate3 提供了属性的延迟加载功能 当Hibernate在查询数据的时候，数据并无存在与内存中，当程序真正对数据的操做时，对象才存在与内存中，就实现了延迟加载，他节省了服务器的内存开销，从而提升了服务器的性能。

Hibernate工做原理及为何要用？

原理：

1)        读取并解析配置文件

2)        读取并解析映射信息

3)        建立SessionFactory

4)        打开Sesssion

5)        建立事务Transation

6)        持久化操做

7)        提交事务

8)        关闭Session

9)        关闭SesstionFactory

为何要用：

1)        对JDBC访问数据库的代码作了封装，大大简化了数据访问层繁琐的重复性代码。

2)        Hibernate是一个基于JDBC的主流持久化框架，是一个优秀的ORM实现。他很大程度的简化DAO层的编码工做

3)        hibernate使用Java反射机制，而不是字节码加强程序来实现透明性。

4)        hibernate的性能很是好，由于它是个轻量级框架。映射的灵活性很出色。它支持各类关系数据库，从一对一到多对多的各类复杂关系。

 

什么是Mybatis？

Mybatis的前生是ibatis，最后升级版本后名称叫mybatis。mybatis是以纯sql操做数据。

Mybatis与Hibernate区别？

Hibernate是面向对象的思想操做数据生成Sql语句，而mybatis是以纯sql操做数据

相对于mybatis容易优化.扩展性好，可是移植性差。

设计模式部分

你熟悉那些设计模式？

总共有23种设计模式

整体来讲设计模式分为三大类：

建立型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。

结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。

行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

企业面试的时候，面试官很是喜欢考单例，并且很是喜欢考手写单例。

什么是单例？单例有那些写法？

单例分类:懒汉式单例、饿汉式单例
单例模式有如下特色：
一、单例类只能有一个实例。
二、单例类必须本身建立本身的惟一实例。
三、单例类必须给全部其余对象提供这一实例。

①懒汉式单例

//懒汉式单例类.在第一次调用的时候实例化本身   

public class Singleton {  

    private Singleton() {}  

    private static Singleton single=null;  

    //静态工厂方法   

    public static Singleton getInstance () {  

         if (single == null) {    

             single = new Singleton();  

         }    

        return single;  

    }  

}  

②饿汉式单例

//饿汉式单例类.在类初始化时，已经自行实例化   

public class Singleton1 {  

    private Singleton1() {}  

    private static final Singleton1 single = new Singleton1();  

    //静态工厂方法   

    public static Singleton1 getInstance() {  

        return single;  

    }  

}  

懒汉式与饿汉式区别？

从名字上来讲，饿汉和懒汉，

饿汉就是类一旦加载，就把单例初始化完成，保证getInstance的时候，单例是已经存在的了，

而懒汉比较懒，只有当调用getInstance的时候，才回去初始化这个单例。

另外从如下两点再区分如下这两种方式：

 

一、线程安全：

饿汉式天生就是线程安全的，能够直接用于多线程而不会出现问题，

懒汉式自己是非线程安全的，为了实现线程安全有几种写法，分别是上面的一、二、3，这三种实如今资源加载和性能方面有些区别。

 

二、资源加载和性能：

饿汉式在类建立的同时就实例化一个静态对象出来，无论以后会不会使用这个单例，都会占据必定的内存，可是相应的，在第一次调用时速度也会更快，由于其资源已经初始化完成，

而懒汉式顾名思义，会延迟加载，在第一次使用该单例的时候才会实例化对象出来，第一次调用时要作初始化，若是要作的工做比较多，性能上会有些延迟，以后就和饿汉式同样了。

 

项目相关面试题

你说说你作的最好的项目？

要重点介绍到①项目是作什么？②用到那些技术？③整个项目中最大的亮点是？核心部分④遇到bug是怎么解决的？

例如： 我认为我作的最好的项目是

创办了蚂蚁课堂it在线教学网站，蚂蚁课堂在线教育网站，相似（慕课网、我要自学网）是一家为IT爱好者提供免费教学服务网站，分为首页、课程、博客、问答四大专区，本身也录制一些Java教学视频发布在蚂蚁课堂网站上。目前国内各大搜索引擎均可以经过搜索“蚂蚁课堂”关键字找到蚂蚁课堂网站，目前日均PV5000-7000等

使用技术SpringMVC+Mybatis+Spring+Maven，视频接口才第三方乐视云接口，使用反向代理nginx+tomcat实现负载均衡及集群减轻单台服务器压力、使用CDN加速提升网络分发。………

你项目遇到bug？怎么查问题？

例如:首先遇到了bug，会查询日志，经过日志定位到某个类的行数，判断是否有代码问题。

你遇到了什么bug？你是怎么解决？

例如我本身项目中，查询量很是大。经过日志发现了堆内存溢出，最后经过优化代码，减轻new和加大堆内存。

大家项目人员是怎么分配的？

项目分配为:

产品经理(负责提需求)

UI设计师（负责设计样式文件）

Web前端（只作Web页面前端静态文件）

Java工程师（写业务逻辑）

测试人员(负责测试bug)

非技术项目经理（负责项目管理、人员分配）

项目架构师（负责架构项目）

大家项目是怎么发布的？

企业当中项目都是发布在linux环境上

小公司:使用maven编译好经过打war包,放入到tomcat的webapps文件下

大公司:使用自动部署系统jenkins  jenkins直接关联svn地址自动打包、自动部署等

说说linux经常使用命令?

Cat 查看某个文件

CP 拷贝

Ls  查看全部列表

Pwd  查看路径

Tail 查看日志

Grep 搜索日志

 

HashMap是Hashtable的轻量级实现（非线程安全的实现），他们都完成了Map接口，主要区别在于HashMap容许空（null）键值（key）,因为非线程安全，效率上可能高于Hashtable。
HashMap容许将null做为一个entry的key或者value，而Hashtable不容许。
HashMap把Hashtable的contains方法去掉了，改为containsvalue和containsKey。由于contains方法容易让人引发误解。 
Hashtable继承自Dictionary类，而HashMap是Java1.2引进的Map interface的一个实现。
最大的不一样是，Hashtable的方法是Synchronize的，而HashMap不是，在多个线程访问Hashtable时，不须要本身为它的方法实现同步，而HashMap 就必须为之提供外同步（若是是ArrayList：List lst = Collections.synchronizedList(new ArrayList());若是是HashMap：Map map = Collections.synchronizedMap(new HashMap());）。
Hashtable和HashMap采用的hash/rehash算法都大概同样，因此性能不会有很大的差别。