学习 java面试题（一）

• 操作系统中heap 和stack 的区别
  堆栈是两种数据结构。堆栈都是一种数据项按序排列的数据结构，只能在一端(称为栈顶(top))对数据项进行插入和删除。在单片机应用中，堆栈是个特殊的存储区，主要功能是暂时存放数据和地址 ，通常用来保护断点和现场。

堆:队列优先,先进先出（FIFO—first in first out）。
栈:先进后出(FILO—First-In/Last-Out)。

一、堆栈空间分配区别：

1、栈（操作系统）：由操作系统自动分配释放 ，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈；
2、堆（操作系统）：一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收，分配方式倒是类似于链表。

二、堆栈缓存方式区别：

1、栈使用的是一级缓存， 他们通常都是被调用时处于存储空间中，调用完毕立即释放；

2、堆是存放在二级缓存中，生命周期由虚拟机的垃圾回收算法来决定（并不是一旦成为孤儿对象就能被回收）。所以调用这些对象的速度要相对来得低一些。

三、堆栈数据结构区别：

堆（数据结构）：堆可以被看成是一棵树，如：堆排序；

栈（数据结构）：一种先进后出的数据结构。

四、Java中栈和堆的区别：

栈(stack)与堆(heap)都是Java用来在Ram中存放数据的地方。与C++不同，Java自动管理栈和堆，程序员不能直接地设置栈或堆。

在函数中定义的一些基本类型的变量和对象的引用变量都在函数的栈内存中分配。当在一段代码块定义一个变量时，Java就在栈中为这个变量分配内存空间，当超过变量的作用域后，Java会自动释放掉为该变量所分配的内存空间，该内存空间可以立即被另作他用。

堆内存用来存放由new创建的对象和数组，在堆中分配的内存，由Java虚拟机的自动垃圾回收器来管理。在堆中产生了一个数组或对象后，还可以在栈中定义一个特殊的变量，让栈中这个变量的取值等于数组或对象在堆内存中的首地址，栈中的这个变量就成了数组或对象的引用变量。引用变量就相当于是为数组或对象起的一个名称，以后就可以在程序中使用栈中的引用变量来访问堆中的数组或对象。
五、Java中变量在内存中的分配:

1、类变量（static修饰的变量）：在程序加载时系统就为它在堆中开辟了内存，堆中的内存地址存放于栈以便于高速访问。静态变量的生命周期–一直持续到整个”系统”关闭。

2、实例变量：当你使用java关键字new的时候，系统在堆中开辟并不一定是连续的空间分配给变量（比如说类实例），然后根据零散的堆内存地址，通过哈希算法换算为一长串数字以表示这个变量在堆中的”物理位置”。 实例变量的生命周期–当实例变量的引用丢失后，将被GC（垃圾回收器）列入可回收“名单”中，但并不是马上就释放堆中内存。

-3、局部变量：局部变量，由声明在某方法，或某代码段里（比如for循环），执行到它的时候在栈中开辟内存，当局部变量一但脱离作用域，内存立即释放。

• 什么是基于注解的切面实现
  在程序运行时，动态的将代码切入到类的指定方法、指定位置上的编程思想就是面向切面编程
  一般而言，我们管切入到指定类指定方法的代码片段为切面，而切入的哪些类、哪些方法则叫切入点。有了AOP，我们就可以把几个类共有的代码，抽取到一个切片中，等到需要时在切入对象中去，从而改变其原有的行为。
  AOP就是OOP的补充而已。OOP从横向上区分出一个个类来，而AOP则从纵向上向对象加入特定的代码。有了AOP，OOP变得立体了，如果加上时间维度，AOP使OOP从二维变成三维。
  从技术上来说，AOP基本上是通过代理机制实现的。
  经典的Spring AOP是基于动态代理技术的。在实现方式上，最常用的是实现MethodInterceptor接口来提供环绕通知，创建若干代理，然后使用ProxyBeanFactory配置工厂Bean，生成拦截器链，完成拦截。
  我们通常使用注解的形式使用AOP
  在xml中的配置

  <context:component-scan base-package="demo.spring"/>
  <aop:aspectj-autoproxy />

context:component-scan，使用@Component自动发布bean，需要配置这个元素
aop:aspectj-autoproxy，使用@AspectJ及其它AOP注解需要配置，否则无法使用注解；@AspectJ注解，将@Component自动发布出来的"interceptor" bean转换为一个aspectj切面，而@Pointcut、@Before、@After、@Around等注解，功能与在xml文件中配置是一样的；@Pointcut注解下面的方法内容无意义，只是要求一个相应方法提供注解依附。
注解只能使用在能活的源码的场景，如果不能获取源码，则只能通过xml配置的形式，将制定的对象配置成拦截器，对指定目标进行拦截；因此，通过xml文件配置，而不是注解，是更加通用的方式。
除基础的springframework框架的jar外，还需要依赖cglib、aspectj的jar包，maven配置如下：

 <dependency>      
       <groupId>cglib</groupId>      
        <artifactId>cglib</artifactId>      
       <version>2.2</version> 
        </dependency> 
       <dependency>     
         <groupId>org.aspectj</groupId>      
         <artifactId>aspectjweaver</artifactId>      
          <version>1.6.11</version> 
   </dependency>

总结：Spring实现AOP，动态代理技术的两种实现是jdk动态代理、cglib代理，根据被通知的方法是否为接口方法，来选择使用哪种代理生成策略。
jdk动态代理：原理是实现接口的实例，拦截定于接口中的目标方法，，性能更优，是spring生成代理的优先选择。
cglib代理：原理是使用cglib库中的字节码动态生成技术，生成被代理类的子类实例，可以拦截代理类中的任一public方法的调用，无论目标方法是否定义与接口中，更通用，但性能相对jdk代理差一些。

• 什么是对象/关系映射集成模块
  所谓对象关系映射（Object Relational Mapping，简称ORM）是通过使用描述对象和数据库之间映射的元数据，将面向对象语言程序中的对象自动持久化到关系数据库中。本质上就是将数据从一种形式转换到另外一种形式。
  详细一点，是 面向对象编程中的 对象(Object)
  和关系数据库的 关系(Relation)
  的一个映射(Mapping)。
  产生的原因是因为软件开发已经是面向对象的了。 所有的值，操作都是基于对象的概念。
  而数据库还是关系数据库。记录的存储还是一条一条的。
  为了在逻辑上使得软件开发与存取数据库保持一致（都按照对象的概念进行开发，
  存取。）。才出现了这种or－mapping
  实际上，如果面向对象数据库成为主流，or－mapping就没用了。
  好处，就是上面所属的逻辑上的一致性，开发人员不必管数据库怎么存储，他只要知道要保存的也是一个对象（和他开发的概念一致）就可以了。

没有O/R M之前，都是直接用SQL操作数据库，或者使用DAO之类的机制进行对象概念到关系数据库概念的转换。

• 什么是Java 的反射机制
  JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。java通常是先有类再有对象，有对象我就可以调用方法或者属性。反射其实是通过Class对象来调用类里面的方法。通过反射可以调用私有方法和私有属性。大部分框架都是运用反射原理，精简总结一下：

1.什么是反射
答：就是可以在程序运行的时候动态装载类，查看类的信息，生成对象，或操作生成对象。类在运行的时候，可以得到该类的信息，并且 可以动态的修改这些信息，自己能看到自己，跟照镜子一样，也就是说Java的反射机制是在编辑的时候并不确定哪个类被加载了，而是在程序运行的时候才加载、探知、自审，使用在编译期并不知道的类，这样的特点就是反射。
2.那么Java反射有什么作用呢？
假如我们有两个程序员，一个程序员在写程序的时候，需要使用第二个程序员所写的类，但第二个程序员并没完成他所写的类。那么第一个程序员的代码能否通过编译呢？这是不能通过编译的。利用Java反射的机制，就可以让第一个程序员在没有得到第二个程序员所写的类的时候，来完成自身代码的编译。Java反射机制主要提供了以下功能： 在运行时判断任意一个对象所属的类；在运行时构造任意一个类的对象；在运行时判断任意一个类所具有的成员变量和方法；在运行时调用任意一个对象的方法；生成动态代理。
Java的反射机制它知道类的基本结构，这种对Java类结构探知的能力，我们称为Java类的“自审”。大家都用过Jcreator和eclipse。 当我们构建出一个对象的时候，去调用该对象的方法和属性的时候。一按点，编译工具就会自动的把该对象能够使用的所有的方法和属性全部都列出来，供用户进行 选择。这就是利用了Java反射的原理，是对我们创建对象的探知、自审。
3.反射技术大量用于Java设计模式和框架技术，最常见的设计模式就是工厂模式和单例模式。
单例模式(Singleton)
这个模式主要作用是保证在Java应用程序中，一个类Class只有一个实例存在。在很多操作中，比如建立目录 数据库连接都需要这样的单线程操作。这样做就是为了节省内存空间，保证我们所访问到的都是同一个对象。
单例模式要求保证唯一，那么怎么样才能保证唯一性呢？对了，这就是静态变量。单例模式有以下两种形式：

第一种形式： 
package reflect; 
public class Singleton {  
    private Singleton() { 
    }  
    private static Singleton instance = new Singleton(); 
    // 这里提供了一个供外部访问本class的静态方法，可以直接访问 
    public static Singleton getInstance() { 
           return instance; 
    }    
} 
class SingRun{ 
    public static void main(String[] args){ 
       //这样的调用不被允许，因为构造方法是私有的。 
       //Singleton x=new Singleton();      
       //得到一个Singleton类实例 
       Singleton x=Singleton.getInstance();   
       //得到另一个Singleton类实例 
       Singleton y=Singleton.getInstance();     
       //比较x和y的地址，结果为true。说明两次获得的是同一个对象 
       System.out.println(x==y); 
    } 
} 
第二种形式： 
public class Singleton { 
    //先申明该类静态对象 
    private static Singleton instance = null;   
    //创建一个静态访问器，获得该类实例。加上同步，表示防止两个线程同时进行对象的创建 
    public static synchronized Singleton getInstance() {      
       //如果为空，则生成一个该类实例 
       if (instance == null){ 
           instance = new Singleton(); 
       } 
       return instance; 
    } 
} 

工厂模式（Factory）
工厂模式是我们最常用的模式了,著名的Jive论坛 ,就大量使用了工厂模式，工厂模式在Java程序系统可以说是随处可见。
为什么工厂模式是如此常用？是因为工厂模式利用Java反射机制和Java多态的特性可以让我们的程序更加具有灵活性。用工厂模式进行大型项目的开发，可以很好的进行项目并行开发。就是一个程序员和另一个程序员可以同时去书写代码，而不是一个程序员等到另一个程序员写完以后再去书写代码。其中的粘合剂就是接口和配置文件。之前说利用接口可以将调用和实现相分离。那么这是怎么样去实现的呢？工厂模式可以为我们解答。
我们先来回顾一下软件的生命周期，分析、设计、编码、调试与测试。其中分析就是指需求分析，就是知道这个软件要做成什么样子，要实现什么样的功能。功能知道了，这时就要设计了。设计的时候要考虑到怎么样高效的实现这个项目，如果让一个项目团队并行开发。这时候，通常先设计接口，把接口给实现接口的程序员和调用接口的程序员，在编码的时候，两个程序员可以互不影响的实现相应的功能，最后通过配置文件进行整合。

代码示例： 
interface InterfaceTest{ 
    public void getName();//定义获得名字的方法 
} 
接口有了，那么得到这个接口，进行实现编码的程序员应该怎么做呢？对了，实现这个接口，重写其中定义的方法 
接口实现方法： 
class Test1 implements InterfaceTest{ 
    public void getName() { 
       System.out.println("test1"); 
    } 
} 
class Test2 implements InterfaceTest{ 
    public void getName() { 
       System.out.println("test2"); 
    } 
   
} 

大家可以发现，当接口定义好了以后，不但可以规范代码，而且可以让程序员有条不紊的进行功能的实现。实现接口的程序员根本不用去管，这个类要被谁去调用。 那么怎么能获得这些程序员定义的对象呢？在工厂模式里，单独定义一个工厂类来实现对象的生产，注意这里返回的接口对象。

工厂类，生产接口对象：
class Factory{ 
    //创建私有的静态的Properties对象 
    private static Properties pro=new Properties(); 
    //静态代码块 
    static{ 
       try {        
           //加载配置文件 
           pro.load(new FileInputStream("file.txt")); 
       } catch (Exception e) { 
           e.printStackTrace(); 
       } 
    } 
    private static Factory factory=new Factory(); 
    private Factory(){}   
    public static Factory getFactory(){ 
       return factory; 
    } 
    public  InterfaceTest getInterface(){ 
       InterfaceTest interfaceTest=null;//定义接口对象     
       try { 
           //根据键，获得值，这里的值是类的全路径 
           String classInfo=pro.getProperty("test");  
           //利用反射，生成Class对象 
           Class c=Class.forName(classInfo);  
           //获得该Class对象的实例 
           Object obj=c.newInstance(); 
           //将Object对象强转为接口对象 
           interfaceTest=(InterfaceTest)obj; 
       } catch (Exception e) { 
           e.printStackTrace(); 
       } 
       //返回接口对象 
       return interfaceTest; 
    } 
} 

配置文件内容：
test=factory.Test2
通过这个类，大家可以发现，在调用的时候，得到的是个接口对象。而一个接口变量可以指向实现了这个接口的类对象。在利用反射的时候，我们并没有直接把类的 全路径写出来，而是通过键获得值。这样的话，就有很大的灵活性，只要改变配置文件里的内容，就可以改变我们调用的接口实现类，而代码不需做任何改变。在调 用的时候，我们也是通过接口调用，甚至我们可以连这个接口实现类的名字都不知道。

调用方法： 
public class FactoryTest { 
    public static void main(String[] args) { 
       //获得工厂类的实例 
       Factory factory=Factory.getFactory(); 
       //调用获得接口对象的方法，获得接口对象 
       InterfaceTest inter=factory.getInterface(); 
       //调用接口定义的方法 
       inter.getName(); 
    } 
} 

上面的代码就是调用方法。大家可以发现，在调用的时候，我们根本没有管这个接口定义的方法要怎么样去实现它，我们只知道这个接口定义这个方法起什么作用就行了。上面代码运行结果要根据配置文件来定。如果配置文件里的内容是test=factory.Test2。那么表示调用factory.Test2这个 类里实现接口的方法，这时候打印“test2”。如果配置文件里的内容是test=factory.Test1。那么表示调用factory.Test1 这个类里实现接口的方法，这时候打印“test1”。

• 什么是ACID

1. Atomicity原子性
2. Consistency一致性
3. Isolation隔离性
4. Durability耐久性

1、原子性（Atomicity）：事务开始后所有操作，要么全部做完，要么全部不做，不可能停滞在中间环节。事务执行过程中出错，会回滚到事务开始前的状态，所有的操作就像没有发生一样。也就是说事务是一个不可分割的整体，就像化学中学过的原子，是物质构成的基本单位。
2、一致性（Consistency）：事务开始前和结束后，数据库的完整性约束没有被破坏 。比如A向B转账，不可能A扣了钱，B却没收到。
3、隔离性（Isolation）：同一时间，只允许一个事务请求同一数据，不同的事务之间彼此没有任何干扰。比如A正在从一张银行卡中取钱，在A取钱的过程结束前，B不能向这张卡转账。
4、持久性（Durability）：事务完成后，事务对数据库的所有更新将被保存到数据库，不能回滚。

如果新insert一个值，会导致B+二叉树进行再平衡重整，这个过程B+二叉树进行重新整理，索引越大，索引越多，重新整理的时间花费越大。所以有时候再进行大批量insert插入时，我们会不建立索引，等数据全部insert完毕，再建立索引

索引优点：查询效率变快。

索引缺点：建立索引过多，会影响insert速度