面试准备

来源：互联网发布：java实时监控系统编辑：程序博客网时间：2024/05/19 12:13

事务隔离级别

[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）

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

适配器模式

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

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

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

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

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

观察者模式

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

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

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

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

0 0