面试题：

面试题z
⑴ 原子性（Atomicity）
⑵ 一致性（Consistency）
⑶ 隔离性（Isolation）
⑷ 持久性（Durability）
1，脏读
2，不可重复读
3，虚读(幻读)

面试题z

1.所有类的实例和数组在栈上分配

所以，并不是所有的对象和数组，都是在堆上进行分配的，由于即时编译的存在，如果JVM发现某些对象没有逃逸出方法，就很有可能被优化成在栈上分配。详解

1.1逃逸分析

2.堆内存有存活和死亡对象，空闲碎片区

堆内存用于存放由new创建的对象和数组。数组和对象在没有引用变量指向它的时候，才变成垃圾，不能再被使用，但是仍然占着内存，在随后的一个不确定的时间被垃圾回收器释放掉。这个也是java比较占内存的主要原因，实际上，栈中的变量指向堆内存中的变量，这就是 Java 中的指针!

3.Nio特性描述

总的来说java 中的IO 和NIO的区别主要有3点：

IO是面向流的，NIO是面向缓冲的；
2. IO是阻塞的，NIO是非阻塞的；
3. IO是单线程的，NIO 是通过选择器来模拟多线程的；

NIO在基础的IO流上发展处新的特点，分别是：内存映射技术，字符及编码，非阻塞I/O和文件锁定。下面我们分别就这些技术做一些说明。

4.构造方法只能用new调用？

在类内部使用关键字this.构造方法名()调用本类构造器
在子类中通过关键字super.父类构造方法名()调用父类构造器
反射机制对于任意一个类，都能够知道这个类的所有属性和方法，包括类的构造方法。
使用new创建对象会自动调用构造方法

看最后一句话，构造方法是新创建的对象的实例变量缺省初始化以及显式初始化之后才执行的，也就是说在构造方法调用之前这个对象已经存在了，更谈不上你例子中的构造方法返回一个对象引用了。

构造方法是一种特殊的方法，具有以下特点。
（1）构造方法的方法名必须与类名相同。
（2）构造方法没有返回类型，也不能定义为void，在方法名前面不声明方法类型。
（3）构造方法的主要作用是完成对象的初始化工作，它能够把定义对象时的参数传给对象的域。
（4）构造方法不能由编程人员调用，而要系统调用。
（5）一个类可以定义多个构造方法，如果在定义类时没有定义构造方法，则编译系统会自动插入一个无参数的默认构造器，这个构造器不执行任何代码。
（6）构造方法可以重载，以参数的个数，类型，或排列顺序区分。

5.软引用，内存溢出后回收
软引用是用来描述一些还有用,但非必需的对象。只被软引用关联着的对象,在系统将要发生内存溢出异常前,会把这些对象列进回收范围之中进行第二次回收,如果这次回收还没有足够的内存,才会抛出内存溢出异常。

软引用通常用来实现内存敏感的缓存。比如: 高速缓存就有用到软引用。如果还有空闲内存,就可以暂时保留缓存,当内存不足时清理掉,这样就保证了使用缓存的同时,不会耗尽内存。

垃圾回收器在某个时刻决定回收软可达的对象的时候,会清理软引用,并可选地把引用存放到一个引用队列(Reference Queue)。

类似弱引用,只不过Java虚拟机尽量让软引用的存活时间长一些,迫不得已才清理。

启动下面的代码时候需加入如下参数:
-Xms10m -Xmx10m -XX:+PrintGCDetails
public class SoftReferenceTest {
public static class User {
public User(int id, String name) {
this.id = id;
this.name = name;
}

    public int id;<br />        public String name;
    @Override<br />        public String toString() {<br />            return "[id=" + id + ", name=" + name + "] ";<br />        }<br />    }
public static void main(String[] args) {<br />        //创建对象，建立软引用<br />//        SoftReference<User> userSoftRef = new SoftReference<User>(new User(1, "songhk"));<br />        //上面的一行代码，等价于如下的三行代码<br />        User u1 = new User(1, "young");<br />        SoftReference<User> userSoftRef = new SoftReference<User>(u1);<br />        u1 = null;//取消强引用
    //从软引用中重新获得强引用对象<br />        System.out.println(userSoftRef.get());
    System.gc();<br />        System.out.println("After GC:");<br />//        //垃圾回收之后获得软引用中的对象<br />        System.out.println(userSoftRef.get());//由于堆空间内存足够，所以不会回收软引用的可达对象。<br />//<br />        try {<br />            //让系统认为内存资源紧张、不够<br />            byte[] b = new byte[1024 * 1024 * 7];<br />//            byte[] b = new byte[1024 * 7168 - 635 * 1024];<br />        } catch (Throwable e) {<br />            e.printStackTrace();<br />        } finally {<br />            //再次从软引用中获取数据<br />            System.out.println(userSoftRef.get());//在报OOM之前，垃圾回收器会回收软引用的可达对象。<br />        }<br />    }<br />}

6.内存溢出和内存泄漏

内存溢出 out of memory，是指程序在申请内存时，没有足够的内存空间供其使用，出现out of memory；比如申请了一个integer,但给它存了long才能存下的数，那就是内存溢出。

内存泄露 memory leak，是指程序在申请内存后，无法释放已申请的内存空间，一次内存泄露危害可以忽略，但内存泄露堆积后果很严重，无论多少内存,迟早会被占光。

memory leak会最终会导致out of memory！

内存溢出就是你要求分配的内存超出了系统能给你的，系统不能满足需求，于是产生溢出。

内存泄漏是指你向系统申请分配内存进行使用(new)，可是使用完了以后却不归还(delete)，结果你申请到的那块内存你自己也不能再访问（也许你把它的地址给弄丢了），而系统也不能再次将它分配给需要的程序。一个盘子用尽各种方法只能装4个果子，你装了5个，结果掉倒地上不能吃了。这就是溢出！比方说栈，栈满时再做进栈必定产生空间溢出，叫上溢，栈空时再做退栈也产生空间溢出，称为下溢。就是分配的内存不足以放下数据项序列,称为内存溢出.

以发生的方式来分类，内存泄漏可以分为4类：

常发性内存泄漏。发生内存泄漏的代码会被多次执行到，每次被执行的时候都会导致一块内存泄漏。
2. 偶发性内存泄漏。发生内存泄漏的代码只有在某些特定环境或操作过程下才会发生。常发性和偶发性是相对的。对于特定的环境，偶发性的也许就变成了常发性的。所以测试环境和测试方法对检测内存泄漏至关重要。
3. 一次性内存泄漏。发生内存泄漏的代码只会被执行一次，或者由于算法上的缺陷，导致总会有一块仅且一块内存发生泄漏。比如，在类的构造函数中分配内存，在析构函数中却没有释放该内存，所以内存泄漏只会发生一次。
4. 隐式内存泄漏。程序在运行过程中不停的分配内存，但是直到结束的时候才释放内存。严格的说这里并没有发生内存泄漏，因为最终程序释放了所有申请的内存。但是对于一个服务器程序，需要运行几天，几周甚至几个月，不及时释放内存也可能导致最终耗尽系统的所有内存。所以，我们称这类内存泄漏为隐式内存泄漏。

7.threadlocal

大致意思就是ThreadLocal提供了线程内存储变量的能力，这些变量不同之处在于每一个线程读取的变量是对应的互相独立的。通过get和set方法就可以得到当前线程对应的值。

做个不恰当的比喻，从表面上看ThreadLocal相当于维护了一个map，key就是当前的线程，value就是需要存储的对象。

这里的这个比喻是不恰当的，实际上是ThreadLocal的静态内部类ThreadLocalMap为每个Thread都维护了一个数组table，ThreadLocal确定了一个数组下标，而这个下标就是value存储的对应位置。。

作为一个存储数据的类，关键点就在get和set方法。

8.servlet请求过程

其中分请求是否为第一次请求

第一次请求:

1.解析请求信息,解析/one/hello;

上下文路径(环境):/one.

资源名称:/hello.

2.根据上下文路径/one去Tomcat根/conf下找到server.xml文件获取所有的元素再判断哪一个元素的path属性值为/one,接着找到的docBase属性值,该属性值就是当前访问项目的根路径.

3.再从当前项目的根路径下的WEB-INF目录中识别web.xml文件.

4.获取web.xml文件中所有的url-pattern元素,判断是否存在/hello的属性值(找不到则报404错误).

5.根据/hello资源名称最终获取对应的Servlet类的全限定名(类的包名.类名).

6.根据Servlet的全限定名,使用反射调用构造器创建对象Servlet obj = Class.forName(Servlet全限定名).

(把创建的Servlet对象存储到Servlet缓存池中,供下一次请求使用)

7.容器创建ServletConfig对象再使用Servlet对象调用init方法进行初始化 obj.init(config).

8.容器创建ServletRequest,ServletResponse对象再使用Servlet对象调用service方法进行服务obj.service(req, resp).

9.在service方法中对客户端做响应操作.

非第一次请求

前五步与上述前五步相同.

6.从Tomcat中的Servlet实例缓存池中取出HelloServlet对象

7.创建HttpRequest,HttpResponse对象调用Service方法进行服务 obj.service(req, resp).

8.在service方法中对客户端做响应.

上述流程均有Tomcat容器完成,Servlet,ServletConfig,HttpRequest,HttpResp对象均由容器创建.

Servlet中方法调用先后顺序:init——>service——>destroy运行时如下图所示:

9.@autowried和@resource的区别

@Autowired
@Autowired为Spring提供的注解，需要导入包org.springframework.beans.factory.annotation.Autowired。

@Autowired采取的策略为按照类型注入。

public class UserService {
@Autowired
private UserDao userDao;
}
如上代码所示，这样装配回去spring容器中找到类型为UserDao的类，然后将其注入进来。这样会产生一个问题，当一个类型有多个bean值的时候，会造成无法选择具体注入哪一个的情况，这个时候我们需要配合着@Qualifier使用。

@Qualifier告诉spring具体去装配哪个对象。

public class UserService {
@Autowired
@Qualifier(name=”userDao1”)
private UserDao userDao;
}
这个时候我们就可以通过类型和名称定位到我们想注入的对象。

@Resource
@Resource注解由J2EE提供，需要导入包javax.annotation.Resource。

@Resource默认按照ByName自动注入。

复制代码
public class UserService {
@Resource
private UserDao userDao;
@Resource(name=”studentDao”)
private StudentDao studentDao;
@Resource(type=”TeacherDao”)
private TeacherDao teacherDao;
@Resource(name=”manDao”,type=”ManDao”)
private ManDao manDao;
}
复制代码
①如果同时指定了name和type，则从Spring上下文中找到唯一匹配的bean进行装配，找不到则抛出异常。

②如果指定了name，则从上下文中查找名称（id）匹配的bean进行装配，找不到则抛出异常。

③如果指定了type，则从上下文中找到类似匹配的唯一bean进行装配，找不到或是找到多个，都会抛出异常。

④如果既没有指定name，又没有指定type，则自动按照byName方式进行装配；如果没有匹配，则回退为一个原始类型进行匹配，如果匹配则自动装配。

总结:
Spring属于第三方的，J2EE是Java自己的东西。使用@Resource可以减少代码和Spring之间的耦合。

两者都可以写在字段和setter方法上。两者如果都写在字段上，那么就不需要再写setter方法。

当存在多个类型，却又没有指定的时候，会报如下的错误:
Exception sendingcontext initialized event to listener instance of classorg.springframework.web.context.ContextLoaderListenerorg.springframework.beans.factory.BeanCreationException: Error creating beanwith name ‘sequenceServiceImpl’: Injection of resource dependencies failed;nested exception isorg.springframework.beans.factory.NoUniqueBeanDefinitionException: Noqualifying bean of type

10.jdbc和mybatis的区别

JDBC：
我们平时使用jdbc进行编程，大致需要下面几个步骤：
1，使用jdbc编程需要连接数据库，注册驱动和数据库信息
2，操作Connection，打开Statement对象
3，通过Statement对象执行SQL，返回结果到ResultSet对象
4，使用ResultSet读取数据，然后通过代码转化为具体的POJO对象
5，关闭数据库相关的资源
jdbc的缺点：
一：工作量比较大，需要连接，然后处理jdbc底层事务，处理数据类型，还需要操作Connection，Statement对象和ResultSet对象去拿数据并关闭他们。
二：我们对jdbc编程可能产生的异常进行捕捉处理并正确关闭资源

由于JDBC存在的缺陷，在实际工作中我们很少直接使用jdbc进行编程，用的更多的是ORM对象关系模型来操作数据库，Hibernate就是一个ORM模型

Mybatis：
为了解决Hibernate的不足，Mybatis出现了，Mybatis是半自动的框架。之所以称它为半自动，是因为它需要手工匹配提供POJO，sql和映射关系，而全表映射的Hibernate只需要提供pojo和映射关系即可。
Mybatis需要提供的映射文件包含了一下三个部分：sql，映射规则，pojo。在Mybatis里面你需要自己编写sql，虽然比Hibernate配置多，但是Mybatis可以配置动态sql，解决了hibernate表名根据时间变化，不同条件下列不一样的问题，同时你也可以对sql进行优化，通过配置决定你的sql映射规则，也能支持存储过程，所以对于一些复杂和需要优化性能的sql查询它就更加方便。Mybatis几乎可以做到jdbc所有能做到的事情。

jdbc,mybatis,hibernate的区别<br />1）从层次上看，JDBC是较底层的持久层操作方式，而Hibernate和MyBatis都是在JDBC的基础上进行了封装使其更加方便程序员对持久层的操作。<br />2）从功能上看，JDBC就是简单的建立数据库连接，然后创建statement，将sql语句传给statement去执行，如果是有返回结果的查询语句，会将查询结果放到ResultSet对象中，通过对ResultSet对象的遍历操作来获取数据；Hibernate是将数据库中的数据表映射为持久层的Java对象，对sql语句进行修改和优化比较困难；MyBatis是将sql语句中的输入参数和输出参数映射为java对象，sql修改和优化比较方便.<br />3）从使用上看，如果进行底层编程，而且对性能要求极高的话，应该采用JDBC的方式；如果要对数据库进行完整性控制的话建议使用Hibernate；如果要灵活使用sql语句的话建议采用MyBatis框架。

11.forward和redirect的区别

是servlet种的两种主要的跳转方式。forward又叫转发，redirect叫做重定向。

区别：（本地效应次数）

地址栏，数据共享，应用场景，效率，本质，次数

两者的区别总结：

从地址栏显示来说：

1）forword是服务器内部的重定向，服务器直接访问目标地址的 url网址，把里面的东西读取出来，但是客户端并不知道，因此用forward的话，客户端浏览器的网址是不会发生变化的。

2）redirect是服务器根据逻辑，发送一个状态码，告诉浏览器重新去请求那个地址，所以地址栏显示的是新的地址。

2。从数据共享来说：

1）由于在整个定向的过程中用的是同一个request，因此forward会将request的信息带到被重定向的jsp或者servlet中使用。即可以共享数据

2）redirect不能共享

从运用的地方来说

1）forword 一般用于用户登录的时候，根据角色转发到相应的模块

2） redirect一般用于用户注销登录时返回主页面或者跳转到其他网站

4。从效率来说：

1）forword效率高，而redirect效率低

从本质来说：

forword转发是服务器上的行为，而redirect重定向是客户端的行为

12.字节流和字符流

13.Runtime异常和以其他异常区别

面试题： - 图1
//其他Exception，受检查异常。可以理解为错误，必须要开发者解决以后才能编译通过，解决的方法有两种，
1：throw到上层，
2，try-catch处理。

//RunTimeException：运行时异常，又称不受检查异常，不受检查！
不受检查！！不受检查！！！重要的事情说三遍，因为不受检查，所以在代码中可能会有RunTimeException时Java编译检查时不会告诉你有这个异常，但是在实际运行代码时则会暴露出来，比如经典的1/0，空指针等。如果不处理也会被Java自己处理。
(1)Error类和Exception类都是继承Throwable类
(2)Error（错误）是系统中的错误，程序员是不能改变的和处理的，是在程序编译时出现的错误，只能通过修改程序才能修正。一般是指与虚拟机相关的问题，如系统崩溃，虚拟机错误，内存空间不足，方法调用栈溢等。对于这类错误的导致的应用程序中断，仅靠程序本身无法恢复和和预防，遇到这样的错误，建议让程序终止。
(3)Exception（异常）表示程序可以处理的异常，可以捕获且可能恢复。遇到这类异常，应该尽可能处理异常，使程序恢复运行，而不应该随意终止异常。
Exception又分为两类:
CheckedException：（编译时异常）需要用try——catch显示的捕获，对于可恢复的异常使用CheckedException。
UnCheckedException（RuntimeException）：（运行时异常）不需要捕获，对于程序错误（不可恢复）的异常使用RuntimeException。
### 异常的分类

Error：一般为底层的不可恢复的类；
Exception：分为未检查异常(RuntimeException)和已检查异常(非RuntimeException)。
未检查异常是因为程序员没有进行必需要的检查，因为疏忽和错误而引起的错误。几个经典的RunTimeException如下：

1.java.lang.NullPointerException;
2.java.lang.ArithmaticException;
3.java.lang.ArrayIndexoutofBoundsException

Runtime Exception：

在定义方法时不需要声明会抛出runtime exception；在调用这个方法时不需要捕获这个runtime exception； runtime exception是从java.lang.RuntimeException或java.lang.Error类衍生出来的。例如：nullpointexception，IndexOutOfBoundsException就属于runtime exception

Exception:

定义方法时必须声明所有可能会抛出的exception；在调用这个方法时，必须捕获它的checked exception，不然就得把它的exception传递下去；exception是从java.lang.Exception类衍生出来的。例如：IOException，SQLException就属于Exception

Exception 属于应用程序级别的异常，这类异常必须捕捉,Exception体系包括RuntimeException体系和其他非RuntimeException的体系

RuntimeException 表示系统异常，比较严重，如果出现RuntimeException，那么一定是程序员的错误

什么是unchecked异常?

即RuntimeException（运行时异常）
不需要try…catch…或throws 机制去处理的异常

常见的运行时异常RuntimeException主要有以下几种：

ArithmeticException:数学计算异常

NullPointerException:空指针异常

NegativeArraySizeException:负数组长度异常

ArrayOutOfBoundsException:数组索引越界异常

ClassNotFoundException:类文件未找到异常

ClassCastException:类强制转换异常

SecurityException:违背安全原则异常

常见非运行异常有：

NoSuchMethodException:方法未找到异常

IOException:输入输出异常

EOFException:文件已结束一场

FileNotFoundException:文件未找到异常

NumberFormatException:字符串转换为数字异常

SQLException:操作数据库异常

14.面向对象的特征

（1）对象唯一性。
每个对象都有自身唯一的标识，通过这种标识，可找到相应的对象。在对象的整个生命期中，它的标识都不改变，不同的对象不能有相同的标识。
（2）抽象性。
抽象性是指将具有一致的数据结构（属性）和行为（操作）的对象抽象成类。一个类就是这样一种抽象，它反映了与应用有关的重要性质，而忽略其他一些无关内容。任何类的划分都是主观的，但必须与具体的应用有关。
（3）继承性。
继承性是子类自动共享父类数据结构和方法的机制，这是类之间的一种关系。在定义和实现一个类的时候，可以在一个已经存在的类的基础之上来进行，把这个已经存在的类所定义的内容作为自己的内容，并加入若干新的内容。
继承性是面向对象程序设计语言不同于其它语言的最重要的特点，是其他语言所没有的。
在类层次中，子类只继承一个父类的数据结构和方法，则称为单重继承。
在类层次中，子类继承了多个父类的数据结构和方法，则称为多重继承。
多重继承，JAVA、VB、NET、Objective-C均仅支持单继承，注意在C++多重继承时，需小心二义性。
在软件开发中，类的继承性使所建立的软件具有开放性、可扩充性，这是信息组织与分类的行之有效的方法，它简化了对象、类的创建工作量，增加了代码的可重用性。
采用继承性，提供了类的规范的等级结构。通过类的继承关系，使公共的特性能够共享，提高了软件的重用性。
（4）多态性（多形性）
多态性是指相同的操作或函数、过程可作用于多种类型的对象上并获得不同的结果。不同的对象，收到同一消息可以产生不同的结果，这种现象称为多态性。
多态性允许每个对象以适合自身的方式去响应共同的消息。
多态性增强了软件的灵活性和重用性。

15.事务的隔离级别和四个特性

⑴ 原子性（Atomicity）

　　原子性是指事务包含的所有操作要么全部成功，要么全部失败回滚，这和前面两篇博客介绍事务的功能是一样的概念，因此事务的操作如果成功就必须要完全应用到数据库，如果操作失败则不能对数据库有任何影响。

⑵ 一致性（Consistency）

　　一致性是指事务必须使数据库从一个一致性状态变换到另一个一致性状态，也就是说一个事务执行之前和执行之后都必须处于一致性状态。

　　拿转账来说，假设用户A和用户B两者的钱加起来一共是5000，那么不管A和B之间如何转账，转几次账，事务结束后两个用户的钱相加起来应该还得是5000，这就是事务的一致性。

⑶ 隔离性（Isolation）

　　隔离性是当多个用户并发访问数据库时，比如操作同一张表时，数据库为每一个用户开启的事务，不能被其他事务的操作所干扰，多个并发事务之间要相互隔离。

　　即要达到这么一种效果：对于任意两个并发的事务T1和T2，在事务T1看来，T2要么在T1开始之前就已经结束，要么在T1结束之后才开始，这样每个事务都感觉不到有其他事务在并发地执行。

　　关于事务的隔离性数据库提供了多种隔离级别，稍后会介绍到。

⑷ 持久性（Durability）

　　持久性是指一个事务一旦被提交了，那么对数据库中的数据的改变就是永久性的，即便是在数据库系统遇到故障的情况下也不会丢失提交事务的操作。

　　例如我们在使用JDBC操作数据库时，在提交事务方法后，提示用户事务操作完成，当我们程序执行完成直到看到提示后，就可以认定事务以及正确提交，即使这时候数据库出现了问题，也必须要将我们的事务完全执行完成，否则就会造成我们看到提示事务处理完毕，但是数据库因为故障而没有执行事务的重大错误。

　　以上介绍完事务的四大特性(简称ACID)，现在重点来说明下事务的隔离性，当多个线程都开启事务操作数据库中的数据时，数据库系统要能进行隔离操作，以保证各个线程获取数据的准确性，在介绍数据库提供的各种隔离级别之前，我们先看看如果不考虑事务的隔离性，会发生的几种问题：

1，脏读

　　脏读是指在一个事务处理过程里读取了另一个未提交的事务中的数据。

　　当一个事务正在多次修改某个数据，而在这个事务中这多次的修改都还未提交，这时一个并发的事务来访问该数据，就会造成两个事务得到的数据不一致。例如：用户A向用户B转账100元，对应SQL命令如下

```
update account set money=money+100 where name=’B’; (此时A通知B)

update account set money=money - 100 where name=’A’;<br />```

　　当只执行第一条SQL时，A通知B查看账户，B发现确实钱已到账（此时即发生了脏读），而之后无论第二条SQL是否执行，只要该事务不提交，则所有操作都将回滚，那么当B以后再次查看账户时就会发现钱其实并没有转。

2，不可重复读

　　不可重复读是指在对于数据库中的某个数据，一个事务范围内多次查询却返回了不同的数据值，这是由于在查询间隔，被另一个事务修改并提交了。

　　例如事务T1在读取某一数据，而事务T2立马修改了这个数据并且提交事务给数据库，事务T1再次读取该数据就得到了不同的结果，发送了不可重复读。

　　不可重复读和脏读的区别是，脏读是某一事务读取了另一个事务未提交的脏数据，而不可重复读则是读取了前一事务提交的数据。

　　在某些情况下，不可重复读并不是问题，比如我们多次查询某个数据当然以最后查询得到的结果为主。但在另一些情况下就有可能发生问题，例如对于同一个数据A和B依次查询就可能不同，A和B就可能打起来了……

3，虚读(幻读)

　　幻读是事务非独立执行时发生的一种现象。例如事务T1对一个表中所有的行的某个数据项做了从“1”修改为“2”的操作，这时事务T2又对这个表中插入了一行数据项，而这个数据项的数值还是为“1”并且提交给数据库。而操作事务T1的用户如果再查看刚刚修改的数据，会发现还有一行没有修改，其实这行是从事务T2中添加的，就好像产生幻觉一样，这就是发生了幻读。

　　幻读和不可重复读都是读取了另一条已经提交的事务（这点就脏读不同），所不同的是不可重复读查询的都是同一个数据项，而幻读针对的是一批数据整体（比如数据的个数）。

　　现在来看看MySQL数据库为我们提供的四种隔离级别：

　　① Serializable (串行化)：可避免脏读、不可重复读、幻读的发生。

　　② Repeatable read (可重复读)：可避免脏读、不可重复读的发生。

　　③ Read committed (读已提交)：可避免脏读的发生。

　　④ Read uncommitted (读未提交)：最低级别，任何情况都无法保证。

16.oracle中round(x,y),trunc(x,y)的区别

/
TRUNC（number,num_digits）
Number 需要截尾取整的数字。
Num_digits 用于指定取整精度的数字。Num_digits 的默认值为 0。
TRUNC()函数截取时不进行四舍五入
/
9.select trunc(123.458) from dual —123
10.select trunc(123.458,0) from dual —123
11.select trunc(123.458,1) from dual —123.4
12.select trunc(123.458,-1) from dual —120
13.select trunc(123.458,-4) from dual —0
14.select trunc(123.458,4) from dual —123.458
15.select trunc(123) from dual —123
16.select trunc(123,1) from dual —123
17.select trunc(123,-1) from dual —120
ROUND函数
描述 : 传回一个数值，该数值是按照指定的小数位元数进行四舍五入运算的结果。
SELECT ROUND( number, [ decimal_places ] ) FROM DUAL
参数:
number : 欲处理之数值
decimal_places : 四舍五入 , 小数取几位 ( 预设为 0 )
Sample :
select round(123.456, 0) from dual; 回传 123
select round(123.456, 1) from dual; 回传 123.5
select round(123.456, 2) from dual; 回传 123.46
select round(123.456, 3) from dual; 回传 123.456
select round(-123.456, 2) from dual; 回传 -123.46

17 null强转

public class Test3 {
public static void testMethod(){
System.out.println(“testMethod”);
}

public static void main(String[] args) {<br />        ((Test3)null).testMethod();<br />    }<br />}<br />/**<br />    只有本类中的静态方法能够被调用，因为本类静态方法属于类而非对象。<br />    别的类中的静态方法不可以被调用，非静态方法会抛出NullPointerException异常<br />*/

18.数据库优化

19.redis好好学

20.8中基本数据类型以及成员变量默认值

public static void main(String[] args) {
Outer outer = new Outer();
System.out.println(“byye=”+outer.aByte);
System.out.println(“boolean=”+outer.flag);
System.out.println(“short=”+outer.s);
System.out.println(“char=”+outer.c);
System.out.println(“float=”+outer.aFloat);
System.out.println(“double=”+outer.aDouble);
System.out.println(“int=”+outer.id);
System.out.println(“long=”+outer.aLong);
}

byye=0
boolean=false
short=0
char=
float=0.0
double=0.0
int=0
long=0

21.内部类

public class Outer {
public int id;
public static String name;
public char c;
public boolean flag;
public short s;
public byte aByte;
public final double aDouble=0;
private float aFloat;
public static long aLong;
public void method(){
final int a=5;
new Inter() {
@Override
public void print() {
System.out.println(“匿名内部类”);
}
}.print();
class Inner1{
public int anInt;
public void innerMethod(){
System.out.println(aLong);
System.out.println(a);
}
}
new Inner1().innerMethod();
}
class Inner2{
public void method(){
System.out.println(“inner2”);
}
}
static class Inner3{
private int ad;
public void method(){
System.out.println(“inner3”);
}
}
}
public static void main(String[] args) {
// BaseDataType();
Outer.Inner3 inner3 = new Outer.Inner3();// 静态内部类
inner3.method();
// Outer outer = new Outer();
Outer.Inner2 inner2 =new Outer().new Inner2();//内部类
inner2.method();
Outer outer = new Outer();
outer.method(); // 方法内部类只能在方法内被调用

22.collection 简述

Collection 接口又有 3 种子类型，List、Set 和 Queue，再下面是一些抽象类，最后是具体实现类，常用的有 [ArrayList]、[LinkedList]、[HashSet]、LinkedHashSet、[HashMap]、LinkedHashMap 等等。
Collection 是一个的接口，是高度抽象出来的集合，包含了集合的基本操作和属性
集合框架是一个用来代表和操纵集合的统一架构。所有的集合框架都包含如下内容：