自制面试宝典

一 .Java基础

1.抽象类和接口的区别

 抽象类:
    含有abstract修饰符的class即为抽象类。
    特色：
       1.不能建立的实例对象
       2.能够有抽象方法
       3.能够有构造方法，但构造方法不能是抽象的
       4.抽象方法必须子类进行实现，若是子类只实现部分方法，该子类必须是抽象的。
接口:
    含有interface修饰符的就是 。
    特色：
       1.接口中的全部方法都必须是抽象的
       2.接口中的方法定义默认为public abstract类型
       3.接口中的成员变量类型默认为public static final

区别:
    1.单继承多实现：一个类能够实现多个接口，但只能继承一个抽象类。
    2.构造方法：抽象类能够有构造方法，接口中不能有构造方法。（JDK7以前）
    3.变量：抽象类中能够有普通成员变量，接口中只有常量。
    4.方法：抽象类中能够包含非抽象的普通方法，接口中的全部方法必须都是抽象的，不能有非抽象的普通方法。
    5.修饰符：抽象类中的抽象方法能够使用public和protected进行修饰，但接口中的抽象方法只能使用public abstract修饰。
    6.静态方法：抽象类中能够包含静态方法，接口中不能包含静态方法
    7.抽象类和接口中均可以包含静态成员变量，抽象类中的静态成员变量的访问类型能够任意，但接口中定义的变量只能是public static final类型，而且默认即为public static final类型。

 

2.抽象类不能被实例化那他的构造器是用来干什么的

子类继承抽象类时，构造函数不会被覆盖。
并且，在实例化子类对象时首先调用的是抽象类中的构造函数再调用子类中的。
在这个阶段初始化抽象类字段或执行其它与子类相关的代码

 

3.经常使用的集合有哪些，谈谈对它们的理解

经常使用的集合有：
    单列集合：List、Set
    双列集合：Map

一、List（有序、可重复）
   List接口：比较经常使用的实现类是LinkedList与ArrayList+
   LinkedList：基于链表实现，(链表实现，查询慢，增删快)
   ArrayList：非线程安全的，效率高；(数组实现,查询快，增删慢)  
二、Set（无序、不能重复）
   Set接口：有两个实现类（HashSet(底层由HashMap实现)，LinkedHashSet）
   HashSet特色:哈希表数据结构,查询速度块,HashSet底层使用HashMap，仅使用key。
   LinkedHashSet继承自HashSet，LinkedHashSet中的元素顺序是能够保证的，也就是说遍历序和插入序是一致的。
三、Map（键值对、键惟1、值不惟一）
   若是要向Map集合中存放两个相同的key，后赋值给key的value的会把先赋值给key的value覆盖掉。
   Map接口：有三个实现类（HashMap，HashTable，LinkedHashMap）
   HashMap：HashMap最多只容许一条记录的键为Null;容许多条记录的值为 Null，不是线程安全的
   LinkedHashMap：LinkedHashMap简单来讲是一个有序的HashMap，其是HashMap的子类，HashMap是无序的。    
   HashTable：Hashtable既不支持Null key也不支持Null value，是线程安全的
   常见集合 描述   实现类
  
  
List   有序、可重复   LinkedList：基于链表实现，查询慢，增删快
       ArrayList：数组实现，查询快，增删慢
Set 无序、不能重复 HashSet：哈希表数据结构,查询速度块
       LinkedHashSet继承自HashSet，LinkedHashSet中的元素顺序是能够保证的，也就是说遍历序和插入序是一致的
Map 键值对、键惟1、值不惟一。
若是要向Map集合中存放两个相同的key，后赋值给key的value的会把先赋值给key的value覆盖掉。   HashMap：HashMap最多只容许一条记录的键为Null;容许多条记录的值为 Null，不是线程安全的
       LinkedHashMap：LinkedHashMap简单来讲是一个有序的HashMap，其是HashMap的子类，HashMap是无序的
       HashTable：Hashtable既不支持Null key也不支持Null value，是线程安全的
  

 

 

.Set如何保证元素惟一

HashSet保存数据底层使用的是HashMap，保存元素时，保存的值为key，而value值为null。经过计算key值的hash值，
若是hash相同，再采用equals()方法比较俩值是否相同，若是相同，则覆盖旧元素。
TreeSet：
    1.若是指定了比较器Comparator，添加元素时会调用compare(T o1, T o2)方法进行比较俩个对象是否相同；
    2.或TreeSet中保存的对象实现了Comparable接口，会使用Comparable接口的compareTo()方法判断俩个对象是否相同；相同则覆盖旧元素。
    3.若是俩种方式都没有使用，则会报错

 

4.ArrayList和LinkedList有什么区别？

1.ArrayList的底层是动态数组；LinkedList的底层是双向链表
2.增长元素：
ArrayList将元素追加至最后，ArrayList数组的默认初始大小为10，若是新增元素后大小超过数组的容量，则会对数组进行扩容，默认扩容大小为1.5倍；同时须要讲旧数组中的元素copy到新数组中
LinkedList将元素添加到链表的末尾，新增的元素做为最后一个节点
3.删除元素
ArrayList根据index删除元素，index索引上的元素被删除，index索引后的元素向前平移一个单位，所以效率不高
LinkedList根据index删除元素，改变index先后元素的指向，效率高；
4.插入元素
ArrayList在index位置上插入元素，需将原先index及日后的元素向后平移一个单位，效率不高
LinkedList在index位置插入元素，只需改变先后元素指向，效率高
5.查询
ArrayList根据index可以直接定位到元素所在位置，效率高
LinkedList查询时，须要从首个元素沿着链表进行查找，直到找到index索引处的元素，而后返回，效率不高

 

5. 如何对list集合中的数据去重

1.借助set集合
2.利用List的contains方法循环遍历

 

6.数组和链表分别适用于什么场景，为何？

1.数组:
    查询多,增删少;
    由于数组必须事先定义固定的长度(元素个数),不能适应数据动态地增减的状况,所以增删少,查询效率高; 
2.链表:
    查询少,增删多;
    由于链表动态地进行存储分配，能够适应数据动态地增减的状况,所以链表结构增删多,查询少;

 

7.HashMap的底层结构

HashMap底层数据结构为数组+链表；在JDK1.8中当链表的长度超过8时，链表会转换为红黑树；
数组的默认数组长度为16，数组的长度老是为2的幂；当数组的某一个链表的长度超出扩容条件：数组长度*负载因子(默认0.75)，如：数组长度16*0.75=12，那么当链表(JDK1.7)或红黑树(JDK1.8)大小超过12，就会进行自动扩容；

 

8.HashMap怎么将数据存在在有限的数组中

一、若是数组尚未初始化（数组长度是0），则先初始化，默认16
二、经过hash方法计算key的hash值，hash值对数组长度进行取余操做，进而计算获得应该放置到数组的位置
三、若是该位置为空，则直接放置此处
四、若是该位置不为空，并且元素是红黑树，则插入到其中
五、若是是链表，则遍历链表，若是找到相等的元素则替换，不然插入到链表尾部
六、若是链表的长度大于或等于8，则将链表转成红黑树

 

9.HashMap在JDK1.8与JDK1.7中有什么不一样

一、1.8中引入了红黑树，而1.7中没有
二、1.8中元素是插在链表的尾部，而1.7中新元素是插在链表的头部
三、扩容的时候，1.8中不会出现死循环，而1.7中容易出现死循环

 

10.HashMap和HashTable的区别

（1）HashMap是非线程安全的，HashTable是线程安全的，内部的方法基本都通过synchronized修饰。
（2）由于同步、哈希性能等缘由，性能确定是HashMap更佳，所以HashTable已被淘汰。
（3） HashMap容许有null值的存在，而在HashTable中put进的键值只要有一个null，直接抛出NullPointerException。
（4）HashMap默认初始化数组的大小为16，HashTable为11。前者扩容时乘2，使用位运算取得哈希，效率高于取模。然后者为乘2加1，都是素数和奇数，这样取模哈希结果更均匀。

 

11.方法重写和方法重载的区别

方法重写(overriding)：子类对父类的重写。
方法重载(overloading)：同一个类中重载已有的方法。

1)重写的特色：
　　一、签名一致：子类重写的方法，必须与父类的方法，返回值、方法名和参数列表都相同。
　　二、异常窄化：子类抛出的异常要么与父类方法抛出的异常相同，要么抛出的异常是父类方法异常的子类或不抛出。(优生：父类有病，子类没有病)
　　三、修饰符宽化：子类方法的的访问级别不能低于父类相应方法的访问级别(子类访问级别不能低于父类访问级别)
2)重载特色
    拥有相同的方法名，可是参数列表不一样（类型、个数、顺序）
    与返回值无关
    与参数变量名无关

 

12.throw 和 throws 的区别

throw和throws都于异常有关。
throw：用于抛出异常。由方法体内的语句处理。
throws：用于声明异常。由该方法的调用者来处理。

    throw出如今方法体中，在不一样的语句中可能有多处throw。每throw一次只能抛出一个异常。throw抛出异常后能够当即try，也能够在方法上使用throws进行声明。
    throws在方法上进行声明，表示一个方法可能出现的异常，须要方法的调用者进行处理。一个方法能够声明多个异常

 

13.描述遇到过的异常有哪些

（1）java.lang.NullPointerException 【空指针异常】
（2）java.lang.ClassNotFoundException 【类找不到异常】
（3）java.lang.NumberFormatException 【数字格式化异常】
（4）java.lang.IndexOutOfBoundsException 【数组角标越界异常】或 【数组索引越界异常】
（5）java.lang.IllegalArgumentException 【非法参数异常】
（6）java.lang.ClassCastException 【类型转换异常】数据类型转换异常
（7）java.lang.NoClassDefFoundException 【类未定义异常】
（8）SQLException 操做数据库异常 【SQL异常】
（9）java.io.IOException  【IO异常】
（10）java.lang.NoSuchMethodException 【没有匹配方法异常】

 

14.final, finally, finalize 的区别

(1)final：修饰符。
    A).被声明为final的类，不能被继承。
    B).被声明final的变量或者方法，不能被改变。
    C).被声明final的方法只能使用，不能被重载。
(2)finally：异常处理机制的一部分
    A).finally结构使代码总会执行，而无论有无无异常发生。
    B).使用finally经常使用于释放资源。
(3)finalize：Java中垃圾回收器执行的方法。
    A).它是一个方法，属于java.lang.Object类。
    B).在垃圾收集器执行的时候会调用的此方法，进行对象的回收，但在调用垃圾回收gc()后，并不能当即执行回收，JVM根据算法定时执行。

 

15.String、 StringBuffer、 StringBuilder 的区别

1.从运行速度来看：
    StringBuilder > StringBuffer > String
    String为字符串常量，而StringBuilder和StringBuffer均为字符串变量，由于String对象一旦建立以后该对象是不可更改的，只会从新赋值，
    然后二者的对象是变量，是能够更改的，因此String运行速度最慢，而StringBuilder比StringBuffer 效率高，因此StringBuilder运行速度最快，其次StringBuffer 。

2.字符修改上的区别：
    String：不可变字符串；显然访问权限  线程安全
    StringBuffer：可变字符串、效率低、线程安全；
    StringBuilder：可变字符序列、效率高、线程不安全；
3.关于单线程和多线程的推荐
    若是程序不是多线程的，那么使用StringBuilder效率高于StringBuffer。
4.总结：
    String：适用于少许的字符串操做的状况
    StringBuilder：适用于单线程下在字符缓冲区进行大量操做的状况
    StringBuffer：适用多线程下在字符缓冲区进行大量操做的状况

 

16.Java 中有几种类型的流？分别是什么？

读写操做，咱们一般称为输入/输入(IO)操做。Java经过流进行IO操做的。
Java 中的流，能够从不一样的角度进行分类。
按流的方向分：输入流和输出流。
按处理数据单位分：字节流和字符流。
按实现功能分：节点流和处理流。


1.字节流: 字节输入输出流，处理二进制数据，它是按字节来处理的
    InputStream是全部字节输入流的祖先，
    OutputStream是全部字节输出流的祖先。
2.字符流: 字符输入输出流，处理字符数据
    Reader是全部读取字符串输入流的祖先
    writer是全部输出字符串的祖先

字节高效流：
    BufferedOutputStream 、BufferedInputStream
字符高效流：
    BufferedWriter、BufferedReader
3.转换流： 将字节流转换为字符流
    OutputStreamWriter、InputStreamReader
4.缓冲流：读入/写出数据时，原理是现将数据缓冲起来，而后一块儿写入或者读取出来；下降了对文件或者其余目标频繁的操做
5.对象流：用于写入对象 的信息和读取对象的信息。 使得对象持久化。须要被持久化的类须要实现接口 Serializable

InputStream -> BufferedInputStream -> InputStreamReader ->  Reader -> BufferedReader

 

17.字节流和字符流的区别

1.字符流主要是读取文本文件内容的，能够一个字符一个字符的读取，也能够一行一行的读取文本文件内容,处理的单元为 2 个字节的 Unicode 字符，分别操做字符、字符数组或字符串。

2.而字节流读取单位为字节(byte),字节做为计算机存储最基本单位，能够用字节流来读取不少其余格式的文件，好比图片歌曲视频等等,处理单元为 1 个字节，操做字节和字节数组。

字符流（一次能够处理一个缓冲区）一次操做比字节流（一次一个字节）效率高。
只要是处理纯文本数据(只是读写文件，和文件内容无关的)，就要优先考虑使用字符流，除此以外都用字节流。
字符流的底层就是字节流(注：除了字符和字节流以外，java还有一种叫对象流。)

 

18.break 和continue 的区别？

（1）break:
      经常使用于循环中，含义：结束循环，跳出循环体
      其余应用场景：switch语句中，结束语句。
（2）continue：
       结束本次循环，进行下一次循环；（注意：若是，循环进行到最后一次，continue执行，结束本次循环， 继续进行循环逻辑判断结束循环。循环结束与continue无关）

扩展：在循环嵌套中，能够经过“循环标号”使内层循环结束外层循环，如：
out : for(......){ 
        for(...){
           break out;    //结束外层out循环
        }
    }

 

19.==与equals()的区别

1.  ==比较的是值
    1.1== 若是比较的是基本数据类型，比较的则是变量值
    1.2 == 若是比较的为引用数据类型，比较的则是地址值
2.  equals比较的是引用数据类型
    2.1若是没有重写hashCode和equals方法，比较的是地址值。由于Object的equals方法中使用是==。
    2.2若是重写hashCode和equals方法，则比较的重写后的规则。
    例如：两个String字符串比较时：比较的是内容。由于String底层重写了equals方法进行内容的比较。

 

20.说说&和&&的区别

& 位运算，求2个二进制数的与。也能够进行逻辑运算，表达式左边为false，表达式右边继续执行。
&& 逻辑运算符，表达式左边为false，整个表达式结果为false，所以表达式右边不执行。此现象称为逻辑短路。

表达式1 & 表达式2  true & true == true
表达式1 && 表达式2   false && …. == false

表达式1 || 表达式2   true || ….  == true

 

21.i++ 和 ++i 有什么区别 哪个效率高。

 1. 区别：
   i++ 是先赋值，后加减；
   ++i 是先加减，后赋值。
  2.效率：
   ++i的效率高些，++i在运算过程当中不产生临时对象，返回的就是i,是个左值，相似++i=1这样的表达式是合法的，而i++在运算的过程当中会产生临时对象，返回的是零时对象的值，是个右值,像i++=1这样的表达式是非法的
   对于内置类型，单独的i++和++i语句，如今的编译器基本上都会优化成++i,因此就没什么区别了xxxxxxxxxx java中的内存泄露的状况：长生命周期的对象持有短生命周期对象的引用就极可能发生内存泄露，尽管短生命周期对象已经再也不须要，可是由于长生命周期对象持有它的引用而致使不能被回收，这就是java中内存泄露的发生场景Java中有垃圾回收机制，它能够保证一对象再也不被引用的时候，对象将自动被垃圾回收器从内存中清除掉

 

22.讲一讲运算符：++i，i++，+=

"++i"：先自增，后赋值
"i++"：先赋值，后自增
"+="： 自身值相加 a+=b  ->  a = a+b

 

23.运算符的种类

运算符的概念:
运算符是用来进行数据 计算/运算的指令
常量和变量均可以参与运算
被运算符操做的数据又称操做数
注意:运算符通常只操做基本数据类型,不操做引用数据类型(String除外)
种类:
算术运算符、位运算符、赋值运算符、关系运算符、逻辑运算符、三目运算符、类型相关运算符

 

 

 

 

 

24. char型变量中能不能存贮一个中文汉字?为何?

    char型变量是用来存储Unicode编码的字符的，unicode编码字符集中包含了汉字，因此，char型变量中固然能够存储汉字啦。不过，若是某个特殊的汉字没有被包含在unicode编码字符集中，那么，这个char型变量中就不能存储这个特殊汉字。补充说明：unicode编码占用两个字节，因此，char类型的变量也是占用两个字节。

 

25.String s = new String("xyz");建立了几个String Object? 两者之间有什么区别？

一个或两个。
    第一次执行 new String("xyz") ，"xyz"将在字符串常量池中建立一个对象。new String() 又在堆内存中建立一个对象，因此建立了两个对象。
    执行第二个语句new String("xyz") ，"xyz"第一次已经在常量池中建立，直接使用不用再建立。每new一次都会在堆内存中建立一个对象，new String() 再次在堆内存中建立对象，因此建立了一个对象。
   
   

 

26. Collection 和 Collections的区别

collection：
    1.  单列集合的顶级父接口
Collections:
    1.  操做集合的工具类
    2.  经常使用于：集合排序、集合不可修改限制等

 

27. GC是什么? 为何要有GC?

GC是垃圾收集的意思。
    Java中没有提供手动分配内存的方式，也没有提供手动释放内存的方式。
    分配和释放所有采用自动完成。GC就用于自动回收内存

    System.gc() 或Runtime.getRuntime().gc() 。

 

28.在java中，对象何时能够被垃圾回收？

通常状况下java中对象可被回收的前提是：该对象再也不被引用。而后垃圾回收器在回收的时候便会把这个对象清理掉

 

29.Java中内存泄漏产生的缘由可能有哪些？

一、静态集合类引发内存泄漏；
二、当集合里面的对象属性被修改后，再调用remove()方法时不起做用；
三、监听器
四、各类链接
五、内部类和外部模块的引用
六、单例模式( 一、死循环   二、递归)
https://blog.csdn.net/c_royi/article/details/79527518

 

30. 经过迭代器遍历list的时候，若是想修改集合对象是否会报错，会报什么错误？如何解决这个错误

若是使用迭代器遍历，使用List提供的方法进行操做，将抛异常，异常是java.util.ConcurrentModificationException并发修改异常。
    若是使用迭代器遍历，使用迭代器提供对应方法，将不会抛异常。

 

31. float型float f=3.4是否正确?

不正确；存在编译时异常，3.4是属于Double类型的，转换为float须要强转
如：float  f = (float)3.4 或 float f = 3.4f
   
    思考：
    short s = 1,  s=s+1; 是否有错误？
    有错误，s为short类型，与int类型的1相加，s+1的返回值为int型 ，int赋值给short就会出现精准度不够的错误提示

    思考
    short s += 1; 是否有错误？
    += 计算结果就是short类型，不存在强制类型的问题。

 

32. 当一个对象被看成参数传递到一个方法后，此方法可改变这个对象的属性，并可返回变化后的结果，那么这里究竟是值传递仍是引用传递?

传递值是不会改变对象的属性的，而传递地址是会改变对象的属性的。因此上面的状况是引用传递。

 

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

数组中只有 length 属性, 不是方法, 没有后面的那对括号, 而String 类中,没有length属性, 只有方法, 也就是 length() 后面有对括号. 属性你能够当作是 数组类中的 变量, 而 length()方法能够当作是 String 类中定义好的方法

数组没有length()这个方法，只有length的属性:
String[] arr = {“1”,”2”,”3”};
System.out.println(“数组长度：”+arr.length);
String只有length()这个方法，没有length属性:
String str = “123”;
System.out.println(“字符串长度：”+str.length());

 

34. error和exception有什么区别

Error和Exception都继承自Throwable
Exception:
1．能够是可被控制(checked) 或不可控制的(unchecked)。                         2．表示一个由程序员致使的错误。                                             3．应该在应用程序级被处理。                                                                            
Error：   
1．老是不可控制的(unchecked)。                                           2．常常用来用于表示系统错误或低层资源的错误。                                 3．如何可能的话，应该在系统级被捕捉。   (一组xqy)

 

35.运行时异常与checked检查型异常有何异同？

1.检查异常 : 编译时被检测的异常，checked 异常也就是咱们常常遇到的IO异常，以及SQL异常都是这种异常。对于这种异常，JAVA编译器强制要求咱们必需对出现的这些异常进行catch。因此，面对这种异常无论咱们是否愿意，只能本身去写一大堆catch块去处理可能的异常。
2.运行时异常：编译时不被检查的异常，在程序运行的时候出现。当出现运行时异常，系统会把异常一直往上层抛，直到遇到try-catch对抛出的异常进行处理。若是异常一直没有被处理，到最上层被抛出，那么当前线程就会就退出了；若是是主程序抛出的异常，那么这整个程序也就退出了

 

36.如何自定义异常

若是想自定义检查性异常类，则须要继承 Exception 类。
若是想自定义运行时异常类，那么须要继承 RuntimeException 类。

 

37. super()与this()的区别

（1）this表明本类对应的引用。
（2）super表明父类存储空间的标识(能够理解为父类引用能够操做父类的成员)
不一样点：super从子类中调用父类的构造方法，this()在同一类内调用其它构造方法。
相同点：super()和this()都必须在构造函数的第一行进行调用，不然就是错误的

 

38.final关键字用法。

1.修饰的类不能被继承
2.修饰的方法不能被重写
3.修饰的变量是常量不能被改变
4.可是final关键字不能用来修饰构造方法：
// 缘由：final修饰普通方法，将致使子类没法重写该方法，而构造方法自己就不可以被子类重写，故若是用final修饰，如同画蛇添足

 

39.static和final关键字

static关键字为静态的
    1.用来修饰成员变量，将其变为类的成员，从而实现全部对象对于该成员的共享；
    2.用来修饰成员方法，将其变为类方法，能够直接使用“类名.方法名”的方式调用，经常使用于工具类；
    3.静态代码块，在类被加载的时候就会被执行的代码块；
final关键字
    1.用来修饰数据，包括成员变量和局部变量，该变量只能被赋值一次且它的值没法被改变。对于成员变量来说，必须在声明时或者构造方法中对它赋值；
    2.修饰方法，表示该方法没法被重写；
    3.修饰类，表示该类没法被继承。

区别：static做用于成员变量用来表示只保存一份副本，而final的做用是用来保证变量不可变

 

40.同步方法和同步代码块的区别是什么

1.同步方法使用synchronized修饰方法，在调用该方法前，须要得到内置锁（java每一个对象都有一个内置锁），不然就处于阻塞状态
代码如： public synchronized void save(){//内容}
2.同步代码块使用synchronized(object){}进行修饰，在调用该代码块时，须要得到内置锁，不然就处于阻塞状态
 代码如：
  synchronized(object){
//内容
    }

 

41. Java的堆和栈的区别?

1.  栈：Java虚拟机内存中的一片区域
  （1） 调用方法将在栈中开辟内存，称为入栈(压栈)。
  （2） 栈内存存放基本类型值和引用数据类型的地址。
  （3） 栈内存中的数据，没有默认初始化值，须要手动设置。
  （4） 方法调用完成，栈内存当即释放，称为出栈(弹栈)。

2.  堆：Java虚拟机内存中的另外一片区域。
  （1） 用于存放使用new建立的对象或数组。
  （2） 全部的对象都有内存地址值。
  （3） 数据都有默认初始化值。
  （4） 堆内存中的对象再也不被指向时，JVM启动垃圾回收机制，自动清除。

 

 

 

42.讲一讲Java内存的堆(heap)、栈(stack)和方法区(method)

1.堆：主要用于存储实例化的对象，数组。由JVM动态分配内存空间。一个JVM只有一个堆内存，线程是能够共享数据的。
2.栈：主要用于存储局部变量和对象的引用变量，每一个线程都会有一个独立的栈空间，因此线程之间是不共享数据的。
3.方法区：又叫静态区，跟堆同样，被全部的线程共享。方法区包含全部的class和static变量。方法区中包含的都是在整个程序中永远惟一的元素，如class，static变量。

 

43.for和加强for哪个遍历list集合更快，为何

1.ArrayList使用普通for循环效率更高，由于对于数组结构的数据来讲，for循环采用的是下标访问；
2.可是LinkedList是经过链表实现的，for循环时每获取第i个元素都必须从头开始遍历；foreach底层是用迭代器实现,是经过iterator实现的遍历，而iterator遍历就是从头开始遍历，遍历完只须要一次；因此使用加强for循环效率更高。
结论：for和foreach循环效率差很少，for循环稍微好一点；可是对于链表来讲，for循环效率明显比foreach低

 

44．JDK、JRE和JVM是什么

1.JDK是整个JAVA的核心，包括Java运行环境JRE，一堆Java工具和Java基础的类库。经过JDK开发人员将源文件(Java文件)编译成字节码文件(class文件) 。
2.JRE是Java运行环境，不含开发环境，即没有编译器和调试器。将class文件加载到内存准备运行
3.JVM就是java虚拟机，是java实现跨平台的最核心的部分。class文件运行整个环境。

 

45.什么是值传递和引用传递

传递基本数据类型，意味着传递了对象的一个副本。所以，就算是改变了对象副本，也不会影响源对象的值。
传递引用数据类型（对象），意味着传递的并非实际的对象，而是对象的引用（即对象的地址）。所以，外部对引用对象所作的改变会反映到全部的对象上。

 

46. 异常处理的时候，finally代码块的重要性是什么

不管是否抛出异常，finally代码块老是会被执行。就算是没有catch语句同时又抛出异常的状况下，finally代码块仍然会被执行。最后要说的是，finally代码块主要用来释放资源，好比：I/O缓冲区，数据库链接。

 

47. 代码中如何实现多态

实现多态主要有如下三种方式：
1. 接口实现
2. 继承父类重写方法
3. 同一类中进行方法重载

 

48.Java中实现多态的机制是什么？

Java中，靠的是父类或接口定义的引用变量能够指向子类或具体实现类的实例对象，而程序调用的方法在运行期才动态绑定，就是引用变量所指向的具体实例对象的方法，也就是内存里正在运行的那个对象的方法，而不是引用变量的类型中定义的方法。

 

49. switch中可否使用string作参数

在jdk 1.7以前，switch只能支持byte, short, char, int或者其对应的封装类以及Enum类型。从jdk 1.7以后switch开始支持String。

 

50. 数据类型有几种?分别是什么

1.基本数据类型：
   1.1 数值型:
        1)整数类型（byte,short,int,long）
        2)浮点类型(float,double)
    1.2 字符型(char)
    1.3 布尔型(boolean)
2.引用数据类型
    2.1类(class)
    2.2接口(interface)
    2.3数组

 

51.基本数据类型有哪些

 

 

 

52.数据类型之间的转换

1.  xxx类型转换字符串：String o = Xxx.toString( obj );
　　①.整型转换成字符型
　　String num = Integer.toString(int n);
　　②.Long型转换成字符型
　　String num = Long.toString(long n);
　　③.Short型转换成字符型
　　String num = Short.toString(Short n);
　　④.Float型转换成字符型
　　String num = Float.toString(Float n);
　　⑤.Double型转换成字符型
String num = Double.toString(Double n);

2.  String类型转换为xxx：Xxx x = Xxx.parseXxx(String s);
　　①.转换成Int型
　　int/Integer num = Integer.parseInt(String str);
　　②.转换成long型
　　Long/long num = Long.parseLong(String str);
　　③.转换成short型
　　short/Short num = Short.parseShort(String str);
　　④.转换成float型
　　float/Float num = Float.parseFloat(String str);
　　⑤.转换成double型
　　double/Double num = Double.parseDouble(String str);

 

53. 说说你对于static关键字的理解

Static能够修饰内部类、方法、变量、代码块
Static修饰的类是静态内部类
Static修饰的方法是静态方法，表示该方法属于当前类的，而不属于某个对象的，静态方法也不能被重写，能够直接使用类名来调用。在static方法中不能使用this或者super关键字。
Static修饰变量是静态变量或者叫类变量，静态变量被全部实例所共享，不会依赖于对象。静态变量在内存中只有一份拷贝，在JVM加载类的时候，只为静态分配一次内存。
Static修饰的代码块叫静态代码块，一般用来作程序优化的。静态代码块中的代码在整个类加载的时候只会执行一次。静态代码块能够有多个，若是有多个，按照前后顺序依次执行。

 

54. JAVA多态的实现原理

A.抽象的来说，多态的意思就是同一消息能够根据发送对象的不一样而采用多种不一样的行为方式。（发送消息就是函数调用）
b.实现的原理是动态绑定，程序调用的方法在运行期才动态绑定，追溯源码能够发现，JVM 经过参数的自动转型来找到合适的办法

 

55. 内部类与外部类的调用

a) 内部类能够直接调用外部类包括private的成员变量，使用外部类引用的this.关键字调用便可
b) 而外部类调用内部类须要创建内部类对象

 

56. 什么是拆装箱

拆箱：把包装类型转成基本数据类型
装箱：把基本数据类型转成包装类型

 

57. 程序的结构有那些

顺序结构
选择结构
循环结构

 

58.Object类经常使用方法有那些

Equals  Hashcode  toString  wait  notify  clone  getClass

 

59. 实例化数组后，能不能改变数组长度呢

不能，数组一旦实例化，它的长度就是固定的

 

60. 抽象类必需要有抽象方法吗

不是必须。抽象类能够没有抽象方法

 

61. 含有抽象方法的类必定是抽象类吗

含有抽象方法的类必定是抽象类

 

62. 静态变量与实例变量的区别

1.语法区别：静态变量须要static关键字修饰，实例变量不须要。
2.程序运行时的区别：静态变量从属于类，实例变量从属于对象。
3.存储区域不一样：静态变量存储在静态存储区，普通变量存储在堆中

 

63.静态方法能够直接调用非静态方法吗

不能够。由于非static是要与对象关联在一块儿的，必须建立一个后，才能够在该对象上进行方法调用，而static方法调用时不须要建立对象，能够直接使用。

 

64. Integer与int的区别

Integer是Java为int提供的封装类。Integer的默认为null。
int是Java的基本数据类型之一。int的默认为0。
Integer能够区分出未赋值和值为0的区别，int则没法表达出未赋值的状况。

 

65.静态变量和成员变量的初始化时机

静态初始化只在Class对象首次被加载的时候进行一次。
成员变量初始化，在new对象的时候被初始化，在构造函数的隐式三步其中一步进行初始化，初始化完成以后才会执行构造器中的代码

 

66. Java中this关键字的几种用法：

调用属性
（1）this能够调用本类中的任何成员变量
调用方法（可省略）
（2）this调用本类中的成员方法（在main方法里面没有办法经过this调用）
调用构造方法
（3）this调用构造方法只能在本构造方法中调用另外一个构造方法
（4）this 调用构造方法必须写在第一行

 

67. JDK在环境变量中的配置

1.首先在环境变量中建立JAVA_HOME,给其赋值为jdk的安装路径
2.而后在编辑环境变量中的path值，添加%JAVA_HOME%\bin
3.最后cmd打开命令模式，输入java -version 检查jdk环境变量是否配置成功

1.1 JAVA_HOME的做用

JAVA_HOME与java相关的系统环境变量。用于配置JDK的安装目录。

 

68.JDK5,6,7,8,9,10,11的区别(8比7的新特性)

 

 

69. 面向对象的四个基本特征

1.抽象
将一些事物的共性抽离出来归为一个类。
如对于动物，具备生命体征、活动能力等区别于其它事物的共同特征

2.封装
有选择地隐藏和暴露数据和方法
好比有U盘这个类，我但愿隐藏内部组成和实现，只暴露USB接口以供使用

3.继承
子类能够直接使用父类的部分数据和方法，能够有选择的扩展
好比鸟是动物，但鸟扩展了飞行的能力。

4.多态
同一类的对象调用相同方法能够表现出不一样的行为
好比动物实现了say()方法，猴子、马等动物重写了say()方法来表现不一样的交流语言。

 

70.为何要用封装?

在面向对象中封装是指隐藏对象的属性和实现的细节，仅对外提供公共访问方式。在类定义中用private关键字来实现封装。
封装的好处:
　1.提升了数据的安全性和模块化
    别人不可以经过 变量名.属性名 的方式来修改某个私有的成员属性

　2.提升了代码的重用性
    封装成工具类之后可以减小不少繁琐的步骤
　
　3.隐藏内部属性和实现方式
    实现过程对调用者是不可见的，只需调用方法便可，不知道具体实现过程,且保护内部状态
 
  4.操做简单
    封装后，多个调用者在使用的时候，只需调用方法便可，调用者不须要再进行判断
   
  5.增长代码的可维护性和可靠性
    一个类能够任意的改变存储数据的方式，只要仍旧使用相同的方法操做数据，那么其余
类就不知道或者介意这种变化

 

71. Java的缓冲区以及它的特性？

Java NIO中提供一种技术，是特定基本类型数据的容器。
    Buffer是缓冲区顶层抽象类，常见的子类有：ByteBuffer, CharBuffer, DoubleBuffer, FloatBuffer, IntBuffer, LongBuffer, ShortBuffer
    每一个缓冲区都是可读取的，但并不是每一个缓冲区都是可写入的。
    缓冲区常见的3个特性：容量、限制和位置。
       容量（capacity）：缓冲区可以容纳元素的最大数量。
       限制（limit）：第一个不该该读取或写入的元素的索引。
       位置（position）：下一个要读取或写入的元素的索引

 

72. Java中的访问权限有哪些

一共四种：private、default（通常省略）、public、protected

  权限         类内    同包    不一样包子类  不一样包非子类
  private       √       ×           ×         ×    
  default       √       √           ×        ×    
  protected   √       √           √        ×    
  public        √       √           √        √  

 

73. String能被继承吗？为何？

不能够，由于String类有final修饰符，而final不能被继承的

 

74. try{}里有一个return语句，那么紧跟在这个try后的finally{}里的code会不会被执行，何时被执行，在return前仍是后?

会执行，在方法返回调用者前执行

 

75.接口是否可继承接口? 抽象类是否可实现接口? 抽象类是否可继承实体类

接口能够继承接口。抽象类能够实现(implements)接口;实体类必须有明确的构造函数,抽象类才可继承实体类

 

76. 匿名内部类是否能够继承其它类，是否能够实现接口?

匿名的内部类是没有名字的内部类。不能extends(继承) 其它类，但一个内部类能够做为一个接口，由另外一个内部类实现。

 

77. 反射的用途及实现?

在运行状态中，对于任意一个类，都可以获取到这个类的全部属性和方法，对于任意一个对象，都可以调用它的任意一个方法和属性(包括私有的方法和属性)，这种动态获取的信息以及动态调用对象的方法的功能就称为java语言的反射机制。通俗点讲，经过反射，该类对咱们来讲是彻底透明的，想要获取任何东西均可以。

基本反射功能的实现　
　一、Class clazz1 = Class.forName("全限定类名");　
　二、Class clazz2  = 类名.class;　　　
　三、Class clazz3 = 类名.getClass();

 

78. java的反射机制机器运用

JAVA反射机制：
    是在运行状态中，对于任意一个实体类，都可以知道这个类的全部属性和方法；
对于任意一个对象，都可以调用它的任意方法和属性；
这种动态获取信息以及动态调用对象方法的功能称为java语言的反射机制。

反射机制的应用：
在运行时判断任意一个对象所属的类；
在运行时构造任意一个类的对象；
在运行时判断任意一个类所具备的成员变量和方法；
在运行时调用任意一个对象的方法；
生成动态代理。

 

79. while循环和do循环有什么不一样？

while结构在循环的开始判断下一个迭代是否应该继续。do/while结构在循环的结尾来判断是否将继续下一轮迭代。do结构至少会执行一次循环体。

 

80. 什么是Java虚拟机?

Java虚拟机是能移植到不一样硬件平台上的软件系统。

 

81. 型向下转换是什么?

向下转换是指由一个通用类型转换成一个具体的类型，在继承结构上向下进行。（能够理解成强转）

 

82. 全部类的父类是什么

Object

 

83. 数值提高是什么?

数值提高是指数据从一个较小的数据类型转换成为一个更大的数据类型，byte,char,short值会被转化成int类型。须要的时候int类型也可能被提高成long。long和float则有可能会被转换成double类型。

 

84. main方法的参数里面，字符串数组的第一个参数是什么?

数组是空的，没有任何元素。不像C或者C++，第一个元素默认是程序名。若是命令行没有提供任何参数的话，main方法中的String数组为空,但不是null。

 

85. 怎么判断数组是null仍是为空?

输出array.length的值，若是是0,说明数组为空。若是是null的话，会抛出空指针异常。

 

86.静态变量在何时加载？编译期仍是运行期？静态代码块加载的时机呢？

静态变量、静态代码块、静态方法都是在编译期

 

87. 一个类能拥有多个main方法吗？

能够，但只能有一个main方法拥有如下签名：
public static void main(String[] args) {}
不然程序将没法经过编译。编译器会警告你main方法已经存在。

 

88. 简单的介绍下JVM是如何工做的?

JVM是一台抽象的计算机，就像真实的计算机那样，它们会先将.java文件编译成.class文件（.class文件就是字节码文件）,而后用它的解释器来加载字节码。

 

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

　不能够。由于非static方法是要与对象关联在一块儿的，必须建立一个对象后，才能够在该对象上进行方法调用，而static方法调用时不须要建立对象，能够直接调用。因此，一个static方法内部不能够发出对非static方法的调用。

 

90. short s1 = 1; s1 = s1 + 1;有什么错? short s1 = 1; s1 += 1;有什么错?

对于short s1 = 1; s1 = s1 + 1; 因为s1+1运算时会自动提高表达式的类型，因此结果是int型，再赋值给short类型s1时，编译器将报告，须要强制转换类型的错误。对于short s1 = 1; s1 += 1;因为 += 是java语言规定的运算符，java编译器会对它进行特殊处理，所以能够正确编译。

 

91. 构造器Constructor是否可被override?

构造器Constructor不能被继承，所以不能重写Override，但能够被重载Overload。

 

92.什么是OOP?

面向对象编程

 

93. 什么是隐式转换，什么是显式转换

显示转换就是类型强转，把一个大类型的数据强制赋值给小类型的数据；隐式转换就是大范围的变量可以接受小范围的数据；隐式转换和显式转换其实就是自动类型转换和强制类型转换。

 

94. 如何将字符串反转？

Stringbuilder或者stringbuffer的reverse方法

 

95.如何将一个字符串变成int？

Integer.parseInt()

 

96. 使用Log4j对程序有影响吗

有，log4j是用来日志记录的，记录一些关键敏感的信息，一般会将日志记录到本地文件或者数据库中。记录在本地文件中，会有频繁的io操做，会耗费一些系统资源。记录在数据库中，会频繁地操做数据库表，对系统性能也有必定的影响。可是为了程序安全以及数据的恢复或者bug的跟踪，这点资源消耗是能够承受的。

 

97. Log4j日志有几个级别？

由低到高：debug、info、wran、error

 

98. 若是对象的引用被置为null，垃圾收集器是否会当即释放对象占用的内存？

不会，在下一个垃圾回收周期中，这个对象将是可被回收的。

 

99. 序列化和反序列化的含义

序列化：将java对象转换为可保持或可传输的格式，即转换为二进制字节序列（字节流）的形式的过程。
反序列化：将二进制字节序列（字节流）形式的java对象解析出来的过程。

 

100. 序列化的用途及好处

序列化能够实现数据的持久化，也就是说能够将数据永久的保存在磁盘上。
序列化能够实现远程通信，即在网络上以二进制字节序列的格式传送对象。
序列化能够将对象状态保存，方便下次取出利用。
有了序列化，两个进程就能够在网络上任性的交互数据了。

 

101. transient关键字对序列化有影响吗

被transient关键字修饰的变量再也不能被序列化，一个静态变量无论是否被transient修饰，均不能被序列化。    

 

102. 怎样实现序列化

实现Serializable接口

 

103. 在异常捕捉时，若是发生异常，那么try.catch.finally块外的return语句会执行吗？

会执行，若是有finally，在finally以后被执行，若是没有finally，在catch以后被执行

 

104. 排序算法：冒泡排序和选择排序的内容，区别与优缺点。

https://www.cnblogs.com/Good-good-stady-day-day-up/p/9055698.html

 

 

105. java中会存在内存泄漏吗，请简单描述。

java中的内存泄露的状况：长生命周期的对象持有短生命周期对象的引用就极可能发生内存泄露，尽管短生命周期对象已经再也不须要，可是由于长生命周期对象持有它的引用而致使不能被回收，这就是java中内存泄露的发生场景

Java中有垃圾回收机制，它能够保证一对象再也不被引用的时候，对象将自动被垃圾回收器从内存中清除掉

 

106.类内存泄露

1.内存泄露：是指程序在申请内存后，没法释放已申请的内存空间。
2.常发性内存泄漏：发生内存泄漏的代码被屡次执行到，每次执行都会致使一块内存泄漏。
3.偶发性内存泄漏：发生内存泄漏的代码只在某些特定环境或操做下才会发生。常发性和偶发性是相对的。对于特定的环境，偶发性的也许就变成了常发性的。
4.一次性内存泄漏：发生内存泄漏的代码只会被执行一次，或者因为算法上的缺陷，致使总会有一块且只有一块内存发生泄漏。
5.隐式内存泄漏：程序在运行过程当中不停的分配内存，可是直到结束的时候才释放内存。
一次内存泄露危害能够忽略，但内存泄露堆积后果很严重，不管多少内存,早晚会被占光，最终致使内存溢出。

 

107.克隆clone和new对象的区别

1.clone()不会调用构造方法；new会调用构造方法。
2.new 操做符的本意是分配内存。程序执行到 new 操做符时，首先去看 new 操做符后面的类型，由于知道了类型， 才能知道要分配多大的内存空间。分配完内存以后，再调用构造函数，填充对象的各个域，这一步叫作对象的初始化，构造方法返回后，一个对象建立完毕，能够把他的引用（地址）发布到外部，在外部就能够使用这个引用操纵这个对象。

clone 在第一步是和 new 类似的，都是分配内存，调用 clone 方法时，分配的内存和原对象（即调用 clone 方法的对象）相同，而后再使用原对象中对应的各个域，填充新对象的域，填充完成以后，clone 方法返回，一个新的相同的对象被建立，一样能够把这个新对象的引用发布到外部。

 

108.为何要克隆？如何实现clone

1.为何要克隆？
①方便，克隆的对象可能包含一些已经修改过的属性，而new出来的对象的属性都仍是初始化时候的值，因此当须要一个新的对象来保存当前对象的“状态”使用clone方式很方便；
②速度快，clone方法最终将调用JVM中的原生方法完成复制也就是调用底层的c++代码，因此通常使用clone方法复制对象要比新建一个对象而后逐一进行元素复制效率要高。

2.实现clone
① 实现Cloneable接口并重写Object类中的clone()方法；
② 实现Serializable接口，经过对象的序列化和反序列化实现克隆，能够实现真正的深度克隆。

对象序列化后写入流中，再从流中读取，生成新的对象，新对象和原对象之间也是彻底互不影响的。

 

109.深克隆和浅克隆的区别？

1.浅克隆：只复制基本类型的数据，引用类型的数据只复制了引用的地址，引用的对象并无复制，在新的对象中修改引用类型的数据会影响原对象中的引用。
2.深克隆：是在引用类型的类中也实现了clone，是clone的嵌套，复制后的对象与原对象之间彻底不会影响。

 

110.类和对象的关系。

一、类是对象的模版，对象是类的实例；
二、一个类能够建立N个对象，每一个对象都是独一无二的。

 

111.什么是面向对象的编程思想？实际开发中是如何应用的

OOP(object oriented programming)，即面向对象编程，其中两个最重要的概念就是类和对象
类：对现实世界事物的抽象表示，包括事物的状态信息（成员变量）和行为信息（成员方法）。
对象：对抽象事物的具体表示，使其具备自身的特色。对类进行实例化能够获得对象。

 

112.静态嵌套类(Static Nested Class)和内部类（Inner Class）的不一样？

Static Nested Class是被声明为静态（static）的内部类，它能够不依赖于外部类实例被实例化。而一般的内部类须要在外部类实例化后才能实例化

 

113.抽象的（abstract）方法是否可同时是静态的（static）,是否可同时是本地方法（native），是否可同时被synchronized修饰？

都不能。抽象方法须要子类重写，而静态的方法是没法被重写的，所以两者是矛盾的。本地方法是由本地代码（如C代码）实现的方法，而抽象方法是没有实现的，也是矛盾的。synchronized和方法的实现细节有关，抽象方法不涉及实现细节，所以也是相互矛盾的。

 

114.内部类能够引用它的包含类（外部类）的成员吗？有没有什么限制？

彻底能够。若是不是静态内部类，那没有什么限制！
若是你把静态嵌套类看成内部类的一种特例，那在这种状况下不能够访问外部类的普通成员变量，而只能访问外部类中的静态成员

 

115.什么是内省

1).内省(Introspector)是Java 语言对Bean类属性、事件的一种缺省处理方法。例如类 A 中有属性 name, 那咱们能够经过 getName,setName 来获得其值或者设置新的值。经过 getName/setName 来访问 name 属性，这就是默认的规则。
   Java 中提供了一套 API 用来访问某个属性的 getter/setter 方法，经过这些 API 能够使你不须要了解这个规则（但你最好仍是要搞清楚），这些 API 存放于包 java.beans 中。
2).直接经过属性的描述器java.beans.PropertyDescriptor类，来访问属性的getter/setter 方法;

 

116.字符串String s ="sfds55d676455dfg32434eertre"; 怎么样把非数字所有去除，只保留数字？

  String str = "sfds55d676455dfg32434eertre";

  String longStr =new String(str.replaceAll("[^\\d]+", ""));
  正则(扩展 如：s.replaceAll(“[^0-9]“,”"),这样非数字就所有去除了，只保留数字了

  System.out.println("字符串=========：" + longStr);

 

117.String s = "Hello";s = s + " world!";这两行代码执行后，原始的String对象中的内容到底变了没有？

 没有。由于String是不可变类（immutable class），不可变类

 

118.java的条件控制语句有几种？分别是什么？如何用

分支语句(if语句,switch语句);
循环语句(for,while,do...while);
跳转语句(break,continue,return)

 

119.for 使用时的注意事项?

 

 

120.list保存数据有限，若是溢出怎么办

 

 

121.在Java中，如何跳出当前的多重嵌套循环？

break

 

122.Java 中会存在内存泄漏吗，请简单描述。

java中的内存泄露的状况：长生命周期的对象持有短生命周期对象的引用就极可能发生内存泄露，尽管短生命周期对象已经再也不须要，可是由于长生命周期对象持有它的引用而致使不能被回收

 

123.Java中有没有多继承

Java的类是单继承的，即每一个类只能继承一个类。可是，Java中也有多继承，接口支持多继承，即一个接口能够继承多个接口

 

124.得到一个类的类对象有哪些方式

第一种.class获取对象 ：类型.class
Class ForClass = **.**.ClassName.class;(类在包中的路径加.class)

第二种:经过类自己来得到对象  ：对象.getClass()
Class classname = this.getClass();

第三种方式:经过类名的字符串获取对象  ：Class.forName()
Class ForName = Class.forName("**.**.ClassName");
在jdbc中经常使用到。

第四种方式:经过子类的实例获取父类的类对象，
    User cn =  new  User(); 
    Class userClass = cn.getClass(); 
    Class subUserClass = userClass.getSuperclass();

 

125.建立对象的有哪几种方式

`   1.使用new关键字
    2.使用Class类的newInstance方法
    3.使用Constructor类的newInstance方法
    4.使用Clone的方法：不管什么时候咱们调用一个对象的clone方法，JVM就会建立一个新的对象，将前面的对象的内容所有复制,返回一个新的对象，用clone方法建立对象并不会调用任何构造函数。
    5.使用反序列化：当咱们序列化和反序列化一个对象，JVM会给咱们建立一个单独的对象，在反序列化时，JVM建立对象并不会调用任何构造函数。

 

126.object类经常使用方法有哪些

    1）常见的三种方法，toString()，equals()和clone()
          a）toString()方法是将对象中的内容转换成字符串的形式
          b）equals()方法是将两个对象的内容进行比较，若是内容相同，则返回true，不然返回false
          c）clone()方法是将一个存在的对象进行克隆 
    2)  要使用Object的clone()方法，得先继承Cloneable接口，为了达到真正的克隆效果 须要对clone()方法进行重写
    3)  在使用Object类的toString()  equals()  clone()方法时，一般会对这三个函数进行重写后再使用
    4）要使用clone()方法得先继承Cloneable接口

 

 

多线程网络编程

1.什么是线程？什么是多线程？

1）什么是线程：
在一个进程中，每一个独立的功能都须要独立的去运行，这时又须要把当前这个进程划分红多个运行区域，每一个独立的小区域（小单元）称为一个线程。
例如：360杀毒软件，同时既能够安全体检电脑又能够清理电脑中的垃圾。那么这里的安全体检是360杀毒软件中的一个线程，清理电脑中的垃圾也是一个线程。
2）什么是多线程：
一个进程若是只有一条执行任务，则称为单线程程序。
一个进程若是有多条执行任务，也就是说在一个进程中，同时开启多个线程，让多个线程同时去完成某些任务（功能）。则称为多线程程序。

 

2.什么是线程安全问题

多线程环境中，且存在数据共享，一个线程访问的共享数据被其它线程修改了，那么就发生了线程安全问题；整个访问过程当中，无一共享的数据被其余线程修改，就是线程安全的

 

3.如何解决线程安全问题

1.使用线程同步机制，使得在同一时间只能由一个线程修改共享数据；
2.消除共享数据：即多个线程数据不共享或者共享的数据不作修改，将全局数据转换为局部数据；
  如在SpringMVC中，就采用的该种方式解决线程安全问题。在Controller中，service为多个线程共享的数据，可是service为单例的，且不会被修改；controller中的方法，接收请求数据方式为局部变量，多个线程不共享数据。即不会产生线程安全问题

 

4.什么是线程同步？

当有一个线程在对内存进行操做时，其余线程都不能够对这个内存地址进行操做，直到该线程完成操做， 其余线程才能对该内存地址进行操做，而其余线程又处于等待状态

 

5.线程和进程的区别？

1）进程是一个具备独立功能的程序，一个程序必须有一个进程，一个进程至少有一个线程。
2）线程是进程的一个实体 ，是进程中的一个方法功能。
举例 ： 一我的有一双手，可是有十个手指，一双手就比如是一个进程，十个手指就比如是十个线程。

 

6.建立多线程的方式

有三种方式建立多线程
(1)经过继承 Thread 类建立
(2)经过实现 Runnable 接口建立
*优先使用实现 Runnable 接口建立，由于 Java 中是单继承，一个类只有一个父类，若继承了 Thread 类，就没法在继承其它类，
     ①避免了Java单继承的局限性；
     ②把线程代码和任务的代码分离，解耦合(解除线程代码和任务的代码模块之间的依赖关系)。代码的扩展性很是好；
     ③方式二能够更方便、灵活的实现数据的共享
(3)经过实现 Callable 接口建立(不经常使用)

 

7.说出同步线程及线程调度相关的方法

1）wait()：使一个线程处于等待（阻塞）状态，而且释放所持有的对象的锁；
2）sleep(): 使一个正在运行的线程处于睡眠状态，是一个静态方法，调用此方法要处理InterruptedException 异常；
3）notify():唤醒一个处于等待状态的线程，固然在调用此方法的时候，并不能确切的唤醒某一个等待状态的线程，而是由 JVM 肯定唤醒哪一个线程，并且与优先级无关；
4）notityAll()：唤醒全部处于等待状态的线程，该方法并非将对象的锁给全部线程，而是让它们竞争，只有得到锁的线程才能进入就绪状态；
注意：java 5 经过 Lock 接口提供了显示的锁机制，Lock 接口中定义了加锁（lock（）方法）和解锁（unLock（）方法），加强了多线程编程的灵活性及对线程的协调

 

8. 启动一个线程是用run()仍是start()

启动一个线程是调用start()方法，使线程就绪状态，之后能够被调度为运行状态,能够由JVM调度并执行,但不必定会当即运行。一个线程必须关联一些具体的执行代码，run()方法是该线程所关联的执行代码。

 

9.什么是线程池，有哪些经常使用线程池？

就是事先建立若干个可执行的线程放入一个池（容器）中，须要的时候从池中获取线程
不用自行建立，使用完毕不须要销毁线程而是放回池中，从而减小建立和销毁线程对象的开
销。
经常使用线程池：
（1）newSingleThreadExecutor：建立一个单线程的线程池，此线程池保证全部任务的执行顺序按照任务的提交顺序执行。
（2）newFixedThreadPool：建立固定大小的线程池，每次提交一个任务就建立一个线程，直到线程达到线程池的最大大小。
（3）newCachedThreadPool：建立一个可缓存的线程池，此线程池不会对线程池大小作限制，线程池大小彻底依赖于操做系统（或者说 JVM）可以建立的最大线程大小。
（4）newScheduledThreadPool：建立一个大小无限的线程池，此线程池支持定时以及周期性执行任务的需求。
（5）newSingleThreadExecutor：建立一个单线程的线程池。此线程池支持定时以及周期性执行任务的需求。

 

10.什么是死锁

两个进程都在等待对方执行完毕才能继续往下执行的时候就发生了死锁。结果就是两个进程 都陷入了无限的等待中
死锁是指每一个线程都在等待被其它线程占用并堵塞了资源

例：若是线程A锁住了记录1并等待记录2，而线程B锁住了记录2并等待记录1，这样两个线程就发生了死锁现象
死锁分为2种锁：排它锁和共享锁

 

11.死锁产生的缘由有哪些？

①系统资源的竞争
一般系统中拥有的不可剥夺资源，其数量不足以知足多个进程运行的须要，使得进程在 运行过程当中，会因争夺资源而陷入僵局，如磁带机、打印机等。只有对不可剥夺资源的竞争 才可能产生死锁，对可剥夺资源的竞争是不会引发死锁的。
②进程推动顺序非法
进程在运行过程当中，请求和释放资源的顺序不当，也一样会致使死锁。例如，并发进程 P一、P2分别保持了资源R一、R2，而进程P1申请资源R2，进程P2申请资源R1时，二者都 会由于所需资源被占用而阻塞

 

12.死锁产生的必要条件？

产生死锁必须同时知足如下四个条件，只要其中任一条件不成立，死锁就不会发生。
①互斥条件(Mutual exclusion)：资源不能被共享，只能由一个进程使用。
②请求与保持条件(Hold and wait)：进程已得到了一些资源，但因请求其它资源被阻塞时，对已得到的资源保持不放。
③不可抢占条件(No pre-emption) ：有些系统资源是不可抢占的，当某个进程已得到这种资源后，系统不能强行收回，只能由进程使用完时本身释放。
④循环等待条件(Circular wait)：若干个进程造成环形链，每一个都占用对方申请的下一个资源。

 

13.如何解决死锁问题？

①加锁顺序（线程按照必定的顺序加锁，只有得到了从顺序上排在前面的锁以后，才能获取后面的锁）
②加锁时限（线程尝试获取锁的时候加上必定的时限，超过期限则放弃对该锁的请求，并释放本身占有的锁）
③死锁检测 (判断系统是否处于死锁状态)
④死锁避免(指进程在每次申请资源时判断这些操做是否安全。例如银行家算法：在分配资源以前先看清楚，资源分配后是否会致使系统死锁。若是会死锁，则不分配，不然就分配。)

 

14.如何确保 N N 个线程能够访问 N N 个资源同时又不致使死锁？

使用多线程的时候，一种很是简单的避免死锁的方式就是：指定获取锁的顺序，并强制线程按照指定的顺序获取锁。所以，若是全部的线程都是以一样的顺序加锁和释放锁，就不会出现死锁了。

 

15.什么是锁机制？及其优缺点

有些业务逻辑在执行过程当中要求对数据进行排他性的访问，因而须要经过一些机制保证在此过程当中数据被锁住不会被外界修改，这就是所谓的锁机制。
优势:保证资源同步
缺点:有等待确定会慢

 

16.乐观锁和悲观锁

悲观锁
老是假设最坏的状况，每次去拿数据的时候都认为别人会修改，因此每次在拿数据的时候都会上锁，这样别人想拿这个数据就会阻塞直到它拿到锁（共享资源每次只给一个线程使用，其它线程阻塞，用完后再把资源转让给其它线程）。传统的关系型数据库里边就用到了不少这种锁机制，好比行锁，表锁等，读锁，写锁等，都是在作操做以前先上锁。Java中synchronized和ReentrantLock等独占锁就是悲观锁思想的实现。

乐观锁
老是假设最好的状况，每次去拿数据的时候都认为别人不会修改，因此不会上锁，可是在更新的时候会判断一下在此期间别人有没有去更新这个数据。乐观锁适用于多读的应用类型，这样能够提升吞吐量。能够使用版本号机制和CAS算法实现(本身了解)


悲观锁：
悲观锁并发模式假定系统中存在足够多的数据修改操做，以至于任何肯定的读操做均可能会受到由个别的用户所制造的数据修改的影响。也就是说悲观锁假定冲突总会发生，经过独占正在被读取的数据来避免冲突。可是独占数据会致使其余进程没法修改该数据，进而产生阻塞，读数据和写数据会相互阻塞。
乐观锁：
乐观锁假定系统的数据修改只会产生很是少的冲突，也就是说任何进程都不大可能修改别的进程正在访问的数据。乐观并发模式下，读数据和写数据之间不会发生冲突，只有写数据与写数据之间会发生冲突。即读数据不会产生阻塞，只有写数据才会产生阻塞。

 

17.简述下你了解的设计模式

1、设计模式的分类（了解）
整体来讲设计模式分为三大类：
建立型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。
结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。
行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、                     状态模式、访问者模式、中介者模式、解释器模式。
2、单例模式
单例设计模式
单例模式的好处：
    1.某些类的建立比较频繁，对于一些大型的对象，这是一笔很大的开销。
    2.省去了new的操做，节省了内存的开销，减轻了GC的压力。
    3.有些状况只能用单例的设计模式，例如，一些交易核心，只能用一个对象，否则就会乱套了。
饿汉式：（线程安全的）
public class Singleton {
    // 私有的构造方法
    private Singleton(){
    }
    // 指向本身实例的私有静态引用
    private static Singleton singleton = new Singleton();
    // 以本身实例为返回值的静态的公有的方法
    public static Singleton getInstance() {
       return singleton;
    }
}

懒汉式（线程不安全）
public class Singleton {
    // 私有的构造方法
    private Singleton() {
    }
    // 不创建对象
    private static Singleton singleton = null;
    // 以本身实例为返回值的静态的公有的方法
    public static Singleton getInstance() {
       if (singleton == null) {// 先判断是否为空
           singleton = new Singleton();// 若是为空创建对象
       }
       return singleton;
    }
}
注：能够经过枚举实现单例模式的绝对单例

3、工厂模式
    1.意图：定义一个建立对象的接口，让其子类本身决定实例化哪个工厂类，工厂模式使其建立过程延迟到子类进行。
    2.主要解决：主要解决接口选择的问题。
    3.什么时候使用：咱们明确地计划不一样条件下建立不一样实例时。
    4.如何解决：让其子类实现工厂接口，返回的也是一个抽象的产品。
    5.关键代码：建立过程在其子类执行

4、适配器模式
    1.意图：将一个类的接口转换成客户但愿的另一个接口。适配器模式使得本来因为接口不兼容而不能一块儿工做的那些类能够一块儿工做。
    2.主要解决：主要解决在软件系统中，经常要将一些"现存的对象"放到新的环境中，而新环境要求的接口是现对象不能知足的。
    3.什么时候使用：
        1)系统须要使用现有的类，而此类的接口不符合系统的须要。
        2)想要创建一个能够重复使用的类，用于与一些彼此之间没有太大关联的一些类，包括一些可能在未来引进的类一块儿工做，这些源类不必定有一致的接口。
       3)经过接口转换，将一个类插入另外一个类系中。（好比老虎和飞禽，如今多了一个飞虎，在不增长实体的需求下，增长一个适配器，在里面包容一个虎对象，实现飞的接口。）
    4.如何解决：继承或依赖（推荐）。
    5.关键代码：适配器继承或依赖已有的对象，实现想要的目标接口。

 

18. sleep() 和 wait() 有什么区别

一、这两个方法来自不一样的类分别是，sleep来自Thread类，和wait来自Object类。
sleep是Thread的静态类方法，谁调用的谁去睡觉，即便在a线程里调用了b的sleep方法，实际上仍是a去睡觉，要让b线程睡觉要在b的代码中调用sleep。

 

19. 线程同步，并发操做怎么控制？

Java中可在方法名前加关键字syschronized来处理当有多个线程同时访问共享资源时候的问题。syschronized至关于一把锁，当有申请者申请该资源时，若是该资源没有被占用，那么将资源交付给这个申请者使用，在此期间，其余申请者只能申请而不能使用该资源，当该资源被使用完成后将释放该资源上的锁，其余申请者可申请使用。并发控制主要是为了多线程操做时带来的资源读写问题。若是不加以空间可能会出现死锁，读脏数据、不可重复读、丢失更新等异常。
并发操做能够经过加锁的方式进行控制，锁又可分为乐观锁和悲观锁。

 

20. 线程的生命周期

新建(New)、就绪（Runnable）、运行（Running）、阻塞(Blocked)和死亡(Dead)5种状态

 

21.TCP和UDP的区别

一、TCP（面向链接如打电话要先拨号创建链接），创建TCP链接需通过三次握手,释放TCP链接需通过四次挥手;UDP是无链接的，即发送数据以前不须要创建链接
二、TCP提供可靠的服务。也就是说，经过TCP链接传送的数据，无差错，不丢失，不重复，且按序到达;UDP尽最大努力交付，即不保证可靠交付
Tcp经过校验和，重传控制，序号标识，滑动窗口、确认应答实现可靠传输。如丢包时的重发控制，还能够对次序乱掉的分包进行顺序控制。
三、UDP具备较好的实时性，工做效率比TCP高，适用于对高速传输和实时性有较高的通讯或广播通讯。
4.每一条TCP链接只能是点到点的;UDP支持一对一，一对多，多对一和多对多的交互通讯
五、TCP对系统资源要求较多，UDP对系统资源要求较少。

 

 

二 .Java Web

1.说一说Servlet生命周期

Servlet是服务器程序，可以响应客户端请求，动态的响应给客户端web内容。

（1）加载和实例化：当Servlet容器启动或客户端发送一个请求时，Servlet容器会查找内存中是否存在该Servlet实例，若存在，则直接读取该实例响应请求；若是不存在，就建立一个Servlet实例。
（2） 初始化init()：实例化后，Servlet容器将调用Servlet的init()方法进行初始化（一些准备工做或资源预加载工做）。
（3）服务service()：初始化后，Servlet处于能响应请求的就绪状态。当接收到客户端请求时，调用service()的方法处理客户端请求，HttpServlet的service()方法会根据不一样的请求 转调doGet()/doPost()方法。
（4）销毁destroy()：当Servlet容器关闭时，Servlet实例也随时销毁。其间，Servlet容器会调用Servlet 的destroy()方法去判断该Servlet是否应当被释放（或回收资源）。

 

2.Servlet接口中有哪些方法？

init():Servlet实例化后，Servlet容器会调用init()方法来初始化该对象 service():容器调用service()方法来处理客户端的请求
destroy()：Servlet对象应该从服务中被移除的时候，容器会调用该对象的destroy()方法
getServletConfig()：ServletConfig对象包含了Servlet的初始化参数
getServletInfo()：返回一个String类型的字符串，其中包括了关于Servlet的信息

 

3.Servlet 3.0 中的异步处理指的是什么？

异步处理容许Servlet从新发起一条新线程去调用 耗时业务方法，这样就能够避免等待

 

4.Servlet中如何获取用户提交的查询参数或表单数据？

一、request.getParameterValues("参数");   //得到指定参数名的一组参数值 （String[]）
二、request.getParameter("参数");            //得到指定参数名的一个参数值（String） ，  UserServlet?username=jack , 经过username得到值jack

 

5.servlet是线程安全的吗

Servlet不是线程安全的。Servlet 默认是单例模式，在web 容器中只建立一个实例，因此多个线程同时访问servlet的时候，Servlet是线程不安全的。

 

6.什么是jsp？jsp和Servlet有什么区别？

jsp是动态web页面，其本质上就是一个Servlet，它是Servlet的一种特殊形式，咱们便可以在jsp页面中书写html、css、JavaScript等前台代码，也能够书写java代码。
Servlet是服务器程序，可以响应客户端请求，动态的响应给客户端web内容。

jsp和servlet的区别：
jsp是html页面中内嵌Java代码，侧重页面显示；Servlet是中书写Java代码，侧重逻辑控制；

mvc设计思想中jsp位于视图层，servlet位于控制层

 

 

7.JSP九大内置对象

    1.page: 当前页(this)
    2.config: 配置对象ServletConfig
    3.servletContext: servlet上下对象 
    4.request：请求对象ServletRequest
       6.session：服务器会话对象,HTTPSession
    5.response：响应对象 ServletResponse
       7.out: 输出对象 PrintWriter,response.getWriter()
    8.exception: 异常对象,记录service出现全部的错误
    9.application：PageContext jsp页面的上下文对象

request：是客户端发送到服务器的请求，包含客户端的请求信息，使用request进行数据的传递，一次请求之间的数据共享；
response：是服务器传回客户端的响应信息，使用response将服务器数据响应给客户端；
session：一次会话，其中保存着一次会话须要共享的全部数据，如SessionID、用户信息等；
pageContext：管理当前页面的数据；
application：服务器启动时建立，服务器关闭时中止，为多个应用程序保存信息
out 用来传送回应的输出
config servlet的构架部件
page JSP网页自己
exception 针对错误网页，未捕捉的例外

 

 

8.列举page指令中至少三种经常使用属性，并说明其含义

application：在全部应用程序中有效 session：在当前会话中有效 request：在当前请求中有效 page：在当前页面有效

 

9.如何实现JSP或Servlet的单线程模式？

经过page指令设置<%@ page isThreadSafe="false"%>,默认Servlet支持多线程模式

 

10.JSP中的<% %>和<% =%>有什么区别？

<% %>里边放的是java代码 <%= %> 至关于 <%out.print();%> <% %>是脚本 <%= %>是表达式

 

11.jsp中解决乱码的几种方式

    1)查看jsp文件头是否设置了编码格式：
    2)查看项目的编码格式：设置为UTF-8
    3)在请求头响应头设置编码：

    //设置编码格式
    req.setCharacterEncoding("UTF-8");
    resp.setCharacterEncoding("UTF-8");

 

12.说说你对过滤器Filter理解，以过滤器常见应用场景

1. 过滤器是Servlet中对用户请求服务器资源拦截的技术
2. 当客户端请求服务器的web资源，如：Jsp，Servlet，静态图片文件或静态HTML等时，经过Filter能够对这些请求进行拦截，在执行真正请求以前作一些通用的工做，如统一编码、统一用户认证等工做。认证成功后，过滤器执行放行动做，再执行真正的请求。
3. 应用场景：统一编码、统一用户认证、屏蔽非法文字，进行响应数据压缩，等等

 

13.说说监听器的概念和常见使用场景

1. 什么是监听器：所谓的监听器是指对WEB环境中Request、Session和ServletContext等的监听,当被监视的对象的建立、销毁或者属性发生变化时，便调用相应的方法进行处理。

2. 使用场景：网站在线人数统计、监听用户的行为(管理员踢人)，等等

3. 网站在线人数统计：使用监听器监听session的建立与销毁，当session会话被建立时，在线用户人数+1，当session会话被销毁时，在线用户人数-1

 

14.cookie是什么？session是什么？，以及它们之间的区别

Cookie是web服务器发送给浏览器的一块信息，浏览器会在本地一个文件中给每一个web服务器存储cookie。浏览器再给特定的web服务器发送请求时，同时会发送全部该服务器存储的cookie。
Session是存储在web服务器的一块信息。session对象存储特定用户会话所需的属性及配置信息。当用户在应用程序Web页面之间跳转时，存储在Session对象中的变量将不会丢失，而是在整个会话中一直存在下去。

区别：

 1.cookie存储在客户端(浏览器)，session存储在服务器端；
 2.数据量：cookie只能存储少许的数据，session能够存放大量数据(服务器内存有多大,就能存储多大的数据)
 3.在存储数据方面：session能存储任意java对象，cookie只能存储英文。
 4.从生命周期方面：
    session默认的生命周期时间间隔是30分钟（session的生命周期是间隔的，从建立时，开始计时如在30分钟，没有访问session，那么session生命周期被销毁，可是，若是在30分钟内（如在第19分钟时）访问过session，那么，将从新计算session的生命周期）；
  若是没有设置cookie的存活时间，当浏览器关闭的时候，cookie便消失了。若是设置cookie有效时间，过时后，浏览器在发送请求前，将删除对应的cookie。

 

15.session设置超时时间

session.setMaxInactiveInterval(设置时间/秒)

 

16.客户的信息存储在哪里？若是浏览器限制了cookie存储怎么办

1.提示用户不要禁用cookie；
2.使用URL重写技术解决cookie被禁用问题：https://blog.csdn.net/m0_38039437/article/details/76718541
3.使用html5的localStorage替代cookie

 

17.token和session的区别

token只是一个32位的UUID:SSSSSSSSUDUDUDUDUDUUDUDUDUD
session是浏览器与服务器的一次会话，在此次会话中包含屡次的request(请求)

 

18.什么是localStorage？

在HTML5中，新加入了一个localStorage特性，这个特性主要是用来做为本地存储来使用的，解决了cookie存储空间不足的问题(cookie中每条cookie的存储空间为4k)，localStorage中通常浏览器支持的是5M大小，这个在不一样的浏览器中localStorage会有所不一样。

 

19.Http常见状态码

 1xx（请求成功）：用于表示临时响应并须要请求者执行操做才能继续的状态代码；
 2xx：用于表示服务器已成功处理了请求的状态代码;
 3xx（请求被重定向）：一般这些状态代码是用于重定向的；
 4xx（客户端错误）：用于指出客户端的错误;
 5xx（服务器错误）：这些状态代码表示，服务器在尝试处理请求时发生内部错误

常见状态码：
 200，服务器已成功处理了请求。通常用于查询
 301/302，请求重定向
 400，请求路径语法错误
 404，请求资源不存在
 405，请求方式不正确，如：一个资源只支持GET方法，可是客户端使用PUT方法访问。
 500，服务器遇到错误，没法完成请求。

 

20.什么是URL重写？能解决什么问题？

URL 重写是拦截客户端传入 Web 请求URL，并获取其URL从新写成网站能处理的URL的过程。好比浏览器发来请求 http://blog.mocoder.com/hello.html ，服务器自动将这个请求中定向为http://blog.mocoder.com/test.do?method=hello。
URL重写的做用：
1.提供安全性：有些大网站采用不一样的技术开发不一样功能的页面。而把拓展名改掉，让黑客没法确认此页面用的技术是什么，从而就无从下手。
2.方便访问者使用。访问者不是程序员，他们不明白什么是.jsp,.php.aspx，他们只知道URL。因此统一把拓展名拿掉，或者赞成把拓展名换为html,htm，有利于用户的使用。
3.使用URL重写技术能够有效解决cookie被禁用问题。

 

21.讲一讲你对Ajax的理解

1.是什么：Ajax 是一种在无需从新加载整个网页的状况下，可以更新部分网页的技术
2.使用ajax的好处有：
    ①经过异步模式，提高了用户体验；
    ②优化了浏览器和服务器之间的传输，减小没必要要的数据往返，减小了带宽占用；
    ③Ajax引擎在客户端运行，承担了一部分原本由服务器承担的工做，从而减小了大用户量下的服务器负载
3.如何使用
    ①jQuery中发送ajax请求：$.ajax({type: "POST",url: "",data: "name=John",success: function(msg){}});
    ②Vue发送get请求：axios.get(url[,options]);发送post请求：axios.post(url,data,[options]);

 

22.什么是上下文对象？如何得到上下文对象？

ServletContext对象是上下文对象 Servlet直接调用getServletContext方法返回ServletContext对象

 

23.如何在基于Java的Web项目中实现文件上传和下载？

1.基于Servlet，在项目中加入Apache的commons-fileupload文件上传组件的相关Jar包
文件上传：修改表单请求为enctype="multipart/form-data"方式，使用文件上传解析器获取上传的文件数据；
文件下载：经过输入流读取文件，经过响应获取输出流response.getOutputStream()，经过输出流将数据响应给浏览器；
                  须要经过设置不让客户端(浏览器)解析文件，而是以附件形式打开（下载）：response.setHeader("Content-Disposition", "attachment;filename="+须要下载的文件名称);
参考文档：https://www.cnblogs.com/xdp-gacl/p/4200090.html
2.基于Spring MVC，在项目中加入Apache的commons-fileupload文件上传组件的相关Jar包，配置文件上传解析器
文件上传：修改表单请求为enctype="multipart/form-data"方式，使用MultipartFile类型接收数据并获取输入流，再写入到对应地方完成文件上传；
文件下载：经过输入流读取文件，经过响应获取输出流response.getOutputStream()，经过输出流将数据响应给浏览器；
                  通知浏览器以attachment（下载方式）下载文件：headers.setContentDispositionFormData("attachment", downloadFielName);
                  设置响应类型为application/octet-stream ： 二进制流数据（最多见的文件下载）。headers.setContentType(MediaType.APPLICATION_OCTET_STREAM);

 

24.get请求和post请求有何区别

1. 常见用法：get通常用于从服务器上获取数据，post通常用于向服务器传送数据；
2. 表现形式：请求的时候参数的位置有区别，get的参数是拼接在url后面，用户在浏览器地址栏能够看到。post是放在http包的包体中；
3. 安全性：get请求的参数直接拼接在url后面，post发送的数据对客户端是不可见的，get较post安全性低；
4. 数据大小：能提交的数据有区别，get方式能提交的数据只能是文本，且大小有限制，而post不只能够提交文本还能够二进制文件，理论上大小是没有限制的，起限制做用的是服务器的处理程序的处理能力

 

25.forward和redirect的区别

1.从地址栏表现看：
forward是服务器内部的重定向，服务器直接访问目标地址的 url网址，把里面的东西读取出来，可是客户端并不知道，所以用forward的话，客户端浏览器的网址是不会发生变化的；
redirect是客户端的重定向，是彻底的跳转。即服务器返回的一个url给客户端浏览器，而后客户端浏览器会从新发送一次请求，到新的url里面，所以浏览器中显示的url网址会发生变化；
2.从request数据共享角度看：
因为在整个定向的过程当中用的是同一个request，所以forward会将request的信息带到被重定向的jsp或者servlet中使用；
redirect是俩次请求，俩个request，数据不能共享
3.从应用层面上看(扩展)
forward通常用于相似用户登录的时候,根据角色转发到相应的模块等业务；
redirect通常用于用户注销登录时返回主页面和跳转到其它的网站等

 

 

26.比较json和xml

1. 是什么：
  json一种轻量级的数据交换格式，具备良好的可读和便于快速编写的特性。可在不一样平台之间进行数据交换。
  xml是扩展标记语言 (Extensible Markup Language, XML) ，用于标记电子文件使其具备结构性的标记语言，能够用来标记数据、定义数据类型，是一种容许用户对本身的标记语言进行定义的源语言
2. 区别：
  ①可读性：xml有不少标记性字符，json只是一个有用的数据块而缺乏一些标记字符，xml的可读性更高；
  ②数据传输：JSON相对于XML来说，数据的体积小，传递的速度更快些；
  ③数据描述：XML的语法格式统一，JSON对数据的描述性比XML较差
3. 适用场景：
  json的体积小，较少包含除有用数据外的数据，比较适合用户数据的传输：如JavaScript与后台的数据交互，各个系统之间数据传输等；
  xml的格式统一，并能够为xml文件提供约束文件，对xml数据进行预约义，适合用于标记文档，在配置文件、webService(了解)等方面具备优点；

 

27.说明json对象和json数组的定义格式

json对象：{"key":"value","key":"value",....}

JSON数组:[ obj , obj , obj , ....]

 

28.http协议底层是什么?

基于TCP的应用层协议，它不关心数据传输的细节，主要是用来规定客户端和服务端的数据传输格式，最初是用来向客户端传输HTML页面的内容

 

29.https是什么?怎么加密的?什么加密算法? 常见的加密算法(非MD5这种不可解密的)

HTTPS（全称：Hyper Text Transfer Protocol over Secure Socket Layer 或 Hypertext Transfer Protocol Secure，超文本传输安全协议），是以安全为目标的HTTP通道，简单讲是HTTP的安全版。
Https工做原理：
客户端在使用HTTPS方式与Web服务器通讯时有如下几个步骤，如图所示。
　　（1）客户使用https的URL访问Web服务器，要求与Web服务器创建SSL链接。
　　（2）Web服务器收到客户端请求后，会将网站的证书信息（证书中包含公钥）传送一份给客户端。
　　（3）客户端的浏览器与Web服务器开始协商SSL链接的安全等级，也就是信息加密的等级。
　　（4）客户端的浏览器根据双方赞成的安全等级，创建会话密钥，而后利用网站的公钥将会话密钥加密，并传送给网站。
　　（5）Web服务器利用本身的私钥解密出会话密钥。
　　（6）Web服务器利用会话密钥加密与客户端之间的通讯。
常见的加密：RC五、RC四、SHA(信息摘要算法，同MD5同样属于不可逆算法)
HTTPS协议的主要做用能够分为两种：一种是创建一个信息安全通道，来保证数据传输的安全；另外一种就是确认网站的真实性。https://www.cnblogs.com/wqhwe/p/5407468.html

 

 

 

30.http和https的区别(详细)

HTTP：是互联网上应用最为普遍的一种网络协议，是一个客户端和服务器端请求和应答的标准（TCP），用于从WWW服务器传输超文本到本地浏览器的传输协议，它能够使浏览器更加高效，使网络传输减小。
HTTPS：是以安全为目标的HTTP通道，简单讲是HTTP的安全版，即HTTP下加入SSL层，HTTPS的安全基础是SSL，所以加密的详细内容就须要SSL。
（1）对数据进行加密，并创建一个信息安全通道，来保证传输过程当中的数据安全;
（2）对网站服务器进行真实身份认证。

HTTPS协议的主要做用能够分为两种：一种是创建一个信息安全通道，来保证数据传输的安全；另外一种就是确认网站的真实性。

区别：
一、https是加密传输协议，http是名文传输协议;
二、https须要到ca申请证书且须要必定费用，而http不用;
三、https标准端口443，http标准端口80(彻底不一样的链接方式);
四、https协议是由SSL+HTTP协议构建的可进行加密传输、身份认证的网络协议，比http协议安全,而http的链接很简单，是无状态的;
五、https基于传输层，http基于应用层;
六、https比http更加安全，对搜索引擎更友好;
七、https在浏览器显示绿色安全锁，http没有显示;

连接：https://www.cnblogs.com/wudaoyongchang/p/6253451.html

 

31.http长链接和短链接?啥时候使用?为何

短连接：客户端和服务器每进行一次HTTP操做，就创建一次链接，任务结束就中断链接。
长链接：用以保持链接特性。 长链接多用于操做频繁，点对点的通信，并且链接数不能太多状况。由于用短链接频繁的通讯会形成socket错误 WEB网站的http服务通常都用短连接。由于长链接对于服务端来讲会耗费必定的资源

 

32.Css选择器的分类

每一条css样式定义由两部分组成，例： [code] 选择器{样式} [/code] 在{}以前的部分就是“选择器”。
“选择器”指明了{}中的“样式”的做用对象，也就是“样式”做用于网页中的哪些元素。

主要的Css选择器：
    标签选择器
    类选择器
    ID选择器
    全局选择器
    组合选择器
字符串匹配的属性选择符

在平常开发中最经常使用的就是标签选择器、类选择器和id选择器。

标签名选择器：能够为整个XHTML文档中的同一个标签指定相同的CSS样式。
类选择器：能够给相同的标签赋予不一样的CSS样式。
id选择器：id选择器是惟一的，只能够获取独一无二的一个元素。

 

 

三 .数据库部分

1.drop,delete与truncate的区别

三者都是删除的意思，区别
一、drop (删除表):删除表结构 (删除内容和定义,释放空间。简单来讲就是把整个表去掉.之后要新增数据是不可能的,除非新增一个表)。
二、truncate (清空表中的数据):清空表中全部的数据，速度快，不可回滚；实质是删除整张表包括数据再从新建立表,使自动增加列重置；
三、delete (删除表中的数据):逐行删除数据，每步删除都是有日志记录的，能够回滚数据；实质是逐行删除表中的数据,但自动增加列没有重置
四、执行速度上,通常来讲: drop> truncate > delete。
五、保留表而想删除全部的数据时用truncate。
6 想删除部分数据时， delete 删除时要带上where语句，回滚段要足够大
七、应用范围上，truncate 只能对table；delete 能够是table和view

 

2. 数据库三大范式介绍( 1至6范式分别是什么?)

（什么是范式：范式是符合某一种级别的关系模式的集合。关系数据库中的关系必须知足必定的要求，知足不一样程度要求的为不一样范式。）
一、第一范式（1NF）：数据表中的每一列（每一个字段）必须是不可拆分的最小单元，也就是确保每一列的原子性（原子性：指事务包含的全部操做要么所有成功，要么所有失败回滚）
二、第二范式（2NF）：知足1NF后，要求表中的全部列，都必须依赖于主键，而不能有任何一列与主键没有关系，也就是说一个表只描述一件事情；
三、 第三范式（3NF）：必须先知足第二范式（2NF），要求：表中的每一列只与主键直接相关而不是间接相关，（表中的每一列只能依赖于主键）；


第一范式（1NF）、第二范式（2NF）、第三范式（3NF）、第四范式（4NF）、第五范式（5NF）和第六范式（6NF）

 

3. 主键和外键的区别

1.  主键是能肯定一条记录的惟一标识，也是做为一个能够被外键有效引用的对象（好比，一条记录包括身份正号，姓名，年龄）
2.  外键用于与另外一张表的关联。是能肯定另外一张表记录的字段，用于保持数据的一致性

 

 

 

4. 在数据库中查询语句速度很慢，如何优化

1.建索引 （必要时创建多级索引,分析MySQL的执行计划，经过表数据统计等方式协助数据库走正确的查询方式）
2.减小表之间的关联
3.优化sql，尽可能让sql很快定位数据，不要让sql作全表查询，应该走索引,把数据 量大的表排在前面
4.简化查询字段，没用的字段不要，已经对返回结果的控制，尽可能返回少许数据
5.尽可能用PreparedStatement来查询，不要用Statement
6.  从磁盘上作文章，数据存放的在磁盘的内、外磁道上，数据获取的效率都是不同的;
七、数据库表的大字段剥离（假如一个表的字段数有100多个,学会拆分字段,保证单条记录的数据量很小）

 

5. union和union all有什么不一样

都是将两个结果集合并为一个
    1)union在进行表连接后会筛选掉重复的记录;union all不会去掉重复记录
    2)union将会按照字段的顺序进行排序;union all只是简单的将两个结果集合并后就返回
    3)union all比union快不少

 

6. order by与group by的区别

order by:
　　用来对数据库的一组数据进行排序
　　  desc：降序
　　  asc：升序
group by：
　　“By”指定的规则对数据进行分组，所谓的分组就是将一个“数据集”划分红若干个“小区域”，而后针对若干个“小区域”进行数据处理。

 

7. group by 是什么

1)根据(by)必定的规则对数据进行分组(Group)
2)就是将一个“数据集”划分红若干个“小区域”，而后针对若干个“小区域”进行数据处理。

 

8. group by 使用时的注意事项?

1)在SELECT 列表中全部未包含在聚合函数中的列都应该包含在 GROUP BY 子句中,除非对这一列使用了聚合函数(avg/sum/count..)如：有部门表和员工表，员工表根据部门id进行分组查询，那么select 不能跟*，应该跟部门id或者聚合函数
    2)不能Group By非标量基元类型的列，如不能Group By text，image或bit类型的列;
    3)进行分组前能够使用Where子句消除不知足条件的行；
    4)使用Group By子句返回的组没有特定的顺序，能够使用Order By子句指定次序。

 

9.使用distinct和分组group by 哪一个效率跟高？（实现去重效果）

1) distinct是将全部查询的字段进行对比去重，全部字段都彻底相同才会去重 distinct 必须放在查询字段开头进行查询
    2) group by 根据字段进行去重，字段相同就会去重 至于那个效率更高 这个我没有研究过

 

10. 行转列、列换行怎么转

1）使用decode函数
2）使用case when语句

 

11. 什么是PL/SQL？

PL/SQL是一种程序语言，叫作过程化SQL语言（Procedural Language/SQL）。PL/SQL是Oracle数据库对SQL语句的扩展。在普通SQL语句的使用上增长了编程语言的特色，因此PL/SQL把数据操做和查询语句组织在PL/SQL代码的过程性单元中，经过逻辑判断、循环等操做实现复杂的功能或者计算。PL/SQL 只有 Oracle 数据库有。 MySQL 目前不支持 PL/SQL 的。

 

12. 怎么去除去重

1)使用distinct关键字
2)借助group by也能够进去去重：GROUP BY [去除重复的字段名列表,....]

 

13. 数据库链接池的做用

①资源重用
      因为数据库链接获得重用，避免了频繁建立、释放链接引发的大量性能开销。在减小系统消耗的基础上，增进了系统环境的平稳性（减小内存碎片以级数据库临时进程、线程的数量）
   ②更快的系统响应速度
      数据库链接池在初始化过程当中，每每已经建立了若干数据库链接置于池内备用。此时链接池的初始化操做均已完成。对于业务请求处理而言，直接利用现有可用链接，避免了数据库链接初始化和释放过程的时间开销，从而缩减了系统总体响应时间。
   ③新的资源分配手段
      对于多应用共享同一数据库的系统而言，可在应用层经过数据库链接的配置，实现数据库链接技术。
   ④统一的链接管理，避免数据库链接泄露
     在较为完备的数据库链接池实现中，可根据预先的链接占用超时设定，强制收回被占用的链接，从而避免了常规数据库链接操做中可能出现的资源泄露

 

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

关系型数据库mysql
一、关系型数据库，是指采用了关系模型来组织数据的数据库,
2.关系型数据库的最大特色就是事务的一致性；
非关系型数据库 特性
一、使用键值对存储数据；
二、分布式；
优势
无需通过sql层的解析，读写性能很高
基于键值对，数据没有耦合性，容易扩展
存储数据的格式：nosql的存储格式是key,value形式
缺点
不支持事务
不提供sql支持

 

15. 什么是内联接、左外联接、右外联接

1)内链接：显示表之间链接匹配的全部行

2)左链接(左外链接)：以左表做为基准进行查询，左表数据会所有显示出来，条件成立，右表数据显示;条件不成立，显示null
select * from 左表
left outer join 右表 on 条件

3)右链接(右外链接)：以右表做为基准进行查询，右表数据会所有显示出来，条件成立，左表数据显示;条件不成立，显示null
在断定左表和右表时，要根据表名出如今Outer Join的左右位置关系。

 

16.列举几种表链接方式, 有什么区别？

1.交叉链接：没有where条件的交叉链接将产生链接表所涉及的笛卡尔积
2.左右外链接：左链接以左表为基表 右表为从表 基表所有展现 从表数据对应匹配条件进行展现
3.内链接：是比较运算符比较要链接的列的值的链接 不匹配的行不会被显示
4.全外链接：左表记录所有展现，右表没有则显示为null；右表记录所有展现，左表没有则显示为null

 

17. 如何在删除主表记录时，一并删除从表相关联的记录

若是两张表存在主外键关系，那么在删除主键表的记录时，若是从表有相关联的记录，那么将致使删除失败。
在定义外键约束时，能够同时指定3种删除策略：一是将从表记录一并删除（级联删除）；二是将从表记录外键字段设置为NULL；三是将从表记录外键字段设置为默认值。
级联删除示例：
alter table 从表名
add constraint 外键名
foreign key(字段名) references 主表名(字段名)
on delete cascade

 

18. SQL 约束有哪几种

NOT NULL: 用于控制字段的内容必定不能为空（NULL）。
UNIQUE: 控件字段内容不能重复，一个表容许有多个 Unique 约束。
PRIMARY KEY: 也是用于控件字段内容不能重复，但它在一个表只容许出现一个。
FOREIGN KEY: 用于预防破坏表之间链接的动做，也能防止非法数据插入外键列，由于它必须是它指向的那个表中的值之一。
CHECK: 用于控制字段的值范围。

1. 主键约束(PRIMARY KEY)：在主键上使用
2. 外键约束(FOREIGN KEY)：创建俩个表之间的关系时使用
3. 惟一约束(UNIQUE)：保证数据表中某个字段数据的惟一性时使用
4. 非空约束(NOT NULL)：须要保证数据库字段值不为空时使用
5. 自动增加列：数据值自增，须要和用在主键列上

 

19.什么样的字段适合建索引

    1)、表的主键、外键必须有索引；
    2)、数据量超过300的表应该有索引；
    3)、常常与其余表进行链接的表，在链接字段上应该创建索引；
    4)、常常出如今Where子句中的字段，特别是大表的字段，应该创建索引；
    5)、索引应该建在选择性高的字段上；
    6)、索引应该建在小字段上，对于大的文本字段甚至超长字段，不要建索引；
    7)、复合索引的创建须要进行仔细分析；尽可能考虑用单字段索引代替：

       A、正确选择复合索引中的主列字段，通常是选择性较好的字段；
       B、复合索引的几个字段是否常常同时以AND方式出如今Where子句中？单字段查询是否极少甚至没有？若是是，则能够创建复合索引；不然考虑单字段索引；
       C、若是复合索引中包含的字段常常单独出如今Where子句中，则分解为多个单字段索引；

       E、若是既有单字段索引，又有这几个字段上的复合索引，通常能够删除复合索引；

    8)、频繁进行数据操做的表，不要创建太多的索引；
    9)、删除无用的索引，避免对执行计划形成负面影响； 
    https://www.cnblogs.com/tangchuanyang/p/6013151.html

 

20.mysql查询条件里如何拼接字符串

1) concat(string1,string2,...)
       string1,string2表明字符串,concat函数在链接字符串的时候,只要其中一个是null,那么就返回null
2)concat_ws(separator,str1,str2,...)
       str1,str2表明字符串,concat_ws表明concat with separator,第一个参数是其它参数的分隔符。分隔符的位置放在要链接的两个字符串之间。分隔符能够是一个字符串，也能够是其它参数。若是分隔符为 NULL，则结果为 NULL。函数会忽略任何分隔符参数后的 NULL 值。

 

21.having是什么

    1)having关键字一般是与group by关键字联合使用
    2)用于过滤group by语句返回的结果集
    3)having关键字弥补了where关键字不能与聚合函数联合使用的不足

 

22.什么是视图?

    1)就是一种虚拟的表 ,是一个逻辑表 ,自己不包含数据,做为一个select语句存在数据字典中的
    2)经过视图 ,能够展现基表的部分数据; 视图数据来自定义视图的查询中使用的表
    3)基表: 用来建立视图的表叫作基表 base table
   
    1)视图是一种数据库对象
    2)是基于 SQL 语句的结果集的可视化的表
    3)方便操做数据库的

 

23.表和视图的关系

联系：
视图（view）是在基本表之上创建的表，它的结构（即所定义的列）和内容（即全部数据行）都来自基本表，它依据基本表存在而存在。一个视图能够对应一个基本表，也能够对应多个基本表。视图是基本表的抽象和在逻辑意义上创建的新关系。

区别：
一、视图是已经编译好的sql语句；而表不是。
二、视图没有实际的物理记录；而表有。
三、视图是窗口；表是内容
四、标致用物理空间而视图不占用物理空间，视图只是逻辑概念的存在；表能够即便对它修改，但视图只能有建立的语句来修改。
五、表是内模式，视图是外模式。
六、视图是查看数据表的一种方法，能够查询数据表中某些字段构成的数据，只是一些sql语句的集合。从安全的角度来讲，视图能够不给用户接触数据表，从而不知道表结构。
七、表属于全局模式中的表，是实表；视图属于局部模式的表，是虚表。
八、视图的创建和删除只影响视图自己，不影响对应的基本表。

---------------------------------------------------------------------
1. 视图 : 就是一种虚拟的表 ,是一个逻辑表 ,自己不包含数据,做为一个select语句存在数据字典中的
2. 经过视图 ,能够展现基表的部分数据; 视图数据来自定义视图的查询中使用的表
3. 基表: 用来建立视图的表叫作基表 base table

1.  表中保存的是数据 而视图中保存的是一个或者多个条件组合而成的结果集
2.  表是物理存在的 视图是虚拟的内存表

 

 

 

24.什么是数据库事务（Transaction)

事务是一组业务逻辑，要么所有成功，要么所有失败，一种技术（机制）。
例如，银行转帐工做：从一个帐号扣款并使另外一个帐号增款，这两个操做要么都执行，要么都不执行

 

25.事务操做

1)开启事务：程序开始时，必须先开启事务
2)提交事务：程序正常执行完成后，必须提交事务
3)回滚事务：程序发生异常后，必须回滚事务

 

26.事务特性：ACID

1)原子性：整个事务是一个总体，不可分割。
2)一致性：事务操做的先后数据保持一致（数据完整性）。
3)隔离性：两个事务同时操做并发访问问题
4)持久性：事务一旦提交，将不能再回滚。

 

27.隔离问题(事务并发访问会产生的问题)

1)脏读：一个事务读到了另外一个事务没有提交的数据。
2)不可重复读：一个事务读到了另外一个事务已经提交的数据。（要求的是一个事务中屡次读取时数据是一致的，这是事务update时引起的问题）
3)虚读(幻读)：一个事务读到了另外一个事务已经提交的数据。（要求在一个事务屡次读取的数据的数量是一致的，这是insert或delete时引起的问题）

 

28.隔离问题解决方案（隔离级别）

1)读未提交：read uncommitted，一个事务读到了另外一个事务没有提交的数据。存在3个问题。
2)读已提交：read committed，一个事务读到另外一个事务已经提交的数据。解决：脏读；存在2个问题。
3)可重复读：repeatable read，在一个事务中，读到的数据一致。解决：脏读、不可重复读；存在1个问题。
4)串行化：serializable，一个事务在操做时，另外一个事务必须等待。（单事务）。解决全部问题。

事务隔离级别                      脏读       不可重复读         幻读
读未提交（read-uncommitted）       是           是             是
读已提交（read-committed）         否           是             是
可重复读（repeatable-read）        否           否             是
串行化（serializable）             否           否             否

 

29.MySQL是怎么管理事务的

MYSQL 事务处理主要有两种方法：
一、用 BEGIN, ROLLBACK, COMMIT来实现

BEGIN 开始一个事务
ROLLBACK 事务回滚
COMMIT 事务确认
二、直接用 SET 来改变 MySQL 的自动提交模式:

SET AUTOCOMMIT=0 禁止自动提交
SET AUTOCOMMIT=1 开启自动提交

 

30.谈谈对事务的保存点理解

在事务的处理过程当中，若是发生错误而且使用rollback进行回滚，那么整个事务对数据库的操做都将被撤销，在一个庞大的事务中，这是很浪费资源的，好比事务前半部分是正确的，事务的后半部分是错误的，那么我想回滚到前半部分结束位置，这时就能够使用保存点。
事务的回滚点有什么做用？相似于单机游戏的存档和读档：
一、若是没有游戏的存档功能，每次玩单机游戏都会从第一关从新开始。
二、若是使用了游戏的存档功能，下次在玩游戏时，就会从存档处开始。关系型数据库中不存在直接多对多关系，采用将一个多对多拆分红2个一对多。
    (多对多其实就是：一对多 和 多对一 的一个组合。)
    1)  两个表若是是多对多关系，已经存在2个主表。
    2)  提供一个中间表

 

 

 

31.在关系型数据库中如何描述多对多的关系

关系型数据库中不存在直接多对多关系，采用将一个多对多拆分红2个一对多。
    (多对多其实就是：一对多 和 多对一 的一个组合。)
       1)  两个表若是是多对多关系，已经存在2个主表。
       2)  提供一个中间表

 

32.sum()和count()的区别？

1)Sum()函数里面的参数是列名的时候，是计算列名的值的相加，而不是有值项的总数
2)count()函数里面的参数是列名的的时候,那么会计算有值项的次数.（NULL 不计入， 可是''值计入）
    记录的列值为NULL时，COUNT(列名)和SUM(列名)都不计 这条记录。

 

33.count(*)和count(1)的效率哪一个更高？结果同样吗?

count(*)和count(1)无任何差异，永远优于其余count，不管加不加任何索引
       1)加索引显著快于不加索引
       2)主键索引快于普通索引
       3)没有索引时，与列含不含空值无关
同样

 

34.列举几种经常使用的聚合函数?

    1)avg()：返回指定组中的平均值，空值被忽略；
    2)count()：返回指定组中的项目个数
    3)max()：返回指定数据中的最大值；
    4)min()：返回指定数据中的最小值；
    5)sum()：返回指定数据的和，只能用于数字列，空值忽略；

 

35.什么是存储过程

什么是存储过程：存储过程能够说是一个记录集吧，它是由一些T-SQL语句组成的代码块，这些T-SQL语句代码像一个方法同样实现一些功能（对单表或多表的增删改查），而后再给这个代码块取一个名字，在用到这个功能的时候调用他就好了
小结：总之存储过程是好东西，在作项目时属于必备利器，下面介绍存储过程的基本语法。

 

36.存储过程的优缺点？

①重复使用。存储过程能够重复使用,从而能够减小数据库开发人员的工做量。 
②提升性能。存储过程在建立的时候在进行了编译,未来使用的时候再也不从新翻译。通常的SQL语句每执行一次就须要编译一次,因此使用存储过程提升了效率。 
③减小网络流量。存储过程位于服务器上,调用的时候只须要传递存储过程的名称以及参数就能够了,所以下降了网络传输的数据量。 
④安全性。参数化的存储过程能够防止SQL注入式攻击,并且能够将Grant、Deny以及Revoke权限应用于存储过程。

缺点 
1:调试麻烦,可是用PL/SQL Developer 调试很方便!弥补这个缺点。 
2:移植问题,数据库端代码固然是与数据库相关的。可是若是是作工程型项目,基本不存在移植问题。 
3:从新编译问题,由于后端代码是运行前编译的,若是带有引用关系的对象发生改变时,受影响的存储过程、包将须要从新编译(不过也能够设置成运行时刻自动编译)。 
4:若是在一个程序系统中大量的使用存储过程,到程序交付使用的时候随着用户需求的增长会致使数据结构的变化,接着就是系统的相关问题了,最后若是用户想维护该系统能够说是很难很难、并且代价是空前的,维护起来更麻烦

　总结:
　　 1. 适当的使用存储过程，可以提升咱们SQL查询的性能，
 　　2. 存储过程不该该大规模使用，滥用。
　　 3. 随着众多ORM 的出现，存储过程不少优点已经不明显。
 　　4. SQL最大的缺点仍是SQL语言自己的局限性——SQL自己是一种结构化查询语言，咱们不该该用存储过程处理复杂的业务逻辑——让SQL回归它“结构化查询语言”的功用。复杂的业务逻辑，仍是交给代码去处理吧。

 

37.超键、候选键、主键、外键分别是什么?

1)超键：在关系模式中，能惟一标识元组的属性集称为关系模式的超键。
2)候选键:若是一个属性集能惟一标识元组，且有不包含多余属性，那么这个属性集称为候选键；也即：不含有多余属性的超键称为候选键。
3)主键：关系模式中用户正在使用的候选键称主键(primary key)
4)外键：在关系模式R中，若是某属性集是其余模式的候选键，那么该属性集对模式R来讲就是外键。

 

38.数据库主键，不设置主键会怎么样

主要：可能存在彻底相同的数据,没法区分
若是设置优点：有助于提升数据的检索速度

 

39.主键和外键的区别？

1)主键是能肯定一条记录的惟一标识,也是做为一个能够被外键有效引用的对象,不能有重复的，不容许为空
2)外键用于与另外一张表的关联.是肯定另外一张表记录的字段,用于保持数据的一致性,能够有重复的, 能够是空值

 

40.数据库图形化工具的好处

1)能够直观的操做数据 查看数据，
2)能够借助图形化界面轻松完成对数据库的各类操做

 

41.你作过那些Mysql数据库优化

1)使用索引
2)使用链接（JOIN）来代替子查询(Sub-Queries)
3)选取最适用的字段属性
4)优化的查询语句
5)使用联合(UNION)来代替手动建立的临时表

 

42.在数据库中查询语句速度很慢，如何优化？

1)建索引
2)减小表之间的关联
3)优化SQL语句,尽可能让SQL很快定位数据,不让SQL作全表查询,应走索引,把数据量大的表排在前面
4)简化查询字段,只返回必要的字段
5)尽可能用PreparedStatement查询,不要用Statement
6)从磁盘上作文章,数据存放在磁盘的内,外磁道上,数据获取的效率是不一样的
7)数据库表的大字段剥离(拆分字段)

 

43.数据库怎么最快速的备份一张表

1).Sql Server 数据库
    select * into 新表名 from 原表名 Where [条件1,条件2];

2).Oracle 数据库

--建立表结构
    create table 新表名 as select * from 原表名 where 1=2;
--备份指定数据
    insert into 新表名 select * from 原表名 Where [条件1,条件2]

 

44.在数据库中你怎么把时间进行格式化

使用DATE_FORMAT(date,format) 函数
       1)date须要格式化字段名
       2)format格式

select DATE_FORMAT( updated_at, '%Y-%m-%d' ) from tb_sku;

 

45.Mysql如何自定义函数?

delimiter 自定义符号
create function 函数名(形参列表) returns 返回类型
begin 函数体
set @x = 1;
return
end
自定义符号
delimiter;


delimiter $$
create function myfun3(ia int, ib int) returns int
begin
    return ia + ib;
end
$$
delimiter;

 

46.说出char和varchar的区别，及它们的适用场景

char是一种固定长度的字符串类型，varchar是一种可变长度的字符串类型；

适用场景：
char通常用来存储长度固定字段，如：手机号，身份证号等
varchar通常用来存储不固定长度的字段：如：用户名，昵称等

 

48.数据库链接池的做用

概念：
数据库链接池是程序启动时创建足够的数据库链接，并将这些链接组成一个链接池，由程序动态地对池中的链接进行申请，使用，释放。
做用：
1.资源重用，避免了数据库链接频繁创建、关闭的开销
2.更快的系统响应速度，直接从链接池中获取链接，响应速度加快
3.控制资源的使用。若是不使用链接池，每次访问数据库都须要建立一个链接，这样系统的稳定性受系统链接需求影响很大，很容易产生资源浪费和高负载异常。链接池可以使性能最大化，将资源利用控制在必定的水平之下。链接池能控制池中的链接数量，加强了系统在大量用户应用时的稳定性。
经常使用的数据库链接池：DBCP、C3P0、Druid

池化技术(扩展)：
简单点来讲，就是提早保存大量的资源，以备不时之需。

对于线程，内存，数据库的链接对象等等，这些都是资源，程序中当建立一个线程或者在堆上申请一块内存时，都涉及到不少系统调用，也是很是消耗CPU的，若是程序须要不少相似的工做线程或者须要频繁的申请释放小块内存，若是没有在这方面进行优化，那颇有可能这部分代码将会成为影响整个程序性能的瓶颈。

池化技术主要有线程池，内存池，数据库链接池，对象池等等，

对象池就是提早建立不少对象，将用过的对象保存起来，等下一次须要这种对象的时候，再拿出来使用，使用完成以后再交还保存，使得能够被重复使用

 

49.什么是索引？

索引是一种独立于表的数据库对象，能够存储在于表不一样的磁盘中间或表空间；索引至关于字典的目录，做用在于提高查询效率，下降磁盘读写，提高数据库性能。

 

50.索引的分类

1. 直接建立索引和间接建立索引：
自动建立--------即在建立主键 primarykey 或惟一性约束 unique 的时候，数据库会自动在相应的列上建立惟一性索引
手动建立--------即在不惟一的列上建立非惟一的索引，加速查询效率
2. 普通索引和惟一性索引
3. 单一索引和复合索引
      参考：https://blog.csdn.net/csdn265/article/details/51889508
      单一索引：即在单列上创建索引
      复合索引：又叫组合索引，在索引创建语句中同时包含多列
4. 聚簇索引和非聚簇索引
    参考：https://blog.csdn.net/zc474235918/article/details/50580639

 

51.索引的优缺点

索引的优势：
1. 经过建立惟一性索引，能够保证数据库表中每一行数据的惟一性；
2. 能够大大加快数据的检索速度，这也是建立索引的最主要的缘由；

索引的缺点：
1. 建立索引和维护索引要耗费时间，这种时间随着数据量的增长而增长；
2. 索引须要占物理空间，除了数据表占数据空间以外，每个索引还要占必定的物理空间，若是要创建聚簇索引，那么须要的空间就会更大；
3. 当对表中的数据进行增长、删除和修改的时候，索引也要动态的维护，这样就下降了数据的维护速度

 

52.MySQL的数据引擎有了解吗？

MySQL 的插件式存储引擎主要包括MyISAM，Innodb，NDB Cluster，Maria，Falcon，Memory，Archive，Merge，Federated 等，其中最著名并且使用最为普遍的MyISAM 和Innodb两种存储引擎。
MyISAM拥有较高的插入、查询速度，但不支持事物；
InnoDB是事务型数据库的首选引擎，支持事务安全表（ACID），支持行锁定和外键，上图也看到了，InnoDB是默认的MySQL引擎。
两种类型最主要的差异就是Innodb 支持事务处理与外键和行级锁。
https://blog.csdn.net/zhangyuan19880606/article/details/51217952
https://blog.csdn.net/xifeijian/article/details/20316775

 

53.数据库的默认的储存引擎

MySQL默认使用InnoDB存储引擎。
InnoDB是事务型数据库的首选引擎，支持事务安全表（ACID），
其它存储引擎都是非事务安全表，支持行锁定和外键，
InnoDB主要特性

为MySQL提供了具备提交、回滚和崩溃恢复能力的事务安全（ACID兼容）存储引擎。
InnoDB锁定在行级而且也在 SELECT语句中提供一个相似Oracle的非锁定读。这些功能增长了多用户部署和性能。
在SQL查询中，能够自由地将InnoDB类型的表和其余MySQL的表类型混合起来，甚至在同一个查询中也能够混合。

 

54.Redis数据类型

Redis 能够存储键与5种不一样数据结构类型之间的映射，这5种数据结构类型分别为String（字符串）、List（列表）、Set（集合）、Hash（散列）和 Zset（有序集合）。

 

 

 

 

四 .(1)框架.MyBatis

1.Mybatis是什么?

mybatis是一个持久层ORM框架。它内部封装了jdbc，使得开发更简洁，更高效。
Mybatis使开发者只须要关注sql语句自己，简化JDBC操做，不须要在关注加载驱动、建立链接、处理SQL语句等繁杂的过程。
MyBatis能够经过xml或注解完成ORM映射关系配置。

 

2.Mybatis和JDBC的关系?

JDBC是Java提供的一个操做数据库的API； MyBatis是一个持久层ORM框架，底层是对JDBC的封装。
MyBatis对JDBC操做数据库作了一系列的优化：
（1） mybatis使用已有的链接池管理，避免浪费资源，提升程序可靠性。
（2） mybatis提供插件自动生成DAO层代码，提升编码效率和准确性。
（3）mybatis 提供了一级和二级缓存，提升了程序性能。
（4） mybatis使用动态SQL语句，提升了SQL维护。（此优点是基于XML配置）
（5） mybatis对数据库操做结果进行自动映射

 

3.什么是ORM？

ORM的全称是Object Relational Mapping，即对象关系映射。
描述的是对象和表之间的映射。操做Java对象，经过映射关系，就能够自动操做数据库。
在ORM关系中，数据库表对应Java中的类，一条记录对应一个对象，一个属性对应一个列。
常见的ORM框架：Mybatis、Hibernate

 

4.MyBatis的两种配置方式?

注解、XML

 

5.Mybatis中#{}和${}的区别是什么？

1.#{}实现的是sql语句的预处理参数，以后再sql中用?号代替，使用时不须要关注数据类型，Mybatis自动实现数据类型的转换，而且能够防止SQL注入；
2.${}实现的是sql语句的直接拼接，不作数据类型转换，须要自行判断数据类型，不能防止SQL注入；
3.在某些特定状况下必须使用${}，如：在分表存储的状况下，对哪张表的查询是不肯定的，也就是sql语句不能写死，代表是动态的，查询条件是固定的,此时代表只能使用${}方式进行字符串拼接，这样:slect * from ${tableName} where id = #{id}

总结：#{}占位符，用于参数传递; ${}用于SQL拼接

 

6.使用Mybatis过程当中当实体类中的属性名和表中的字段名不同 ，怎么解决？

1. 经过在查询的sql语句中定义字段名的别名，让字段名的别名和实体类的属性名一致
2.使用通用Mapper时，能够经过@Column注解设置
3.若是进行自定义查询，能够经过@Result进行设置
【了解】4.若是使用的xml配置，经过<resultMap>进行配置

 

7.模糊查询like语句该怎么写?

1.使用通用Mapper的Criteria进行like语句的拼凑
2.使用#{}占位符方式，参数先后拼凑%。（select * from t_user where username like #{username} ，username数据为"%jack%"）
【了解】3.使用${}字符串拼接方式，可能引起sql注入问题：select * from t_user where username like '%${username}%'

 

8.【了解】一个Xml映射文件，都会写一个Dao接口与之对应，这个Dao接口的工做原理是什么？

Dao接口的工做原理是JDK动态代理，Mybatis运行时会使用JDK动态代理为Dao接口生成代理proxy对象，代理对象proxy会拦截接口方法，转而执行接口方法所对应的MappedStatement所表明的sql，而后将sql执行结果返回。

MappedStatement解释:MappedStatement维护了一条<select|update|delete|insert>节点的封装,包括了传入参数映射配置、执行的SQL语句、结果映射配置等信息。如如下一个<select/>节点
<select id="selectAuthorLinkedHashMap" resultType="java.util.LinkedHashMap">
        select id, username from author where id = #{value}
</select>

 

9.编写了一个Dao接口，提供须要的方法，在方法添加对应的注解就能够完成对应的功能，工做原理是什么？

Dao接口在使用时，MyBatis建立接口对应的代理类。
在调用对应的方法时，执行的是代理类对应的方法。
代理类的方法进行方法上添加的注解完成增删改查对应的操做，若是是查询将结果封装到方法返回值类型声明的对象中。

 

10.使用Mybatis时Dao接口里的方法能重载吗？

不能重载的，
由于是全限定名+方法名的必须惟一。

 

11.Mybatis是如何进行分页的？

使用第三方分页助手：PageHelper
使用方式：
在将要执行查询sql语句以前使用分页助手：PageHelper.startPage(pageNum:页码, pageSize:每页显示数量);

 

12.Mybatis分页插件的原理是什么？

使用MyBatis插件（也称为拦截器）机制，对须要使用分页的功能进行加强。也就是重写SQL，根据不一样的数据库生产不一样的分页语句。
Mysql生成limit语句，Oracle借助rownum生产对应子查询语句。

 

13.Mybatis是如何将sql执行结果封装为目标对象的?

提供POJO和表之间的映射关系，查询结果就能够完成封装。
1.使用通用Mapper，须要在POJO上字段上使用@Column注解
2.若是是自定义查询，须要经过Dao接口里使用@Result注解
3.若是是xml，须要使用<resultMap>配置映射关系

 

14.Mybatis动态sql标签有那些?

动态SQL标签主要是基于XML进行配置的，在校主要学习的是注解，没有使用过XML。
不过注解也支持部分动态标签，@Select("<script> select * from user where 1=1  <if test='username != null '> and username = #{username} </if>  </script>")

 

15.【了解】Mybatis的Xml映射文件中，不一样的Xml映射文件，id是否能够重复？

不一样的Xml映射文件，若是配置了namespace，那么id能够重复；若是没有配置namespace，那么id不能重复。
MyBatis经过namespace+id来进行不一样XML标识。

 

16.Mybatis与Hibernate区别在哪里？

Hibernate是全自动的ORM框架，也就是使用hibernate不用编写任何SQL语句。关联对象直接调用对应方法，能够自动完成数据的查询。
MyBatis封装了JDBC基本操做，但仍须要编写SQL语句，也称为半自动ORM框架。使用经过Mapper能够简化MyBatis单表操做，多表仍须要本身编写SQL语句。

 

17.【了解】解释一下MyBatis中命名空间（namespace）的做用。

namespace用于标识不一样的XML配置文件。这样不一样xml文件中sql语句的id相同也不会有冲突。
注解开发没有相似要求，只要保证接口全限定名不一样便可(包+类名)

 

18.【了解】MyBatis中的动态SQL是什么意思？

在xml配置文件，根据数据的不一样，动态拼凑对应的SQL语句。
例如：
<if>用于处理条件成立时显示部分SQL语句
<where> 若是有条件就显示 where 子句，若是没有条件则不显示。

 

19.【了解】Mybatis的缓存机制

Mybatis的缓存机制分为一级缓存和二级缓存
1.一级缓存：一级缓存的做用域是sqlSession会话级，至关于JDBC的Connection链接。一级缓存默认开启，用户不能手动配置。当在同一个sqlSession中执行两次相同的sql语句时，第一次执行完毕会将数据库中查询的数据写到缓存（内存），第二次查询时会从缓存中获取数据，再也不去底层数据库查询，从而提升查询效率；
2.二级缓存：二级缓存的做用域为同一个mapper的namespace，是跨sqlSession的，同一个namespace中不一样的查询SQL能够从二级缓存中命中。二级缓存默认关闭，可是能够经过配置进行开启。
二级缓存的对象必须序列化，例如：User对象必须实现Serializable接口。

Mybatis中，执行select时，查询数据会被缓存；当执行insert、update、delete等操做的时候，缓存则会被清除

 

 

四 .(2)框架.Spring

1.什么是Spring？

Spring是一个分层的JavaSE/EEfull-stack(一站式)轻量级开源框架。
Spring为不一样的层都提供的企业级解决方案：
web层：spring mvc
service层：spring
dao层：JDBCTemplate
Spring的核心思想是IOC(控制反转)和AOP(面向切面编程)

 

2.为何要用Spring？

1.方便解耦，简化开发 （高内聚低耦合）
      Spring就是一个大工厂（容器），用于建立对象(bean)和维护对象间的依赖关系。
2.AOP编程的支持
      Spring提供面向切面编程，方便实现对程序进行权限拦截、运行监控等功能.
     声明式事务的支持 ，只须要经过配置就能够完成对事务的管理，而无需手动编程
3.方便程序的测试
      Spring对Junit4支持，能够经过注解的测试Spring程序
4.方便集成各类优秀框架
      Spring支持各类优秀框架（如：Struts、Hibernate、MyBatis、Quartz等）
5.下降JavaEE API的使用难度
      Spring 对JavaEE开发中很是难用的一些API（JDBC、JavaMail等），都提供了封装，下降这些API应用难度

 

3.Spring框架有哪些主要模块？

1.Spring Core：Spring框架的核心容器，提供了Spring框架的基本功能。这个模块中最主要的一个组件为BeanFactory,它使用工厂模式来建立所需的对象。同时BeanFactory使用IOC思想，经过读取XML文件的方式来实例化对象，即BeanFactory提供了组件生命周期的管理，组件的建立，装配以及销毁等功能;
2.Spring AOP：采用了面向切面编程的思想，使Spring框架管理的对象支持AOP，并也提供事务管理，能够不依赖具体的EJB组件，就能够将事务管理集成到应用程序中;
3.Spring Web：提供Servlet监听器的Context和Web应用的上下文。并集成一些现有的Web框架，例如Struts;
4.Spring Context：扩展核心容器，提供Spring上下文环境，给开发人员提供不少有用的服务，例如国际化,Email和JNDI访问等；
5.Spring Web MVC：提供一个构建Web应用程序的MVC的实现
6.Spring ORM：提供对现有的ORM框架的支持，例如Hibernate等；
7.Spring DAO：提供对DAO（Data Access Object,数据访问对象）模式和JDBC的支持。DAO能够实现将业务逻辑与数据库访问的代码分离，从而下降代码的耦合度。经过对JDBC的抽象，简化开发工做，并简化对异常的处理(能够很好的处理不一样数据库厂商抛出的异常);

 

4.Spring Bean有几种配置方式？

1.基于XML配置
      在XML文件中经过<bean>元素定义Bean，如：<bean class="com.czxy.UserService">
2.基于注解配置
      在Bean实现类处经过标注@Component或衍型类(@Repository、@Service及@Controller)定义Bean
3.基于Java类配置
      在标注了@Configuration的Java类中，经过在类方法上标注@Bean定义一个Bean。方法必须提供Bean的实例化逻辑

 

 

 

5.请解释Spring Bean的生命周期？

Spring Bean生命周期共分10个步骤，简述以下：
1.实例化：实例化一个Bean
2.注入：按照Spring上下文对实例化的Bean进行依赖注入
7.初始化：自动调用init-method初始化方法
//此处就是项目中使用的bean
10.销毁：当bean再也不须要时，执行销毁方法destroy-method

专业解释，参考文档以下：
https://blog.csdn.net/fuzhongmin05/article/details/73389779
https://www.jianshu.com/p/3944792a5fff

 

 

 

6.Spring Bean的做用域之间有什么区别？

1.singleton：单例，默认值，在Spring IOC容器只有一个Bean实例；
2.prototype：多例，每次从容器中得到Bean时，都返回一个新的实例；
3.request：一次请求，请求开始建立bean，请求结束销毁bean。只有在Web应用中使用Spring时，该做用域才有效
4.session：一次会话，同一个会话共享一个Bean实例，在session过时后，bean会随之失效。且只有在Web应用中使用Spring时，该做用域才有效
5.global-session：全局会话，在不一样的portlet间共享session。（Portal是一个基于Web的应用）

 

7.Spring框架中的单例Bean是线程安全的吗？

线程安全产生的缘由是，多个线程对共享数据同时进行修改。
该问题分如下俩种状况：
1.有问题：若是类中存在成员变量（即共享数据），且成员变量中的数据在方法中会被修改，此时可能会产生线程安全问题；
2.没有问题：若是Bean没有成员变量，或者成员变量数据在访问的时候不会被修改，则不会产生线程安全问题。

 

8.Spring和SpringBoot中的扫描机制

1.Spring组件扫描：
      在spring的配置类中使用@ComponentScan(basePackages = "com.czxy")能够扫描com.czxy包以及子包下添加的指定注解的类。
常见的注解有：@Component、@Service、@Controller、@Repository

2.SpringBoot扫描机制
      1）默认扫描规则，SpringBoot中会自动扫描启动类所在包及其子包中的全部添加的指定注解类
      2）使用@ComponentScan注解能够覆盖默认扫描规则。

 

9.请解释Spring Bean的自动装配？

自动装配，自动完成各个bean之间的依赖关系装配。
Spring提供了5个自动装配模式：
1.no：默认值，没有使用自动装配
2.byName 按照属性名自动装配。
3.byType 按照属性的数据类型自动装配。若是存在多个这样的bean，将抛出异常。
4.constructor 按照构造函数参数类型自动装配。
5.autodetect 自动。先constructor自动装配，若是不执行，再按照 byType 自动装配

 

10.自动装配有哪些局限性？

1. 显示的依赖注入 @Resource 会重写自动装配
2. 不能自动装配基本数据类型、字符串、数组等
3. 自动装配不如显示依赖注入精确

 

11.注解开发怎么返回集合数据

 

 

12.解释@Autowired和@Resource注解

1.
   @Autowired ： 默认是以byType按类型自动注入。
   @Autowired + @Qualifier("名称")：将按照名称自动注入
2.
   @Resource() :
        1)若是没有指定name属性:
                ① 当注解写在字段上时，默认取字段名进行按照名称注入，
                ② 若是注解写在setter方法上默认取属性名进行注入。
         2)当找不到与名称匹配的bean时才按照类型进行装配。
         3)若是指定了name属性，就只会按照名称进行装配。 @Resource(name="")  将按照名称自动注入

 

13.Spring中如何使用注解来配置Bean？有哪些相关注解？

1.在指定类中添加指定注解，配置类添加@ComponentScan注解进行包扫描，就能够完成bean的配置。
2.相关注解
  @Component 通用组件类
  @Controller 用于配置web层的controller类
  @Service  用于配置service层的service类
  @Repository 用于配置dao层dao类
  @Bean 用于配置第三方实例，只能修饰方法。

 

14.Spring不经过注入的方式怎么获取到对象？

1.经过ApplicationContext手动获取：手动加载xml或配置类得到上下文对象，经过getBean()得到指定名称的bean。
2.实现BeanFactoryAware接口：先得到BeanFactory，再getBean()得到指定名称的bean。
3.实现ApplicationContextAware 接口 ：先得到ApplicationContext，再getBean()得到指定名称的bean。

https://www.aliyun.com/jiaocheng/812869.html

 

15.介绍一下Spring的事务管理？

事务就是对一组逻辑进行操做，要么所有成功，要么所有失败
Spring经过平台事务管理器（PlatformTransactionManager）进行事务管理
事务管理器经过事务定义（TransactionDefinition）进行具体的事务操做。
事务定义经过4个方面对事务进行详细描述:
1.readOnly：是否只读
2.timeout：超时时间
3.isolationLevel：事务隔离级别，隔离级别4种：读未提交、读已提交、可重复读、串行化
4.propagationBehavior：传播行为，共7种，常见的有：必须有事务 PROPAGATION_REQUIRED、每次必须新的 PROPAGATION_REQUIRES_NEW

 

16.Spring提供了几个关于事务处理的类？

Spring事务管理高层抽象主要包括3个接口，Spring的事务主要是由他们共同完成的：
PlatformTransactionManager：事务管理器—主要用于平台相关事务的管理
TransactionDefinition： 事务定义信息(隔离、传播、超时、只读)—经过配置肯定如何进行事务管理。
TransactionStatus：事务具体运行状态—事务管理过程当中，每一个时间点事务的状态信息。

 

17.Spring什么状况下进行事务回滚？

有异常就会回滚
能够经过@Transactional(rollbackFor=Exception.class,notRollbackFor=RunTimeException.class)修改默认行为
rollbackFor用于设置那些异常将发生回滚
notRollbackFor用于设置那些异常不会发生回滚

 

18.谈谈Spring事务的隔离级别？

DEFAULT(默认)：使用后端数据库默认的隔离级别(spring中的的选择项)
READ_UNCOMMITTED(读未提交)：容许读取还未提交的改变了的数据。问题: 脏、幻、不可重复读
READ_COMMITTED(读已提交)：容许在并发事务已经提交后读取。解决: 脏读，问题: 幻读 , 不可重复读
REPEATABLE_READ(可重复读)：对相同字段的屡次读取是一致的，除非数据被事务自己改变。解决: 脏、不可重复读，问题: 幻读。
SERIALIZABLE(串行化)：彻底服从ACID的隔离级别，解决: 脏、幻、不可重复读。是隔离级别中最慢的，是典型的经过彻底锁定在事务中涉及的数据表来完成的。

 

19.什么是事务的传播行为？ 有什么做用？

事务传播行：多个事务方法相互调用时，事务如何在这些方法间传播
做用：事务的传播行为就是一个个的事务策略，根据需求、设备等条件选择对应的策略，从而完成需求或优化程序。

 

20.Spring事务控制放在service层，在service方法中一个方法调用service中的另外一个方法，默认开启几个事务？

1.只开启了一个事务，Spring默认的传播行为是PROPAGATION_REQUIRED，即若是当前存在事务，即加入该事务；若是当前没有事务，则新建一个新的事务。所以只开启了一个事务。

Spring事务的传播行为的7种类型
TransactionDefinition.PROPAGATION_REQUIRED：若是当前存在事务，则加入该事务；若是当前没有事务，则建立一个新的事务。这是默认值。
TransactionDefinition.PROPAGATION_REQUIRES_NEW：建立一个新的事务，若是当前存在事务，则把当前事务挂起。
TransactionDefinition.PROPAGATION_SUPPORTS：若是当前存在事务，则加入该事务；若是当前没有事务，则以非事务的方式继续运行。
TransactionDefinition.PROPAGATION_NOT_SUPPORTED：以非事务方式运行，若是当前存在事务，则把当前事务挂起。
TransactionDefinition.PROPAGATION_NEVER：以非事务方式运行，若是当前存在事务，则抛出异常。
TransactionDefinition.PROPAGATION_MANDATORY：若是当前存在事务，则加入该事务；若是当前没有事务，则抛出异常。
TransactionDefinition.PROPAGATION_NESTED：若是当前存在事务，则建立一个事务做为当前事务的嵌套事务来运行；若是当前没有事务，则该取值等价于TransactionDefinition.PROPAGATION_REQUIRED。

 

21.什么是控制反转(IOC)？

IOC：Inversion of Control，即“控制反转”，不是什么技术，而是一种设计思想。IOC意味着将你设计好的对象交给容器控制，而不是new。
IOC 控制反转，指将对象的建立权，反转到Spring容器

 

22.什么是Spring IOC容器？

IOC容器是具备依赖注入功能的容器，负责实例化、定位、配置应用程序中的对象及创建这些对象间的依赖。应用程序无需直接在代码中new相关的对象，应用程序由IOC容器进行组装。在Spring中BeanFactory是IOC容器的实际表明者。

 

23.IOC的优势是什么？

1.减小代码的耦合，能够使应用更加模块化
2.增长代码的复用率
3.资源更加统一管理
4.维护代码更加方便，通常只须要修改一下配置文件就ok了。
5.提高了程序的测试性
连接：https://www.imooc.com/article/35099

 

24.什么是依赖注入(DI)？

DI：Dependency Injection 依赖注入，在Spring框架建立Bean对象时，动态的将依赖对象注入到Bean组件

 

25.DI是怎么实现的？

1.实例化Bean对象：服务器启动时，初始化spring容器，建立由XML配置或添加了相应注解的类的实例，并将实例保存到Spring容器中；
2.完成ID操做：经过XML描述或对应注解，完成对象之间的依赖关系，此过程称为依赖注入，spring支持3种注入实现：
        ①注解注入：经过注解显示注入。经常使用注解@Resource。
        ②XML注入：经过xml显示注入。
        ③自动注入：隐式进行bean搜索并自动装配

 

26.IOC和DI的关系

IOC 控制反转，指将对象的建立权，反转到Spring容器 ，
DI 依赖注入，指Spring建立对象的过程当中，将对象依赖属性经过配置进行注入
DI依赖注入不能单独存在，必须在IOC控制反转的基础上才能完成。

 

27.如何在Web项目中配置Spring IOC容器？

在web项目中配置Spring的IOC容器其实就是建立web应用的上下文(WebApplicationContext)
1.若是使用Spring Boot，默认扫描启动类所在包以及子包，启动完成上下文对象建立。
2.使用注解的普通web项目，须要在配置类中使用@ComponentScan肯定扫描包位置，启动完成上下文对象建立。
3.使用xml的普通web项目，须要在web.xml配置初始化参数肯定xml文件位置，从而肯定加载的内容，启动完成上下文对象建立。

参考：
http://www.cnblogs.com/qf123/p/8488404.html

 

28.Spring框架中都用到了哪些设计模式？

1.单例设计模式：
    Spring中Bean默认是单例的，底层采用的是单例设计模式；
2.工厂模式：
    BeanFactory，做用就是配置、新建、管理 各类Bean
3.代理模式：
    代理模式的定义是为其它对象提供一种代理，以控制这个对象的访问；在Spring AOP中就使用了代理模式，使用代理模式完成在不修改代码的状况下，实现对功能的加强；
4.适配器模式：
    将一个类的接口变换成客户所期待的另外一种接口，从而使本来不匹配而没法一块儿工做的俩个类可以在一块儿工做；SpringMVC中的适配器HandlerAdatper，HandlerAdatper根据不一样的handler规则执行不一样的handler；
5.模板方法模式：
    父类定义了骨架（调用哪些方法及顺序），某些特定方法由子类实现；在Spring的 JdbcTemplate，RestTemplate, JmsTemplate等地方使用了模板方法模式；
连接：https://blog.csdn.net/z69183787/article/details/65628166；

 

29.Spring的拦截如何实现？

 

 

30.什么是AOP？

AOP (Aspect Oriented Programing) 称为：面向切面编程，它是一种编程思想。在程序运行的时候，动态地将代码切入到类的指定方法、指定位置上的编程思想就是面向切面的编程。

基于代理思想，对原来目标对象，建立代理对象，在不修改原对象代码状况下，对原有业务方法进行加强 ！

 

31.AOP和代理模式

代理模式：分为静态代理、JDK动态代理、cglib代理
1.静态代理
代理类和被代理类实现共同的接口（或继承），代理类中存有指向被代理类的引用，实际执行时经过调用代理类的方法、实际执行的是被代理类的方法。
2.jdk动态代理：必须有接口和实现类（目标类），经过工具类Proxy生产接口对应的代理类，从而对目标类进行加强。
3.Cglib代理：Cglib代理生成的代理类是目标类的子类，因此目标类不能使用final修饰。

AOP
Spring AOP经过代理的方式，对目标类进行加强。
Spring AOP底层默认使用JDK动态代理，经过配置能够修改为cglib代理。

 

 

 

32.说说你对切面的理解？

描述切面必须先了解如下几个概念：
1.目标类：须要被加强的类。
2.链接点：可能被加强的点，目标类中的全部方法。
3.切入点：将会被加强的链接点，目标类中被加强的方法。
4.通知/加强：对切入点加强的内容。加强的内容一般以方法的形式体现的。加强执行的位置不一样，称呼不一样。
  （前置通知、后置通知、环绕通知、抛出异常通知、最终通知）
   通知方法所在的类，一般称为切面类。
5.切面：通知和切入点的结合。一个通知对应一个切入点就造成一条线，多个通知对应多个切入点造成多条线，多条线造成了一个面，称为切面。

 

33.Spring AOP中什么是通知？

通知：对切入点加强的内容。加强的内容一般以方法的形式体现的。
在spring中根据加强执行位置的不一样，将通知分红如下5种：
1.前置通知（before）：在一个方法执行前被调用。
2.后置通知（after-returning）：仅当方法成功完成后执行。
3.环绕通知（around）：在方法执行以前和以后调用。
4.抛出异常通知（after-throwing）：在方法抛出异常退出时执行。
5.最终通知（after）： 在方法执行以后调用，不管方法执行是否成功。

实现细节，方便理解
try{
   //1 前置通知
   // 目标方法
   //2 后置通知
} catch(){
   //4 抛出异常通知
} finally{
   //5 最终通知
}

 

34.Spring AOP中什么是切点？

在说切入点前，须要先说链接点
链接点：可能被加强的点，目标类中的全部方法。
切入点：将会被加强的链接点，目标类中被加强的方法。

 

35.Spring AOP中什么是目标对象？

目标类：须要被加强的类。

 

36.Spring AOP中什么是代理？

AOP经过生成代理对象，对目标类进行加强。
在spring AOP中，代理对象，将通知和切入点链接起来，从而实现加强的过程。

 

37.你是如何理解“横切关注”这个概念的

使用"横切"技术，AOP把软件系统分为两个部分：核心关注点和横切关注点。
业务处理的主要流程是核心关注点，与之关系不大的部分是横切关注点。
横切关注点的一个特色是，常常发生在核心关注点的多处，而各处基本类似，好比权限认证、日志、事物。
AOP的做用在于分离系统中的各类关注点，将核心关注点和横切关注点分离开来。

参考：https://www.cnblogs.com/hongwz/p/5764917.html

 

38.你如何理解AOP中的链接点（Joinpoint）、切点（Pointcut）、加强（Advice）、引介（Introduction）、织入（Weaving）、切面（Aspect）这些概念？

1.目标类（target）：须要被加强的类。
2.链接点（Joinpoint）：可能被加强的点，目标类中的全部方法。
3.切入点（Pointcut）：将会被加强的链接点，目标类中被加强的方法。
4.通知/加强（Advice）：对切入点加强的内容。加强的内容一般以方法的形式体现的。加强执行的位置不一样，称呼不一样。
  （前置通知、后置通知、环绕通知、抛出异常通知、最终通知）
   通知方法所在的类，一般称为切面类。
5.切面（Aspect）：通知和切入点的结合。一个通知对应一个切入点就造成一条线，多个通知对应多个切入点造成多条线，多条线造成了一个面，称为切面。
6.织入（Weaving）： 生成切面并建立代理对象的过程。（将通知和切入点的结合，并建立代理对象的过程）
f. 切面（Aspect）：
切面是由切点和加强（引介）组成的，它包括了对横切关注功能的定义，也包括了对链接点的定义。

参考：https://www.cnblogs.com/hongwz/p/5764917.html

 

39.AOP的运用？

1.事务  Transaction
2.日志处理 logging, tracing, profiling and monitoring
3.缓存 　Caching
4.权限控制 Authentication
5.错误处理　Error handling
6.懒加载 Lazy loading

连接：http://blog.sina.com.cn/s/blog_7045cb9e01010a9r.html
     https://blog.csdn.net/qq513165077/article/details/78288999

 

40.怎么不用Spring框架下实现IOC

IOC控制反转：指将对象的建立权，反转到Spring容器
方式1：建立工厂
     建立一个工厂，用于建立目标对象，就是最简单的IOC。但工厂和目标类耦合。
方式2：工厂 + 配置文件
     1）配置文件中存放类的全限定名称
     2）编写工厂，用于读取配置文件中的内容，并经过反射建立对象。
     问题：工厂只能生产一个对象
方式3：工厂 + properties文件
     1）properties配置文件存放一组，key是标识，value是全限定名称
     2）编写工厂类，读取配置文件
     3）提供getBean( name ) 用于生成实例：经过name得到对应的全限定名称，再经过反射建立对应的实例。

 

 

四 .(3)框架.Spring MVC

1.讲一下MVC

MVC设计模式： Model-View-Controller简写。
MVC是软件工程中的一种软件架构模式，它是一种分离业务逻辑与显示界面的设计方法。它把软件系统分为三个基本部分：模型（Model）、视图（View）和控制器（Controller）。
① 控制器Controller：对请求进行处理，负责选择视图；
② 视图View：用户与程序交互的界面；
③ 模型Model：用于业务处理

 

2.springmvc的执行流程

SpringMVC是一个MVC框架，springmvc的工做流程：
   1. 发送请求：在浏览器输入请求路径，发送请求，前端控制器链接全部的请求。
   2. 得到处理器：核心控制器（DispatcherServlet）接收到请求，经过处理器映射器（handlerMapping）得到对应的处理器（Handler）
          即根据请求路径得到对应的controller。
   3. 执行处理器：经过处理器适配器（HandlerAdapter）执行处理器（Handler），并返回视图模型对象（ModelAndView）
          即执行controller方法。若是方法返回的字符串，底层也会转换成ModelAndView。
   4. 解析视图：经过视图解析器（ViewResolver）解析ModelAndView中的视图，将逻辑视图解析成真正的视图。
   5. 渲染视图：将Model中的数据渲染到视图（View）中
   6. 响应结果
          即将模型数据（查询结果）渲染到jsp页面中，并将处理结果响应给浏览器。

 

3.什么是Spring MVC框架的控制器？

Spring框架的核心控制器（前端控制器）是DispatherServlet
他的核心功能就是分发请求，请求会被分发给对应处理的类handler。

 

4.SpringMVC跳转一个页面，怎么返回一个json数据?

使用@ResponseBody注解，将返回json数据。
1.若是在方法使用该注解，当前方法返回json数据。
2.若是在类上使用该注解，当前类中全部的方法，都将返回json数据。

springmvc默认用jackson对json数据进行转换，但须要添加jackson的包

扩展阅读：
消息转换器原理解析：https://blog.csdn.net/shadabing/article/details/84664402
SpringBoot配置Fastjson：https://blog.csdn.net/cjq2013/article/details/76421101
SpringMVC配置Fastjson：https://blog.csdn.net/do_bset_yourself/article/details/51324186

 

5.分层设计的优缺点

优势：
一、开发人员能够只关注整个结构中的其中某一层；
二、容易用新的实现来替换原有层次的实现；
三、下降层与层之间的依赖；
四、有利于标准化；
五、有利于各层逻辑的复用
缺点：
一、下降了系统的性能。这是不言而喻的。若是不采用分层式结构，不少业务能够直接造访数据库，以此获取相应的数据，现在却必须经过中间层来完成。
二、有时会致使级联的修改。这种修改尤为体如今自上而下的方向。若是在表示层中须要增长一个功能，为保证其设计符合分层式结构，可能须要在相应的业务逻辑层和数据访问层中都增长相应的代码。

 

6.SpringMVC和Spring的经常使用注解

1.Spring相关注解
1.1）声明bean的注解
@Component 通用注解，用于声明bean。能够配置任意组件。
@Repository 派生注解，与@Component等效，Dao实现类推荐使用的注解，不只能够声明bean，并且提升可读性。
@Service 派生注解，与@Component等效，Service实现类推荐使用的注解，不只能够声明bean，并且提升可读性。
@Controller 派生注解，与@Component等效，Controller实现类推荐使用的注解，不只能够声明bean，并且提升可读性。

1.2）bean注入的相关注解
@Autowired：按类型注入，
@Resource(name="")：按名称注入
@Resource()：先按名称注入，若是没有再按照类型。

1.3）配置类相关注解
@Bean 在方法上，声明当前方法的返回值为一个bean。
@Configuration 声明当前类为配置类，内部常使用@Bean进行详细配置。取代了xml文件配置。
@ComponentScan 用于对Component进行扫描，能够配置扫描的包路径

1.4）@Value：为属性注入简单值

2.SpringMVC相关注解
@RequestMapping 修饰方法，将请求路径映射到Controller对应的处理方法上。
                              修饰类，给请求路径添加访问前缀（二级路径）
@ResponseBody 将返回值转换成json数据，并响应给浏览器。
@RequestBody 将json格式的请求参数，封装到指定的JavaBean中。
@PathVariable 用于接收路径参数，好比@RequestMapping(“/hello/{name}”)申明的路径，参数前使用注解@PathVariable("name")，就能够获取name对应的值。
@RestController 该注解为一个组合注解，至关于@Controller和@ResponseBody的组合，注解在类上，意味着，该Controller的全部方法都响应JSON格式数据。

 

7.从页面传数据到后台的几种方式，以及后台如何接收

1.地址栏参数或普通表单请求，如：age=18&gender=man，SpringMVC方法参数须要使用@RequestParam("参数名")得到参数值。
2.提交json类型数据，SpringMVC 方法参数须要使用@RequestBody 将数据封装到java对象中。
3.路径占位符：如 http://localhost:8080/user/findById/1，使用@RequestMapping("findById/{id}")匹配路径，使用@PathVariable("id")得到对应的参数值。
4.文件上传，修改表单请求为"multipart/form-data"方式，SpringMVC采用MultipartFile参数类型接收数据

 

8.SpringMVC是怎么处理Http请求的?

DispatcherServlet用来处理全部的HTTP请求和请求响应

回答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. 将渲染结果返回给客户端。

 

9.@Controller 注解的做用

@Controller 是@Component的派生注解，功能就是将被修饰的类添加到spring容器。
用于修饰Controller层的组件，提升可读性。

 

10.@RequestMapping 注解的做用

修饰方法，将请求路径映射到Controller对应的处理方法上。
修饰类，给请求路径添加访问前缀（二级路径）

 

11.注解开发怎么返回集合数据

使用 @ResponseBody 注解将Java集合转换json数组，并将结果响应给浏览器。