java面试中可能常问的几个技术问题及答案

string和stringBuffer的区别；

a.      常量和变量的区别，string虽然可以在后面增加其他字符串，但是增加后就成了另一个对象，所以是个常量，stringBuffer字符串改变后；

b.     当字符串需要经常改变的时候，一般用StringBuffer，运行效果更快；

c.      String中有的api方法，stringbuffer一般都有，但stringbuffer中有的方法，string中不一定有，如append，reverse，insert，delete等方法；

d.     StringBuffer可以通过toString方法转换为String类型。

StringBuffer和StringBuilder的区别

a.      StringBuffer：线程安全的，StringBuilder：线程非安全，即多线程运行的情况下，可能会运行不正常；

b.     只有一个线程运行时，一般StringBuilder不会运行不正常，所以单线程情况下字符串需要做大量改变行为时，可用stringBuilder，多线程运行时，要用StringBuffer。

系统中怎么上传文件；

A．             表单里有默认的文件提交组件，把input的type设置为file，然后设置表单的enctype：multipart/form-data，表单上传的enctype有三种，分别为：application/x-www-form-urlencoded，multipart/form-data，text/plain，一般只能用multipart/form-data,才能进行完整的文件上传。

B． 上传文件默认enctype为application/x-www-form-urlencoded,会对上传的文件内容进行编码，而进行编码的文件将不能进行上传活动；multipart/form-data不对文件内容进行编码，将以二进制格式上传文件，form里的input值将以二进制格式传递到后台服务器，而text/plain将以文本格式传递表单里面的input的值。

 

mybatis和Hibernate哪个性能更好；

a． Hibernate是在jdbc上进行的封装，而mybatis是基于原生jdbc的封装，所以运行速度上，性能上mybatis会优于hibernate；

b．Hibernate对于表的查询，是需要将对象中与表关联的所有属性都查出来，而mybatis可以选择性查询表的字段，查询效率较Hibernate高；

二者的其他区别：

hibernate的学习门槛较高，相对于mybatis更复杂，而mybatis是一个比较简陋的持久层框架；hiberrnate支持对象与表之间的映射，即对象中的属性，直接与表中的字段进行关联，对数据库表的操作可以直接通过对对象的操作来完成，而mybatis一般是直接在配置文件中写sql；缓存机制有差别，hebernate有二级缓存机制，一级缓存在session中可直接设置，二级缓存可在sessionFactory体现，而mybatis的缓存也有自己的session机制，且可在写sql的配置文件中，通过写cache标签来对相应数据进行缓存。

要是我自己选择，我会选择用mybatis框架，嘿嘿。。。

 

 

 

缓存机制；

Redis是最常用的缓存技术；spring整合了redis，故可以直接用spring整合的redis来开发java所开发系统的缓存机制。

Spring的缓存机制，redisTemplate类中有关于缓存的相关api，一般是将前端经常会进行操作或查询的数据，放入到spring缓存中，然后前端若对这部分数据进行操作，spring可直接从缓存中取出，以供用户查询或其他操作；

Redis五大类型，分别有redisTemplate的五种方法来对应操作（以下为转载内容）：

Redis五大类型:字符串（String）、哈希/散列/字典（Hash）、列表（List）、集合（Set）、有序集合（sorted set）五种
Controller:@Resource RedisTemplate<String, String> redisTemplate;
总括:
redisTemplate.opsForValue();//操作字符串
redisTemplate.opsForHash();//操作hash
redisTemplate.opsForList();//操作list
redisTemplate.opsForSet();//操作set
redisTemplate.opsForZSet();//操作有序set，

经常被访问的数据可放在一级缓存，一级缓存中的数据不允许出现并发问题；

很少被修改，不是很重要的数据，很少用到的数据，可以放到二级缓存，可以允许少量的并发问题；

经常被修改的数据，重要的数据，如财务数据，客户信息数据，不能放入二级缓存，不允许出现并发问题。

 

 

 

java的反射机制（以下为转载内容）

比较全的解释了：JAVA反射机制
    JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。
Java反射机制主要提供了以下功能：在运行时判断任意一个对象所属的类；在运行时构造任意一个类的对象；在运行时判断任意一个类所具有的成员变量和方法；在运行时调用任意一个对象的方法；生成动态代理。
1. 得到某个对象的属性

1 public Object getProperty(Object owner, String fieldName) throws Exception {
2     Class ownerClass =owner.getClass();
3
4     Field field = ownerClass.getField(fieldName);
5
6     Object property = field.get(owner);
7
8     return property;
9 }
Class ownerClass = owner.getClass()：得到该对象的Class。

Field field = ownerClass.getField(fieldName)：通过Class得到类声明的属性。

Object property = field.get(owner)：通过对象得到该属性的实例，如果这个属性是非公有的，这里会报IllegalAccessException。

2. 得到某个类的静态属性

 1 public Object getStaticProperty(StringclassName, String fieldName)
 2             throws Exception {
 3    Class ownerClass = Class.forName(className);
 4
 5    Field field = ownerClass.getField(fieldName);
 6
 7    Object property = field.get(ownerClass);
 8
 9    return property;
10 }

Class ownerClass = Class.forName(className) ：首先得到这个类的Class。

Field field = ownerClass.getField(fieldName)：和上面一样，通过Class得到类声明的属性。

Object property = field.get(ownerClass) ：这里和上面有些不同，因为该属性是静态的，所以直接从类的Class里取。

3. 执行某对象的方法

 1 public Object invokeMethod(Objectowner, String methodName, Object[] args) throws Exception {
 2
 3    Class ownerClass = owner.getClass();
 4
 5    Class[] argsClass = new Class[args.length];
 6
 7    for (int i = 0, j = args.length; i < j; i++) {
 8        argsClass[i] = args[i].getClass();
 9    }
10
11     Method method =ownerClass.getMethod(methodName, argsClass);
12
13     return method.invoke(owner, args);
14 }
Class owner_class = owner.getClass() ：首先还是必须得到这个对象的Class。

5～9行：配置参数的Class数组，作为寻找Method的条件。

Method method = ownerClass.getMethod(methodName, argsClass)：通过Method名和参数的Class数组得到要执行的Method。

method.invoke(owner, args)：执行该Method，invoke方法的参数是执行这个方法的对象，和参数数组。返回值是Object，也既是该方法的返回值。

4. 执行某个类的静态方法

 1 public ObjectinvokeStaticMethod(String className, String methodName,
 2             Object[] args) throws Exception {
 3    Class ownerClass = Class.forName(className);
 4
 5    Class[] argsClass = new Class[args.length];
 6
 7    for (int i = 0, j = args.length; i < j; i++) {
 8        argsClass[i] = args[i].getClass();
 9    }
10
11     Method method =ownerClass.getMethod(methodName, argsClass);
12
13     return method.invoke(null, args);
14 }

基本的原理和实例3相同，不同点是最后一行，invoke的一个参数是null，因为这是静态方法，不需要借助实例运行。

5. 新建实例
 1
 2 public Object newInstance(StringclassName, Object[] args) throws Exception {
 3    Class newoneClass = Class.forName(className);
 4
 5    Class[] argsClass = new Class[args.length];
 6
 7    for (int i = 0, j = args.length; i < j; i++) {
 8        argsClass[i] = args[i].getClass();
 9    }
10
11     Constructor cons =newoneClass.getConstructor(argsClass);
12
13     return cons.newInstance(args);
14
15 }

这里说的方法是执行带参数的构造函数来新建实例的方法。如果不需要参数，可以直接使用newoneClass.newInstance()来实现。

Class newoneClass = Class.forName(className)：第一步，得到要构造的实例的Class。

第5～第9行：得到参数的Class数组。

Constructor cons = newoneClass.getConstructor(argsClass)：得到构造子。

cons.newInstance(args)：新建实例。

6. 判断是否为某个类的实例

1 public boolean isInstance(Object obj, Class cls) {
2     return cls.isInstance(obj);
3 }

7. 得到数组中的某个元素
1 public Object getByArray(Object array, int index) {
2     return Array.get(array,index);
3 }

 

；