学步园

1.下列哪一种叙述是正确的（）

　　A． abstract修饰符可修饰字段、方法和类

　　B．抽象方法的body部分必须用一对大括号{ }包住

　　C．声明抽象方法，大括号可有可无

　　D．声明抽象方法不可写出大括号

　　答案：D

abstract不能修饰字段,抽象方法不用实现,不能用{}.

2.指出正确的表达式 C 

A byte=128;  

B Boolean=null;  

 C long l=0xfffL;  

D double=0.9239d;

3.public class Person{       C
static int arr[] = new int[5];
public static void main(String a[]) {

System.out.println(arr[0]); }  
}

A、编译时将产生错误        B、编译时正确，运行时将产生错误 C、输出零            D、输出空

4.不能用来修饰interface的有：（）A C D

A.private  B.public  C.protected  D.static

5.jsp有哪些内置对象?作用分别是什么?

JSP共有以下9种基本内置组件

 1、request对象 客户端请求，此请求会包含来自GET/POST请求的参数通过它才能了 解到客户的需求，然后做出响应。

 2、response对象 响应客户请求的有关信息

 3、session对象 它指的是客户端与服务器的一次会话，从客户端连到服务器的一个      WebApplication开始，直到客户端与服务       器断开连接为止。

 4、out对象   它是JspWriter类的实例,是向客户端输出内容常用的对象

 5、page对象   它是指向当前JSP页面本身，有点象类中的this指针，它是 java.lang.Object类的实例

 6、application对象 它实现了用户间数据的共享，可存放全局变量。它开始于服务器的启动，直到服务器的关闭

 7、exception对象 它是一个例外对象，当一个页面在运行过程中发生了例外，就产生这个对象。

 8、pageContext对象 它提供了对JSP页面内所有的对象及名字空间的访问

 9、config对象 它是在一个Servlet初始化时，JSP引擎向它传递信息用的

6.jsp有哪些动作?作用分别是什么?

答:JSP共有以下6种基本动作
jsp:include：在页面被请求的时候引入一个文件。
jsp:useBean：寻找或者实例化一个JavaBean。
jsp:setProperty：设置JavaBean的属性。
jsp:getProperty：输出某个JavaBean的属性。
jsp:forward：把请求转到一个新的页面。
jsp:plugin：根据浏览器类型为Java插件生成OBJECT或EMBED标记

7.post与get的区别？

 1.post传输数据时，不在URL中显示出来，而get方法要在URL中显示

 2.post传输数据量大，而get传输数据小

 3.post向服务器传数据，get从服务器取数据

 4.post方式要比get方式安全

8.函数cast(2.5 as int)/2 的执行结果是：1.5

9.FLOOR——对给定的数字取整数位
SQL> select floor(2345.67) from dual;

FLOOR(2345.67)
--------------
2345

CEIL-- 返回大于或等于给出数字的最小整数
SQL> select ceil(3.1415927) from dual;

CEIL(3.1415927)
---------------
4

ROUND——按照指定的精度进行四舍五入
SQL> select round(3.1415926,4) from dual;

ROUND(3.1415926,4)
------------------
3.1416

TRUNC——按照指定的精度进行截取一个数
SQL> select trunc(3.1415926,4) from dual;

ROUND(3.1415926,4)
------------------
3.1415

10.在oracle的聚合函数中，合计函数、最大值函数、最小值函数、平均值函数分别是 count 、max、min、avg

11.数据库系统的核心是 数据库管理系统

12.

 1.但接口中的抽象方法只能是public类型的，并且默认即为public
abstract类型

 2.接口中定义的变量只能是public 
static类型，并且默认为public static类型

 3. 接口更多的是在系统框架设计方法发挥作用，主要定义模块之间的通信，而抽象类在代码实现方面发挥作用，可以实现代码的重用

13.&与&&的区别

&按位与  &&逻辑与

&两边都要判断

&&只要前面是false就输出false，而不继续判断后面

14.error和exception有什么区别？

  error：系统级错误或程序不必处理的异常，比如：内存资源不足 这种错误无能为力

  exception：需要捕捉或需要程序处理的异常，因为程序设计瑕疵或外部输入引起的异常，程序必须处理

  exception 分为： 运行时异常：因为错误的操作引起的

                             受检查异常：程序可以自我的处理

15.JavaScript标准中规定了6种类型:Undefined,Null,Boolean,String,Number,Object

16.String,StringBuffer,StringBuilder区别：

执行速度：Stringbuilder->StringBuffer->String

String:不可改变
 Stringbuffer和StringBuilder可以改变 

StringBuffer单线程
线程安全 可以实现同步  StringBuilder多线程  线程不安全

17.WebService是一种跨编程语言和跨操作系统平台的远程调用技术。

18.B/S
与C/S的联系与区别？

C/S
Client/Server 局域网内高性能的数据库交互，安装专用客户端软件。

B/S
Browser/Server 浏览器与数据库进行交互。

20.IOC和AOP的概念以及在spring中是如何应用的

IOC
控制反转 容器通过配置文件注入就是IOC的思想。  利用反射机制实例化类

AOP
面向切面编程 在不修改代码的情况下，给程序动态同意添加的一种技术。 利用动态代理机制

21.简述RBAC（Role-Based Access Control）

基于角色的访问控制（Role-Based Access Control）作为传统访问控制（自主访问，强制访问）的有前景的代替受到广泛的关注。在RBAC中，权限与角色相关联，用户通过成为适当角色的成员而得到这些角色的权限。

22.解决hibernate 1+n 问题？

 1.延迟加载 2.默认fetch=“select” 把fetch设置成“join” 但失去了延迟加载的特性

Hibernate的两个类设置了manyToOne（oneToMany）之后，在查询的时候，由于N 对1的一方默认的fetch=FetchType.EAGER,所以会把被关联    
     的对象一起取出来
      解决方法一：设置fetch=FetchType.LAZY,这种方法在合适的时候（具体使用到对象时）还是会发出select语句。
      解决方法二：
                         //List<Student> students= (List<Student>)session.createCriteria(Student.class).list();
                         List<Student> students= (List<Student>)session.createQuery("from Student").list();
                         也就是用session.createCriteria()做查询，而不是用createQuery。
       解决方法三：使用BatchSize（size=5）方法，他会发出1+N/5条select语句。
       解决方法四：使用join fetch做外连接查询。from Topic t left join fetch t.category c

23.写一个单例模式的类出来：

public class Singleton { 
　　private static Singleton instance = null;
　　public static synchronized Singleton getInstance() {
　　//这个方法比上面有所改进，不用每次都进行生成对象，只是第一次　　　 　
　　//使用时生成实例，提高了效率！
　　if (instance==null)
　　　　instance＝new Singleton();
return instance; 　　} 
} 

24.写出冒泡排序：

冒泡排序法：关键字较小的记录好比气泡逐趟上浮，关键字较大的记录好比石块下沉，每趟有一块最大的石块沉底。

算法本质：（最大值是关键点，肯定放到最后了，如此循环）每次都从第一位向后滚动比较，使最大值沉底，最小值上升一次，最后一位向前推进（即最后一位刚确定的最大值不再参加比较，比较次数减1）

复杂度： 时间复杂度 O(n2)
，空间复杂度O(1)

/**
 * 冒泡排序
 *
 */
public class Bubble {

	public static void main(String[] args) {
		int[] array = { 49, 38, 65, 97, 76, 13, 27 };
		buddleSort(array);
		for (int i = 0; i < array.length; i++) {
			System.out.println(array[i]);
		}
	}

	public static void buddleSort(int[] array) {
		int temp;
		for (int i = 0; i < array.length; i++) {//趟数
			for (int j = 0; j < array.length - i - 1; j++) {//比较次数
				if (array[j] > array[j+1]) {
					temp = array[j];
					array[j] = array[j+1];
					array[j+1] = temp;

				}
			}
		}
	}
}

25.策略模式：定义了算法族，并分别封装起来，让它们之间可以相互替换。

   观察者模式：定义了对象间一对多依赖

26.CI服务器:持续集成服务器

      38.hashmap为什么线程不安全
    当然了如果只是读，没有写肯定没有并发的问题了。改换Hashtable或者ConcurrentHashMap肯定也是没有问题了

        addEntry 导致线程不安全

     39.hibernate获取数据连接的过程

Map map = new HashMap();
map.put("Rajib Sarma","100");
map.put("Rajib Sarma","200");//The value "100" is replaced by "200".
map.put("Sazid Ahmed","200");

Iterator iter = map.entrySet().iterator();
while (iter.hasNext()) {
    Map.Entry entry = (Map.Entry) iter.next();
    Object key = entry.getKey();
    Object val = entry.getValue();
}

public class Hashtable extends Dictionary implements Map
public class HashMap  extends AbstractMap implements Map

package cn.nio;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Iterator;

/**
 * NIO服务端
 * @author 小路
 */
public class NIOServer {
	//通道管理器
	private Selector selector;

	/**
	 * 获得一个ServerSocket通道，并对该通道做一些初始化的工作
	 * @param port  绑定的端口号
	 * @throws IOException
	 */
	public void initServer(int port) throws IOException {
		// 获得一个ServerSocket通道
		ServerSocketChannel serverChannel = ServerSocketChannel.open();
		// 设置通道为非阻塞
		serverChannel.configureBlocking(false);
		// 将该通道对应的ServerSocket绑定到port端口
		serverChannel.socket().bind(new InetSocketAddress(port));
		// 获得一个通道管理器
		this.selector = Selector.open();
		//将通道管理器和该通道绑定，并为该通道注册SelectionKey.OP_ACCEPT事件,注册该事件后，
		//当该事件到达时，selector.select()会返回，如果该事件没到达selector.select()会一直阻塞。
		serverChannel.register(selector, SelectionKey.OP_ACCEPT);
	}

	/**
	 * 采用轮询的方式监听selector上是否有需要处理的事件，如果有，则进行处理
	 * @throws IOException
	 */
	@SuppressWarnings("unchecked")
	public void listen() throws IOException {
		System.out.println("服务端启动成功！");
		// 轮询访问selector
		while (true) {
			//当注册的事件到达时，方法返回；否则,该方法会一直阻塞
			selector.select();
			// 获得selector中选中的项的迭代器，选中的项为注册的事件
			Iterator ite = this.selector.selectedKeys().iterator();
			while (ite.hasNext()) {
				SelectionKey key = (SelectionKey) ite.next();
				// 删除已选的key,以防重复处理
				ite.remove();
				// 客户端请求连接事件
				if (key.isAcceptable()) {
					ServerSocketChannel server = (ServerSocketChannel) key
							.channel();
					// 获得和客户端连接的通道
					SocketChannel channel = server.accept();
					// 设置成非阻塞
					channel.configureBlocking(false);

					//在这里可以给客户端发送信息哦
					channel.write(ByteBuffer.wrap(new String("向客户端发送了一条信息").getBytes()));
					//在和客户端连接成功之后，为了可以接收到客户端的信息，需要给通道设置读的权限。
					channel.register(this.selector, SelectionKey.OP_READ);
					
					// 获得了可读的事件
				} else if (key.isReadable()) {
						read(key);
				}

			}

		}
	}
	/**
	 * 处理读取客户端发来的信息 的事件
	 * @param key
	 * @throws IOException 
	 */
	public void read(SelectionKey key) throws IOException{
		// 服务器可读取消息:得到事件发生的Socket通道
		SocketChannel channel = (SocketChannel) key.channel();
		// 创建读取的缓冲区
		ByteBuffer buffer = ByteBuffer.allocate(10);
		channel.read(buffer);
		byte[] data = buffer.array();
		String msg = new String(data).trim();
		System.out.println("服务端收到信息："+msg);
		ByteBuffer outBuffer = ByteBuffer.wrap(msg.getBytes());
		channel.write(outBuffer);// 将消息回送给客户端
	}
	
	/**
	 * 启动服务端测试
	 * @throws IOException 
	 */
	public static void main(String[] args) throws IOException {
		NIOServer server = new NIOServer();
		server.initServer(8000);
		server.listen();
	}

}

简单选择排序：（选出最小值，放在第一位，然后第一位向后推移，如此循环）第一位与后面每一个逐个比较，每次都使最小的置顶，第一位向后推进（即刚选定的第一位是最小值，不再参与比较，比较次数减1）

复杂度： 所需进行记录移动的操作次数较少 0--3(n-1) ，无论记录的初始排列如何，所需的关键字间的比较次数相同，均为n(n-1)/2，总的时间复杂度为O(n2)；
空间复杂度 O(1)

算法改进：每次对比，都是为了将最小的值放到第一位，所以可以一比到底，找出最小值，直接放到第一位，省去无意义的调换移动操作。也可以换一个方向，最后一位与前面每一个比较，每次使最大值沉底，最后一位向前推进。

/**
 * 
 * 简单选择
 */
public class SimpleSelectSort {

	public static void main(String[] args) {    
        int[] array = { 49, 38, 65, 97, 76, 13, 27 };    
        selectSort(array);    
        for (int i = 0; i < array.length; i++) {    
            System.out.println(array[i]);    
        }    
    }    
	
	public static void selectSort(int[] array){
		int minIndex;
		int tempValue;
		for(int i=0;i<array.length-1;i++){//最后一位已经排好序不用再排了
			minIndex=i;
			for(int j=i+1;j<array.length;j++){//从下一位开始找出最小位的下标
				if(array[j]<array[minIndex]){
					minIndex=j;
				}
			}
			if(minIndex!=i){//如果最小值没有变化不互调位置 
				tempValue=array[minIndex];
				array[minIndex]=array[i];
				array[i]=tempValue;
			}
		}
	}
}

96.直接插入排序

直接插入排序（Straight Insertion Sorting）的基本思想：在要排序的一组数中，假设前面(n-1) [n>=2] 个数已经是排好顺序的，现在要把第n个数插到前面的有序数中，使得这n个数也是排好顺序的。如此反复循环，直到全部排好顺序。

复杂度：时间复杂度  O（n2） ，空间复杂度O(1)

稳定性： 插入排序是稳定的，排序前后两个相等元素相对次序不变（能保证排序前2个相等的数其在序列的前后位置顺序和排序后它们两个的前后位置顺序相同。在简单形式化一下，如果Ai = Aj, Ai原来在位置前，排序后Ai还是要在Aj位置前。）

结构的复杂性及适用情况：是一种简单的排序方法，不仅适用于顺序存储结构(数组)，而且适用于链接存储结构，不过在链接存储结构上进行直接插入排序时，不用移动元素的位置，而是修改相应的指针。

哨兵的作用
    　算法中引进的附加记录R[0]称监视哨或哨兵(Sentinel)。
   　 哨兵有两个作用：
　　① 进人查找(插入位置)循环之前，它保存了R[i]的副本，使不致于因记录后移而丢失R[i]的内容；
　　② 它的主要作用是：在查找循环中"监视"下标变量j是否越界。一旦越界(即j=0)，因为R[0].key和自己比较，循环判定条件不成立使得查找循环结束，从而避免了在该循环内的每一次均要检测j是否越界(即省略了循环判定条件"j>=1")。
 注意：
　  ① 实际上，一切为简化边界条件而引入的附加结点(元素)均可称为哨兵。
　　  【例】单链表中的头结点实际上是一个哨兵

　　② 引入哨兵后使得测试查找循环条件的时间大约减少了一半，所以对于记录数较大的文件节约的时间就相当可观。对于类似于排序这样使用频率非常高的算法，要尽可能地减少其运行时间。所以不能把上述算法中的哨兵视为雕虫小技，而应该深刻理解并掌握这种技巧。

package com.sort3;

/**
 * 直接插入
 * 
 */
public class StraightInsertionSort {

	public static void main(String[] args) {
		int[] array = { 49, 38, 65, 97, 76, 13, 27 };
		straightInsertionSort(array);
		for (int i = 0; i < array.length; i++) {
			System.out.println(array[i]);
		}
	}

	public static void straightInsertionSort(int[] array) {
		for (int i = 0; i < array.length - 1; i++) {// 在倒数第二位的时候就已经排好序了
			int j = i;// i之前的顺序是正确
			int sentryValue = array[j + 1];
			while (j >= 0 && array[j] > sentryValue) {// 当有小值的时候，前面排好序的向后移
				array[j + 1] = array[j];
				j--;
			}
			if(j!=i){
				array[j + 1] = sentryValue;
			}
			
		}
	}
}

97.希尔排序

希尔排序（缩小增量排序）基本思想：算法先将要排序的一组数按某个增量d（n/2,n为要排序数的个数）分成若干组，每组中记录的下标相差d。对每组中全部元素进行直接插入排序，然后再用一个较小的增量（d/2）对它进行分组，在每组中再进行直接插入排序。当增量减到1时，进行直接插入排序后，排序完成。

复杂度：平均时间复杂度O(n1.25)   空间复杂度 O(1)

实例图 

增量序列的选择
    　Shell排序的执行时间依赖于增量序列。
    　好的增量序列的共同特征：
　　① 最后一个增量必须为1；
　　② 应该尽量避免序列中的值(尤其是相邻的值)互为倍数的情况。
    　有人通过大量的实验，给出了目前较好的结果：当n较大时，比较和移动的次数约在nl.25到1.6n1.25之间。

Shell排序的时间性能优于直接插入排序
    　希尔排序的时间性能优于直接插入排序的原因：
　　①当文件初态基本有序时直接插入排序所需的比较和移动次数均较少。
　　②当n值较小时，n和n2的差别也较小，即直接插入排序的最好时间复杂度O(n)和最坏时间复杂度0(n2)差别不大。
　　③在希尔排序开始时增量较大，分组较多，每组的记录数目少，故各组内直接插入较快，后来增量di逐渐缩小，分组数逐渐减少，而各组的记录数目逐渐增多，但由于已经按di-1作为距离排过序，使文件较接近于有序状态，所以新的一趟排序过程也较快。
    　因此，希尔排序在效率上较直接插人排序有较大的改进。

稳定性： 希尔排序是不稳定的。

/**
 * 希尔排序
 * 
 */
public class ShellSort {

	public static void main(String[] args) {
		int[] array = { 49, 38, 65, 97, 76, 13, 27 };
		shellSort(array);
		for (int i = 0; i < array.length; i++) {
			System.out.println(array[i]);
		}
	}

	public static void shellSort(int[] array) {
		double increment = array.length;// 增量长度
		int dk;// 确定增量长度
		int k;// 替换参数防止遍历错误
		while (true) {
			increment = (int) Math.ceil(increment / 2);
			dk = (int) increment;// 确定增量长度
			for (int i = 0; i < dk; i++) {
				for (int j = i; j < array.length - dk; j += dk) {// j不以0开始,以i开始可以减少遍历次数
					k = j;
					int sentryValue = array[k + dk];// 哨兵位
					while (k >= 0 && array[k] > sentryValue) {
						array[k + dk] = array[k];
						k -= dk;
					}
					if (k != j) {// 如果这轮没有换位，就不需要把哨兵位补上去
						array[k + dk] = sentryValue;
					}

				}
			}
			if (dk == 1) {// 增量为1的时候结束
				break;
			}

		}

	}
}

98.排序算法分析

冒择入希快归堆

99.二分查找法

public class BinarySearch {

	public static void main(String[] args) {
		int[] src = new int[] { 1, 3, 5, 7, 8, 9 };
		System.out.println(binarySearch(src, 3));
	}

	public static boolean binarySearch(int[] array, int desc) {
		int low = 0;
		int high = array.length - 1;
		while (low <= high) {
			int middle = (low + high) / 2;
			if (array[middle] == desc) {
				return true;
			} else if (array[middle] > desc) {
				high = middle - 1;
			} else if (array[middle] < desc) {
				low = middle + 1;
			}
		}

		return false;
	}
}

/** 
 * 二分查找又称折半查找，它是一种效率较高的查找方法。  
　　【二分查找要求】：1.必须采用顺序存储结构 2.必须按关键字大小有序排列。 
 * 
 */  
public class BinarySearch {

	public static void main(String[] args) {  
        int[] src = new int[] {1, 3, 5, 7, 8, 9};   
        System.out.println(binarySearch(src, 3));  
        System.out.println(binarySearch(src,3,0,src.length-1));  
    }  
    
	/** 
     * * 二分查找算法 * * 
     *  
     * @param srcArray 
     *            有序数组 * 
     * @param des 
     *            查找元素 * 
     * @return des的数组下标，没找到返回-1 
     */   
	public static int binarySearch(int[] array,int desc){
		int low=0;
		int high=array.length-1;
		while(low<=high){
			int middle=(low+high)/2;
			if(desc==array[middle]){
				return desc;
			}else if(desc>array[middle]){
				low=middle+1;
			}else if(desc<array[middle]){
				high=middle-1;
			}
		}
		return -1;
	}
	
	 /**   
     *二分查找特定整数在整型数组中的位置(递归)   
     *@paramdataset   
     *@paramdata   
     *@parambeginIndex   
     *@paramendIndex   
     *@returnindex   
     */  
	public static int binarySearch(int[] array,int desc,int low,int high){
		int middle=(low+high)/2;
		if(low>high||desc<array[low]||desc>array[high]){
			return -1;
		}
		if(desc>array[middle]){
			return binarySearch(array,desc,middle+1,high);
		}else if(desc<array[middle]){
			return binarySearch(array,desc,low,middle-1);
		}else{
			return desc;
		}
	}
}

100.MySQL的btree索引和hash索引的区别

mysql最常用的索引结构是btree(O(log(n)))，但是总有一些情况下我们为了更好的性能希望能使用别的类型的索引。hash就是其中一种选择，例如我们在通过用户名检索用户id的时候，他们总是一对一的关系，用到的操作符只是=而已，假如使用hash作为索引数据结构的话，时间复杂度可以降到O(1)。不幸的是，目前的mysql版本(5.6)中，hash只支持MEMORY和NDB两种引擎，而我们最常用的INNODB和MYISAM都不支持hash类型的索引。

Hash 索引结构的特殊性，其检索效率非常高，索引的检索可以一次定位，不像B-Tree 索引需要从根节点到枝节点，最后才能访问到页节点这样多次的IO访问，所以 Hash 索引的查询效率要远高于 B-Tree 索引。
可能很多人又有疑问了，既然 Hash 索引的效率要比 B-Tree 高很多，为什么大家不都用 Hash 索引而还要使用 B-Tree 索引呢？任何事物都是有两面性的，Hash 索引也一样，虽然 Hash 索引效率高，但是 Hash 索引本身由于其特殊性也带来了很多限制和弊端，主要有以下这些。

（1）Hash 索引仅仅能满足"=","IN"和"<=>"查询，不能使用范围查询。

由于 Hash 索引比较的是进行 Hash 运算之后的 Hash 值，所以它只能用于等值的过滤，不能用于基于范围的过滤，因为经过相应的 Hash 算法处理之后的 Hash 值的大小关系，并不能保证和Hash运算前完全一样。

（2）Hash 索引无法被用来避免数据的排序操作。

由于 Hash 索引中存放的是经过 Hash 计算之后的 Hash 值，而且Hash值的大小关系并不一定和 Hash 运算前的键值完全一样，所以数据库无法利用索引的数据来避免任何排序运算；

（3）Hash 索引不能利用部分索引键查询。

对于组合索引，Hash 索引在计算 Hash 值的时候是组合索引键合并后再一起计算 Hash 值，而不是单独计算 Hash 值，所以通过组合索引的前面一个或几个索引键进行查询的时候，Hash 索引也无法被利用。

（4）Hash 索引在任何时候都不能避免表扫描。

前面已经知道，Hash 索引是将索引键通过 Hash 运算之后，将 Hash运算结果的 Hash 值和所对应的行指针信息存放于一个 Hash 表中，由于不同索引键存在相同 Hash 值，所以即使取满足某个 Hash 键值的数据的记录条数，也无法从 Hash 索引中直接完成查询，还是要通过访问表中的实际数据进行相应的比较，并得到相应的结果。

（5）Hash 索引遇到大量Hash值相等的情况后性能并不一定就会比B-Tree索引高。

对于选择性比较低的索引键，如果创建 Hash 索引，那么将会存在大量记录指针信息存于同一个 Hash 值相关联。这样要定位某一条记录时就会非常麻烦，会浪费多次表数据的访问，而造成整体性能低下

101.memcached对item的过期时间有什么限制？

item对象的过期时间最长可以达到30天。memcached把传入的过期时间（时间段）解释成时间点后，一旦到了这个时间点，memcached就把item置为失效状态，这是一个简单的观察者机制。