面试题整理 !=!=未看 *****面试题整理最全有用

最新推荐文章于 2024-04-27 09:13:51 发布

okbin1991

最新推荐文章于 2024-04-27 09:13:51 发布

阅读量110

点赞数

文章标签： java 开发语言

本文链接：https://blog.csdn.net/okbin1991/article/details/129156724

版权

1. String类为什么是final的。

最佳答案：主要是为了“效率”和“安全性”的缘故。如String允许被继承，由于它的高度被实用性，可能会降低程序的性能，所有String被定义成final。

2. HashMap的源码，实现原理，底层结构。

参考： http://blog.csdn.net/vking_wang/article/details/14166593 or

3. 说说你知道的几个Java集合类：list、set、queue、map实现类咯。。。

参考： http://www.cnblogs.com/LittleHann/p/3690187.html?utm_source=tuicool&utm_medium=referral

HashMap

Hashtable
    是一个古老的Map实现类
        2.1) Properties 
        Properties对象在处理属性文件时特别方便(windows平台上的.ini文件)，Properties类可以把Map对象和属性文件关联起来，从而可以把Map对象中的key-value对写入到属性文

 HashSet
        HashSet是Set接口的典型实现，HashSet使用HASH算法来存储集合中的元素，因此具有良好的存取和查找性能。当向HashSet集合中存入一个元素时，HashSet会调用该对象的
　　　　 hashCode()方法来得到该对象的hashCode值，然后根据该HashCode值决定该对象在HashSet中的存储位置。
        值得主要的是，HashSet集合判断两个元素相等的标准是两个对象通过equals()方法比较相等，并且两个对象的hashCode()方法的返回值相等
            1.1.1) LinkedHashSet
            LinkedHashSet集合也是根据元素的hashCode值来决定元素的存储位置，但和HashSet不同的是，它同时使用链表维护元素的次序，这样使得元素看起来是以插入的顺序保存的。
　　　　　　　当遍历LinkedHashSet集合里的元素时，LinkedHashSet将会按元素的添加顺序来访问集合里的元素。
            LinkedHashSet需要维护元素的插入顺序，因此性能略低于HashSet的性能，但在迭代访问Set里的全部元素时(遍历)将有很好的性能(链表很适合进行遍历)

Deque
        Deque接口代表一个"双端队列"，双端队列可以同时从两端来添加、删除元素，因此Deque的实现类既可以当成队列使用、也可以当成栈使用
            3.2.1) ArrayDeque
            是一个基于数组的双端队列，和ArrayList类似，它们的底层都采用一个动态的、可重分配的Object[]数组来存储集合元素，当集合元素超出该数组的容量时，系统会在底层重

     PriorityQueue并不是一个比较标准的队列实现，PriorityQueue保存队列元素的顺序并不是按照加入队列的顺序，而是按照队列元素的大小进行重新排序，这点从它的类名也可以

4. 描述一下ArrayList和LinkedList各自实现和区别

参考：http://www.importnew.com/6629.html

5. Java中的队列都有哪些，有什么区别。

种类：普通队列、阻塞队列、非阻塞队列

区别：

(1)阻塞队列与普通队列区别在于，当队列是空时，从队列中获取元素的操作将被阻塞，或者当队列满时，往队列里添加元素的操作会被阻塞。试图从空的阻塞队列中获取元素的线程将会被阻塞，直到其他的线程往空的队列插入新的元素。同样，试图往已满的阻塞队列中添加新的元素的线程同样会被阻塞，知道其他的线程使得队列重新变的空闲起来，如从队列中溢出一个或多个元素，或者完全情况队列。

举例说明：阻塞队列(LinkedBlockingQueue)和非阻塞队列(ConcurrentLinkedQueue)的区别

相同点：二者都是线程安全的。

不同点：

(1)阻塞队列：按FIFO排序元素。队列的头部是在队列中时间最长的元素。队列的尾部是在队列中最短的元素。新元素插入队列的尾部，并且队列检索操作会获得位于队列头部的元素。链接队列的吞吐量通常要高于基于数组的队列，但是在大多数并发应用程序中，其可预知性能要低。

注意：A:必须要使用take()方法获取的时候达成阻塞结果

B:使用poll()方法产生非阻塞效果

(2)非阻塞队列：基于链接节点的、无界的、线程安全。按FIFO排序元素。队列的头部是在队列中时间最长的元素。队列的尾部是在队列中最短的元素。新元素插入队列的尾部，并且队列检索操作会获得位于队列头部的元素。当许多线程共享访问一个公共Collection时，ConcurrentLinkedQueue是一个恰当的选择。此队列不允许为null元素。

(3)在并发编程中，一般推荐使用阻塞队列，这样实现可以尽量避免程序出现意外错误。阻塞队列使用最经典的场景就是socket客户端数据的读取和解析，读取数据的线程不断将数据放入队列，然后解析线程不断从队列取数据解析。只要符合生产者-消费者模型的都可以使用阻塞队列。

(4)使用非阻塞队列，虽然能即时返回结果(消费结果)，但是必须自行编码解决返回为空的情况(以及消费重试等问题)。

6. 反射中，Class.forName和classloader的区别

都可以用来对类进行加载。Class.forName不但将类.class文件加载到jvm中之外，还会对类进行解释执行类中的static块。而classloader只是将.class文件加载到jvm中，不会执行static中的内容，只有在newInstance时才会去执行static块。

对比两者具体的执行过程：

(1)LoadClass()方法加载类及其初始化过程：

类加载---》newInstance() (链接+初始化)

newInstance():

(开始连接)静态代码块-->普通变量分配准备(a=0;b=0;c=null)-->(开始初始化)普通变量赋值(a=1;b=2;c='haha')-->构造方法-->初始化成功

(2)Class.forName(String className)一个参数方法加载类及其初始化过程：

类加载--->静态代码块-->newInstance() (链接+初始化)

newInstance():

(开始连接)普通变量分配准备(a=0;b=0;c=null)-->(开始初始化)普通变量赋值(a=1;b=2;c='haha')-->构造方法-->初始化成功

JVM加载类及其初始化过程：

(1)类加载：Boostrap Loader(启动类加载器)-->Extened Loader(扩展类加载器)-->System Loader(系统加载器)

(2)静态代码块初始化

(3)链接：A:验证：是否符合java规范是否有正确的内部结构及数据是否符合JVM规范 B:准备：静态变量默认初始值 C:解析：符号引用转为直接引用，解析地址

(4)初始化：A:赋值，真正的初始化，用户给变量赋予的值 B：构造方法

7. Java7、Java8的新特性(baidu问的,好BT)

参考：http://blog.csdn.net/zhongweijian/article/details/9258997

Java7的新特性：

(1)语法上：

A：二进制变量的标示，支持将整数类型用二进制来标示，用0b开头。

B:Switch语句支持String类型

C:Try-witch-resource语句

D:Catch多个异常(catch异常类型为final)

E:数字类型的下划线标示，更友好的表达式

F:泛型实例的创建可以通过类型推断来简化可以去掉后面new部分的泛型类型，只用<>就可以了。

G:在可变参数方法中传递非具体化参数,改进编译警告和错误

H:信息更丰富的回溯追踪就是上面try中try语句和里面的语句同时抛出异常时，异常栈的信息

Java8的新特性

(1)接口的默认方法：允许给接口添加一个非抽象的方法实现，只需要使用default关键字即可，这个特征又叫扩展方法。

(2)Lambda表达式

(3)函数式接口：仅仅只包含一个抽象对象的接口，每一个该类型的lambda表达式都会被匹配到这个抽象方法。只需给接口添加@FunctionalInterface注释，编译器如果发现你标注了这个注解的接口有多于一个抽象方法的时候会报错的。

(4)方法与构造函数引用：允许你使用::关键字来传递方法或者构造函数引用，以下代码展示了如何引用一个静态方法。

构造函数引用：

(5)lambda作用域：

在lambda表达式中访问外层作用域和老版本的匿名对象中的方式相似，你可以直接访问标记了final的外层局部变量，或者实例的字段以及静态变量。

(6)访问局部变量

(7)访问对象字段与静态变量

和本地变量不同的是，lambda内部对于实例的字段以及静态变量是既可读又可写的。

(8)访问接口的默认方法

(9)Date API

Clock时钟：提供了访问当前日期和时间方法。java.time.Clock

(10)Annotation注解：支持多种注解

8. Java数组和链表两种结构的操作效率，在哪些情况下(从开头开始，从结尾开始，从中间开始)，哪些操作(插入，查找，删除)的效率高

参考： http://blog.csdn.net/a19881029/article/details/22695289

9. Java内存泄露的问题调查定位：jmap，jstack的使用等等

参考： http://blog.csdn.net/gzh0222/article/details/8538727

下面就来认识一下MemoryAnalyzer.exe。java内存泄漏检查工具利器。

首先我们必须对jvm的堆内存进行dump，只有拿到这个文件我们才能分析出jvm堆内存中到底存了些什么内容，到底在做什么？

MemoryAnalyzer的用户我在这里就不一一说明了，我的博客里也有说明，下面就展示我测试的成功图：

其中深蓝色的部分就为内存泄漏的部分，java的堆内存一共只有481.5M而内存泄漏的部分独自占有了336.2M所以本次的内存泄漏很明显，那么我就来看看那个方法导致的内存泄漏：

从上图我们可以发现红线圈着的方法占用了堆内存的67.75%，如果能把这个测试结果交给开发，开发是不是应该很好定位呢。所以作为一名高级测试工程师，我们需要学习的东西太多。

虽然不确定一定是内存泄漏，但是可以准确的告诉开发问题出现的原因，有一定的说服力。

本人刚刚完成了云存储架构师的培训学习(包括了linux的内核了解、 shell的高级编程、linux安全的学习重点iptables和tcp/ip等各种协议的抓包分析、linux的集群、性能调优等接下来还有dba的课程等待着我挑战)。

10. string、stringbuilder、stringbuffer区别

参考： http://www.cnblogs.com/xudong-bupt/p/3961159.html

可变与不可变

　　String类中使用字符数组保存字符串，如下就是，因为有“final”修饰符，所以可以知道string对象是不可变的。

　　　　private final char value[];

　　StringBuilder与StringBuffer都继承自AbstractStringBuilder类，在AbstractStringBuilder中也是使用字符数组保存字符串，如下就是，可知这两种对象都是可变的。

　　　　char[] value;

2.是否多线程安全

　　String中的对象是不可变的，也就可以理解为常量，显然线程安全。

　　AbstractStringBuilder是StringBuilder与StringBuffer的公共父类，定义了一些字符串的基本操作，如expandCapacity、append、insert、indexOf等公共方法。

　　StringBuffer对方法加了同步锁或者对调用的方法加了同步锁，所以是线程安全的。

.StringBuilder与StringBuffer共同点

　　StringBuilder与StringBuffer有公共父类AbstractStringBuilder(抽象类)。

　　抽象类与接口的其中一个区别是：抽象类中可以定义一些子类的公共方法，子类只需要增加新的功能，不需要重复写已经存在的方法；而接口中只是对方法的申明和常量的定义。

　　StringBuilder、StringBuffer的方法都会调用AbstractStringBuilder中的公共方法，如super.append(...)。只是StringBuffer会在方法上加synchronized关键字，进行同步。

　　最后，如果程序不是多线程的，那么使用StringBuilder效率高于StringBuffer。

11. hashtable和hashmap的区别

参考：http://www.cnblogs.com/carbs/archive/2012/07/04/2576995.html

Hashtable 和 HashMap 的比较

	Hashtable	HashMap
并发操作	使用同步机制，实际应用程序中，仅仅是Hashtable本身的同步并不能保证程序在并发操作下的正确性，需要高层次的并发保护。下面的代码试图在key所对应的value值等于x的情况下修改value为x+1 { value = hashTable.get(key); if(value.intValue()== x){ hashTable.put(key, new Integer(value.intValue()+1)); } } 如2个线程同时执行以上代码，可能放入不是x+1，而是x+2.	没有同步机制，需要使用者自己进行并发访问控制
数据遍历的方式	Iterator 和 Enumeration	Iterator
是否包含Contains方法	包含	不包含但是改成containskey 和containsvalue
是否接受值为null的Key 或Value？	不接受	接受
根据hash值计算数组下标的算法	当数组长度较小，并且Key的hash值低位数值分散不均匀时，不同的hash值计算得到相同下标值的几率较高 hash = key.hashCode(); index=(hash&0x7FFFFFFF) % tab.length;	优于hashtable，通过对Key的hash做移位运算和位的与运算，使其能更广泛地分散到数组的不同位置 hash = hash (k); index = indexFor(hash, table.length); static int hash(Object x) { int h = x.hashCode(); h += ~(h << 9); h ^= (h >>> 14); h += (h << 4); h ^= (h >>> 10); return h; } static int indexFor(int h, int length) { return h & (length-1); }
Entry数组的长度	Ø 缺省初始长度为11， Ø 初始化时可以指定initial capacity	Ø 缺省初始长度为16， Ø 长度始终保持2的n次方 Ø 初始化时可以指定initial capacity，若不是2的次方，HashMap将选取第一个大于initial capacity 的2n次方值作为其初始长度
LoadFactor负荷因子	0.75
负荷超过(loadFactor * 数组长度)时，内部数据的调整方式	*扩展数组：2原数组长度+1**	**扩展数组：原数组长度 2***
负荷超过(loadFactor * 数组长度)时，内部数据的调整方式	两者都会重新根据Key的hash值计算其在数组中的新位置，重新放置。算法相似，时间、空间效率相同

13 .异常的结构，运行时异常和非运行时异常，各举个例子

参考： http://www.tuicool.com/articles/YVZBNfN

4.运行时异常和非运行时异常

(1)运行时异常都是RuntimeException类及其子类异常，如NullPointerException、IndexOutOfBoundsException等，这些异常是不检查异常，程序中可以选择捕获处理，也可以不处理。这些异常一般是由程序逻辑错误引起的，程序应该从逻辑角度尽可能避免这类异常的发生。

当出现RuntimeException的时候，我们可以不处理。当出现这样的异常时，总是由虚拟机接管。比如：我们从来没有人去处理过NullPointerException异常，它就是运行时异常，并且这种异常还是最常见的异常之一。

出现运行时异常后，系统会把异常一直往上层抛，一直遇到处理代码。如果没有处理块，到最上层，如果是多线程就由Thread.run()抛出，如果是单线程就被main()抛出。抛出之后，如果是线程，这个线程也就退出了。如果是主程序抛出的异常，那么这整个程序也就退出了。运行时异常是Exception的子类，也有一般异常的特点，是可以被Catch块处理的。只不过往往我们不对他处理罢了。也就是说，你如果不对运行时异常进行处理，那么出现运行时异常之后，要么是线程中止，要么是主程序终止。

如果不想终止，则必须扑捉所有的运行时异常，决不让这个处理线程退出。队列里面出现异常数据了，正常的处理应该是把异常数据舍弃，然后记录日志。不应该由于异常数据而影响下面对正常数据的处理。

(2)非运行时异常是RuntimeException以外的异常，类型上都属于Exception类及其子类。如 IOException、SQLException 等以及用户自定义的Exception异常。对于这种异常，JAVA编译器强制要求我们必需对出现的这些异常进行catch并处理，否则程序就不能编译通过。所以，面对这种异常不管我们是否愿意，只能自己去写一大堆catch块去处理可能的异常。

14. String a= “abc” String b = "abc" String c = new String("abc") String d = "ab" + "c" .他们之间用 == 比较的结果

15. String 类的常用方法

参考： http://www.pc6.com/java/j_50343.html

、String类常用方法1、求字符串长度public int length()//返回该字符串的长度

1 String str = new String("asdfzxc");
2 int strlength = str.length();//strlength = 7

2、求字符串某一位置字符public char charAt(int index)//返回字符串中指定位置的字符；注意字符串中第一个字符索引是0，最后一个是length()-1。

1 String str = new String("asdfzxc");
2 char ch = str.charAt(4);//ch = z

3、提取子串用String类的substring方法可以提取字符串中的子串，该方法有两种常用参数:1)public String substring(int beginIndex)//该方法从beginIndex位置起，从当前字符串中取出剩余的字符作为一个新的字符串返回。2)public String substring(int beginIndex, int endIndex)//该方法从beginIndex位置起，从当前字符串中取出到endIndex-1位置的字符作为一个新的字符串返回。

1 String str1 = new String("asdfzxc");
2 String str2 = str1.substring(2);//str2 = "dfzxc"
3 String str3 = str1.substring(2,5);//str3 = "dfz"

4、字符串比较1)public int compareTo(String anotherString)//该方法是对字符串内容按字典顺序进行大小比较，通过返回的整数值指明当前字符串与参数字符串的大小关系。若当前对象比参数大则返回正整数，反之返回负整数，相等返回0。2)public int compareToIgnore(String anotherString)//与compareTo方法相似，但忽略大小写。3)public boolean equals(Object anotherObject)//比较当前字符串和参数字符串，在两个字符串相等的时候返回true，否则返回false。4)public boolean equalsIgnoreCase(String anotherString)//

字符串中字符的大小写转换1)public String toLowerCase()//返回将当前字符串中所有字符转换成小写后的新串2)public String toUpperCase()//返回将当前字符串中所有字符转换成大写后的新串

1 String str = new String("asDF");
2 String str1 = str.toLowerCase();//str1 = "asdf"
3 String str2 = str.toUpperCase();//str2 = "ASDF"

8、字符串中字符的替换1)public String replace(char oldChar, char newChar)//用字符newChar替换当前字符串中所有的oldChar字符，并返回一个新的字符串。

9、其他类方法1)String trim()//截去字符串两端的空格，但对于中间的空格不处理。

1 String str = " a sd ";
2 String str1 = str.trim();
3 int a = str.length();//a = 6
4 int b = str1.length();//b = 4

2)boolean statWith(String prefix)或boolean endWith(String suffix)//用来比较当前字符串的起始字符或子字符串prefix和终止字符或子字符串suffix是否和当前字符串相同，重载方法中同时还可以指定比较的开始位置offset。

1 String str = "asdfgh";
2 boolean a = str.statWith("as");//a = true
3 boolean b = str.endWith("gh");//b = true

3)regionMatches(boolean b, int firstStart, String other, int otherStart, int length)//从当前字符串的firstStart位置开始比较，取长度为length的一个子字符串，other字符串从otherStart位置开始，指定另外一个长度为length的字符串，两字符串比较，当b为true时字符串不区分大小写。4)contains(String str)//判断参数s是否被包含在字符串中，并返回一个布尔类型的值。

1 String str = "student";
2 str.contains("stu");//true
3 str.contains("ok");//false

5)String[] split(String str)//将str作为分隔符进行字符串分解，分解后的字字符串在字符串数组中返回。

1 String str = "asd!qwe|zxc#";
2 String[] str1 = str.split("!|#");//str1[0] = "asd";str1[1] = "qwe";str1[2] = "zxc";

五、字符串与基本类型的转换1、字符串转换为基本类型java.lang包中有Byte、Short、Integer、Float、Double类的调用方法：1)public static byte parseByte(String s)2)public static short parseShort(String s)3)public static short parseInt(String s)4)public static long parseLong(String s)5)public static float parseFloat(String s)6)public static double parseDouble(String s)例如：

16. Java 的引用类型有哪几种

强引用、软引用、弱引用、虚引用

参考： http://blog.csdn.net/coding_or_coded/article/details/6603549

17. 抽象类和接口的区别

参考： http://www.importnew.com/12399.html

抽象类和接口的对比

参数	抽象类	接口
默认的方法实现	它可以有默认的方法实现	接口完全是抽象的。它根本不存在方法的实现
实现	子类使用extends关键字来继承抽象类。如果子类不是抽象类的话，它需要提供抽象类中所有声明的方法的实现。	子类使用关键字implements来实现接口。它需要提供接口中所有声明的方法的实现
构造器	抽象类可以有构造器	接口不能有构造器
与正常Java类的区别	除了你不能实例化抽象类之外，它和普通Java类没有任何区别	接口是完全不同的类型
访问修饰符	抽象方法可以有public、protected和default这些修饰符	接口方法默认修饰符是public。你不可以使用其它修饰符。
main方法	抽象方法可以有main方法并且我们可以运行它	接口没有main方法，因此我们不能运行它。
多继承	抽象方法可以继承一个类和实现多个接口	接口只可以继承一个或多个其它接口
速度	它比接口速度要快	接口是稍微有点慢的，因为它需要时间去寻找在类中实现的方法。
添加新方法	如果你往抽象类中添加新的方法，你可以给它提供默认的实现。因此你不需要改变你现在的代码。	如果你往接口中添加方法，那么你必须改变实现该接口的类。

什么时候使用抽象类和接口

如果你拥有一些方法并且想让它们中的一些有默认实现，那么使用抽象类吧。
如果你想实现多重继承，那么你必须使用接口。由于Java不支持多继承，子类不能够继承多个类，但可以实现多个接口。因此你就可以使用接口来解决它。

18. java的基础类型和字节大小。

参考： http://www.cnblogs.com/doit8791/archive/2012/05/25/2517448.html

19. Hashtable,HashMap,ConcurrentHashMap 底层实现原理与线程安全问题(建议熟悉 jdk 源码，才能从容应答)

参考： http://blog.csdn.net/xuefeng0707/article/details/40834595

20. 如果不让你用Java Jdk提供的工具，你自己实现一个Map，你怎么做。说了好久，说了HashMap源代码，如果我做，就会借鉴HashMap的原理，说了一通HashMap实现

参考：http://www.cnblogs.com/xwdreamer/archive/2012/05/14/2499339.html

21. Hash冲突怎么办？哪些解决散列冲突的方法？

参考：http://xiaolu123456.iteye.com/blog/1485349

22. HashMap冲突很厉害，最差性能，你会怎么解决?从O(n)提升到log(n)咯，用二叉排序树的思路说了一通

参考： http://www.2cto.com/kf/201505/399352.html

理解了hashmap的实现，聪明的人肯定已经知道怎么更加高性能的使用hashmap。不过在此之前还是先说明下初始容量和负载因子的含义。

Hashmap的设想是在O(1)的时间复杂度存取数据，根据我们的分析，在最坏情况下，时间复杂度很可能是o(n)，但这肯定极少出现。但是某个链表中存在多个元素还是有相当大的可能的。当hashmap中的元素数量越接近数组长度，这个几率就越大。为了保证hashmap的性能，我们对元素数量/数组长度的值做了上限，此值就是负载因子。当比值大于负载因子时，就需要对内置数组进行扩容，从而提高读写性能。但这也正是问题的所在，对数组扩容，代价较大，时间复杂度时O(n)。

故我们在hashmap需要存放的元素数量可以预估的情况下，预先设定一个初始容量，来避免自动扩容的操作来提高性能。

最直观的判断就是程序中采用了二分，且二分后只运算数据的一半。但如果两部分都运算的话，时间复杂度就是O(nlogn)了。其实不一定是二分，只不过二分比较常用罢了

23. rehash

参考：http://www.tuicool.com/articles/qqyENz

再哈希就是扩容的过程

在扩容的过程中需要进行ReHash操作，而这是非常耗时的，在实际中应该尽量避免

24. hashCode() 与 equals() 生成算法、方法怎么重写

参考： http://blog.csdn.net/jiangwei0910410003/article/details/22739953

二、Java IO

1. 讲讲IO里面的常见类，字节流、字符流、接口、实现类、方法阻塞。

参考：http://blog.csdn.net/zxman660/article/details/7875799

字节流与字符流的区别

字节流在操作的时候本身是不会用到缓冲区(内存)的，是与文件本身直接操作的，而字符流在操作的时候是使用到缓冲区的

字节流在操作文件时，即使不关闭资源(close方法)，文件也能输出，但是如果字符流不使用close方法的话，则不会输出任何内容，说明字符流用的是缓冲区，并且可以使用flush方法强制进行刷新缓冲区，这时才能在不close的情况下输出内容

那开发中究竟用字节流好还是用字符流好呢？

在所有的硬盘上保存文件或进行传输的时候都是以字节的方法进行的，包括图片也是按字节完成，而字符是只有在内存中才会形成的，所以使用字节的操作是最多的。

如果要java程序实现一个拷贝功能，应该选用字节流进行操作(可能拷贝的是图片)，并且采用边读边写的方式(节省内存)。

2. 讲讲NIO。

参考：http://blog.jobbole.com/88984/

3. String 编码UTF-8 和GBK的区别?

参考：http://blog.csdn.net/chruan/article/details/8812110

iso8859-1属于单字节编码，最多能表示的字符范围是0-255，应用于英文系列很明显，iso8859-1编码表示的字符范围很窄，无法表示中文字符

GB2312/GBK这就是汉子的国标码，专门用来表示汉字，是双字节编码，而英文字母和iso8859-1一致

unicode 这是最统一的编码，可以用来表示所有语言的字符，而且是定长双字节(也有四字节的)编码，包括英文字母在内。所以可以说它是不兼容iso8859-1编码的，也不兼容任何编码

UTF 考虑到unicode编码不兼容iso8859-1编码，而且容易占用更多的空间：因为对于英文字母，unicode也需要两个字节来表示。所以unicode不便于传输和存储。因此而产生了utf编码 ,而汉字使用三个字节

4. 什么时候使用字节流、什么时候使用字符流?

参考：http://blog.csdn.net/zj8692286/article/details/12650731

字节流与字符流的区别

字节流和字符流使用是非常相似的，那么除了操作代码的不同之外，还有哪些不同呢？

字节流在操作的时候本身是不会用到缓冲区(内存)的，是与文件本身直接操作的，而字符流在操作的时候是使用到缓冲区的

字节流在操作文件时，即使不关闭资源(close方法)，文件也能输出，但是如果字符流不使用close方法的话，则不会输出任何内容，说明字符流用的是缓冲区，并且可以使用flush方法强制进行刷新缓冲区，这时才能在不close的情况下输出内容

那开发中究竟用字节流好还是用字符流好呢？

5. 递归读取文件夹下的文件，代码怎么实现

参考：http://www.cnblogs.com/zhouyalei/p/3324491.html

 private List<String> ergodic(File file,List<String> resultFileName){
        File[] files = file.listFiles();
        if(files==null)return resultFileName;// 判断目录下是不是空的
        for (File f : files) {
            if(f.isDirectory()){// 判断是否文件夹
                resultFileName.add(f.getPath());
                ergodic(f,resultFileName);// 调用自身,查找子目录
            }else
                resultFileName.add(f.getPath());
        }
        return resultFileName;
    }

调用时,使用:return ergodic(new File(forderPath), resultList);返回结果就是目录下包括子目录下全部的文件路径,包括子目录的子目录.....

三、Java Web

1. session和cookie的区别和联系，session的生命周期，多个服务部署时session管理。

1. 由于HTTP协议是无状态的协议，所以服务端需要记录用户的状态时，就需要用某种机制来识具体的用户，这个机制就是Session.典型的场景比如购物车，当你点击下单按钮时，由于HTTP协议无状态，所以并不知道是哪个用户操作的，所以服务端要为特定的用户创建了特定的Session，用用于标识这个用户，并且跟踪用户，这样才知道购物车里面有几本书。这个Session是保存在服务端的，有一个唯一标识JssessionId。在服务端保存Session的方法很多，内存、数据库、文件都有。集群的时候也要考虑Session的转移，在大型的网站，一般会有专门的Session服务器集群，用来保存用户会话，这个时候 Session 信息都是放在内存的，使用一些缓存服务比如Memcached之类的来放 Session。 2. 思考一下服务端如何识别特定的客户？这个时候Cookie就登场了。每次HTTP请求的时候，客户端都会发送相应的Cookie信息到服务端。实际上大多数的应用都是用 Cookie 来实现Session跟踪的，第一次创建Session的时候，服务端会在HTTP协议中告诉客户端，需要在 Cookie 里面记录一个Session ID，以后每次请求把这个会话ID发送到服务器，我就知道你是谁了。有人问，如果客户端的浏览器禁用了 Cookie 怎么办？一般这种情况下，会使用一种叫做URL重写的技术来进行会话跟踪，即每次HTTP交互，URL后面都会被附加上一个诸如 sid=xxxxx 这样的参数，服务端据此来识别用户。 3. Cookie其实还可以用在一些方便用户的场景下，设想你某次登陆过一个网站，下次登录的时候不想再次输入账号了，怎么办？这个信息可以写到Cookie里面，访问网站的时候，网站页面的脚本可以读取这个信息，就自动帮你把用户名给填了，能够方便一下用户。这也是Cookie名称的由来，给用户的一点甜头。所以，总结一下： Session是在服务端保存的一个数据结构，用来跟踪用户的状态，这个数据可以保存在集群、数据库、文件中； Cookie是客户端保存用户信息的一种机制，用来记录用户的一些信息，也是实现Session的一种方式。

2. servlet的一些相关问题

3. webservice相关问题

3.是多个跨语言跨平台的应用间通信整合的方案(实际)

webservice相当于什么？ http + xml + schema

**SOAP(Simple Object Access Protocal)简单对象访问协议 1.是一种简单的，基于HTTP和XML的协议，用于在WEB交换结构化(XML)的数据 2.SOAP消息：请求消息和响应消息 3.HTTP+XML片断

**如何请求一个webservice

1.根据wsdl文档生成客户端代码

2.根据生成的代码调用webservice 找到wsdl文档中service标签的name属性对应的类，找到这个port标签的name属性调用这个方法

4. jdbc连接，forname方式的步骤，怎么声明使用一个事务。举例并具体代码

5. 无框架下配置web.xml的主要配置内容

6. jsp和servlet的区别

四、JVM

1. Java的内存模型以及GC算法

参考：http://www.cnblogs.com/AloneSwo

rd/p/4262255.html

2. jvm性能调优都做了什么

参考：http://blog.csdn.net/chen77716/article/details/5695893

JVM性能调优有很多设置,这个参考JVM参数即可.

主要调优的目的:

1. 控制GC的行为.GC是一个后台处理,但是它也是会消耗系统性能的,因此经常会根据系统运行的程序的特性来更改GC行为
2. 控制JVM堆栈大小.一般来说,JVM在内存分配上不需要你修改,(举例)但是当你的程序新生代对象在某个时间段产生的比较多的时候,就需要控制新生代的堆大小.同时,还要需要控制总的JVM大小避免内存溢出
3. 控制JVM线程的内存分配.如果是多线程程序,产生线程和线程运行所消耗的内存也是可以控制的,需要通过一定时间的观测后,配置最优结果

3. 介绍JVM中7个区域，然后把每个区域可能造成内存的溢出的情况说明

参考：http://www.codeceo.com/article/jvm-memory-overflow.html

JVM

1、内存模型以及分区，需要详细到每个区放什么。

JVM 分为堆区和栈区，还有方法区，初始化的对象放在堆里面，引用放在栈里面，class类信息常量池等放在方法区

2、堆里面的分区：Eden，survival (from+ to)，老年代，各自的特点。

堆里面分为新生代和老生代，新生代包含Eden+Survivor区，survivor区里面分为from和to区，内存回收时，用的是复制算法，从from复制到to，当经过一次或者多次GC之后，存活下来的对象会被移动到老年区，当JVM内存不够用的时候，会触发Full GC，清理JVM老年区

当新生区满了之后会触发YGC,先把存活的对象放到其中一个Survice区，然后进行垃圾清理。因为如果仅仅清理需要删除的对象，这样会导致内存碎片，因此一般会把Eden 进行完全的清理，然后整理内存。那么下次GC 的时候，就会使用下一个Survive，这样循环使用。如果有特别大的对象，新生代放不下，就会使用老年代的担保，直接放到老年代里面。因为JVM 认为，一般大对象的存活时间一般比较久远。

3、对象创建方法，对象的内存分配，对象的访问定位。

new 一个对象

4、GC的两种判定方法：

引用计数法：指的是如果某个地方引用了这个对象就+1，如果失效了就-1，当为0就会回收但是JVM没有用这种方式，因为无法判定相互循环引用(A引用B,B引用A)的情况

引用链法：通过一种GC ROOT的对象(方法区中静态变量引用的对象等)来判断，如果有一条链能够到达GC ROOT就说明，不能到达GC ROOT就说明可以回收

5、GC的三种收集方法：标记清除、标记整理、复制算法的原理与特点，分别用在什么地方，如果让你优化收集方法，有什么思路？

先标记，标记完毕之后再清除，效率不高，会产生碎片

复制算法：分为8：1的Eden区和survivor区，就是上面谈到的YGC

标记整理：标记完毕之后，让所有存活的对象向一端移动清除边缘以外的

6、GC收集器有哪些？CMS收集器与G1收集器的特点。

CMS收集器是基于“标记—清除”算法实现的，它的运作过程相对于前面几种收集器来说更复杂一些

G1从整体来看是基于“标记—整理”算法实现的收集器，从局部(两个Region之间)上来看是基于“复制”算法实现的

GC收集器参见http://www.jianshu.com/p/50d5c88b272d

7、Minor GC与Full GC分别在什么时候发生？

新生代内存不够用时候发生MGC也叫YGC，JVM内存不够的时候发生FGC

8、几种常用的内存调试工具：jmap、jstack、jconsole。

jstack可以看当前栈的情况，jmap查看内存

9、类加载的五个过程：

加载、验证、准备、解析、初始化。然后是使用和卸载了

通过全限定名来加载生成class对象，然后进行验证这个class文件，包括元数据验证，字节码校验等。准备是对这个静态变量对象分配内存并初始化为0。解析是将符号引用转化为直接引用(指针引用)，初始化就是开始执行构造器的代码

10、双亲委派模型：Bootstrap ClassLoader、Extension ClassLoader、ApplicationClassLoader。

Bootstrap ClassLoader:启动类加载器，负责将$ Java_Home/lib下面的类库加载到内存中(比如rt.jar

Extension ClassLoader：标准扩展(Extension)类加载器，它负责将$Java_Home /lib/ext或者由系统变量 java.ext.dir指定位置中的类库加载到内存中。

ApplicationClassLoader：它负责将系统类路径(CLASSPATH)中指定的类库加载到内存中。开发者可以直接使用系统类加载器

11、双亲委派模型是某个特定的类加载器在接到加载类的请求时，首先将加载任务委托给父类加载器，依次递归，如果父类加载器可以完成类加载任务，就成功返回；只有父类加载器无法完成此加载任务时，才自己去加载。-----例如类java.lang.Object，它存在在rt.jar中，无论哪一个类加载器要加载这个类，最终都是委派给处于模型最顶端的Bootstrap ClassLoader进行加载，因此Object类在程序的各种类加载器环境中都是同一个类。相反，如果没有双亲委派模型而是由各个类加载器自行加载的话，如果用户编写了一个java.lang.Object的同名类并放在ClassPath中，那系统中将会出现多个不同的Object类，程序将混乱

12、分派：静态分派(重载)与动态分派(重写)。

13、你知道哪些JVM性能调优

设定堆内存大小-Xms

-Xmx：堆内存最大限制。

设定新生代大小。新生代不宜太小，否则会有大量对象涌入老年代

-XX:NewSize：新生代大小

-XX:NewRatio 新生代和老生代占比

-XX:SurvivorRatio：伊甸园空间和幸存者空间的占比

设定垃圾回收器

年轻代用 -XX:+UseParNewGC 年老代用-XX:+UseConcMarkSweepGC

作者：itar 链接：https://www.jianshu.com/p/763ade0c7267 來源：简书著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

4. 介绍GC 和GC Root不正常引用。

参考：http://blog.csdn.net/fenglibing/article/details/8928927

5. 自己从classload 加载方式，加载机制说开去，从程序运行时数据区，讲到内存分配，讲到String常量池，讲到JVM垃圾回收机制，算法，hotspot。反正就是各种扩展

类加载机制：http://developer.51cto.com/art/201103/249613.htm

程序运行数据区：http://www.cnblogs.com/lrh-xl/p/5277585.html

内存分配： http://javawebsoa.iteye.com/blog/1558776

string常量池：http://developer.51cto.com/art/201106/266454.htm

hotspot :http://blog.csdn.net/jewes/article/details/42174893

6. jvm 如何分配直接内存， new 对象如何不分配在堆而是栈上，常量池解析

Java中堆和栈创建对象的区别：

JVM字节码初探——常量池和符号解析

7. 数组多大放在 JVM 老年代(不只是设置 PretenureSizeThreshold ，问通常多大，没做过一问便知)

参考：http://book.2cto.com/201306/25496.html

8. 老年代中数组的访问方式

参考：http://book.51cto.com/art/201107/278927.htm

9. GC 算法，永久代对象如何 GC ， GC 有环怎么处理

针对HotSpot VM的实现，它里面的GC其实准确分类只有两大种：

Partial GC：并不收集整个GC堆的模式
- Young GC：只收集young gen的GC
- Old GC：只收集old gen的GC。只有CMS的concurrent collection是这个模式
- Mixed GC：收集整个young gen以及部分old gen的GC。只有G1有这个模式
Full GC：收集整个堆，包括young gen、old gen、perm gen(如果存在的话)等所有部分的模式。

Major GC通常是跟full GC是等价的，收集整个GC堆。但因为HotSpot VM发展了这么多年，外界对各种名词的解读已经完全混乱了，当有人说“major GC”的时候一定要问清楚他想要指的是上面的full GC还是old gen。

最简单的分代式GC策略，按HotSpot VM的serial GC的实现来看，触发条件是：

young GC：当young gen中的eden区分配满的时候触发。注意young GC中有部分存活对象会晋升到old gen，所以young GC后old gen的占用量通常会有所升高。
full GC：当准备要触发一次young GC时，如果发现统计数据说之前young GC的平均晋升大小比目前old gen剩余的空间大，则不会触发young GC而是转为触发full GC(因为HotSpot VM的GC里，除了CMS的concurrent collection之外，其它能收集old gen的GC都会同时收集整个GC堆，包括young gen，所以不需要事先触发一次单独的young GC)；或者，如果有perm gen的话，要在perm gen分配空间但已经没有足够空间时，也要触发一次full GC；或者System.gc()、heap dump带GC，默认也是触发full GC。

HotSpot VM里其它非并发GC的触发条件复杂一些，不过大致的原理与上面说的其实一样。当然也总有例外。Parallel Scavenge(-XX:+UseParallelGC)框架下，默认是在要触发full GC前先执行一次young GC，并且两次GC之间能让应用程序稍微运行一小下，以期降低full GC的暂停时间(因为young GC会尽量清理了young gen的死对象，减少了full GC的工作量)。这是HotSpot VM里的奇葩嗯。

并发GC的触发条件就不太一样。以CMS GC为例，它主要是定时去检查old gen的使用量，当使用量超过了触发比例就会启动一次CMS GC，对old gen做并发收集。(RednaxelaFX——知乎)

Java的GC原理不是引用计数，所以即使有环，只要他是从GC Root不可达的，同样也会被收集。

10. 谁会被 GC ，什么时候 GC

程序认为的死去的对象，也就是不可达对象会被GC。

11. 如果想不被 GC 怎么办

不被GC，创建对象的强引用，并一直不释放

12. 如果想在 GC 中生存 1 次怎么办

生存一次，释放掉对象的引用，但是在对象的finalize方法中重新建立引用，但是有一此方法只会被调用一次，所以能在GC中生存一次

13.如何在JVM虚拟机挂掉的时候，做一些操作，例如发邮件通知

可以使用Runtime里面的addShutdownHook(Thread hook)方法，把JVM挂掉的时候所需要启动的线程注册到runtime中，就可以帮你完成这个动作

五、开源框架

1. hibernate和ibatis的区别

参考： http://blog.csdn.net/cdh1213/article/details/5967405

hibernate 是当前最流行的o/r mapping框架，它出身于sf.net，现在已经成为jboss的一部分了。
ibatis 是另外一种优秀的o/r mapping框架，目前属于apache的一个子项目了。
相对hibernate“o/r”而言，ibatis是一种“sql mapping”的orm实现。
hibernate对数据库结构提供了较为完整的封装，hibernate的o/r mapping实现了pojo 和数据库表之间的映射，以及sql 的自动生成和执行。程序员往往只需定义好了pojo 到数据库表的映射关系，即可通过hibernate 提供的方法完成持久层操作。程序员甚至不需要对sql 的熟练掌握， hibernate/ojb 会根据制定的存储逻辑，自动生成对应的sql 并调用jdbc 接口加以执行。
而ibatis 的着力点，则在于pojo 与sql之间的映射关系。也就是说，ibatis并不会为程序员在运行期自动生成sql 执行。具体的sql 需要程序员编写，然后通过映射配置文件，将sql所需的参数，以及返回的结果字段映射到指定pojo。
使用ibatis 提供的orm机制，对业务逻辑实现人员而言，面对的是纯粹的java对象。
这一层与通过hibernate 实现orm 而言基本一致，而对于具体的数据操作，hibernate会自动生成sql 语句，而ibatis 则要求开发者编写具体的sql 语句。相对hibernate而言，ibatis 以sql开发的工作量和数据库移植性上的让步，为系统设计提供了更大的自由空间。
hibernate与ibatis的对比：
1．ibatis非常简单易学，hibernate相对较复杂，门槛较高。
2．二者都是比较优秀的开源产品
3．当系统属于二次开发,无法对数据库结构做到控制和修改,那ibatis的灵活性将比hibernate更适合
4．系统数据处理量巨大，性能要求极为苛刻，这往往意味着我们必须通过经过高度优化的sql语句(或存储过程)才能达到系统性能设计指标。在这种情况下ibatis会有更好的可控性和表现。
5．ibatis需要手写sql语句，也可以生成一部分，hibernate则基本上可以自动生成，偶尔会写一些hql。同样的需求,ibatis的工作量比hibernate要大很多。类似的，如果涉及到数据库字段的修改，hibernate修改的地方很少，而ibatis要把那些sql mapping的地方一一修改。
6．以数据库字段一一对应映射得到的po和hibernte这种对象化映射得到的po是截然不同的，本质区别在于这种po是扁平化的，不像hibernate映射的po是可以表达立体的对象继承，聚合等等关系的，这将会直接影响到你的整个软件系统的设计思路。
7．hibernate现在已经是主流o/r mapping框架，从文档的丰富性，产品的完善性，版本的开发速度都要强于ibatis。

2. 讲讲mybatis的连接池。

参考：http://www.tuicool.com/articles/RvqEjeR

3. spring框架中需要引用哪些jar包，以及这些jar包的用途

参考： http://www.cnblogs.com/BensonHe/p/3903050.html

4. springMVC的原理

参考： http://blog.sina.com.cn/s/blog_7ef0a3fb0101po57.html

5. springMVC注解的意思

参考： http://aijuans.iteye.com/blog/2160141

6. spring中beanFactory和ApplicationContext的联系和区别

作用：
1. BeanFactory负责读取bean配置文档，管理bean的加载，实例化，维护bean之间的依赖关系，负责bean的声明周期。
2. ApplicationContext除了提供上述BeanFactory所能提供的功能之外，还提供了更完整的框架功能：
a. 国际化支持
b. 资源访问：Resource rs = ctx. getResource(“classpath:config.properties”), “file:c:/config.properties”
c. 事件传递：通过实现ApplicationContextAware接口
3. 常用的获取ApplicationContext的方法：
FileSystemXmlApplicationContext：从文件系统或者url指定的xml配置文件创建，参数为配置文件名或文件名数组
ClassPathXmlApplicationContext：从classpath的xml配置文件创建，可以从jar包中读取配置文件
WebApplicationContextUtils：从web应用的根目录读取配置文件，需要先在web.xml中配置，可以配置监听器或者servlet来实现
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<servlet>
<servlet-name>context</servlet-name>
<servlet-class>org.springframework.web.context.ContextLoaderServlet</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>
这两种方式都默认配置文件为web-inf/applicationContext.xml，也可使用context-param指定配置文件
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/myApplicationContext.xml</param-value>
</context-param>

7. spring注入的几种方式(循环注入)

参考：http://developer.51cto.com/art/201207/348019.htm

8. spring如何实现事物管理的

参考： http://michael-softtech.iteye.com/blog/813835

9. springIOC

参考： http://blog.csdn.net/it_man/article/details/4402245

10. spring AOP的原理

参考：http://blog.csdn.net/moreevan/article/details/11977115

11. hibernate中的1级和2级缓存的使用方式以及区别原理(Lazy-Load的理解)

参考： http://www.jb51.net/article/75161.htm

12. Hibernate的原理体系架构，五大核心接口，Hibernate对象的三种状态转换，事务管理。

参考： http://www.cnblogs.com/shysunlove/archive/2012/11/21/2780240.html

六、多线程

1. Java创建线程之后，直接调用start()方法和run()的区别

参考： http://www.tuicool.com/articles/7nyEziU

2. 常用的线程池模式以及不同线程池的使用场景

参考： http://www.cnblogs.com/dolphin0520/p/3932921.html

3. newFixedThreadPool此种线程池如果线程数达到最大值后会怎么办，底层原理。

参考： http://www.oschina.net/question/565065_86540

4. 多线程之间通信的同步问题，synchronized锁的是对象，衍伸出和synchronized相关很多的具体问题，例如同一个类不同方法都有synchronized锁，一个对象是否可以同时访问。或者一个类的static构造方法加上synchronized之后的锁的影响。

参考： http://www.cnblogs.com/shipengzhi/articles/2223100.html

5. 了解可重入锁的含义，以及ReentrantLock 和synchronized的区别

参考：http://outofmemory.cn/java/java.util.concurrent/synchronized-locks-Lock-ReentrantLock

6. 同步的数据结构，例如concurrentHashMap的源码理解以及内部实现原理，为什么他是同步的且效率高

参考： http://www.cnblogs.com/ITtangtang/p/3948786.html

7. atomicinteger和volatile等线程安全操作的关键字的理解和使用

参考： http://www.cnblogs.com/dolphin0520/p/3920373.html

8. 线程间通信，wait和notify

参考： http://www.jb51.net/article/40746.htm

3. 为什么在执行wait, notify时，必须获得该对象的锁？这是因为，如果没有锁，wait和notify有可能会产生竞态条件(Race Condition)。考虑以下生产者和消费者的情景： 1.1生产者检查条件(如缓存满了)-> 1.2生产者必须等待 2.1消费者消费了一个单位的缓存 -> 2.2重新设置了条件(如缓存没满) -> 2.3调用notifyAll()唤醒生产者我们希望的顺序是： 1.1->1.2->2.1->2.2->2.3 但在多线程情况下，顺序有可能是 1.1->2.1->2.2->2.3->1.2。也就是说，在生产者还没wait之前，消费者就已经notifyAll了，这样的话，生产者会一直等下去。所以，要解决这个问题，必须在wait和notifyAll的时候，获得该对象的锁，以保证同步

9. 定时线程的使用

参考： http://www.2cto.com/kf/201502/376021.html

10. 场景：在一个主线程中，要求有大量(很多很多)子线程执行完之后，主线程才执行完成。多种方式，考虑效率。

参考： http://www.tuicool.com/articles/ZvAFny

11. 进程和线程的区别

参考： http://www.cnblogs.com/way_testlife/archive/2011/04/16/2018312.html

12. 什么叫线程安全？举例说明

线程安全：如果你的代码所在的进程中有多个线程在同时运行，而这些线程可能会同时运行这段代码。如果每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。或者说:一个类或者程序所提供的接口对于线程来说是原子操作或者多个线程之间的切换不会导致该接口的执行结果存在二义性,也就是说我们不用考虑同步的问题

13. 线程的几种状态

参考： http://lavasoft.blog.51cto.com/62575/99153/

14. 并发、同步的接口或方法

参考： http://blog.csdn.net/woshisap/article/details/43119569

1：线程池
与每次需要时都创建线程相比，线程池可以降低创建线程的开销，这也是因为线程池在线程执行结束后进行的是回收操作，而不是真正的
销毁线程。
2：ReentrantLock
ReentrantLock提供了tryLock方法，tryLock调用的时候，如果锁被其他线程持有，那么tryLock会立即返回，返回结果为false，如果锁没有被
其他线程持有，那么当前调用线程会持有锁，并且tryLock返回的结果是true,
lock.lock();
try {
//do something
} finally {
lock.unlock();
}
3：volatile
保证了同一个变量在多线程中的可见性，不可以被缓存，因为volatile保证了只有一份主存中的数据。
4：Atomics
public class Count {
private AtomicInteger counter = new AtomicInteger();
public int increase() {
return counter.incrementAndGet();
}
public int decrease() {
return counter.decrementAndGet();
}
}
AtomicInteger内部通过JNI的方式使用了硬件支持的CAS指令。
5：CountDownLatch
它是java.util.concurrent包中的一个类，它主要提供的机制是当多个(具体数量等于初始化CountDown时的count参数的值)线程都到达了预期状态
或完成预期工作时触发事件，其他线程可以等待这个事件来出发自己后续的工作，等待的线程可以是多个，即CountDownLatch是可以唤醒多个等待
的线程的，到达自己预期状态的线程会调用CountDownLatch的countDown方法，而等待的线程会调用CountDownLatch的await方法
6：CyclicBarrier
循环屏障，CyclicBarrier可以协同多个线程，让多个线程在这个屏障前等待，直到所有线程都到达了这个屏障时，再一起继续执行后面的动作。
CyclicBarrier和CountDownLatch都是用于多个线程间的协调的，二者的一个很大的差别是，CountDownLatch是在多个线程都进行了latch.countDown
后才会触发事件，唤醒await在latch上的线程，而执行countDown的线程，执行完countDown后，会继续自己线程的工作；
CyclicBarrier是一个栅栏，用于同步所有调用await方法的线程，并且等所有线程都到了await方法，这些线程才一起返回继续各自的工作，因为使用CyclicBarrier的线程都会阻塞在await方法上，所以在线程池中使用CyclicBarrier时要特别小心，如果线程池的线程数过少，那么就会发生死锁了,
CyclicBarrier可以循环使用，CountDownLatch不能循环使用。
7：Semaphore
是用于管理信号量的，构造的时候传入可供管理的信号量的数值，信号量对量管理的信号就像令牌，构造时传入个数，总数就是控制并发的数量。
semaphore.acquire();
try {
//调用远程通信的方法
} finally () {
semahore.release();
}
8：Exchanger
Exchanger，从名字上讲就是交换，它用于在两个线程之间进行数据交换，线程会阻塞在Exchanger的exchange方法上，直到另一个线程也到了
同一个Exchanger的exchange方法时，二者进行交换，然后两个线程会继续执行自身相关的代码。
9：Future和FutureTask
Future<HashMap> future = getDataFromRemote2();
//do something
HashMap data = (HashMap)future.get();
private Future<HashMap> getDateFromRemote2() {
return threadPool.submit(new Callable<HashMap>() {
public HashMap call() {
return getDataFromRemote();
}
});
}
思路：调用函数后马上返回，然后继续向下执行，急需要数据时再来用，或者说再来等待这个数据，具体实现方式有两种，一个是用Future，另一个使用回调。

15. HashMap 是否线程安全，为何不安全。 ConcurrentHashMap，线程安全，为何安全。底层实现是怎么样的。

参考： http://blog.csdn.net/xuefeng0707/article/details/40834595

16. J.U.C下的常见类的使用。 ThreadPool的深入考察； BlockingQueue的使用。(take，poll的区别，put，offer的区别)；原子类的实现。

参考： http://wsmajunfeng.iteye.com/blog/1629354 http://ifeve.com/j-u-c-framework/

17. 简单介绍下多线程的情况，从建立一个线程开始。然后怎么控制同步过程，多线程常用的方法和结构

参考： http://www.jb51.net/article/36553.htm

18. volatile的理解

参考： http://www.infoq.com/cn/articles/java-memory-model-4/

19. 实现多线程有几种方式，多线程同步怎么做，说说几个线程里常用的方法

参考： http://www.jb51.net/article/43417.htm

http://www.cnblogs.com/psjay/archive/2010/04/01/1702465.html

http://blog.csdn.net/you_off3/article/details/7572704

七、网络通信

1. http是无状态通信，http的请求方式有哪些，可以自己定义新的请求方式么。

参考： http://www.cnblogs.com/yin-jingyu/archive/2011/08/01/2123548.html

2. socket通信，以及长连接，分包，连接异常断开的处理。

参考： http://developer.51cto.com/art/201202/318163.htm

3. socket通信模型的使用，AIO和NIO。

参考：AIO：http://www.52im.net/thread-306-1-1.html

NIO：http://www.cnblogs.com/dolphin0520/p/3916526.html

4. socket框架netty的使用，以及NIO的实现原理，为什么是异步非阻塞。

参考：http://www.importnew.com/15656.html

NIO：http://www.cnblogs.com/dolphin0520/p/3916526.html

5. 同步和异步，阻塞和非阻塞。

参考：http://blog.csdn.net/hguisu/article/details/7453390

6. OSI七层模型，包括TCP,IP的一些基本知识

参考：http://www.2cto.com/net/201307/232200.html

http://blog.csdn.net/ysdaniel/article/details/6636641

7. http中，get post的区别

参考：http://www.cnblogs.com/hyddd/archive/2009/03/31/1426026.html

8. 说说http,tcp,udp之间关系和区别。

参考：http://www.javalm.com/thread-2259-1-1.html

一.TCP/IP代表传输控制协议/网际协议，指的是一系列协组。

　　可分为四个层次：数据链路层、网络层、传输层和应用层。

在网络层:有IP协议、ICMP协议、ARP协议、RARP协议和BOOTP协议。
在传输层:中有TCP协议与UDP协议。
在应用层:有FTP、HTTP、TELNET、SMTP、DNS等协议。

　　TCP和UDP使用IP协议从一个网络传送数据包到另一个网络。把IP想像成一种高速公路，它允许其它协议在上面行驶并找到到其它电脑的出口。TCP和UDP是高速公路上的“卡车”，它们携带的货物就是像HTTP，文件传输协议FTP这样的协议等。 TCP和UDP是FTP，HTTP和SMTP之类使用的传输层协议。虽然TCP和UDP都是用来传输其他协议的，它们却有一个显著的不同：TCP提供有保证的数据传输，而UDP不提供。这意味着TCP有一个特殊的机制来确保数据安全的不出错的从一个端点传到另一个端点，而UDP不提供任何这样的保证。

二.HTTP本身就是一个协议，是从Web服务器传输超文本到本地浏览器的传送协议。

　　HTTP(超文本传输协议)是利用TCP在两台电脑(通常是Web服务器和客户端)之间传输信息的协议。客户端使用Web浏览器发起HTTP请求给Web服务器，Web服务器发送被请求的信息给客户端。

    HTTP协议是建立在请求/响应模型上的。首先由客户建立一条与服务器的TCP链接，并发送一个请求到服务器，请求中包含请求方法、URL、协议版本以及
相关的MIME样式的消息。服务器响应一个状态行，包含消息的协议版本、一个成功和失败码以及相关的MIME式样的消息。
    HTTP/1.0为每一次HTTP的请求/响应建立一条新的TCP链接，因此一个包含HTML内容和图片的页面将需要建立多次的短期的TCP链接。一次TCP链接的建立
将需要3次握手。
    另外，为了获得适当的传输速度，则需要TCP花费额外的回路链接时间(RTT)。每一次链接的建立需要这种经常性的开销，而其并不带有实际有用的数据
，只是保证链接的可靠性，因此HTTP/1.1提出了可持续链接的实现方法。HTTP/1.1将只建立一次TCP的链接而重复地使用它传输一系列的请求/响应消息，
因此减少了链接建立的次数和经常性的链接开销。

　　虽然HTTP本身是一个协议，但其最终还是基于TCP的。

三.SOCKET：TCP/IP网络的API。

　　Socket是应用层与TCP/IP协议族通信的中间软件抽象层，它是一组接口。在设计模式中，Socket其实就是一个门面模式，它把复杂的TCP/IP协议族隐藏在Socket接口后面，对用户来说，一组简单的接口就是全部，让Socket去组织数据，以符合指定的协议。

　　Socket 接口是TCP/IP网络的API，Socket接口定义了许多函数或例程，用以开发TCP/IP网络上的应用程序。

    这是为了实现以上的通信过程而建立成来的通信管道，其真实的代表是客户端和服务器端的一个通信进程，双方进程通过socket进行通信，而通信的规则
采用指定的协议。socket只是一种连接模式，不是协议,tcp,udp，简单的说(虽然不准确)是两个最基本的协议,很多其它协议都是基于这两个协议如，http
就是基于tcp的，用socket可以创建tcp连接，也可以创建udp连接，这意味着，用socket可以创建任何协议的连接，因为其它协议都是基于此的。

综上所述：需要IP协议来连接网络;TCP是一种允许我们安全传输数据的机制，使用TCP协议来传输数据的HTTP是Web服务器和客户端使用的特殊协议。HTTP基于TCP协议，但是却可以使用socket去建立一个TCP连接。

9. 说说浏览器访问www.taobao.com，经历了怎样的过程。

参考：http://blog.csdn.net/a2796749/article/details/48032341

假设你用一个全新的浏览器(第一次启动的那种)，访问百度(http://www.baidu.com/)，在你敲入网址并按下回车之后，将会发生以下神奇的事情：

浏览器先尝试从Host文件中获取http://www.baidu.com/对应的IP地址，如果能取到当然万事大吉大家都能嗨，如果不能，就使用DNS协议来获取IP咯。

在DNS协议中，PC会向你的本地DNS服务器求助(一般是路由器)，希望从本地DNS服务器那里得到百度的IP，得到就好，得不到还得向更高层次的DNS服务器求助，最终总能得到百度的IP。

得到百度的IP，下一步是使用TCP协议，建立TCP连接。

在TCP协议中，建立TCP需要与百度服务器握手三次，你先告诉服务器你要给服务器发东西(SYN)，服务器应答你并告诉你它也要给你发东西(SYN、ACK)，然后你应答服务器(ACK)，总共来回了3次，称为3次握手。

不过，建立TCP连接有个前提(或者说给服务器发消息有个前提)：你必须能成功地把消息发到服务器上。虽然已经知道IP，但并无啥用(比如说，你在广东，你知道北京的地理坐标经纬度就能到北京了？你得知道有哪些路通往北京吧你得准备盘缠吧你得花时间吧)。

为了将消息从你的PC上传到服务器上，需要用到IP协议、ARP协议和OSPF协议。

我们都知道，你的PC和百度服务器之间一般会有许多路由器之类的东西，IP协议指定了出发地(你的PC)和目的地(服务器)；你的数据会经过一个又一个路由器，OSPF决定了会经过那些路由器(用一种叫路由算法的玩意，找出最佳路径)；从一个路由器怎么传给下一个路由器？这是ARP协议的JOB，ARP负责求下一个节点的地址(我们不止是要目的地，还要中间节点的地址)。 IP协议使用的是IP地址，整个发送过程中只涉及出发地和目的地2个IP地址，而ARP协议使用的是MAC地址，整个发送过程中涉及到每一个节点的MAP地址

现在，我们能和服务器通信，还建立了TCP连接，下一步干嘛，当然是用HTTP协议请求网页内容咯。

你发个HTTP请求报文给服务器，如果服务器禁止你访问它就给你回个"Forbidden"，如果它暂时挂掉了就给你回个“内部服务错误”，如果它正常才给你回个“OK“并将你要的数据传给你；如果你还需要其它的东西再去跟它要(它一般还会给你的-_-)。

你收到了服务器的回复，是一坨HTML形式的文本。浏览器必须要能够理解文本的内容，并快速地渲染到屏幕上(浏览器一般用有限自动机来理解文本内容，渲染的话就各看本事了，之所以微软IE卡成狗而谷歌浏览器很6，就是它们的渲染速度不同...)

渲染出来后，你就看到百度的首页了

10. HTTP协议、 HTTPS协议，SSL协议及完整交互过程；

参考：http://blog.csdn.net/dfsaggsd/article/details/50910999

5. HTTP与HTTPS的区别：

1) https协议需要申请证书。

2) http是超文本传输协议，

3) http端口80,；https端口443。

4) http连接简单无状态；https由SSL+HTTP协议构件的可进行加密传输、身份验证的网络协议。

11. tcp的拥塞，快回传，ip的报文丢弃

参考：http://www.cnblogs.com/newwy/p/3254029.html

拥塞避免

从慢启动可以看到,cwnd可以很快的增长上来,从而最大程度的利用网络带宽资源，但是cwnd不能一直这样无限增长下去，一定需要某个限制。TCP使用了一个叫慢启动门限(ssthresh)的变量，当cwnd超过该值后，慢启动过程结束，进入拥塞避免阶段。对于大多数TCP实现来说，ssthresh的值是65536(同样以字节计算)。拥塞避免的主要思想是加法增大，也就是cwnd的值不再指数级往上升，开始加法增加。此时当窗口中所有的报文段都被确认时，cwnd的大小加1，cwnd的值就随着RTT开始线性增加，这样就可以避免增长过快导致网络拥塞，慢慢的增加调整到网络的最佳值。

快速重传

其实TCP还有一种情况会进行重传：那就是收到3个相同的ACK。TCP在收到乱序到达包时就会立即发送ACK，TCP利用3个相同的ACK来判定数据包的丢失，此时进行快速重传，快速重传做的事情有： 1.把ssthresh设置为cwnd的一半 2.把cwnd再设置为ssthresh的值+3 3.重新进入拥塞避免阶段

12. https处理的一个过程，对称加密和非对称加密

参考：http://my.oschina.net/shede333/blog/359290

13. head各个特点和区别

参考：

八、数据库MySql

参考：http://www.cnblogs.com/wangwanchao/p/5267164.html

1. MySql的存储引擎的不同

参考：http://c.biancheng.net/cpp/html/1465.html

2. 单个索引、联合索引、主键索引

参考：http://blog.csdn.net/u011341352/article/details/47731255

3. Mysql怎么分表，以及分表后如果想按条件分页查询怎么办(如果不是按分表字段来查询的话，几乎效率低下，无解)

1)、做mysql集群，例如：利用mysql cluster ，mysql proxy，mysql replication，drdb等等

优点：扩展性好，没有多个分表后的复杂操作(php代码)

缺点：单个表的数据量还是没有变，一次操作所花的时间还是那么多，硬件开销大。

2)、预先估计会出现大数据量并且访问频繁的表，将其分为若干个表

优点：避免一张表出现几百万条数据，缩短了一条sql的执行时间

缺点：当一种规则确定时，打破这条规则会很麻烦，上面的例子中我用的hash算法是crc32，如果我现在不想用这个算法了，改用md5后，会使同一个用户的消息被存储到不同的表中，这样数

据乱套了。扩展性很差。

3)、利用merge存储引擎来实现分表

优点：扩展性好，并且程序代码改动的不是很大

缺点：这种方法的效果比第二种要差一点

4. 分表之后想让一个id多个表是自增的，效率实现

参考：http://www.ttlsa.com/mysql/mysql-table-to-solve-the-increment-id-scheme/

5. MySql的主从实时备份同步的配置，以及原理(从库读主库的binlog)，读写分离

参考：http://www.cnblogs.com/alvin_xp/p/4162249.html

6. 写SQL语句。。。

7. 索引的数据结构，B+树

参考：http://www.uml.org.cn/sjjm/201107145.asp

MySQL数据库支持多种索引类型，如BTree索引，哈希索引，全文索引等等

MySQL就普遍使用B+Tree实现其索引结构

8. 事务的四个特性，以及各自的特点(原子、隔离)等等，项目怎么解决这些问题

9. 数据库的锁：行锁，表锁；乐观锁，悲观锁

mysql中有一种机制是表锁定和行锁定，为什么要出现这种机制，是为了保证数据的完整性

举个例子来说吧，如果有二个sql都要修改同一张表的同一条数据，这个时候怎么办呢，是不是二个sql都可以同时修改这条数据呢？

很显然mysql对这种情况的处理是，一种是表锁定(myisam存储引擎)，一个是行锁定(innodb存储引擎)。

表锁定表示你们都不能对这张表进行操作，必须等我对表操作完才行。行锁定一样

10. 数据库事务的几种粒度；

数据库级、表级、记录级(行级)和属性级(字段级)

11. 关系型和非关系型数据库区别

参考：http://my.oschina.net/u/1773689/blog/364548

nosql和关系型数据库比较？优点： 1)成本：nosql数据库简单易部署，基本都是开源软件，不需要像使用oracle那样花费大量成本购买使用，相比关系型数据库价格便宜。 2)查询速度：nosql数据库将数据存储于缓存之中，关系型数据库将数据存储在硬盘中，自然查询速度远不及nosql数据库。 3)存储数据的格式：nosql的存储格式是key,value形式、文档形式、图片形式等等，所以可以存储基础类型以及对象或者是集合等各种格式，而数据库则只支持基础类型。 4)扩展性：关系型数据库有类似join这样的多表查询机制的限制导致扩展很艰难。缺点： 1)维护的工具和资料有限，因为nosql是属于新的技术，不能和关系型数据库10几年的技术同日而语。 2)不提供对sql的支持，如果不支持sql这样的工业标准，将产生一定用户的学习和使用成本。

3)不提供关系型数据库对事物的处理。

非关系型数据库的优势：1. 性能NOSQL是基于键值对的，可以想象成表中的主键和值的对应关系，而且不需要经过SQL层的解析，所以性能非常高。2. 可扩展性同样也是因为基于键值对，数据之间没有耦合性，所以非常容易水平扩展。

关系型数据库的优势：1. 复杂查询可以用SQL语句方便的在一个表以及多个表之间做非常复杂的数据查询。2. 事务支持使得对于安全性能很高的数据访问要求得以实现。对于这两类数据库，对方的优势就是自己的弱势，反之亦然。

12.数据库的隔离级别：

脏读: 脏读就是指当一个事务正在访问数据，并且对数据进行了修改，而这种修改还没有提交到数据库中，这时，另外一个事务也访问这个数据，然后使用了这个数据。

不可重复读:是指在一个事务内，多次读同一数据。在这个事务还没有结束时，另外一个事务也访问该同一数据。那么，在第一个事务中的两次读数据之间，由于第二个事务的修改，那么第一

个事务两次读到的的数据可能是不一样的。这样就发生了在一个事务内两次读到的数据是不一样的，因此称为是不可重复读。

幻读:第一个事务对一个表中的数据进行了修改，这种修改涉及到表中的全部数据行。同时，第二个事务也修改这个表中的数据，这种修改是向表中插入一行新数据。那么，以后就会发生操作第

一个事务的用户发现表中还有没有修改的数据行，就好象发生了幻觉一样。

未提交读(Read Uncommitted)：允许脏读，也就是可能读取到其他会话中未提交事务修改的数据

提交读(Read Committed)：只能读取到已经提交的数据。Oracle等多数数据库默认都是该级别 (不重复读)

可重复读(Repeated Read)：可重复读。在同一个事务内的查询都是事务开始时刻一致的，InnoDB默认级别。在SQL标准中，该隔离级别消除了不可重复读，但是还存在幻象读

串行读(Serializable)：完全串行化的读，每次读都需要获得表级共享锁，读写相互都会阻塞

九、设计模式

1. 单例模式：饱汉、饿汉。以及饿汉中的延迟加载,双重检查

参考：http://blog.csdn.net/nsw911439370/article/details/50456231

2. 工厂模式、装饰者模式、观察者模式。

参考：http://www.cnblogs.com/lyl6796910/p/4337362.html

3. 工厂方法模式的优点(低耦合、高内聚，开放封闭原则)

参考：http://blog.csdn.net/chenssy/article/details/8974868

十、算法

1. 使用随机算法产生一个数，要求把1-1000W之间这些数全部生成。(考察高效率，解决产生冲突的问题)

参考：http://www.cnblogs.com/Geometry/archive/2011/01/25/1944582.html

2. 两个有序数组的合并排序

参考：http://blog.163.com/l_greatsea/blog/static/204986044201521303816600/

3. 一个数组的倒序

参考：http://k0441258778983.iteye.com/blog/1177353

public class T { public static void main(String[] args) { char[] chars={'1','3','4','5','6'}; for(int i= 0 ; i < chars.length;i++){ char top =chars[0];//把数组的第一个提取出来，放进top for(int j=1;j<chars.length-i;j++){ chars[j-1]= chars[j];//将组数除第一个之外的其余数向左边挪一位 } chars[chars.length-i-1]=top;//将top 即原来数组的第一个数赋予到数组的最后一位 } System.out.println(chars);

4. 计算一个正整数的正平方根

5. 说白了就是常见的那些查找、排序算法以及各自的时间复杂度

参考：http://blog.csdn.net/hguisu/article/details/7776068

6. 二叉树的遍历算法

参考：http://ocaicai.iteye.com/blog/1047397

7. DFS,BFS算法

参考：http://www.cnblogs.com/developerY/p/3323264.html

9. 比较重要的数据结构，如链表，队列，栈的基本理解及大致实现。

参考：http://blog.csdn.net/amork/article/details/7258216

10. 排序算法与时空复杂度(快排为什么不稳定，为什么你的项目还在用)

参考：http://blog.csdn.net/hguisu/article/details/7776068

11. 逆波兰计算器

参考：http://blog.csdn.net/java2010czp/article/details/8033031

12. Hoffman 编码

参考：http://www.cnblogs.com/skywang12345/p/3706833.html

13. 查找树与红黑树

参考：http://www.cnblogs.com/yangecnu/p/Introduce-Red-Black-Tree.html

十一、并发与性能调优

1. 有个每秒钟5k个请求，查询手机号所属地的笔试题(记得不完整，没列出)，如何设计算法?请求再多，比如5w，如何设计整个系统?

这不是算法的问题吧，是架构设计。

1、服务器直接用数据库连接池从数据库拿数据，数据加索引，这是最原始方式，看看这个的承载量

2、1方式达不到需求就用数据缓存，比如redis，先从缓存取，取不到再从数据库取，取出来放入缓存，记得加个缓存时效，避免内存暴增。

3、利用集群和负载均衡，结合缓存技术，别说5k，就算5w都行

2. 高并发情况下，我们系统是如何支撑大量的请求的

认清系统的高并发由3个层面导致：

1. 传输层

大量用户对系统请求后，将会造成网络带宽和Web服务器的I/O瓶颈。

2. 计算层

接收大量用户请求进行计算，将会造成业务服务器和业务支撑服务器的瓶颈。

3. 存储层

传输层和计算层将会产生大量的数据，数据量暴增，将会导致数据库和储存上的瓶颈。

高并发的解决方法有两种，一种是使用缓存、另一种是使用生成静态页面；

1.用分布式应用设计2、分布式缓存数据库3、代码优化。

1.不要频繁的new对象,对于在整个应用中只需要存在一个实例的类使用单例模式.对于String的连接操作,使用StringBuffer或者

StringBuilder.对于utility类型的类通过静态方法来访问。

2. 避免使用错误的方式,如Exception可以控制方法推出,但是Exception要保留stacktrace消耗性能,除非必要不要使用 instanceof做条件判

断,尽量使用比的条件判断方式.使用JAVA中效率高的类,比如ArrayList比Vector性能好。)

3、使用静态页面

补充：页面静态化

3. 集群如何同步会话状态

参考：http://blog.csdn.net/shimiso/article/details/8978922

4. 负载均衡的原理

nginx：http://baidutech.blog.51cto.com/4114344/1033718/

http://virtualadc.blog.51cto.com/3027116/615836/

5 .如果有一个特别大的访问量，到数据库上，怎么做优化(DB设计，DBIO，SQL优化，Java优化)

参考：http://blog.sina.com.cn/s/blog_8fb83eec0101cpg7.html

表的设计具体注意的问题：

1、数据行的长度不要超过8020字节，如果超过这个长度的话在物理页中这条数据会占用两行从而造成存储碎片，降低查询效率。 2、能够用数字类型的字段尽量选择数字类型而不用字符串类型的(电话号码)，这会降低查询和连接的性能，并会增加存储开销。这是因为引擎在处理查询和连接回逐个比较字符串中每一个字符，而对于数字型而言只需要比较一次就够了。

3、对于不可变字符类型char和可变字符类型varchar 都是8000字节,char查询快，但是耗存储空间，varchar查询相对慢一些但是节省存储空间。在设计字段的时候可以灵活选择，例如用户名、密码等长度变化不大的字段可以选择CHAR，对于评论等长度变化大的字段可以选择VARCHAR。

4、字段的长度在最大限度的满足可能的需要的前提下，应该尽可能的设得短一些，这样可以提高查询的效率，而且在建立索引的时候也可以减少资源的消耗。

二、查询的优化保证在实现功能的基础上，尽量减少对数据库的访问次数；通过搜索参数，尽量减少对表的访问行数,最小化结果集，从而减轻网络负担；能够分开的操作尽量分开处理，提高每次的响应速度；在数据窗口使用SQL时，尽量把使用的索引放在选择的首列；算法的结构尽量简单；在查询时，不要过多地使用通配符如SELECT * FROM T1语句，要用到几列就选择几列如：SELECT COL1,COL2 FROM T1；在可能的情况下尽量限制尽量结果集行数如：SELECT TOP 300 COL1,COL2,COL3 FROM T1,因为某些情况下用户是不需要那么多的数据的。在没有建索引的情况下，数据库查找某一条数据，就必须进行全表扫描了，对所有数据进行一次遍历，查找出符合条件的记录。在数据量比较小的情况下，也许看不出明显的差别，但是当数据量大的情况下，这种情况就是极为糟糕的了。SQL语句在SQL SERVER中是如何执行的，他们担心自己所写的SQL语句会被SQL SERVER误解。比如： select * from table1 where name='zhangsan' and tID > 10000 和执行: select * from table1 where tID > 10000 and name='zhangsan' 一些人不知道以上两条语句的执行效率是否一样，因为如果简单的从语句先后上看，这两个语句的确是不一样，如果tID是一个聚合索引，那么后一句仅仅从表的10000条以后的记录中查找就行了；而前一句则要先从全表中查找看有几个name='zhangsan'的，而后再根据限制条件条件tID>10000来提出查询结果。事实上，这样的担心是不必要的。SQL SERVER中有一个“查询分析优化器”，它可以计算出where子句中的搜索条件并确定哪个索引能缩小表扫描的搜索空间，也就是说，它能实现自动优化。虽然查询优化器可以根据where子句自动的进行查询优化，但有时查询优化器就会不按照您的本意进行快速查询。在查询分析阶段，查询优化器查看查询的每个阶段并决定限制需要扫描的数据量是否有用。如果一个阶段可以被用作一个扫描参数(SARG)，那么就称之为可优化的，并且可以利用索引快速获得所需数据。 SARG的定义：用于限制搜索的一个操作，因为它通常是指一个特定的匹配，一个值的范围内的匹配或者两个以上条件的AND连接。形式如下：列名操作符 <常数或变量> 或 <常数或变量> 操作符列名列名可以出现在操作符的一边，而常数或变量出现在操作符的另一边。如： Name=’张三’ 价格>5000 5000<价格 Name=’张三’ and 价格>5000 如果一个表达式不能满足SARG的形式，那它就无法限制搜索的范围了，也就是SQL SERVER必须对每一行都判断它是否满足WHERE子句中的所有条件。所以一个索引对于不满足SARG形式的表达式来说是无用的。所以，优化查询最重要的就是，尽量使语句符合查询优化器的规则避免全表扫描而使用索引查询。

具体要注意的：

1.应尽量避免在 where 子句中对字段进行 null 值判断，否则将导致引擎放弃使用索引而进行全表扫描，如：select id from t where num is null可以在num上设置默认值0，确保表中num列没有null值，然后这样查询：select id from t where num=0

2.应尽量避免在 where 子句中使用!=或<>操作符，否则将引擎放弃使用索引而进行全表扫描。优化器将无法通过索引来确定将要命中的行数,因此需要搜索该表的所有行。

3.应尽量避免在 where 子句中使用 or 来连接条件，否则将导致引擎放弃使用索引而进行全表扫描，如：select id from t where num=10 or num=20可以这样查询：select id from t where num=10union allselect id from t where num=20

4.in 和 not in 也要慎用，因为IN会使系统无法使用索引,而只能直接搜索表中的数据。如：select id from t where num in(1,2,3)对于连续的数值，能用 between 就不要用 in 了：select id from t where num between 1 and 3

5.尽量避免在索引过的字符数据中，使用非打头字母搜索。这也使得引擎无法利用索引。见如下例子： SELECT * FROM T1 WHERE NAME LIKE ‘%L%’ SELECT * FROM T1 WHERE SUBSTING(NAME,2,1)=’L’ SELECT * FROM T1 WHERE NAME LIKE ‘L%’ 即使NAME字段建有索引，前两个查询依然无法利用索引完成加快操作，引擎不得不对全表所有数据逐条操作来完成任务。而第三个查询能够使用索引来加快操作。

6.必要时强制查询优化器使用某个索引，如在 where 子句中使用参数，也会导致全表扫描。因为SQL只有在运行时才会解析局部变量，但优化程序不能将访问计划的选择推迟到运行时；它必须在编译时进行选择。然而，如果在编译时建立访问计划，变量的值还是未知的，因而无法作为索引选择的输入项。如下面语句将进行全表扫描：select id from t where num=@num可以改为强制查询使用索引：select id from t with(index(索引名)) where num=@num

7.应尽量避免在 where 子句中对字段进行表达式操作，这将导致引擎放弃使用索引而进行全表扫描。如：SELECT * FROM T1 WHERE F1/2=100 应改为: SELECT * FROM T1 WHERE F1=100*2

SELECT * FROM RECORD WHERE SUBSTRING(CARD_NO,1,4)=’5378’ 应改为: SELECT * FROM RECORD WHERE CARD_NO LIKE ‘5378%’

SELECT member_number, first_name, last_name FROM members WHERE DATEDIFF(yy,datofbirth,GETDATE()) > 21 应改为: SELECT member_number, first_name, last_name FROM members WHERE dateofbirth < DATEADD(yy,-21,GETDATE()) 即：任何对列的操作都将导致表扫描，它包括数据库函数、计算表达式等等，查询时要尽可能将操作移至等号右边。

8.应尽量避免在where子句中对字段进行函数操作，这将导致引擎放弃使用索引而进行全表扫描。如：select id from t where substring(name,1,3)='abc'--name以abc开头的idselect id from t where datediff(day,createdate,'2005-11-30')=0--‘2005-11-30’生成的id应改为:select id from t where name like 'abc%'select id from t where createdate>='2005-11-30' and createdate<'2005-12-1'

9.不要在 where 子句中的“=”左边进行函数、算术运算或其他表达式运算，否则系统将可能无法正确使用索引。

10.在使用索引字段作为条件时，如果该索引是复合索引，那么必须使用到该索引中的第一个字段作为条件时才能保证系统使用该索引，否则该索引将不会被使用，并且应尽可能的让字段顺序与索引顺序相一致。

11.很多时候用 exists是一个好的选择：elect num from a where num in(select num from b)用下面的语句替换：select num from a where exists(select 1 from b where num=a.num)

SELECT SUM(T1.C1)FROM T1 WHERE( (SELECT COUNT(*)FROM T2 WHERE T2.C2=T1.C2>0) SELECT SUM(T1.C1) FROM T1WHERE EXISTS( SELECT * FROM T2 WHERE T2.C2=T1.C2) 两者产生相同的结果，但是后者的效率显然要高于前者。因为后者不会产生大量锁定的表扫描或是索引扫描。

如果你想校验表里是否存在某条纪录，不要用count(*)那样效率很低，而且浪费服务器资源。可以用EXISTS代替。如： IF (SELECT COUNT(*) FROM table_name WHERE column_name = 'xxx') 可以写成： IF EXISTS (SELECT * FROM table_name WHERE column_name = 'xxx')

经常需要写一个T_SQL语句比较一个父结果集和子结果集，从而找到是否存在在父结果集中有而在子结果集中没有的记录，如： SELECT a.hdr_key FROM hdr_tbl a---- tbl a 表示tbl用别名a代替 WHERE NOT EXISTS (SELECT * FROM dtl_tbl b WHERE a.hdr_key = b.hdr_key) SELECT a.hdr_key FROM hdr_tbl a LEFT JOIN dtl_tbl b ON a.hdr_key = b.hdr_key WHERE b.hdr_key IS NULL SELECT hdr_key FROM hdr_tbl WHERE hdr_key NOT IN (SELECT hdr_key FROM dtl_tbl) 三种写法都可以得到同样正确的结果，但是效率依次降低。

12.尽量使用表变量来代替临时表。如果表变量包含大量数据，请注意索引非常有限(只有主键索引)。

13.避免频繁创建和删除临时表，以减少系统表资源的消耗。

14.临时表并不是不可使用，适当地使用它们可以使某些例程更有效，例如，当需要重复引用大型表或常用表中的某个数据集时。但是，对于一次性事件，最好使用导出表。

15.在新建临时表时，如果一次性插入数据量很大，那么可以使用 select into 代替 create table，避免造成大量 log ，以提高速度；如果数据量不大，为了缓和系统表的资源，应先create table，然后insert。

16.如果使用到了临时表，在存储过程的最后务必将所有的临时表显式删除，先 truncate table ，然后 drop table ，这样可以避免系统表的较长时间锁定。 17.在所有的存储过程和触发器的开始处设置 SET NOCOUNT ON ，在结束时设置 SET NOCOUNT OFF 。无需在执行存储过程和触发器的每个语句后向客户端发送 DONE_IN_PROC 消息。

18.尽量避免大事务操作，提高系统并发能力。

19.尽量避免向客户端返回大数据量，若数据量过大，应该考虑相应需求是否合理。 20. 避免使用不兼容的数据类型。例如float和int、char和varchar、binary和varbinary是不兼容的。数据类型的不兼容可能使优化器无法执行一些本来可以进行的优化操作。例如: SELECT name FROM employee WHERE salary > 60000 在这条语句中,如salary字段是money型的,则优化器很难对其进行优化,因为60000是个整型数。我们应当在编程时将整型转化成为钱币型,而不要等到运行时转化。

21.充分利用连接条件，在某种情况下，两个表之间可能不只一个的连接条件，这时在 WHERE 子句中将连接条件完整的写上，有可能大大提高查询速度。例： SELECT SUM(A.AMOUNT) FROM ACCOUNT A,CARD B WHERE A.CARD_NO = B.CARD_NO SELECT SUM(A.AMOUNT) FROM ACCOUNT A,CARD B WHERE A.CARD_NO = B.CARD_NO AND A.ACCOUNT_NO=B.ACCOUNT_NO 第二句将比第一句执行快得多。

22、使用视图加速查询 把表的一个子集进行排序并创建视图，有时能加速查询。它有助于避免多重排序操作，而且在其他方面还能简化优化器的工作。例如：SELECT cust.name，rcvbles.balance，……other columns FROM cust，rcvbles WHERE cust.customer_id = rcvlbes.customer_id AND rcvblls.balance>0 AND cust.postcode>“98000” ORDER BY cust.name

如果这个查询要被执行多次而不止一次，可以把所有未付款的客户找出来放在一个视图中，并按客户的名字进行排序： CREATE VIEW DBO.V_CUST_RCVLBES AS SELECT cust.name，rcvbles.balance，……other columns FROM cust，rcvbles WHERE cust.customer_id = rcvlbes.customer_id AND rcvblls.balance>0 ORDER BY cust.name 然后以下面的方式在视图中查询： SELECT ＊ FROM V_CUST_RCVLBES WHERE postcode>“98000” 视图中的行要比主表中的行少，而且物理顺序就是所要求的顺序，减少了磁盘I/O，所以查询工作量可以得到大幅减少。

23、能用DISTINCT的就不用GROUP BY SELECT OrderID FROM Details WHERE UnitPrice > 10 GROUP BY OrderID 可改为： SELECT DISTINCT OrderID FROM Details WHERE UnitPrice > 10

24.能用UNION ALL就不要用UNION UNION ALL不执行SELECT DISTINCT函数，这样就会减少很多不必要的资源 35.尽量不要用SELECT INTO语句。 SELECT INOT 语句会导致表锁定，阻止其他用户访问该表。

上面我们提到的是一些基本的提高查询速度的注意事项,但是在更多的情况下,往往需要反复试验比较不同的语句以得到最佳方案。最好的方法当然是测试，看实现相同功能的SQL语句哪个执行时间最少，但是数据库中如果数据量很少，是比较不出来的，这时可以用查看执行计划，即：把实现相同功能的多条SQL语句考到查询分析器，按CTRL+L看查所利用的索引，表扫描次数(这两个对性能影响最大)，总体上看询成本百分比即可。三、算法的优化

尽量避免使用游标，因为游标的效率较差，如果游标操作的数据超过1万行，那么就应该考虑改写。.使用基于游标的方法或临时表方法之前，应先寻找基于集的解决方案来解决问题，基于集的方法通常更有效。与临时表一样，游标并不是不可使用。对小型数据集使用 FAST_FORWARD 游标通常要优于其他逐行处理方法，尤其是在必须引用几个表才能获得所需的数据时。在结果集中包括“合计”的例程通常要比使用游标执行的速度快。如果开发时间允许，基于游标的方法和基于集的方法都可以尝试一下，看哪一种方法的效果更好。　　游标提供了对特定集合中逐行扫描的手段，一般使用游标逐行遍历数据，根据取出的数据不同条件进行不同的操作。尤其对多表和大表定义的游标(大的数据集合)循环很容易使程序进入一个漫长的等特甚至死机。　在有些场合，有时也非得使用游标，此时也可考虑将符合条件的数据行转入临时表中，再对临时表定义游标进行操作，可时性能得到明显提高。(例如：对内统计第一版)封装存储过程

四、建立高效的索引

　创建索引一般有以下两个目的：维护被索引列的唯一性和提供快速访问表中数据的策略。大型数据库有两种索引即簇索引和非簇索引，一个没有簇索引的表是按堆结构存储数据，所有的数据均添加在表的尾部，而建立了簇索引的表，其数据在物理上会按照簇索引键的顺序存储，一个表只允许有一个簇索引，因此，根据B树结构，可以理解添加任何一种索引均能提高按索引列查询的速度，但会降低插入、更新、删除操作的性能，尤其是当填充因子(Fill Factor)较大时。所以对索引较多的表进行频繁的插入、更新、删除操作，建表和索引时因设置较小的填充因子，以便在各数据页中留下较多的自由空间，减少页分割及重新组织的工作。

6. 如果出现大面积并发，在不增加服务器的基础上，如何解决服务器响应不及时问题“。

参考：http://www.cnblogs.com/zengjin93/p/5569556.html

http://www.linuxidc.com/Linux/2011-12/50536.htm

1. 提高CPU并发计算能力

多进程 & 多线程

减少进程切换

最简单的做法就是减少进程数，尽量使用线程并配合其它I/O模型来设计并发策略。

减少使用不必要的锁

服务器处理大量并发请求时，多个请求处理任务时存在一些资源抢占竞争，这时一般采用“锁”机制来控制资源的占用，当一个任务占用资源时，我们锁住资源，这时其它任务都在等待锁的释放，这个现象称为锁竞争。

进程调度器会动态调整运行队列中进程的优先级，通过top观察进程的PR值

2. 考虑减少内存分配和释放

例如Apache,在运行开始时一次申请大片的内存作为内存池，若随后需要时就在内存池中直接获取，不需要再次分配，避免了频繁的内存分配和释放引起的内存整理时间

3. 考虑使用持久连接

持久连接也为长连接，它本身是TCP通信的一种普通方式，即在一次TCP连接中持续发送多分数据而不断开连接

4. 改进I/O 模型

2. 异步I/O

异步I/O指主动请求数据后便可以继续处理其它任务，随后等待I/O操作的通知，这样进程在数据读写时不发生阻塞。

异步I/O是非阻塞的，当函数返回时，真正的I/O传输已经完成，这让CPU处理和I/O操作达到很好的重叠。

6. 改进硬件环境

7. 假如你的项目出现性能瓶颈了，你觉得可能会是哪些方面，怎么解决问题。

8. 如何查找造成性能瓶颈出现的位置，是哪个位置照成性能瓶颈。

参考：http://blog.csdn.net/beijiguangyong/article/details/17684797

9. 你的项目中使用过缓存机制吗？有没用用户非本地缓存

redis 缓存 hibernate 的session一级缓存

十二、其他

1.常用的linux下的命令

参考：http://www.jb51.net/LINUXjishu/43335.html

Java抽象类与接口的区别

2014/07/16 | 分类：基础技术 | 4 条评论 | 标签：抽象类, 接口

分享到：

本文由 ImportNew - jessenpan 翻译自 javacodegeeks。欢迎加入翻译小组。转载请见文末要求。

很多常见的面试题都会出诸如抽象类和接口有什么区别，什么情况下会使用抽象类和什么情况你会使用接口这样的问题。本文我们将仔细讨论这些话题。

在讨论它们之间的不同点之前，我们先看看抽象类、接口各自的特性。

抽象类

抽象类是用来捕捉子类的通用特性的。它不能被实例化，只能被用作子类的超类。抽象类是被用来创建继承层级里子类的模板。以JDK中的GenericServlet为例：

 
            public abstract class GenericServlet implements Servlet, ServletConfig, Serializable { 
           
                // abstract method 
           
                abstract void service(ServletRequest req, ServletResponse res); 
           
                void init() { 
           
                    // Its implementation 
           
                } 
           
                // other method related to Servlet 
           
            }

当HttpServlet类继承GenericServlet时，它提供了service方法的实现：

 
            public class HttpServlet extends GenericServlet { 
           
                void service(ServletRequest req, ServletResponse res) { 
           
                    // implementation 
           
                } 
           
                protected void doGet(HttpServletRequest req, HttpServletResponse resp) { 
           
                    // Implementation 
           
                } 
           
                protected void doPost(HttpServletRequest req, HttpServletResponse resp) { 
           
                    // Implementation 
           
                } 
           
                // some other methods related to HttpServlet 
           
            }

接口

接口是抽象方法的集合。如果一个类实现了某个接口，那么它就继承了这个接口的抽象方法。这就像契约模式，如果实现了这个接口，那么就必须确保使用这些方法。接口只是一种形式，接口自身不能做任何事情。以Externalizable接口为例：

 
            public interface Externalizable extends Serializable { 
           
                void writeExternal(ObjectOutput out) throws IOException; 
           
                void readExternal(ObjectInput in) throws IOException, ClassNotFoundException; 
           
            }

当你实现这个接口时，你就需要实现上面的两个方法：

 
            public class Employee implements Externalizable { 
           
                int employeeId; 
           
                String employeeName; 
           
                @Override 
           
                public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException { 
           
                    employeeId = in.readInt(); 
           
                    employeeName = (String) in.readObject(); 
           
                } 
           
                @Override 
           
                public void writeExternal(ObjectOutput out) throws IOException { 
           
                    out.writeInt(employeeId); 
           
                    out.writeObject(employeeName); 
           
                } 
           
            }

抽象类和接口的对比

参数	抽象类	接口
默认的方法实现	它可以有默认的方法实现	接口完全是抽象的。它根本不存在方法的实现
实现	子类使用extends关键字来继承抽象类。如果子类不是抽象类的话，它需要提供抽象类中所有声明的方法的实现。	子类使用关键字implements来实现接口。它需要提供接口中所有声明的方法的实现
构造器	抽象类可以有构造器	接口不能有构造器
与正常Java类的区别	除了你不能实例化抽象类之外，它和普通Java类没有任何区别	接口是完全不同的类型
访问修饰符	抽象方法可以有public、protected和default这些修饰符	接口方法默认修饰符是public。你不可以使用其它修饰符。
main方法	抽象方法可以有main方法并且我们可以运行它	接口没有main方法，因此我们不能运行它。
多继承	抽象方法可以继承一个类和实现多个接口	接口只可以继承一个或多个其它接口
速度	它比接口速度要快	接口是稍微有点慢的，因为它需要时间去寻找在类中实现的方法。
添加新方法	如果你往抽象类中添加新的方法，你可以给它提供默认的实现。因此你不需要改变你现在的代码。	如果你往接口中添加方法，那么你必须改变实现该接口的类。

什么时候使用抽象类和接口

如果你拥有一些方法并且想让它们中的一些有默认实现，那么使用抽象类吧。
如果你想实现多重继承，那么你必须使用接口。由于Java不支持多继承，子类不能够继承多个类，但可以实现多个接口。因此你就可以使用接口来解决它。

okbin1991

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
面试题整理 !=!=未看 *****面试题整理最全有用

1. String类为什么是final的。最佳答案：主要是为了“效率”和“安全性”的缘故。如String允许被继承，由于它的高度被实用性，可能会降低程序的性能，所有String被定义成final。2. HashMap的源码，实现原理，底层结构。参考：http://blog.csdn.net/vking_wang/article/details/1416659...
复制链接

扫一扫