面试准备

事务隔离级别

[1] 脏读：

所谓脏读，就是读了未提交的数据。举个例子：B事务读取了A事务尚未commit的数据，不巧的是，之后A事务rollback了，这就叫脏读。

[2] 不可重复读：

所谓不可重复读，就是一个事务多次读取某一行，但是这一行在多次读取之中的值不一致（这个事务并为对这行作任何修改操作）。举例：A事务多次读取某一行，在它多次读取操作之间，B事务修改了这一行，这就是不可重复读。

[3] 幻像：

所谓幻像，在一个尚未提交的事务的读取的行的范围中插入新行或删除现有行。举例：B事务对A事务读取的行范围内插入新行或删除行，而A事务之后还会访问这些行（即操作会受到这些行的影响），这样A事务中就发生了幻像。

有序集合合并

//有序集合合并
int i=0,j=0,k=0;
c = new int[a.length+b.length];
while(i<a.length&&j<b.length){
if(a[i]<b[j]){
c[k++] = a[i++];

}else{
c[k++] = b[j++];
}

}
while(i<a.length){
c[k++] = a[i++];
}

while(j<b.length){
c[k++] = b[j++];
}

快排

<span style="font-size:12px;">/*
* 1．i =L; j = R; 将基准数挖出形成第一个坑a[i]。
*
* 2．j--由后向前找比它小的数，找到后挖出此数填前一个坑a[i]中。
*
* 3．i++由前向后找比它大的数，找到后也挖出此数填到前一个坑a[j]中。
*
* 4．再重复执行2，3二步，直到i==j，将基准数填入a[i]中
*/
public static void quickSort(int[] arr, int l, int h) {
int lx = l;
int hx = h;
int x = arr[lx];// 基数
while (lx < hx) {
while (hx > lx && arr[hx] > x)
hx--;
if (hx > lx) {
arr[lx] = arr[hx];
hx--;
}

while (lx < hx && arr[lx] < x)
lx++;
if (lx < hx) {
arr[lx] = arr[hx];
lx++;
}
;

}
arr[lx] = x;
quickSort(arr, l, lx - 1);
quickSort(arr, hx, h);
};</span>

冒泡

<span style="font-size:12px;">/*
* 1.比较相邻的元素。如果第一个比第二个大，就交换他们两个。
*
* 2.对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
*
* 3.针对所有的元素重复以上的步骤，除了最后一个。
*
* 4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
*/

public static void bubbleSort(int[] arr) {
for (int j = arr.length - 1; j > 0; j--)
for (int i = 0; i < j; i++) {

if (arr[i] > arr[i + 1]) {
int temp;
temp = arr[i];
arr[i] = arr[i + 1];
arr[i + 1] = temp;
}
}
for(int i: arr){
System.out.print(i+"\t");
}
}</span>

常见异常

ArithmeticException（算术异常）

ClassCastException （类转换异常）

IllegalArgumentException （非法参数异常）

IndexOutOfBoundsException （下表越界异常）

NullPointerException （空指针异常）

String的编码转换

String s1 = "你好";

String s2 = new String(s1.getBytes("GB2312"), "ISO-8859-1");

递归实现字符串反转

public static String reverse(String originStr) {
02.        if(originStr == null || originStr.length() <= 1)
03.            return originStr;
04.        return reverse(originStr.substring(1)) + originStr.charAt(0);
05.    }

类的初始化顺序

1.先初始化静态成员，

2.然后调用父类构造器，

3.再初始化非静态成员，

4.最后调用自身构造器。

序列化

用处：实现深度克隆、实现对象持久化、实现对象网络流传输

持久化到文件的例子：

Customer customer = new Customer("gacl",25);
// ObjectOutputStream 对象输出流
ObjectOutputStream oo = new ObjectOutputStream(new FileOutputStream(
new File("E:/Customer.txt")));
oo.writeObject(customer);
System.out.println("Customer对象序列化成功！");
oo.close();

ObjectInputStream ois = new ObjectInputStream(new FileInputStream(
new File("E:/Customer.txt")));
Customer customer = (Customer) ois.readObject();
System.out.println("Customer对象反序列化成功！");
return customer;

深度克隆的例子：

ByteArrayOutputStream bout = new ByteArrayOutputStream();
16.        ObjectOutputStream oos = new ObjectOutputStream(bout);
17.        oos.writeObject(obj);
18.
19.        ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
20.        ObjectInputStream ois = new ObjectInputStream(bin);
21.        return (T) ois.readObject();

序列化ID的用处

1、 在某些场合，希望类的不同版本对序列化兼容，因此需要确保类的不同版本具有相同的serialVersionUID；

2、 在某些场合，不希望类的不同版本对序列化兼容，因此需要确保类的不同版本具有不同的serialVersionUID。

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

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

设计模式的六大原则

总原则：开闭原则。

对扩展开放，对修改关闭。

单一职责原则。类的职责应该是单一的。

里氏替换原则。子类可以随时随地替换父类。

依赖倒置原则。面向接口编程。依赖于抽象而不依赖于具体。

接口隔离原则。每个接口中不存在子类用不到却必须实现的方法。

合成复用原则。尽量用关联而不是继承。

迪米特法则。一个类对自己依赖的类知道的越少越好。

静态内部类版本的单例模式：

<span style="font-size:12px;color:#000000;">public class Singleton {
2.
3.     /* 私有构造方法，防止被实例化 */
4.     private Singleton() {
5.     }
6.
7.     /* 此处使用一个内部类来维护单例 */
8.     private static class SingletonFactory {
9.         private static Singleton instance = new Singleton();
10.     }
11.
12.     /* 获取实例 */
13.     public static Singleton getInstance() {
14.         return SingletonFactory.instance;
15.     }
16.
17.     /* 如果该对象被用于序列化，可以保证对象在序列化前后保持一致 */
18.     public Object readResolve() {
19.         return getInstance();
20.     }
21. }
</span>

原型模式 就是复制原型对象。
浅复制：将一个对象复制后，基本数据类型的变量都会重新创建，而引用类型，指向的还是原对象所指向的。

深复制：将一个对象复制后，不论是基本数据类型还有引用类型，都是重新创建的。简单来说，就是深复制进行了完全彻底的复制，而浅复制不彻底。

浅复制的原型模式：

<span style="font-size:12px;color:#000000;">public class Prototype implements Cloneable {
2.
3.     public Object clone() throws CloneNotSupportedException {
4.         Prototype proto = (Prototype) super.clone();
5.         return proto;
6.     }
7. }
</span>

装饰模式（Decorator）

顾名思义，装饰模式就是给一个对象增加一些新的功能，要求装饰对象和被装饰对象实现同一个接口，装饰对象持有被装饰对象的实例，

适配器模式

适配器模式将某个类的接口转换成客户端期望的另一个接口表示，目的是消除由于接口不匹配所造成的类的兼容性问题。主要分为三类：类的适配器模式、对象的适配器模式、接口的适配器模式。

类的适配器模式是：继承原类，实现目标接口。

对象的适配器模式是：持有原对象（关联关系），实现目标接口。

接口的适配器模式是：通过抽象类实现接口，类只实现抽象类中需要的方法就好。

享元模式-共享池-数据库连接池

观察者模式

　　抽象主题角色：把所有对观察者对象的引用保存在一个集合中，每个抽象主题角色都可以有任意数量的观察者。抽象主题提供一个接口，可以增加和删除观察者角色。一般用一个抽象类和接口来实现。

　　抽象观察者角色：为所有具体的观察者定义一个接口，在得到主题的通知时更新自己。

　　具体主题角色：在具体主题内部状态改变时，给所有登记过的观察者发出通知。具体主题角色通常用一个子类实现。

　　具体观察者角色：该角色实现抽象观察者角色所要求的更新接口，以便使本身的状态与主题的状态相协调。通常用一个子类实现。如果需要，具体观察者角色可以保存一个指向具体主题角色的引用。