面试题3

34.集合类
   集合类的由来：
	当对象多了，为了方便于操作，需要一个容器存储。通常使用集合来对对象进行存储。
	为什么不使用数组呢？
	数组虽然可以存储对象，但是长度是固定的，而集合的长度是可变的。
	数组可以存储基本数据类型，而集合只存储对象。


	当容器多了以后，每一个容器因为数据结构的不同，分出了很多容器。那么这些都具备一些共性的特点
	出现上向抽取。最终顶层类或者接口中定义的就是集合框架的共性方法。
	这个顶层接口之一就是Collection 。

35.Map:以键值对的形式存入，必须要保证键的唯一性。
    添加：put(key,value):
		如果存入已有的键，会发生值覆盖的情况。
    判断：containsKey(key),containsValue(value)
    删除：remove(key)
    个数：size();
    取出：get(key)
	当返回为null时，对于HashMap有两种情况，一，该键不存在，二，该键存在对应的值是null。
    取出所有元素:
	原理：将Map集合转成Set集合。再通过迭代器取出。
	keySet():将Map集合中的所有键取出存入到了Set集合中，在通过迭代器遍历，在遍历过程中，
		 使用Map集合的get方法取出键所对应的值。

	entrySet():将Map集合中的键值映射关系取出，被封装成了Map.Entry对象。并将Map.Entry对象存入到了Set集合中。
		   通过迭代器取出Map.Entry 对象，并通过该对象的getKey(),getValue()方法取出map集合中的键和值。

    取出所有值：values();
	
	|--HashMap:数据结构是哈希表，线程是不安全的，可以存入null键null值。
	|--HashTable:数据结构是哈希表，线程是安全的，不可以存入null键null值，被HashMap所取代。
	|--TreeMap:数据结构是二叉树，线程是不安全的，可以对Map集合中的键进行排序。

    什么时候使用Map集合呢？
    当分析问题时，对象间出现了映射关系时，就要先想到Map集合。

36.JDK1.5版本出现的新特性：
	可变参数。
	void show(String... arr){}
	其实arr接收就是一个String类型的数组。但是好处在于传递参数的时候，可以将String类型的元素，直接作为参数传递，
	而不用将这些元素封装成数组在传递，简化了参数传递过程。
	注意：可变参数一定要定义在参数列表的最后。

	增强型的for循环：
	for(Element e　：集合或者数组)
	{
	
	}
	增强for循环在使用时，必须有被遍历的目标。

37.IO流和网络编程好像一直没有用到
   集合经常用于处理数据，业务层常用到
   多线程估计以后java高级水平才会用吧

38.反射:


39.hibernate和mybatis区别
   Hibernate与Mybatis对比总结
   两者相同点

    Hibernate与MyBatis都可以是通过SessionFactoryBuider由XML配置文件生成SessionFactory，然后由SessionFactory 生成Session，最后由Session来开启执行事务和SQL语句。其中SessionFactoryBuider，SessionFactory，Session的生命周期都是差不多的。
    Hibernate和MyBatis都支持JDBC和JTA事务处理。

   Mybatis优势

    MyBatis可以进行更为细致的SQL优化，可以减少查询字段。
    MyBatis容易掌握，而Hibernate门槛较高。

   Hibernate优势

    Hibernate的DAO层开发比MyBatis简单，Mybatis需要维护SQL和结果映射。
    Hibernate对对象的维护和缓存要比MyBatis好，对增删改查的对象的维护要方便。
    Hibernate数据库移植性很好，MyBatis的数据库移植性不好，不同的数据库需要写不同SQL。
    Hibernate有更好的二级缓存机制，可以使用第三方缓存。MyBatis本身提供的缓存机制不佳。

   他人总结

    Hibernate功能强大，数据库无关性好，O/R映射能力强，如果你对Hibernate相当精通，而且对Hibernate进行了适当的封装，那么你的项目整个持久层代码会相当简单，需要写的代码很少，开发速度很快，非常爽。
    Hibernate的缺点就是学习门槛不低，要精通门槛更高，而且怎么设计O/R映射，在性能和对象模型之间如何权衡取得平衡，以及怎样用好Hibernate方面需要你的经验和能力都很强才行。
    iBATIS入门简单，即学即用，提供了数据库查询的自动对象绑定功能，而且延续了很好的SQL使用经验，对于没有那么高的对象模型要求的项目来说，相当完美。
    iBATIS的缺点就是框架还是比较简陋，功能尚有缺失，虽然简化了数据绑定代码，但是整个底层数据库查询实际还是要自己写的，工作量也比较大，而且不太容易适应快速数据库修改。
 
   ---------------
   葵花宝典
   相同点： 屏蔽 jdbc api 的底层访问细节， 使用我们不用与 jdbc api 打交道， 就可以访问数据。
   jdbc api 编程流程固定，还将 sql 语句与 java 代码混杂在了一起，经常需要拼凑 sql 语句，
   细节很繁琐。
   ibatis 的好处：屏蔽 jdbc api 的底层访问细节；将 sql 语句与 java 代码进行分离;提供了将结
   果集自动封装称为实体对象和对象的集合的功能，queryForList 返回对象集合，用
   queryForObject 返回单个对象；提供了自动将实体对象的属性传递给 sql 语句的参数。
   Hibernate 是一个全自动的 orm 映射工具，它可以自动生成 sql 语句,ibatis 需要我们自己在
   xml 配置文件中写 sql 语句，hibernate 要比 ibatis 功能负责和强大很多。因为 hibernate 自
   动生成 sql 语句，我们无法控制该语句，我们就无法去写特定的高效率的 sql。对于一些不
   太复杂的 sql 查询， hibernate 可以很好帮我们完成， 但是， 对于特别复杂的查询， hibernate
   就很难适应了，这时候用 ibatis 就是不错的选择，因为 ibatis 还是由我们自己写 sql 语句。

40.MVC
   M 即Model(模型层)，主要负责出来业务逻辑以及数据库的交互
   V 即View(视图层)，主要用于显示数据和提交数据
   C 即Controller(控制器)，主要是用作捕获请求并控制请求转发

41.面试题：请解释字符串比较之中“==”和equals()的区别？

     ==：比较的是两个字符串内存地址（堆内存）的数值是否相等，属于数值比较；
     equals()：比较的是两个字符串的内容，属于内容比较。

   以后进行字符串相等判断的时候都使用equals()。


42.Java中的内存
   博客园：
   Java把内存分成两种，一种叫做栈内存，一种叫做堆内存
   在函数中定义的一些基本类型的变量和对象的引用变量都是在函数的栈内存中分配。
   当在一段代码块中定义一个变量时，java就在栈中为这个变量分配内存空间，
   当超过变量的作用域后，java会自动释放掉为该变量分配的内存空间，该内存空间可以立刻被另作他用。
   
   堆内存用于存放由new创建的对象和数组。
   在堆中分配的内存，由java虚拟机自动垃圾回收器来管理。
   在堆中产生了一个数组或者对象后，还可以在栈中定义一个特殊的变量，
   这个变量的取值等于数组或者对象在堆内存中的首地址，在栈中的这个特殊的变量就变成了数组或者对象的引用变量，
   以后就可以在程序中使用栈内存中的引用变量来访问堆中的数组或者对象，引用变量相当于为数组或者对象起的一个别名，或者代号。

   引用变量是普通变量，定义时在栈中分配内存，引用变量在程序运行到作用域外释放。
   而数组＆对象本身在堆中分配，即使程序运行到使用new产生数组和对象的语句所在地代码块之外，
   数组和对象本身占用的堆内存也不会被释放，数组和对象在没有引用变量指向它的时候，才变成垃圾，不能再被使用，
   但是仍然占着内存，在随后的一个不确定的时间被垃圾回收器释放掉。这个也是java比较占内存的主要原因，实际上，
   栈中的变量指向堆内存中的变量，这就是 Java 中的指针! 

43.求2/1+3/2+5/3+8/5+13/8+......前100项和的小程序！
    package com.tsak;
    public class Test {
         public static void main(String[] args){
             double a=2;
             double b=1;
             double t;
             double sum=0;
             for(int i=1;i<=100;i++){
                double A=a/b;
                sum=sum+A;
                t=a;
                a=a+b;
                b=t;
           }
             System.out.println("前100项和为：sum="+sum);
        }
     }
    ----------------------------------------------------------------------
   
44.如何实现字符串的反转，如：输入abc，输出cba  
   String str = "abc";
   String reStr = new StringBuilder(str).reverse().toString();

45.存储过程


46.内连接(等值连接)（博客园）
   外连接
     左外连接（左连接）：是以左表为基准，将a.stuid = b.stuid的数据进行连接，然后将左表没有的对应项显示，右表的列为NULL
     右外连接（右连接）：是以右表为基准，将a.stuid = b.stuid的数据进行连接，然以将右表没有的对应项显示，左表的列为NULL
     全外连接（全连接）：完整外部联接返回左表和右表中的所有行。当某行在另一个表中没有匹配行时，则另一个表的选择列表列包含空值。如果表之间有匹配行，则整个结果集行包含基表的数据值。

47.建视图语句（博客园）
   创建视图的语法

   CREATE [OR REPLACE] [ALGORITHM = {UNDEFINED | MERGE | TEMPTABLE}]
      VIEW view_name [(column_list)]
      AS select_statement
      [WITH [CASCADED | LOCAL] CHECK OPTION]

   其中，CREATE：表示新建视图；

   REPLACE：表示替换已有视图

   ALGORITHM ：表示视图选择算法

   view_name ：视图名

   column_list：属性列

   select_statement：表示select语句

   [WITH [CASCADED | LOCAL] CHECK OPTION]参数表示视图在更新时保证在视图的权限范围之内
   
48.索引（博客园）
   索引的优点：

   1、通过创建唯一索引，保证数据库表每行数据的唯一性

   2、大大加快数据查询速度

   3、在使用分组和排序进行数据查询时，可以显著减少查询中分组和排序的时间

   索引的缺点：

   1、维护索引需要耗费数据库资源

   2、索引需要占用磁盘空间，索引文件可能比数据文件更快达到最大文件尺寸

   3、当对表的数据进行增删改的时候，因为要维护索引，速度会受到影响

49.触发器（博客园）
   触发器是一个特殊的存储过程，不同的是存储过程要用CALL来调用，而触发器不需要使用CALL

   也不需要手工启动，只要当一个预定义的事件发生的时候，就会被MYSQL自动调用。 

   创建触发器

   法如下：

   CREATE TRIGGER trigger_name trigger_time trigger_event
       ON tbl_name FOR EACH ROW trigger_stmt

   触发程序是与表有关的命名数据库对象，当表上出现特定事件时，将激活该对象。 

50.sql注入（程序员的sql经典）
   对付 SQL 注入漏洞有两种方式：过滤敏感字符和使用参数化 SQL。

51.sql优化（博客园）
   1.创建必要的索引
   2.使用预编译查询
   3.调整 WHERE 子句中的连接顺序
   4. SELECT 语句中避免使用'*'
   5.尽量将多条 SQL 语句压缩到一句 SQL 中
   6.用 Where 子句替换 HAVING 子句
   7.使用表的别名
   8.用 EXISTS 替代 IN
   9.。。。略

52.单元测试（博客园）
   单元测试是开发者编写的一小段代码，用于检验被测代码的一个很小的、很明确的功能是否正确。
   通常而言，一个单元测试是用于判断某个特定条件（或者场景）下某个特定函数的行为。
   例如，你可能把一个很大的值放入一个有序list 中去，然后确认该值出现在list 的尾部。
   或者，你可能会从字符串中删除匹配某种模式的字符，然后确认字符串确实不再包含这些字符了。

53.设计模式


54.springMVC和struts2的区别


55.SSH(博客园)
   Struts作为系统的整体基础架构，负责MVC的分离，在Struts框架的模型部分，控制业务跳转，利用Hibernate框架对持久层提供支持，
   Spring做管理，管理struts和hibernate。具体做法是：用面向对象的分析方法根据需求提出一些模型，
   将这些模型实现为基本的Java对象，然后编写基本的DAO(Data Access Objects)接口，并给出Hibernate的DAO实现，
   采用Hibernate架构实现的DAO类来实现Java类与数据库之间的转换和访问，最后由Spring做管理，管理struts和hibernate。

   ------------
   博客园
   集成SSH框架的系统框架图如图4所示，系统从职责上分为四层：表示层、业务逻辑层、数据持久层和域模块层。
   其中使用Struts作为系统的整体基础架构，负责MVC的分离，在Struts框架的模型部分，利用Hibernate框架对持久层提供支持，
   业务层用Spring支持。具体做法是：用面向对象的分析方法根据需求提出一些模型，将这些模型实现为基本的Java对象，
   然后编写基本的DAO接口，并给出Hibernate的DAO实现，
   采用Hibernate架构实现的DAO类来实现Java类与数据库之间的转换和访问，最后由Spring完成业务逻辑。

   系统的基本业务流程是： 在表示层中，首先通过JSP页面实现交互界面，负责传送请求(Request)和接收响应(Response)，
   然后Struts根据配置文件(struts-config.xml)将ActionServlet接收到的Request委派给相应的Action处理。
   在业务层中，管理服务组件的Spring IoC容器负责向Action提供业务模型(Model)组件和该组件的协作对象数据处理(DAO)组件完成业务逻辑，
   并提供事务处理、缓冲池等容器组件以提升系统性能和保证数据的完整性。
   而在持久层中，则依赖于Hibernate的对象化映射和数据库交互，处理DAO组件请求的数据，并返回处理结果。

56.MongoDB(博客园)
   非关系型数据库
   NoSQL采用的是对集合（类似"表"）中的文档（类似于"行"）进行动态追加，在创建集合之初不会对数据类型进行限定，
   任何文档都可以追加到任何集合中去，例如我们可以将这样两条文档添加到一个集合中去：
   {"name" : "John", "song" : "Come Together"}

   {"name" : "小明",  "age":"20", "email" : "xiaoming@111.com"}

   MongoDB中文档的格式类似于我们常见的JSON，由此可见，我们第一个拥有"name"、"song"两个字段，
   而第二个拥有"name"、"age"、"email"三个字段，这在预设计模式中的数据库是不可能插入成功的，
   但在MongoDB的动态模式是可以的，这样做的优势是我们不必为一些数量很少，
   但种类很多的字段单独设计一张表，可以将他们集中在单独一张表进行存储，
   但这样做的弊病也是显而易见的，我们在获取数据时需要对同一张表的不同文档进行区分，
   增加了开发上的代码量。所以在设计之初需要权衡动态模式的优劣来选择表中的数据类型。

57.mybatis和hibernate本质区别和应用场景（Springmvc+Mybatis由浅入深全套视频教程）
   hibernate：是一个标准ORM框架（对象关系映射）。入门门槛较高的，不需要程序写sql，sql语句自动生成了。
   对sql语句进行优化、修改比较困难的。
   应用场景：
	适用与需求变化不多的中小型项目，比如：后台管理系统，erp、orm、oa。。

   mybatis：专注是sql本身，需要程序员自己编写sql语句，sql修改、优化比较方便。mybatis是一个不完全 的ORM框架，虽然程序员自己写sql，mybatis 也可以实现映射（输入映射、输出映射）。
   应用场景：
	适用与需求变化较多的项目，比如：互联网项目。

   企业进行技术选型，以低成本 高回报作为技术选型的原则，根据项目组的技术力量进行选择。


58.数据类型(掌握)
	(1)Java是一种强类型语言，针对每种数据都提供了对应的数据类型。
	(2)分类：
		A:基本数据类型：4类8种
		B:引用数据类型：类，接口，数组。
	(3)基本数据类型
		A:整数			占用字节数
			byte			1
			short			2
			int 			4
			long			8
		B:浮点数
			float			4
			double			8
		C:字符
			char			2
		D:布尔
			boolean			1
			
		注意：
			整数默认是int类型，浮点数默认是double。
			
			长整数要加L或者l。
			单精度的浮点数要加F或者f。
59.Java的内存分配
		A:栈 存储局部变量
		B:堆 存储所有new出来的
		C:方法区(面向对象部分详细讲解)
		D:本地方法区(系统相关)
		E:寄存器(CPU使用)
		
		注意：
			a:局部变量 在方法定义中或者方法声明上定义的变量。
			b:栈内存和堆内存的区别
				栈：数据使用完毕，就消失。
				堆：每一个new出来的东西都有地址
				    每一个变量都有默认值
						byte,short,int,long 0
						float,double 0.0
						char '\u0000'
						boolean false
						引用类型 null
				    数据使用完毕后，在垃圾回收器空闲的时候回收。
   
60.Java中的参数传递问题
		Java中只有值传递。
		
		基本类型：形式参数的改变不影响实际参数
		引用类型：形式参数的改变直接影响实际参数

61.成员变量和局部变量的区别(理解)
	(1)在类中的位置不同
		成员变量：类中方法外
		局部变量：方法定义中或者方法声明上
	(2)在内存中的位置不同
		成员变量：在堆中
		局部变量：在栈中
	(3)生命周期不同
		成员变量：随着对象的创建而存在，随着对象的消失而消失
		局部变量：随着方法的调用而存在，随着方法的调用完毕而消失
	(4)初始化值不同
		成员变量：有默认值
		局部变量：没有默认值，必须定义，赋值，然后才能使用

62.代码：Student s = new Student();做了哪些事情?(理解)
	(1)把Student.class文件加载到内存
	(2)在栈内存为s开辟空间
	(3)在堆内存为学生对象申请空间
	(4)给学生的成员变量进行默认初始化。null,0
	(5)给学生的成员变量进行显示初始化。林青霞,27
	(6)通过构造方法给成员变量进行初始化。刘意,30
	(7)对象构造完毕，把地址赋值给s变量

63.static关键字(理解)
	(1)静态的意思。可以修饰成员变量和成员方法。
	(2)静态的特点：
		A:随着类的加载而加载
		B:优先与对象存在
		C:被类的所有对象共享
			这其实也是我们判断该不该使用静态的依据。
			举例：饮水机和水杯的问题思考
		D:可以通过类名调用
			既可以通过对象名调用，也可以通过类名调用，建议通过类名调用。
	(3)静态的内存图
		静态的内容在方法区的静态区
	(4)静态的注意事项；
		A:在静态方法中没有this对象
		B:静态只能访问静态(代码测试过)
	(5)静态变量和成员变量的区别
		A:所属不同
			静态变量：属于类，类变量
			成员变量：属于对象，对象变量，实例变量
		B:内存位置不同
			静态变量：方法区的静态区
			成员变量：堆内存
		C:生命周期不同
			静态变量：静态变量是随着类的加载而加载，随着类的消失而消失
			成员变量：成员变量是随着对象的创建而存在，随着对象的消失而消失
		D:调用不同
			静态变量：可以通过对象名调用，也可以通过类名调用
			成员变量：只能通过对象名调用

64.final关键字(掌握)
	面试：
        用final关键字修饰对象变量，只是不允许这个对象引用再指向其他的对象，但是这个引用所指向的对象的内容是可以改变的。！！！
	博客园：
        需要注意的是，如果将引用类型（任何类的类型）的变量标记为 final，
        那么该变量不能指向任何其它对象。但可以改变对象的内容，因为只有引用本身是 final 的。

	(1)是最终的意思，可以修饰类，方法，变量。
	(2)特点：
		A:它修饰的类，不能被继承。
		B:它修饰的方法，不能被重写。
		C:它修饰的变量，是一个常量。
	(3)面试相关：
		A:局部变量
			a:基本类型 值不能发生改变
			b:引用类型 地址值不能发生改变，但是对象的内容是可以改变的
		B:初始化时机
			a:只能初始化一次。
			b:常见的给值
				定义的时候。(推荐)
				构造方法中。
65.形式参数和返回值的问题(理解)
	(1)形式参数：
		类名：需要该类的对象
		抽象类名：需要该类的子类对象
		接口名：需要该接口的实现类对象
	(2)返回值类型：
		类名：返回的是该类的对象
		抽象类名：返回的是该类的子类对象
		接口名：返回的是该接口的实现类的对象
	(3)链式编程
		对象.方法1().方法2().......方法n();
		
		这种用法：其实在方法1()调用完毕后，应该一个对象；
			      方法2()调用完毕后，应该返回一个对象。
				  方法n()调用完毕后，可能是对象，也可以不是对象。

66.权限修饰符(掌握)
	(1)权限修饰符
				本类	同一个包下	不同包下的子类	不同包下的无关类
		private		Y
		默认		Y	        Y
		protected	Y		Y		Y
		public		Y		Y		Y	Y
	(2)这四种权限修饰符在任意时刻只能出现一种。
		public class Demo {}	

67.面试题 
			==和equals()的区别?
			A:==
				基本类型：比较的是值是否相同
				引用类型：比较的是地址值是否相同
			B:equals()
				只能比较引用类型。默认情况下，比较的是地址值是否相同。
				但是，我们可以根据自己的需要重写该方法。

68.String类的概述和使用(掌握)
	(1)多个字符组成的一串数据。
		其实它可以和字符数组进行相互转换。
	(2)构造方法：
		A:public String()
		B:public String(byte[] bytes)
		C:public String(byte[] bytes,int offset,int length)
		D:public String(char[] value)
		E:public String(char[] value,int offset,int count)
		F:public String(String original)
		下面的这一个虽然不是构造方法，但是结果也是一个字符串对象
		G:String s = "hello";
	(3)字符串的特点
		A:字符串一旦被赋值，就不能改变。
			注意：这里指的是字符串的内容不能改变，而不是引用不能改变。
		B:字面值作为字符串对象和通过构造方法创建对象的不同
			String s = new String("hello");和String s = "hello"的区别?
			有。前者会创建2个对象，后者创建1个对象。
	(4)字符串的面试题(看程序写结果)
		A:==和equals()
			String s1 = new String("hello");
			String s2 = new String("hello");
			System.out.println(s1 == s2);// false
			System.out.println(s1.equals(s2));// true

			String s3 = new String("hello");
			String s4 = "hello";
			System.out.println(s3 == s4);// false
			System.out.println(s3.equals(s4));// true

			String s5 = "hello";
			String s6 = "hello";
			System.out.println(s5 == s6);// true
			System.out.println(s5.equals(s6));// true
		B:字符串的拼接
			String s1 = "hello";
			String s2 = "world";
			String s3 = "helloworld";
			System.out.println(s3 == s1 + s2);// false
			System.out.println(s3.equals((s1 + s2)));// true

			System.out.println(s3 == "hello" + "world");// false 这个我们错了，应该是true
			System.out.println(s3.equals("hello" + "world"));// true
	(5)字符串的功能(自己补齐方法中文意思)
		A:判断功能
			boolean equals(Object obj)
			boolean equalsIgnoreCase(String str)
			boolean contains(String str)
			boolean startsWith(String str)
			boolean endsWith(String str)
			boolean isEmpty()
		B:获取功能
			int length()
			char charAt(int index)
			int indexOf(int ch)
			int indexOf(String str)
			int indexOf(int ch,int fromIndex)
			int indexOf(String str,int fromIndex)
			String substring(int start)
			String substring(int start,int end)
		C:转换功能
			byte[] getBytes()
			char[] toCharArray()
			static String valueOf(char[] chs)
			static String valueOf(int i)
			String toLowerCase()
			String toUpperCase()
			String concat(String str)
		D:其他功能
			a:替换功能 
				String replace(char old,char new)
				String replace(String old,String new)
			b:去空格功能
				String trim()
			c:按字典比较功能
				int compareTo(String str)
				int compareToIgnoreCase(String str) 

69.博客园
   什么是JavaBean？

　　JavaBean 是一种JAVA语言写成的可重用组件，本质上是一个类，具有以下特性：

    它是一个public类型的类，属性则为private类型的，通过public的方法暴露给其它程序
    必须具有一个无参的构造函数
    提供setXXX()方法和getXXX()方法让外部程序设置和获取JavaBean属性

　　一个JavaBean主要由三个部分组成：

    属性：是JavaBean组件内部状态的抽象表示
    方法：就是通常的Java方法，默认情况下所有的方法都可以被外部调用
    事件：Bean与其他软件组织交流信息的主要方式是发送和接收事件

70.StringBuffer(掌握)
	(1)用字符串做拼接，比较耗时并且也耗内存，而这种拼接操作又是比较常见的，为了解决这个问题，Java就提供了
	   一个字符串缓冲区类。StringBuffer供我们使用。
	(2)StringBuffer的构造方法
		A:StringBuffer()
		B:StringBuffer(int size)
		C:StringBuffer(String str)
	(3)StringBuffer的常见功能(自己补齐方法的声明和方法的解释)
		A:添加功能
		B:删除功能
		C:替换功能
		D:反转功能
		E:截取功能(注意这个返回值)
	(4)StringBuffer的练习(做一遍)
		A:String和StringBuffer相互转换
			String -- StringBuffer
				构造方法
			StringBuffer -- String
				toString()方法
		B:字符串的拼接
		C:把字符串反转
		D:判断一个字符串是否对称
	(5)面试题
		小细节：
			StringBuffer：同步的，数据安全，效率低。
			StringBuilder：不同步的，数据不安全，效率高。
		A:String,StringBuffer,StringBuilder的区别
		B:StringBuffer和数组的区别?
	(6)注意的问题：
		String作为形式参数，StringBuffer作为形式参数。

71.List集合的特有遍历功能
		A:由size()和get()结合。
		B:代码演示
					//创建集合对象
					List list = new ArrayList();
					
					//创建并添加元素
					list.add("hello");
					list.add("world");
					list.add("java");
					
					//遍历集合
					Iterator it = list.iterator();
					while(it.hasNext()) {
						String s =(String) it.next();
						System.out.println(s);
					}
					System.out.println("----------");
					
					for(int x=0; x<list.size(); x++) {
						String s =(String) list.get(x);
						System.out.println(s);
					}
   (6)常见数据结构
		A:栈 先进后出
		B:队列 先进先出
		C:数组 查询快，增删慢
		D:链表 查询慢，增删快
   (7)List的子类特点(面试题)
		ArrayList
			底层数据结构是数组，查询快，增删慢。
			线程不安全，效率高。
		Vector
			底层数据结构是数组，查询快，增删慢。
			线程安全，效率低。
		LinkedList
			底层数据结构是链表，查询慢，增删快。
			线程不安全，效率高。
72.Collection
		|--List	有序,可重复
			|--ArrayList
				底层数据结构是数组，查询快，增删慢。
				线程不安全，效率高
			|--Vector
				底层数据结构是数组，查询快，增删慢。
				线程安全，效率低
			|--LinkedList
				底层数据结构是链表，查询慢，增删快。
				线程不安全，效率高
		|--Set	无序,唯一
			|--HashSet
				底层数据结构是哈希表。
				如何保证元素唯一性的呢?
					依赖两个方法：hashCode()和equals()
					开发中自动生成这两个方法即可
				|--LinkedHashSet
					底层数据结构是链表和哈希表
					由链表保证元素有序
					由哈希表保证元素唯一
			|--TreeSet
				底层数据结构是红黑树。
				如何保证元素排序的呢?
					自然排序
					比较器排序
				如何保证元素唯一性的呢?
					根据比较的返回值是否是0来决定

73.Map(掌握)
	(1)将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。 
	(2)Map和Collection的区别?
		A:Map 存储的是键值对形式的元素，键唯一，值可以重复。夫妻对
		B:Collection 存储的是单独出现的元素，子接口Set元素唯一，子接口List元素可重复。光棍
	(3)Map接口功能概述(自己补齐)
		A:添加功能
		B:删除功能
		C:判断功能
		D:获取功能
		E:长度功能
	(4)Map集合的遍历
		A:键找值
			a:获取所有键的集合
			b:遍历键的集合,得到每一个键
			c:根据键到集合中去找值
		
		B:键值对对象找键和值
			a:获取所有的键值对对象的集合
			b:遍历键值对对象的集合，获取每一个键值对对象
			c:根据键值对对象去获取键和值
			
		代码体现：
			Map<String,String> hm = new HashMap<String,String>();
			
			hm.put("it002","hello");
			hm.put("it003","world");
			hm.put("it001","java");
			
			//方式1 键找值
			Set<String> set = hm.keySet();
			for(String key : set) {
				String value = hm.get(key);
				System.out.println(key+"---"+value);
			}
			
			//方式2 键值对对象找键和值
			Set<Map.Entry<String,String>> set2 = hm.entrySet();
			for(Map.Entry<String,String> me : set2) {
				String key = me.getKey();
				String value = me.getValue();
				System.out.println(key+"---"+value);
			}

74.单点登录（Single sign-on，SSO）是一种访问控制，在多个软件应用中，用户只需登录其中一个应用，就可以成功访问其他应用；
   同样，用户只需注销其中一个应用，就可以成功注销其他应用。

   当一个公司产品线越来越复杂，做的东西越来越多，考虑到用户的便利性和业务的交集，单点登录也就变得越来越必然。
   譬如，阿里巴巴中的淘宝网，天猫，聚划算和一淘，考虑下面的场景：我们用户登录淘宝网购物，紧接着朋友打电话说出去玩，
   于是打开聚划算的时候你会发现，你已经登了聚划算！可能这些细节都被大多数人忽略了（被谁给惯坏了），
   但如果要让用户再次手动登录聚划算，用户体验可想而知。这种便利性就是单点登录所带来的。

   在单点登录中，认证系统会为每一个应用分配一把钥匙，也就是说有了这把钥匙，账号密码的输入就可以免去了。这把钥匙就藏在浏览器的 cookie 中。

75.SVN命令：
   1、检出 co
   2、导出 export  
   3、添加新文件 add
   4、提交 commit
   5、更新文件 update
   6、删除文件 delete
   7、加锁/解锁 lock unlock
   8、比较差异 diff 
   ...
   15、恢复本地修改 revert
   17、解决冲突 resolved
   20、合并内容到分支 merge

76.Oracle安装后的优化配置（云融网）

77.表空间：
   Oracle数据库是通过表空间来存储物理表的，一个数据库实例可以有N个表空间，一个表空间下可以有N张表。

   有了数据库，就可以创建表空间。

   表空间(tablespace)是数据库的逻辑划分，每个数据库至少有一个表空间（称作SYSTEM表空间）。为了便于管理和提高运行效率，可以使用一些附加表空间来划分用户和应用程序。例如：USER表空间供一般用户使用，RBS表空间供回滚段使用。一个表空间只能属于一个数据库。

   创建表空间语法：

   Create TableSpace 表空间名称  
   DataFile          表空间数据文件路径  
   Size              表空间初始大小  
   Autoextend on

   如：

   create tablespace db_test  
   datafile 'D:\oracle\product\10.2.0\userdata\db_test.dbf'  
   size 50m  
   autoextend on;

   查看已经创建好的表空间：

   select default_tablespace, temporary_tablespace, d.username  
   from dba_users d

   用户：

   Oracle数据库建好后，要想在数据库里建表，必须先为数据库建立用户，并为用户指定表空间。

   上面我们建好了数据库和表空间，接下来建用户：

   创建新用户：

   CREATE USER          用户名  
   IDENTIFIED BY        密码  
   DEFAULT TABLESPACE   表空间(默认USERS)  
   TEMPORARY TABLESPACE 临时表空间(默认TEMP) 

   如：

   CREATE USER utest  
   IDENTIFIED BY utestpwd  
   DEFAULT TABLESPACE db_test  
   TEMPORARY TABLESPACE temp;（这里临时表空间不能使用我们创建的db_test，不知为何？） 

   有了用户，要想使用用户账号管理自己的表空间，还得给它分权限：

   GRANT CONNECT TO utest;  
   GRANT RESOURCE TO utest;  
   GRANT dba TO utest;--dba为最高级权限，可以创建数据库，表等。

   查看数据库用户：

   select  * from dba_users;

   表：
   有了数据库，表空间和用户，就可以用自定义的用户在自己的表空间创建表了。有了表，我们可以开发了。

78.使用分区方式建立的表叫分区表

   范围分区
   每个分区都由一个分区键值范围指定（对于一个以日期列作为分区键的表，“2005 年 1 月”分区包含分区键值为从“2005 年 1 月 1 日”
   到“2005 年 1 月 31 日”的行）。

   列表分区
   每个分区都由一个分区键值列表指定（对于一个地区列作为分区键的表，“北美”分区可能包含值“加拿大”“美国”和“墨西哥”）。

   分区功能通过改善可管理性、性能和可用性，从而为各式应用程序带来了极大的好处。
   通常，分区可以使某些查询以及维护操作的性能大大提高。此外,分区还可以极大简化常见的管理任务。
   通过分区,数据库设计人员和管理员能够解决前沿应用程序带来的一些难题。分区是构建千兆字节数据系统或超高可用性系统的关键工具。

   ----------------------
   在大量业务数据处理的项目中，可以考虑使用分区表来提高应用系统的性能并方便数据管理，本文详细介绍了分区表的使用。
 
　 在大型的企业应用或企业级的数据库应用中，要处理的数据量通常可以达到几十到几百GB，有的甚至可以到TB级。虽然存储介质和数据处理技术的发展也很快，但是仍然不能满足用户的需求，为了使用户的大量的数据在读写操作和查询中速度更快，Oracle提供了对表和索引进行分区的技术，以改善大型应用系统的性能。

　 使用分区的优点：

　·增强可用性：如果表的某个分区出现故障，表在其他分区的数据仍然可用；

　·维护方便：如果表的某个分区出现故障，需要修复数据，只修复该分区即可；

　·均衡I/O：可以把不同的分区映射到磁盘以平衡I/O，改善整个系统性能；

　·改善查询性能：对分区对象的查询可以仅搜索自己关心的分区，提高检索速度。 

79.索引：
   “索引（Index）提供查询的速度”这是对索引的最基本的解释，接下来我们将通过介绍索引的组成，让大家对索引有更深入的理解。

   索引是数据库中的一个独特的结构，由于它保存数据库信息，那么我们就需要给它分配磁盘空间和维护索引表。
   创建索引并不会改变表中的数据，它只是创建了一个新的数据结构指向数据表；打个比方，平时我们使用字典查字时，
   首先我们要知道查询单词起始字母，然后翻到目录页，接着查找单词具体在哪一页，这时我们目录就是索引表，而目录项就是索引了。

   当然，索引比字典目录更为复杂，因为数据库必须处理插入，删除和更新等操作，这些操作将导致索引发生变化。

   索引的类型：

   我们知道索引的类型有两种：聚集索引和非聚集索引。

   聚集索引：物理存储按照索引排序。

   非聚集索引：物理存储不按照索引排序。 

80.hibernate的关系维护配置：（云融网）
   项目中没有使用到

81.Tomcat端口号配置在什么文件中：server.xml

82.spring事务
   

83.spring集成Quartz定时任务
   在JavaEE系统中，我们会经常用到定时任务，比如每天凌晨生成前天报表，每一小时生成汇总数据等等。
   我们可以使用java.util.Timer结合java.util.TimerTask来完成这项工作，但时调度控制非常不方便，并且我们需要大量的代码。
   使用Quartz框架无疑是非常好的选择，并且与Spring可以非常方便的集成
 

84.oracle行列转换（博客园）

JOB 	10(DEPTNO) 	20(DEPTNO) 	30(DEPTNO) 	40(DEPTNO)
CLERK 	   1 	          2 	            1 	             0
SALESMAN   0 	          0 	            4 	             0
PRESIDENT  1 	          0 	            0 	             0
MANAGER    1 	          1 	            1 	             0
ANALYST    0 	          2 	            0 	             0


一、经典的实现方式（其他的暂时略过）

主要是利用decode函数、聚合函数（如max、sum等）、group by分组实现的
  select t.job, count(decode(t.deptno, '10', 1)) as "10(DEPTNO)",
       count(decode(t.deptno, '20', 1)) as "20(DEPTNO)",
       count(decode(t.deptno, '30', 1)) as "30(DEPTNO)",
       count(decode(t.deptno, '40', 1)) as "40(DEPTNO)"
  from scott.emp t
  group by t.job;


85.在oracle中varchar和varchar2有什么区别？（上海大域南京分公司）
1.varchar2把所有字符都占两字节处理(一般情况下)，varchar只对汉字和全角等字符占两字节，数字，英文字符等都是一个字节； 
2.VARCHAR2把空串等同于null处理，而varchar仍按照空串处理； 
3.VARCHAR2字符要用几个字节存储，要看数据库使用的字符集， 大部分情况下建议使用varchar2类型，可以保证更好的兼容性。


varchar是ANSI SQL标准的数据类型，Oracle作为SQL数据库对其提供部分支持。
两者的不同点是：ANSI标准的varchar可以存储空字符串，而Oracle并不区分空字符串和NULL(也就是把空字符串做为NULL处理)。
因为Oracle保留在未来对ANSI标准提供完全支持的权利，所以可能会出现允许varchar中存储空字符串，或者随着ANSI标准的修订而变更varchar类型定义的情况。因此Oracle中的varchar类型不能保证始终向前兼容。varchar2是Oracle特有的数据类型，不会受到外界标准的影响，可以在Oracle内部保证向前兼容。
常见的9i和10g中，varchar与varchar2是同义词，二者完全一致。但由于上述原因，Oracle不推荐使用varchar类型。11g我不清楚，细节请查阅相关文档。


86.springmvc和struts2的区别
 
1. 机制：spring mvc的入口是servlet，而struts2是filter（这里要指出，filter和servlet是不同的。以前认为filter是servlet的一种特殊），这样就导致了二者的机制不同，这里就牵涉到servlet和filter的区别了。

2. 线程安全：struts2线程安全，springmvc线程不安全

3. 参数传递：sturts是基于类，每次发一次请求都会实例一个action，然后调用setter getter方法把request中的数据注入.一个Action对象对应一个request上下文。

                   spring3 mvc是方法级别的拦截，拦截到方法后根据参数上的注解，把request数据通过反射注入进去，一个方法对应一个request上下文。

4. 设计思想上：struts更加符合oop的编程思想， spring就比较谨慎，在servlet上扩展。

 
5. intercepter的实现机制：struts有以自己的interceptor机制，spring mvc用的是独立的AOP方式。这样导致struts的配置文件量还是比spring mvc大，虽然struts的配置能继承，所以我觉得论使用上来讲，spring mvc使用更加简洁，开发效率Spring MVC确实比struts2高。

    spring mvc是方法级别的拦截，一个方法对应一个request上下文，而方法同时又跟一个url对应，所以说从架构本身上spring3 mvc就容易实现restful url。     struts2是类级别的拦截，一个类对应一个request上下文；实现restful url要费劲，因为struts2 action的一个方法可以对应一个url；而其类属性却被所有方法共享，这也就无法用注解或其他方式标识其所属方法了。

     spring3 mvc的方法之间基本上独立的，独享request response数据，请求数据通过参数获取，处理结果通过ModelMap交回给框架方法之间不共享变量，而struts2搞的就比较乱，虽然方法之间也是独立的，但其所有Action变量是共享的，这不会影响程序运行，却给我们编码，读程序时带来麻烦。

 
6. 另外，spring3 mvc的验证也是一个亮点，支持JSR303，处理ajax的请求更是方便，只需一个注解@ResponseBody ，然后直接返回响应文本即可。


87.江苏欣网视讯面试，上午面试完，下午就收到通知了
先是笔试，问题不难，基本上都是java面试宝典上的，还有些可以从网上找到，说明这些都是常见的面试问题
现在整理如下：

1.java如何调用c   我百度了下，好像是JNT技术

2.char型变量中能不能存储一个中文汉子

2.什么是java序列化，如何实现java序列化

3.final finally finalize的区别 java面试宝典上的

4.short s1=1 s1=s1+1 s1+=1有什么错

5.说出arraylist vector linklist的存储性能

6.abstract class和interface的区别

7.java语言如何进行异常处理，关键字throws throw try,catch,finally分别代表什么意思

8.什么时候用asssert  我百度了下：断言

9.当一个对象被当作参数传递到一个方法后，此方法可以改变这个对象的属性，并可返回变化后的结果，那么这里到底是值传递还是引用传递

10.string和stringbuffer的区别

11.sleep和wait的区别

12.值传递

7.编程题目:
   
   1.设计一方法来实现：输入两长度相等字符串，然后检查是否两字符串包含相同字符的的子串（大于2字符串）。。。
   2.设计四个线程，其中两个线程每次对j增加1，另外两个线程对j每次减少1