1. 在Java中,负责对字节代码解释执行的是(B)
A. 应用服务器
B. 虚拟机
C. 垃圾回收器
D. 编译器
2. 一个栈的输入序列为1 2 3 4 5,则下列序列中不可能是栈输出的序列的是(A)
A. 5 4 1 3 2
B. 2 3 4 1 5
C. 1 5 4 3 2
D. 2 3 1 4 5
3. 下列那一个选项按照顺序包括了OSI模型的7个层次( C)
A. 物理层 数据链路层 传输层 网络层 会话层 表示层 应用层
B. 物理层 数据链路层 会话层 网络层 传输层 表示层 应用层
C. 物理层 数据链路层 网络层 传输层 会话层 表示层 应用层
D. 网络层 传输层 物理层 数据链路层 会话层 表示层 应用层
4. 当客户度关闭一个从连接池中获取的连接, 会发生下面哪一种情况?(A)
A. 连接不会关闭, 只是简单地归还给连接池
B. 连接被关闭 , 但又被重新打开并归还给连接池
C. 连接永久性关闭
5. 以下哪些不是javaScript 的全局函数( C)
A. eval
B. escape
C. setTimeout
D. parseFloat
6. 你使用mkdir命令创建一个临时的文件夹/tmp/aaa, 并将一些文件复制其中，使用完后要删除/mnt/tmp文件夹及其中的所有文件, 应该使用命令（B）
A. rm /tmp/aaa
B. rm –r /tmp/aaa
C. rmdir –r /tmp/aaa
D. rmdir /tmp/aaa
7. 在UML提供的图中, ( C)用于按数据顺序描述对象间的交互
A. 协作图
B. 网络图
C. 序列图
D. 状态图
8. 下面有关系统并发访问数估算数据哪个最有效:（B）
A. 高峰时段日处理业务量100000
B. 高峰时段平均每秒请求数80
C. 同时在线用户100
D. 平均每秒用户请求 50
9. 不同级别的用户对同一对象拥有不同的访问权利或某个客户端不能直接操作到某个对象,但有必须和那个对象有所互动, 这种情况最好使用什么设计模式.( D)
A．Bridge 模式
B. Fa?ade 模式
C. Adapter 模式
D. Proxy 模式
10. 下面哪个Set是排序的? (C)
A. LinkedHashSet
B. HashSet
C. TreeSet
D. AbstractSet
11. 用1,2 , 2 ,3, 4 ,5这6个数字, 用Java 写一个main 函数, 打印出所有不同的排列, 如: 512234, 412345等, 要求: “4”不能在第三位,“3”与”5”不能相连。
package test;
import java.util.Iterator;
import java.util.TreeSet;
public class numberRandom {
String[] stra = { "1", "2", "2", "3", "4", "5" };
int n = stra.length;
boolean[] visited = new boolean[n];
String result = "";
TreeSet<String> ts = new TreeSet<String>();
int[][] a = new int[n][n];
private void searchMap(){
for(int i=0;i<n;i++){
for(int j=0;j<n;j++){
if(i==j){
a[i][j]=0; //图中对角线部分是无法访问的
}else{
a[i][j]=1;
}
}
}
//3和5不能相连
a[3][5]=0;
a[5][3]=0;
//开始遍历
for(int i=0;i<n;i++){
search(i);
}
Iterator<String> it = ts.iterator();
while(it.hasNext()){
String str =it.next();
//4不能在第三位
if(str.indexOf("4")!=2){
System.out.println(str);
}
}
}
//这是个深度优先的遍历
private void search(int startIndex){
visited[startIndex] = true;
result = result + stra[startIndex];
if(result.length() ==n){
ts.add(result);
}
for(int j=0;j<n;j++){
if(a[startIndex][j]==1&&visited[j]==false){
search(j);
}else{
continue;
}
}
//一个result结束后踢掉最后一个，寻找别的可能性，若没有的话，则继续向前踢掉当前最后一个
result = result.substring(0,result.length()-1);
visited[startIndex] = false;
}
public static void main(String[] args) {
new numberRandom().searchMap();
}
}package test;
public class Demo8 {
private static String[] forbidenNumber = new String[] { "0", "6", "7", "8", "9" };
private static String[] mustExistNumber = new String[] { "1", "2", "2", "3", "4", "5" };
private static boolean isValidNumber(String str) {
// 检查是否有非法数字，有返回false，否则继续
for (String number : forbidenNumber) {
if (str.indexOf(number) >= 0) {
return false;
}
}
// 检查是否存在要的数字，如果不存在返回false，否则继续
for (String number : mustExistNumber) {
int temp = str.indexOf(number);
if (temp < 0) {
return false;
} else if ((str.indexOf(number, temp + 1) > temp)
&& str.charAt(temp) != '2') {
return false;
}
}
// 检查4在不在第三位，是返回false
if (str.charAt(2) == '4') {
return false;
}
// 检查是否存在35在一起，有返回false
if (str.indexOf("35") >= 0 || str.indexOf("53") >= 0) {
return false;
}
return true;
}
public static void main(String[] args) {
// TODO code application logic here
for (int i = 122345; i < 543221; i++) {
if (isValidNumber(String.valueOf(i))) {
System.out.println(i);
}
}
}
}
package test;
public class Demo9 {
private static String[] mustExistNumber = new String[] { "1", "2", "2","3", "4", "5" };
private static boolean isValidNumber(String str) {
// 检查是否包含12345这五个数，不包含返回false
for (String number : mustExistNumber) {
if (str.indexOf(number) < 0)
return false;
}
// 检查是否有两个2，只有一个返回false
// 不需要考虑3个2的情况，因为第一个条件已经限制了最多有两个2
if (str.lastIndexOf("2") == str.indexOf("2")) {
return false;
}
// 检查4在不在第三位，是返回false
if (str.charAt(2) == '4') {
return false;
}
// 检查是否存在35在一起，有返回false
if (str.indexOf("35") >= 0 || str.indexOf("53") >= 0) {
return false;
}
return true;
}
public static void main(String[] args) {
// TODO code application logic here
for (int i = 122345; i < 543221; i++) {
if (isValidNumber(String.valueOf(i))) {
System.out.println(i);
}
}
}
}
12. 一个数如果恰好等于它的因子之和,这个数就称为”完数”.例如 6 = 1+2+3。编程找出1000以内的所有完数。
package test;
/**
* 一个数如果恰好等于它的因子之和，这个数就称为 "完数 "。例如6=1＋2＋3.编程 找出1000以内的所有完数。
* 根据题意，这里的因子是不包括它本身，本身是指假因子。
*/
public class Wanshu {
public static void main(String[] args) {
int s;
for (int i = 1; i <= 1000; i++) {
s = 0;
for (int j = 1; j <= i / 2; j++)
if (i % j == 0)
s = s + j;
if (s == i)
System.out.print(i + " ");
}
System.out.println();
}
}
答案：当往集合在添加元素时，调用add（Object）方法时候，首先会调用Object的hashCode()方法判hashCode是否已经存在，如不存在则直接插入元素；
如果已存在则调用Object对象的equals()方法判断是否返回true，如果为true则说明元素已经 存在，如为false则插入元素。
答案：List,Set是继承Collection接口； Map不是。
List：元素有放入顺序，元素可重复 ，通过下标来存取 和值来存取
Map：元素按键值对存取，无放入顺序
Set：元素无存取顺序，元素不可重复（注意：元素虽然无放入顺序，但是元素在set中的位置是有该元素的HashCode决定的，其位置其实是固定的）
按值传递是指的是在方法调用时，传递的参数是按值的拷贝传递。
按值传递重要特点：传递的是值的拷贝，也就是说传递后就互不相关了
public class TempTest {
private void test1(int a) {
a = 5;
System.out.println("test1方法中的a=" + a);
}
public static void main(String[] args) {
TempTest t = new TempTest();
int a = 3;
t.test1(a);// 传递后，test1方法对变量值的改变不影响这里的a
System.out.println("main方法中的a=" + a);
}
}运行结果是：
test1方法中的a=5
main方法中的a=3
按引用传递是指的是在方法调用时，传递的参数是按引用进行传递，其实传递的引用的地址，也就是变量所对应的内存空间的地址。传递的是值的引用，也就是说传递前和传递后都指向同一个引用（也就是同一个内存空间）。
package test;
public class TempTest {
private void test1(A a) {
a.age = 20;
System.out.println("test1方法中的age=" + a.age);
}
public static void main(String[] args) {
TempTest t = new TempTest();
A a = new A();
a.age = 10;
t.test1(a);
System.out.println("main方法中的age=" + a.age);
}
}
class A {
public int age = 0;
}test1方法中的age=20
main方法中的age=20
16. switch是否作用在byte上, 是否能作用在long上, 是否能作用在String上？
答案：switch可作用于char byte short int；
switch可作用于char byte short int对应的包装类；
switch不可作用于long double float boolean，包括他们的包装类；
17 Java语言如何进行异常处理? 请写出几个常见的运行时异常的编译时异常
答案：java语言进行异常处理的方式有：
throws: throws是方法可能抛出异常的声明。(用在声明方法时，表示该方法可能要抛出异常)
throw : throw是语句抛出一个异常。
常见的运行时异常的编译时异常:
NullPointerException - 空指针引用异常
ClassCastException - 类型强制转换异常。
IllegalArgumentException - 传递非法参数异常。
ClassNotFoundException - 类找不到异常
ArrayStoreException - 向数组中存放与声明类型不兼容对象异常
IndexOutOfBoundsException - 下标越界异常
NegativeArraySizeException - 创建一个大小为负数的数组错误异常
NumberFormatException - 数字格式异常
SecurityException - 安全异常
UnsupportedOperationException - 不支持的操作异常
18. 简述数据库事务和实际工作中的作用
所谓事务是用户定义的一个数据库操作序列,这些操作要么全做要么全不做,是一个不可分割的工作单位。例如,在关系数据库中,一个事务可以是一条SQL语句、一组SQL语句或整个程序。
简单举个例子就是你要同时修改数据库中两个不同表的时候，如果它们不是一个事务的话，当第一个表修改完，可是第二表改修出现了异常而没能修改的情况下，就只有第二个表回到未修改之前的状态，而第一个表已经被修改完毕。而当你把它们设定为一个事务的时候，当第一个表修改完，可是第二表改修出现了异常而没能修改的情况下，第一个表和第二个表都要回到未修改的状态！这就是所谓的事务回滚。
例如，在将资金从一个帐户转移到另一个帐户的银行应用中，一个帐户将一定的金额贷记到一个数据库表中，同时另一个帐户将相同的金额借记到另一个数据库表中。由于计算机可能会因停电、网络中断等而出现故障，因此有可能更新了一个表中的行，但没有更新另一个表中的行。如果数据库支持事务，则可以将数据库操作组成一个事务，以防止因这些事件而使数据库出现不一致。如果事务中的某个点发生故障，则所有更新都可以回滚到事务开始之前的状态。如果没有发生故障，则通过以完成状态提交事务来完成更新。
19. 已知一棵二叉树，如果先序遍历的节点顺序是： ADCEFGHB ，中序遍历是： CDFEGHAB ，则后序遍历结果为：（ D ）
A. CFHGEBDA
B. CDFEGHBA
C. FGHCDEBA
D. CFHGEDBA
知识点
对于二叉树的遍历方式一般分为三种先序、中序、后序三种方式：
先序遍历（根左右）
若二叉树为空，则不进行任何操作：否则
1、访问根结点。
2、先序方式遍历左子树。
3、先序遍历右子树。
中序遍历（左根右）
若二叉树为空，则不进行任何操作：否则
1、中序遍历左子树。
2、访问根结点。
3、中序遍历右子树。
后序遍历（左右根）
若二叉树为空，则不进行任何操作：否则
1、后序遍历左子树。
2、后序遍历右子树。
3、放问根结点。
因此，根据题目给出的先序遍历和中序遍历，可以画出二叉树
20. 下列哪两个数据结构，同时具有较高的查找和删除性能？（CD）
A. 有序数组
B. 有序链表
C. AVL 树
D. Hash 表
知识点：
平衡二叉树的查找，插入和删除性能都是O(logN) ，其中查找和删除性能较好；哈希表的查找、插入和删除性能都是 O(1) ，都是最好的。所以最后的结果选择： CD
21. 下列排序算法中，哪些时间复杂度不会超过 nlogn？（BC）
A. 快速排序
B. 堆排序
C. 归并排序
D. 冒泡排序
22. 初始序列为 1 8 6 2 5 4 7 3 一组数采用堆排序，当建堆（小根堆）完毕时，堆所对应的二叉树中序遍历序列为：（ A ）
A. 8 3 2 5 1 6 4 7
B. 3 2 8 5 1 4 6 7
C. 3 8 2 5 1 6 7 4
D. 8 2 3 5 1 4 7 6
初始化序列：1 8 6 2 5 4 7 3,，小根堆就是要求结点的值小于其左右孩子结点的值，左右孩子的大小没有关系，那么小根堆排序之后为：1 2 4 3 5 6 7 8；中序遍历：左根右，故遍历结果为：8 3 2 5 1 6 4 7
21. 当n = 5 时，下列函数的返回值是：（A）
int foo(int n){
if(n<2)return n;
return foo(n-1)+foo(n-2);
}A．5
B．7
C．8
D．1
22. S市 A ，B 共有两个区，人口比例为 3：5 ，据历史统计 A 区的犯罪率为 0.01% ，B 区为 0.015% ，现有一起新案件发生在 S 市，那么案件发生在 A 区的可能性有多大？（C）
A．37.5%
B．32.5%
C．28.6%
D．26.1%
这道题首先得了解犯罪率是什么？犯罪率就是犯罪人数与总人口数的比。因此可以直接得出公式：( 3 0.01% ) / ( 3 0.01% + 5 * 0.015% ) = 28.6%
当然如果不好理解的话，我们可以实例化，比如B 区假设 5000 人，A 区 3000 人，A 区的犯罪率为 0.01%，那么 A 区犯罪人数为 30 人，B 区的犯罪率为 0.015% ，那么 B 区的犯罪人数为 75 人 ，求发生在 A 区的可能性，就是说 A 区的犯罪人数在总犯罪人数的多少，也就是 30/(30+75)=0.2857
当然，也可以回归到我们高中遗忘的知识：
假设C表示犯案属性
在A区犯案概率：P(C|A)=0.01%
在B区犯案概率：P(C|B)=0.015%
在A区概率：P(A)=3/8
在B区概率：P(B)=5/8
犯案概率：P(C)=（3/80.01%+5/80.015%)
根据贝叶斯公式：P(A|C) = P(A,C) / P(C) = [P(C|A) P(A)] / [ P(C|A) P(A)+ P(C|B) P(B) ] 也可以算出答案来
故，最后结果选择为：C
23. Unix系统中，哪些可以用于进程间的通信？（ABCD ）
A．Socket
B．共享内存
C．消息队列
D．信号量
知识点
管道（Pipe）及有名管道（named pipe）：管道可用于具有亲缘关系进程间的通信，有名管道克服了管道没有名字的限制，因此，除具有管道所具有的功能外，它还允许无亲缘关系进程间的通信；
信号（Signal）：信号是比较复杂的通信方式，用于通知接受进程有某种事件发生，除了用于进程间通信外，进程还可以发送信号给进程本身；linux除了支持Unix早期信号语义函数sigal外，还支持语义符合Posix.1标准的信号函数sigaction（实际上，该函数是基于BSD的，BSD为了实现可靠信号机制，又能够统一对外接口，用sigaction函数重新实现了signal函数）；
报文（Message）队列（消息队列）：消息队列是消息的链接表，包括Posix消息队列system V消息队列。有足够权限的进程可以向队列中添加消息，被赋予读权限的进程则可以读走队列中的消息。消息队列克服了信号承载信息量少，管道只能承载无格式字节流以及缓冲区大小受限等缺点。
共享内存：使得多个进程可以访问同一块内存空间，是最快的可用IPC形式。是针对其他通信机制运行效率较低而设计的。往往与其它通信机制，如信号量结合使用，来达到进程间的同步及互斥。
信号量（semaphore）：主要作为进程间以及同一进程不同线程之间的同步手段。
套接口（Socket）：更为一般的进程间通信机制，可用于不同机器之间的进程间通信。起初是由Unix系统的BSD分支开发出来的，但现在一般可以移植到其它类Unix系统上：Linux和System V的变种都支持套接字。
故最后选择的结果为：ABCD
24. 静态变量通常存储在进程哪个区？（ C ）
A．栈区
B．堆区
C．全局区
D．代码区
静态变量的修饰关键字：static，又称静态全局变量。故最后选择的结果为： C
25. 如何提供查询Name字段的性能（ B ）
A． 在Name字段上添加主键
B． 在Name字段上添加索引
C． 在Age字段上添加主键
D． 在Age字段上添加索引
26. IP地址131.153.12.71是一个（B）类IP地址
A．A
B．B
C．C
D．D
27. 浏览器访问某页面，HTTP 协议返回状态码为 403 时表示：（ B ）
A. 找不到该页面
B. 禁止访问
C. 内部服务器访问
D. 服务器繁忙
28. 如果某系统 15*4=112 成立，则系统采用的是（ A ）进制
A．6
B．7
C．8
D．9
这题因为是选择题，我们可以直接从A 的选项开始，假设是 6 进制的，我们把等式 15 4 = 112 转为十进制，就是 11 4 = 44，最后验证等式是否成立，明显等式是成立的，因此答案已经出来了，选择 A 。
当然我们也可以假设是X 进制，且我们知道 X 大于 5， 则：（x+5）4 = xx +x +2，所以最后计算的结果也为 6。
29. TCP和 IP 分别对应了 OSI 中的哪几层？（CD）
A. Application layer
B. Presentation layer
C. Transport layer
D. Network layer
30. 一个栈的入栈序列是A，B，C，D，E，则栈的不可能的输出序列是？（C）
A．EDCBA
B．DECBA
C．DCEAB
D．ABCDE
堆栈分别是先进后出,后进先出，
选项a 是 abcde 先入栈,然后依次出栈,正好是 edcba
选项b 是 abcd 先依次入栈,然后 d 出栈, e 再入栈, e 出栈
选项c 是错误的,不可能 a 先出栈
选项d 是 a 入栈,然后 a 出栈；b 再入栈, b 出栈.依此类推
最后的结果选择C。
31. 同一进程下的线程可以共享以下？（BD）
A．stack
B．data section
C．register set
D．file fd
知识点
线程共享的内容包括：
1.进程代码段
2.进程的公有数据(利用这些共享的数据，线程很容易的实现相互之间的通讯)
3.进程打开的文件描述符、
4.信号的处理器、
5.进程的当前目录和
6.进程用户ID与进程组ID
线程独有的内容包括：
1.线程ID
2.寄存器组的值
3.线程的堆栈
4.错误返回码
5.线程的信号屏蔽码
所以选择为BD。
32. 对于派生类的构造函数，在定义对象时构造函数的执行顺序为？（D）
1：成员对象的构造函数
2：基类的构造函数
3：派生类本身的构造函数
A．123
B．231
C．321
D．213
33. 递归函数最终会结束，那么这个函数一定？（B）
A. 使用了局部变量
B. 有一个分支不调用自身
C. 使用了全局变量或者使用了一个或多个参数
D. 没有循环调用
34. 编译过程中，语法分析器的任务是（BCD）
A. 分析单词是怎样构成的
B. 分析单词串是如何构成语言和说明的
C. 分析语句和说明是如何构成程序的
D. 分析程序的结构
知识点
1.词法分析（lexical analysis）
词法分析是编译过程的第一个阶段。这个阶段的任务是从左到右的读取每个字符，然后根据构词规则识别单词。词法分析可以用lex等工具自动生成。
2.语法分析（syntax analysis）
语法分析是编译过程的一个逻辑阶段。语法分析在词法分析的基础上，将单词序列组合成各类语法短语，如“程序”，“语句”，“表达式”等等。语法分析程序判断程序在结构上是否正确。
3.语义分析（semantic analysis）
属于逻辑阶段。对源程序进行上下文有关性质的审查，类型检查。如赋值语句左右端类型匹配问题。
所以BCD 都属于词法分析，选择结果为 BCD。
35. 同步机制应该遵循哪些基本准则？（ABCD）
A．空闲让进
B．忙则等待
C．有限等待
D．让权等待
36. 进程进入等待状态有哪几种方式？（D）
A. CPU调度给优先级更高的线程
B. 阻塞的线程获得资源或者信号
C. 在时间片轮转的情况下，如果时间片到了
D. 获得spinlock未果
37. 设计模式中，属于结构型模式的有哪些？（BC）
A. 状态模式
B. 装饰模式
C. 代理模式
D. 观察者模式
public static void main(String[] args) {
List<String> a = null;
test(a);
System.out.println(a.size());
}
public static void test(List<String> a) {
a = new ArrayList<String>();
a.add("abc");
}A．０
B．１
C．Java.lang.NullPointerException
D．以上都不正确
A. Ps
B. Cat
C. More
D. Sep
40. JVM内存里哪个区域不可能发生OutOfMerncyError( A)
A. 程序计数器
B. 堆
C. 方法区
D. 本地方法栈
41. 下面关于阻塞队列（java.util.concurrent.BlockingQueue）的说法不正确的是(C)
A. 阻塞队列是线程安全的
B. 阻塞队列的主要应用场景是“生产者-消费者”模型
C. 阻塞队列里的元素不能为null
D. 阻塞队列的实现必须显示地设置容量
42. 如果现在需要创建一组任务，他们并行的执行工作，然后进行下一个步骤之前等待，直至所有的任务都完成，而去这种控制可以重用多次，这种情形使用java.util.concurrent包中引入哪种同步工具最适合（B）
A. CountDownLatch
B. CyclicBarrier
C. Semaphore
D. FutureTask
43. java中， 为什么基类不能做为HashMap的键值， 而只能是引用类型，把引用类型作为HashMap的键值， 需要注意哪些地方？
答案：引用类型和原始类型的行为完全不同，并且它们具有不同的语义。引用类型和原始类型具有不同的特征和用法，它们包括：大小和速度问题，这种类型以哪种类型的数据结构存储，当引用类型和原始类型用作某个类的实例数据时所指定的缺省值。对象引用实例变量的缺省值为null，而原始类型实例变量的缺省值与它们的类型有关。
44. 编写一个工具类StringUtil,提供方法 int compare(char[] v1 ,char[] v2)方法，比较字符串v1,v2 ,如果按照字符顺序v1>v2则return 1 ,v1=v2 则return 0, v1。
public class StringUtil {
int compare(char[] v1, char[] v2) {
String str1 = new String(v1);
String str2 = new String(v2);
int result = str1.compareTo(str2);
return result == 0 ? 0 : (result > 0 ? 1 : -1);
}
}触发java.lang.OutOfMemoryError:最常见的原因就是应用程序需要的堆空间是大的，但是JVM提供的却小。这个的解决方法就是提供大的堆空间即可。除此之外还有复杂的原因：，
内存泄露：特定的编程错误会导致你的应用程序不停的消耗更多的内存，每次使用有内存泄漏风险的功能就会留下一些不能被回收的对象到堆空间中，随着时间的推移，泄漏的对象会消耗所有的堆空间，最终触发java.lang.OutOfMemoryError: Java heap space错误。
解决方案：
第一个解决方案是显而易见的，你应该确保有足够的堆空间来正常运行你的应用程序，在JVM的启动配置中增加如下配置：
-Xmx1024m
流量/数据量峰值：应用程序在设计之初均有用户量和数据量的限制，某一时刻，当用户数量或数据量突然达到一个峰值，并且这个峰值已经超过了设计之初预期的阈值，那么以前正常的功能将会停止，并触发java.lang.OutOfMemoryError: Java heap space异常
解决方案，如果你的应用程序确实内存不足，增加堆内存会解决GC overhead limit问题，就如下面这样，给你的应用程序1G的堆内存：
java -Xmx1024m com.yourcompany.YourClass
46 下列关于栈的描述错误的是（B）
A.栈是先进后出的线性表
B.栈只能顺序存储
C.栈具有记忆功能
D.对栈的插入和删除操作中，不需要改变栈底指针
47 对于长度为n的线性表，在最坏的情况下，下列个排序法所对应的比较次数中正确的是（D）
A.冒泡排序为n/2
B.冒泡排序为n
C.快速排序为n
D.快速排序为n(n-1)/2
48 阅读下列代码后，下列正确的说法是（A）
public class Demo {
int arr[] = new int[10];
public static void main(String args[ ]){
System.out.println(arr[1]);
}
}A 编译时将产生错误
B 编译时正确，运行时将产生错误
C 输出空
D 输出0
49. 执行以下程序后输出的结果是（D）
public static void main(String[] args) {
StringBuffer a = new StringBuffer("A");
StringBuffer b = new StringBuffer("B");
operator(a, b);
System.out.println(a + "," + b);
}
public static void operator(StringBuffer x, StringBuffer y) {
x.append(y);
y = x;
}A . A,A
B. A,B
C. B,B
D. AB,B
50. 下列不属于持久化的是（A）
A. 把对象转换成为字符串的形式通过网络传输，在另一端接收到字符串把对象还原出来
B. 把程序数据从数据库中读出来
C. 从XML配置文件中读取程序的配置信息
D. 把程序数据保存为文件
51. 下列程序段输出的结果是（B）
void complicatedexpression_f(){
int x=20,y=30;
boolean j;
j=x>50&&y>60|| x>50&& y<-60 || x<-50&&y>60 || x<-50&& y<-60;
System.out.println(j);
}A. true
B. false
C. 1
D. 001
52. 一个栈的输入序列为123，则下列序列中不可能是栈输出的序列的是（C）
A. 2 3 1
B. 3 2 1
C. 3 1 2
D. 1 2 3
53. 当 n = 5时， 下列函数的返回值是（D）
int foo(int n){
if(n<2) return n;
return foo(n-1)+foo(n-2);
}A. 1
B. 8
C. 7
D. 5
54. 设有一个二维数组A[m][n],假设A[0][0]存放的位置在644（10），A[2][2]存放的文职在676（10）每个元素占一个空间，问A[3][3]（10）存放在什么位置? 脚注（10）表示用10进制表示（C）
A. 688
B. 678
C. 692
D. 699
55. 下列代码执行结果是（B）
public static void main(String args[]) {
Thread t = new Thread() {
public void run() {
pong();
}
};
t.run();
System.out.print("ping");
}
static void pong() {
System.out.print("pong");
}A. pingpong
B. pongping
C. pingpong和pongping都有可能
D.都有可能
56. 下面程序能正常运行吗（可以）
public class NULL{
public static void haha(){
System.out.println(“haha”);
}
public static void main(String[] args){
((NULL)null).haha();
}
}57. 解释一下什么是Servlet,说一说Servlet的生命周期
Servlet是一种服务器端的Java应用程序，具有独立于平台和协议的特性,可以生成动态的Web页面。 它担当客户请求（Web浏览器或其他HTTP客户程序）与服务器响应（HTTP服务器上的数据库或应用程序）的中间层。 Servlet是位于Web 服务器内部的服务器端的Java应用程序，与传统的从命令行启动的Java应用程序不同，Servlet由Web服务器进行加载，该Web服务器必须包含支持Servlet的Java虚拟机。
Servlet生命周期可以分成四个阶段：加载和实例化、初始化、服务、销毁。
当客户第一次请求时，首先判断是否存在Servlet对象，若不存在，则由Web容器创建对象，而后调用init()方法对其初始化，此初始化方法在整个Servlet生命周期中只调用一次。
完成Servlet对象的创建和实例化之后，Web容器会调用Servlet对象的service()方法来处理请求。
当Web容器关闭或者Servlet对象要从容器中被删除时，会自动调用destory()方法。
58. 过滤器有哪些作用和用法？
对于一个web应用程序来说，过滤器是处于web容器内的一个组件，它会过滤特定请求资源请求信息和响应信息。一个请求来到时，web容器会判断是否有过滤器与该信息资源相关联，如果有则交给过滤器处理，然后再交给目标资源，响应的时候则以相反的顺序交给过滤器处理，最后再返回给用户浏览器。
常见的过滤器用途主要包括：对用户请求进行统一认证、对用户的访问请求进行记录和审核、对用户发送的数据进行过滤或替换、转换图象格式、对响应内容进行压缩以减少传输量、对请求或响应进行加解密处理、触发资源访问事件等。
59. 写出一个冒泡排序
public void BigAndSmall() {
int arr[] = { -5, 29, 7, 10, 5, 16 };
for (int i = 0; i < arr.length-1; i++) {
for (int j = 0; j < arr.length-1-i; j++) {
if (arr[j] > arr[j+1]) {
int temp;
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
for (int i = 0; i < arr.length; i++) {
System.out.print(" " + arr[i] + " ");
}
}public class LazySingleton {
private LazySingleton() {
}
private static class SingletonHolder {
private static LazySingleton instance = new LazySingleton();
}
public static LazySingleton getInstance() {
return SingletonHolder.instance;
}
}A. 124
B. 96
C. 216
D. 348
62. 2006年某人连续打工24天，共赚了190元（日工资10元，星期日工资5元，星期日休息无工资）。已知他打工是从1月下旬的某一天开始的，这个月的1日恰好是星期日，这人打工结束的那一天是2月（C）日
A. 2月6日
B. 2月14日
C. 2月18日
D. 2月21日
63. 由甲地到乙地有一天线路的巴士，全程行驶时间42分钟，到达总站后，司机至少休息10分钟，巴士就掉头行驶，如果这条线路甲，乙两边总站每隔8分钟都发一辆（不必是同一时间），则这条线路至少需要是多少俩巴士（C）
A. 15
B. 14
C. 13
D.12
64. 编号为1至10的10个果盘中，每盘都盛有水果，共盛放100个。其中第一盘里有16个，并且编号相邻的三个果盘中水果是的和都相等，求第8盘中水果最多可能有几个（A）
A. 11
B. 12
C. 13
D. 14
65. 一只蜗牛掉进20米深的井中，白天往上爬3米，晚上有掉下去2米，请问要几天才能爬出来？
第一天爬了3米,然后掉了2米,实际上爬了1米；
第二天从1米处开绐向上爬了3米,然后掉了2米,实际上爬了2米；
第三天从2米处开绐向上爬了3米,然后掉了2米,实际上爬了3米；
. .......
第十八天从17米处开始向上爬了3米,嘿刚好是20米.到了
正解:18
66. 按规律填数字1， 1， 2， 3， ？。
答案：5。
67. 假设一个池塘，里面有无穷多的水，现在有2个空水壶容积分别是5升和6升，问如何用这两只水壶取得3升水。
答案：5L桶打满水，全部倒入6L桶；
5L桶再次打满，往6L桶倒水至其满。此时5L桶留下4L水；
6L桶清空，将5L桶中的4L水倒入6L桶；
5L桶打满水，往6L桶倒水至其满，则5L桶中得3L水。
68. 在房里有三盏灯，房外有三个开关，在房外看不见房内的情况，你只能进门一次，你用什么方法来区分那个开关控制哪一盏灯。
答案：先打开第一个开关，开一会再关上，然后打开第二个开关进入房间
再摸一下每个灯，发热的那盏是第一个开关的，
亮的那盏是第二个开关的，
没变化的那盏是第三个开关的。
69. 两个盲人，他们各自买个两双黑袜和白袜，8双袜子的布质，大小完全相同，每双袜子都有1张商标纸连着，两位盲人不小心把8双袜子混在的一起，问他们怎样才能取回黑袜和白袜各两双。
答案：把每双袜子分成两只。 每人各拿一只。 这样，每人手中就有四只黑袜，四只白袜。 每人也就有两双黑袜，两双白袜了。
70. 一楼到十楼的每层电梯门口都方和一颗钻石，钻石大小不一，你乘坐电梯从一楼到十楼，每层楼电梯门都会打开一次，手里只能拿一颗钻石，问怎样才能拿到最大的钻石。
答案：电梯每层都会开一下的，所以，在第一层就拿，到第二层，看到更大就换一下，更小就不换，一直这样上去，到最上层后，拿到的就是最大的
71. ArrayList list = new ArrayList(20);语句中的list集合大小扩充了几次（A）
A.0
B.1
C.2
D.3
72. 如果去掉了main方法的static修饰符会怎样（B）
A.程序无法翻译
B.程序能正常编译，运行时或抛出NoSuchMethodError异常
C.程序能正常编译，正常运行
D.程序能正常编译，正常运行一会会立刻退出
73. 启动java程序进程时，输入一下哪个参数可以实现年轻代的堆大小为50M(C )
A.-Xms50M
B.-Xmx50M
C.-Xmn50M
D.-Xss50M
74. 下面程序输出的结果是（A）
static boolean foo(char c) {
System.out.print(c);
return true;
}
public static void main(String[] args) {
int i = 0;
for (foo('A'); foo('B') && (i < 2); foo('C')) {
i++;
foo('D');
}
}A. ABDCBDCB
B. ABDCDBCB
C. ABDBCDCB
D. ABDBCDCB
75. 下面哪些是Thread类的方法（A，B）
A.start()
B.run()
C.exit()
D.getPriority()
76. 以下语句输出的结果是什么（C）
System.out.print(Integer.MAX_VALUE*2);
System.out.print(Integer.MIN_VALUE*2);A. -2-1
B. -1-2
C. -2 0
D. -1-1
77. log4j的优先级从高到低的排序为（A）
A. error>warn>info>debug
B. warn>info>debug>error
C. warn >debug>error>info
D. error>warn>debug>info
78. 下列哪些方法可以使线程从运行状态进入到阻塞状态（BCD）
A.notify
B.wait
C.sleep
D.yield
79. 下列关于Thread类提供的线程控制的方法中，错误的一项是（A）
A. 在线程A中执行线程B的join()方法，则线程A等待直到B执行完成
B. 线程A通过调用interrupt()方法来中断其阻塞状态。
C. currentThread()方法返回当前线程的引用
D. 若线程A调用方法isAlive（）返回为true,则说明A正在执行中
80. 设String s1 =”Topwalk”;String s2 =”Company”;以下方法可以得到字符串“TopwalkCompany” 有：（ABD）
A. s2+s1;
B. s1.concat(s2)
C. s1.append(s2);
D.StringBuffer buf = new StringBuffer(s1);buf.append(s2);
81. String a = new String(“1”+”2”)最终创建了几个对象（B）
A.1
B.2
C.3
D.4
82. int 类型占用（C）个字节？
A.2
B.4
C.8
D.16
83. 下列那一条语句可以实现快速的复制一张数据库表（C）
A. select * into b from a where 1<>1;
B. creat table b as select * from a where 0=1;
C. insert into b as select * from a where 1<>1;
D. insert into b select * from a where 1<>1;
84. 属于单例模式的特点的是（ACD）
A. 提供了对唯一实现的受控访问
B. 允许可变数目的实例
C. 单利模式的抽象层会导致单例类扩展有和那的困难
D. 单利模式很容易导致数据库的连接池溢出
85. 选择Oracle的分页语句的关键字（A）
A. rownum
B. limit
C.TOP
D. pagenum
86. 选出可以查询出所有的表和视图的方法：（B）
A.preparedStatement.getMetaData().getTables(***);
B.connection.getMetaData().getTables(***);
C.result.getMetaData().getTables(***);
D..DiverManager.getMeta().getTables(***);
87. 可以监控到数据库变化的机制有哪些（AB）
A. 存储过程
B. 数据库日志
C. 触发器
D. 物化视图
88. 清空表所有数据的性能最优的语句是哪一个(B)
A. delete from tsuer;
B. truncate table tuser;ss
C. drop table tuser;
D. delete tuser;
89. 文件对外共享的协议有哪几个（AB）
A. FTP
B. Windows共享
C. TCP
D.SSH
90. 关于Java中国特殊符号的用法正确的是（AD）
A. 判断一个字符串str中是否含有“.”,可以根据str.indexOf(“.”)是否等于-1判断。
B. 判断一个字符串str是否含有“.”,可以根据str.indexOf(“\\.”)是否等于-1判断。
C. 根据“.”分隔字符串str的写法可以是str.split(“\\.”)
D. 根据“.”分隔字符串str的写法可以是str.split(“.”)
91. 根据以下代码回答问题，放置什么方法在地6行，会引起编译错误的是（B）
1 class Super{
2 public float getNum(){
3 }
4 }
5 public class Sub extends Super{
6
7 }A. public float getNum{return 4,0f;}
B.public void getNum(){};
C.public void getNum(double d()){}
D.public double getNum（float d）{return 4,0d;}
92. 根据以下代码回答问题：输出结果是什么？(B)
public class Foo{
public static void main(String args[]){
try{return;}
finally{System.out.println("Finally");}
}
}A. print out nothing;
B. print out “Finally”
C. 编译错误
D. 以上都不对
93. 根据以下代码回答问题，请问输出i和j的值是多少（D）
public static void main(String[] args) {
int i=1,j=10;
do{
if(i++>--j) continue;
}while(i<5);
}A. i=6 j=5
B i=5 j=5
C i=6 j=4
D i=5 j=6
94. 请问java关键字？（CD）
A. run
B. low
C. import
D. implement
95. 以下哪些不属于约束（CD）
A.主键
B.外键
C.索引
D.唯一索引
E.not null
96. 下列关于数据库连接池的说法中哪个是错误的（D）
A. 服务器启动时会初始建立一定数量的池连接，并一直维持不少于此数目的池连接
B.客户端程序需要连接时，池驱动程序会返回一个使用的池连接并将其使用计数加1；
C. 如果当前没有空闲连接，驱动程序就会再新建一定数量的连接，新建连接的数量可以由配置参数决定。
D. 当使用池连接调用完成后，池驱动程序将此连接标记为空间，其他调用就可以使用这个连接
97. 以下哪句是对索引的错误描述（C）
A. 选择性差的索引只会降低DML语句的执行速度
B. 选择性强的索引只有被Access Path使用到才是有用的索引
C. 过多的索引只会阻碍性能的提升，而不是加速性能
D.在适当的时候将最常用的列放在复合索引的最前面
E. 索引和表的数据都存储在同一个Segment中
98. 关于锁locks，描述正确的是（A）
A. 当一个事务在表上防止了共享锁（shared lock）,其他事务，能阅读表里的数据
B. 当一个事务在表上防止了共享锁（shared lock）,其他事务，能更新表里的数据
C. 当一个事务在表上防止了排他锁（exclusive lock）,其他事务，能阅读表里的数据
D. 当一个事务在表上防止了排他锁（exclusive lock）,其他事务，能更新表里的数据
99. 如下那种情况下，Oracle不会使用Full Table Scean(D)
A.缺乏索引，特别是在列上使用了函数，如果要利用索引，则需要使用函数索引。
B.当访问的数据占整个表中的大部分数据时
C.如果时一个表的high water mark 数据块数少于初始化参数DB_FILE_MULTIBLOCK_READ_COUNT
D.本次查询可以用到该张表的一个引用，但是该表具有多个索引包含用于过滤的字段
100. 如何判断两个单向链表相交，如何找相交点？
第一种情况：两个链表均不含有环思路：
1)、直接法
采用暴力的方法，遍历两个链表，判断第一个链表的每个结点是否在第二个链表中，时间复杂度为O(len1*len2)，耗时很大。
2)、hash计数法
如果两个链表相交，则两个链表就会有共同的结点；而结点地址又是结点唯一标识。因而判断两个链表中是否存在地址一致的节点，就可以知道是否相交了。可以对第一个链表的节点地址进行hash排序，建立hash表，然后针对第二个链表的每个节点的地址查询hash表，如果它在hash表中出现，则说明两个链表有共 同的结点。这个方法的时间复杂度为：O(max(len1+len2)；但同时还得增加O(len1)的存储空间存储哈希表。这样减少了时间复杂度，增加 了存储空间。
以链表节点地址为值，遍历第一个链表，使用Hash保存所有节点地址值，结束条件为到最后一个节点（无环）或Hash中该地址值已经存在（有环）。
再遍历第二个链表，判断节点地址值是否已经存在于上面创建的Hash表中。
这个方面可以解决题目中的所有情况，时间复杂度为O(m+n)，m和n分别是两个链表中节点数量。由于节点地址指针就是一个整型，假设链表都是在堆中动态创建的，可以使用堆的起始地址作为偏移量，以地址减去这个偏移量作为Hash函数
3)、第三种思路是比较奇特的，在编程之美上看到的。先遍历第一个链表到他的尾部，然后将尾部的next指针指向第二个链表(尾部指针的next本来指向的是null)。这样两个链表就合成了一个链表，判断原来的两个链表是否相交也就转变成了判断新的链表是否有环的问题了：即判断单链表是否有环？
这样进行转换后就可以从链表头部进行判断了，其实并不用。通过简单的了解我们就很容易知道，如果新链表是有环的，那么原来第二个链表的头部一定在环上。因此我们就可以从第二个链表的头部进行遍历的，从而减少了时间复杂度(减少的时间复杂度是第一个链表的长度)。
这种方法可以判断两个链表是否相交，但不太容易找出他们的交点。
4)、仔细研究两个链表，如果他们相交的话，那么他们最后的一个节点一定是相同的，否则是不相交的。因此判断两个链表是否相交就很简单了，分别遍历到两个链表的尾部，然后判断他们是否相同，如果相同，则相交；否则不相交。
判断出两个链表相交后就是判断他们的交点了。假设第一个链表长度为len1，第二个问len2，然后找出长度较长的，让长度较长的链表指针向后移动|len1 - len2| (len1-len2的绝对值)，然后在开始遍历两个链表，判断节点是否相同即可。
101. 如何从cookie中拿到session?
答案：session 在服务器端，cookie 在客户端（浏览器），session 默认被存在在服务器的一个文件里（不是内存），session 的运行依赖 session id，而 session id 是存在 cookie 中的，也就是说，如果浏览器禁用了 cookie ，同时 session 也会失效（但是可以通过其它方式实现，比如在 url 中传递 session_id）； session 可以放在 文件、数据库、或内存中都可以。用户验证这种场合一般会用session ，因此，维持一个会话的核心就是客户端的唯一标识，即 session id
102. System.out.println(3/2); System.out.println(3.0/2); System.out.println(3.0/2.0); 分别会打印什么结果？
答案：1, 1.5，1.5
103. 打印出下面两个数组的交集，结果不能重复
String[] arr1 = {"112","wqw","2121"};
String[] arr2 = {"112","aad","ewqw"};打印出两个数组的交集，结果不能重复
答案：
public class Demo_4 {
@Test // 测试程序
public void test() {
String[] arr1 = { "112", "wqw", "2121" };
String[] arr2 = { "112", "aad", "ewqw" };
String[] result = StringIntersection(arr1, arr2);
for (String str : result) {
System.out.printf(str);
}
}
// 取两个string数组的交集
public String[] StringIntersection(String[] arr1, String[] arr2) {
Map<String,Object> map = new HashMap<String,Object>();
List<String> list = new LinkedList<String>();
// 取出str1数组的值存放到map集合中，将值作为key，所以的value都设置为false
for (String str1 : arr1) {
if (!map.containsKey(str1)) {
map.put(str1, Boolean.FALSE);
}
}
// 取出str2数组的值循环判断是否有重复的key，如果有就将value设置为true
for (String str2 : arr2) {
if (map.containsKey(str2)) {
map.put(str2, Boolean.TRUE);
}
}
// 取出map中所有value为true的key值，存放到list中
for (Map.Entry entry : map.entrySet()) {
if (entry.getValue().equals(Boolean.TRUE)) {
list.add((String) entry.getKey());
}
}
// 声明String数组存储交集
String[] result = {};
return list.toArray(result);
}
}104. SpringMvc 拦截器用过吗？什么场景会用到，过滤器，拦截器，监听器有什么区别？
拦截器是指通过统一拦截从浏览器发往服务器的请求来完成功能的增强。
使用场景：解决请求的共性问题（乱码问题、权限验证问题）
过滤器
Servlet中的过滤器Filter是实现了javax.servlet.Filter接口的服务器端程序，主要的用途是过滤字符编码、做一些业务逻辑判断等。其工作原理是，只要你在web.xml文件配置好要拦截的客户端请求，它都会帮你拦截到请求，此时你就可以对请求或响应(Request、Response)统一设置编码，简化操作；同时还可进行逻辑判断，如用户是否已经登陆、有没有权限访问该页面等等工作。它是随你的web应用启动而启动的，只初始化一次，以后就可以拦截相关请求，只有当你的web应用停止或重新部署的时候才销毁。
监听器
现在来说说Servlet的监听器Listener，它是实现了javax.servlet.ServletContextListener 接口的服务器端程序，它也是随web应用的启动而启动，只初始化一次，随web应用的停止而销毁。主要作用是： 做一些初始化的内容添加工作、设置一些基本的内容、比如一些参数或者是一些固定的对象等等
拦截器
拦截器是在面向切面编程中应用的，就是在你的service或者一个方法前调用一个方法，或者在方法后调用一个方法。是基于JAVA的反射机制。拦截器不是在web.xml
1).过滤器：所谓过滤器顾名思义是用来过滤的，在java web中，你传入的request,response提前过滤掉一些信息，或者提前设置一些参数，然后再传入servlet或者struts的action进行业务逻辑，比如过滤掉非法url（不是login.do的地址请求，如果用户没有登陆都过滤掉）,或者在传入servlet或者struts的action前统一设置字符集，或者去除掉一些非法字符（聊天室经常用到的，一些骂人的话）。filter 流程是线性的， url传来之后，检查之后，可保持原来的流程继续向下执行，被下一个filter, servlet接收等.
2).监听器：这个东西在c/s模式里面经常用到，他会对特定的事件产生产生一个处理。监听在很多模式下用到。比如说观察者模式，就是一个监听来的。又比如struts可以用监听来启动。Servlet监听器用于监听一些重要事件的发生，监听器对象可以在事情发生前、发生后可以做一些必要的处理。
3).java的拦截器 主要是用在插件上，扩展件上比如 hivernate spring struts2等 有点类似面向切片的技术，在用之前先要在配置文件即xml文件里声明一段的那个东西。
105. ThreadLocal的原理和应用场景
每一个ThreadLocal能够放一个线程级别的变量，可是它本身能够被多个线程共享使用，并且又能够达到线程安全的目的，且绝对线程安全。ThreadLocal的应用场景：
最常见的ThreadLocal使用场景为 用来解决数据库连接、Session管理等
106. 简述TCP的三次握手
在TCP/IP协议中,TCP协议提供可靠的连接服务,采用三次握手建立一个连接。
1).第一次握手：建立连接时,客户端发送syn包(syn=j)到服务器,并进入SYN_SEND状态, 等待服务器确认；SYN：同步序列编号(Synchronize Sequence Numbers)
2).第二次握手：服务器收到syn包,必须确认客户的SYN（ack=j+1）,同时自己也发送一个SYN包（syn=k）,即SYN+ACK包,此时服务器进入SYN_RECV状态；
3)第三次握手：客户端收到服务器的SYN＋ACK包,向服务器发送确认包ACK(ack=k+1), 此包发送完毕,客户端和服务器进入ESTABLISHED状态,完成三次握手。
完成三次握手,客户端与服务器开始传送数据。
107. SpringMVC request接收设置是线程安全的吗？
答案：是线程安全的，request、response以及requestcontext在使用时不需要进行同步。而根据spring的默认规则，controller对于beanfactory而言是单例的。即controller只有一个， controller中的request等实例对象也只有一个
108. 列举Maven常见的六种依赖范围
答案：
1.compile:编译依赖范围(默认),对其三种都有效
2.test:测试依赖范围,只对测试classpath有效
3.runtime:运行依赖范围,只对测试和运行有效,编译主代码无效,例如JDBC
4.provided:已提供依赖范围,只对编译和测试有效,运行时无效,例如selvet-api
5.system:系统依赖范围.谨慎使用.例如本地的,maven仓库之外的类库文件
6.import(maven2.0.9以上):导入依赖范围,不会对其他三种有影响
109. Mybatis如何防止sql注入？mybatis拦截器了解过吗，应用场景是什么？
答案：Mybatis使用#{}经过预编译的，是安全的，防止sql注入。
Mybatis拦截器只能拦截四种类型的接口：Executor、StatementHandler、 ParameterHandler和ResultSetHandler。这是在Mybatis的Configuration中写死了的，如果要支持拦截其他接口就需要我们重写Mybatis的Configuration。Mybatis可以对这四个接口中所有的方法进行拦截。Mybatis拦截器常常会被用来进行分页处理。
110. 简单解释自动装配的各种模式，或者叫装配方式。
在Spring框架中共有5种自动装配:
no：这是Spring框架的默认设置，在该设置下自动装配是关闭的，开发者需要自行在bean 定义中用标签明确的设置依赖关系。
byName：该选项可以根据bean名称设置依赖关系。当向一个bean中自动装配一个属 性时，容器将根据bean的名称自动在在配置文件中查询一个匹配的bean。如果找到的 话，就装配这个属性，如果没找到的话就报错。
byType：该选项可以根据bean类型设置依赖关系。当向一个bean中自动装配一个属性时，容器将根据bean的类型自动在在配置文件中查询一个匹配的bean。如果找到的话，就装配这个属性，如果没找到的话就报错。
constructor：造器的自动装配和byType模式类似，但是仅仅适用于与有构造器相同参数 的bean，如果在容器中没有找到与构造器参数类型一致的bean，那么将会抛出异常。
autodetect：该模式自动探测使用构造器自动装配或者byType自动装配。首先，首先会 尝试找合适的带参数的构造器，如果找到的话就是用构造器自动装配，如果在bean内部 没有找到相应的构造器或者是无参构造器，容器就会自动选择byTpe的自动装配方式。
111. mvc的各个部分都有哪些技术来实现？如何实现的？
MVC 是 Model－View－Controller 的简写。 Model 代表的是应用的业务逻辑（ 通过JavaBean， EJB 组件实现）， View 是应用的表示面（ 由 JSP 页面产生）， Controller 是提供应用的处理过程控制（一般是一个Servlet）， 通过这种设计模型把应用逻辑， 处 理过程和显示逻辑分成不同的组件实现。这些组件可以进行交互和重用。
112. 反射机制一般应用在什么场景？
答案：反射机制的应用场景：
1)逆向代码 ，例如反编译
3)与注解相结合的框架 例如Retrofit
4)单纯的反射机制应用框架 例如EventBus 2.x
5)动态生成类框架 例如Gson
113. 设计Java程序，假设有50瓶饮料，喝完三个空瓶可以换一瓶饮料，依次类推，请问总共喝了多少饮料。
答案：
public class Buy {
public static void main(String[] args) {
int n = 50; // 初始饮料总数
int i = 0; // 兑换次数
while (true) {
n -= 3; // 喝3瓶
n++; // 兑换1瓶
i++; // 兑换次数+1
if (n < 3){
System.out.println("共喝了" + (50 + i) + "瓶");
break;
}
}
}
}114. 根据某年某月某日，输出这是一年中第几天。
答案：
public class Demo_5 {
/**
* 输入某年某月某日，判断这一天是这一年的第几天？
*
*/
public static void main(String[] args) {
int year;
int mouth;
int day = 0;
int days;
// 累计天数
int d = 0;
int e = 0;
Scanner scanner = new Scanner(System.in);
do {
System.out.println("输入年:");
year = scanner.nextInt();
System.out.println("输入月:");
mouth = scanner.nextInt();
System.out.println("输入日:");
days = scanner.nextInt();
if (mouth < 0 || mouth > 12 || days < 0 || days > 31) {
System.out.println("input error!");
e = 1;
}
} while (e == 1);
for (int i = 1; i < mouth; i++) {
switch (i) {
case 1:
case 3:
case 5:
case 7:
case 8:
case 10:
case 12: {
day = 31;
break;
}
case 4:
case 6:
case 9:
case 11: {
day = 30;
break;
}
case 2: {
/**
* 闰年:①：非整百年数除以4，无余为闰，有余为平；②整百年数除以400，无余为闰有余平 二月：平年28天、闰年29天
*/
if ((year % 100 != 0 && year % 4 == 0) || (year % 100 == 0 && year % 400 == 0)) {
day = 29;
} else {
day = 28;
}
}
default:
break;
}
d += day;
}
System.out.println("这是" + year + "年的" + (d + days) + "天");
}
}115. 利润与奖金，某公司销售10万元到20万元的奖金10%，在20万元的奖金10万元以上的奖金7.5%，到40万元超出20万元的部分奖金为5%,到60万元的超出40万元的部分奖金3%，到100万元的超出60万元部分奖金1%，请输出说的奖金。
答案：
public static void main(String[] args) {
float jiangjin = 0;
Scanner scan = new Scanner(System.in);
System.out.print("请输入利润：");
float num = scan.nextInt();
if (num <= 100000) {
jiangjin = (float) (num * 0.1);
}else if (num <= 200000) {
jiangjin = (float) ((num - 100000) * 0.075 + 100000 * 0.1);
}else if (num <= 400000) {
jiangjin = (float) ((num - 200000) * 0.5 + 100000 * 0.175);
}else if (num <= 600000) {
jiangjin = (float) ((num - 400000) * 0.3 + 100000 * 0.175 + 200000 * 0.5);
}else if (num <= 1000000) {
jiangjin = (float) ((num - 600000) * 0.015 + 100000 * 0.175 + 200000 * 0.5 + 200000 * 0.3);
}else {
jiangjin = (float) ((num - 1000000) * 0.01 + 100000 * 0.175 + 200000 * 0.5 + 200000 * 0.3 + 400000 * 0.015);
}
System.out.println("奖金：" + jiangjin);
}117. 除了懒汉式和饿汉式你还了解那些单利模式？
答案：
第一种：双重查锁模式
public class DoubleCheckLock {
private static DoubleCheckLock instance = null;
private DoubleCheckLock() {
}
public static DoubleCheckLock getInstance() {
if (instance == null) {
synchronized (DoubleCheckLock.class) {
if (instance == null) {
instance = new DoubleCheckLock();
}
}
}
return instance;
}
}
第二种：枚举单例
public enum SingleEnum {
INSTANCE;
public void doSomething() {
System.out.println("do something...");
}
}第三种：静态内部类方式
public class StaticInner {
private static StaticInner instance;
public static StaticInner getInstance() {
return SingletonHolder.STATIC_INNER;
}
private static class SingletonHolder {
private static final StaticInner STATIC_INNER = new StaticInner();
}
}118. 简述SSH的概念以及中主要的设计思想？
SSH是 struts+spring+hibernate的一个集成框架，是目前比较流行的一种Web应用程序开源框架。
集成SSH框架的系统从职责上分为四层：表示层、业务逻辑层、数据持久层和域模块层，以帮助开发人员在短期内搭建结构清晰、可复用性好、维护方便的Web应用程序。其中使用Struts作为系统的整体基础架构，负责MVC的分离，在Struts框架的模型部分，控制业务跳转，利用Hibernate框架对持久层提供支持，Spring做管理，管理struts和hibernate。具体做法是：用面向对象的分析方法根据需求提出一些模型，将这些模型实现为基本的Java对象，然后编写基本的DAO(Data Access Objects)接口，并给出Hibernate的DAO实现，采用Hibernate架构实现的DAO类来实现Java类与数据库之间的转换和访问，最后由Spring做管理
119. unix下如何让命令在后台执行？
要让程序在后台执行，只需在命令行的最后加上“&”符号。
例如：$ find . -name abc -print&；
120. rm -i与rm -r 个实现什么功能？
rm -i --interactive 交互模式删除文件，删除文件前给出提示。
rm -r -r或-R：递归处理，将指定目录下的所有文件与子目录一并处理。
121. 什么是乐观锁，什么是悲观锁，两者的区别是什么？
悲观锁(Pessimistic Lock), 顾名思义，就是很悲观，每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁，这样别人想拿这个数据就会block直到它拿到锁。传统的关系型数据库里边就用到了很多这种锁机制，比如行锁，表锁等，读锁，写锁等，都是在做操作之前先上锁。它指的是对数据被外界（包括本系统当前的其他事务，以及来自外部系统的事务处理）修改持保守态度，因此，在整个数据处理过程中，将数据处于锁定状态。悲观锁的实现，往往依靠数据库提供的锁机制（也只有数据库层提供的锁机制才能真正保证数据访问的排他性，否则，即使在本系统中实现了加锁机制，也无法保证外部系统不会修改数据）。
乐观锁(Optimistic Lock), 顾名思义，就是很乐观，每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断一下在此期间别人有没有去更新这个数据，可以使用版本号等机制。乐观锁适用于多读的应用类型，这样可以提高吞吐量，像数据库如果提供类似于write_condition机制的其实都是提供的乐观锁。
两种锁各有优缺点，不可认为一种好于另一种，像乐观锁适用于写比较少的情况下，即冲突真的很少发生的时候，这样可以省去了锁的开销，加大了系统的整个吞吐量。但如果经常产生冲突，上层应用会不断的进行retry，这样反倒是降低了性能，所以这种情况下用悲观锁就比较合适。
122. 日志打印的log4j的配置中%t表示什么？
答案：%t 输出产生该日志事件的线程名
扩展：%M是输出方法的名字、%m是输出代码指定的日志信息。
指定的打印信息的具体格式ConversionPattern，具体参数：
%m 输出代码中指定的消息
%p 输出优先级，即DEBUG，INFO，WARN，ERROR，FATAL
%r 输出自应用启动到输出该log信息耗费的毫秒数
%c 输出所属的类目，通常就是所在类的全名
%t 输出产生该日志事件的线程名
%n 输出一个回车换行符，Windows平台为"rn”，Unix平台为"n”
%d 输出日志时间点的日期或时间，默认格式为ISO8601，也可以在其后指定格式，比如：%d{yyyy MM dd HH:mm:ss,SSS}，输出类似：2002年10月18日 22：10：28，921 %l 输出日志事件的发生位置，包括类目名、发生的线程，以及在代码中的行数。
%x: 输出和当前线程相关联的NDC(嵌套诊断环境),尤其用到像java servlets这样的多客户多线程的应用中。
%%: 输出一个”%”字符
%F: 输出日志消息产生时所在的文件名称
%M: 输出执行方法
%L: 输出代码中的行号
123.Spring中什么时候引起NotWritablePropertyException
和Could not open calss path resource[ApplicationContext.xml]?
出现NotWritablePropertyException异常的原因一般是在ApplicationContext.xml中property name的错误等相关错误。
124. 关于Web应用程序，下列说法错误的是（b）。a) WEB-INF目录存在于web应用的根目录下
b) WEB-INF目录与classes 目录平行
c) web.xml在WEB-INF目录下
d) Web应用程序可以打包为war文件
解释：classes目录位于WEB-INF目录之下，而不是平行的关系。
125. 有关Servlet的生命周期说法正确的有（ cd）。
a) Servlet的生命周期由Servlet实例控制
b) init()方法在创建完Servlet实例后对其进行初始化，传递的参数为实现ServletContext接口的对象
c) service()方法响应客户端发出的请求
d) destroy()方法释放Servlet实例
解释：Servlet的生命周期是由Servlet容器（Tomcat就是常见的Servlet容器）管理的，因此a不对。
Servlet中的init（）方法有两个重载，一个是空参的，另外一个是带ServletConfig形参的，而不是ServletContext，因此b不对。
关于d选项，说法其实并不好，正确的表达应该是因为Servlet实例要释放（销毁）了，才会先调用destroy（）方法。
126. 有关会话跟踪技术描述正确的是（abc）。
a) Cookie是Web服务器发送给客户端的一小段信息，客户端请求时，可以读取该信息发送到服务器端
b) 关闭浏览器意味着会话ID丢失，但所有与原会话关联的会话数据仍保留在服务器上，直至会话过期
c) 在禁用Cookie时可以使用URL重写技术跟踪会话
d) 隐藏表单域将字段添加到HTML表单并在客户端浏览器中显示
127. 以下web.xml片断（ d ）正确地声明servlet 上下文参数。a) <init-param>
<param-name>MAX</param-name>
<param-value>100</param-value>
</init-param>
b) <context-param>
<param name="MAX" value="100" />
<context-param>
c) <context>
<param name="MAX" value="100" />
<context>
d) <context-param>
<param-name>MAX</param-name>
<param-value>100</param-value>
<context-param>a) session. getAttribute (“userid”);
b) session. setAttribute (“userid”);
c) request. getParameter (“userid”);
d) request. getAttribute (“userid”);
129.下列JSP代码，以下（cd）可放置在//1处，不会发生编译错误。<%
for(int i = 0; i < 10; i++) {
//1
}
%>a) <%= i %>
b) i
c) %><%= i %><%
d) 不写任何内容
128.考虑下面两个JSP文件代码片断：test1.jsp:
<HTML>
<BODY>
<% pageContext.setAttribute(”ten”,new Integer(10));%>
//1
</BODY>
</HTML> 数字为：<%= pageContext.getAttribute(”ten”)%>
以下（C）放置在test1.jsp中的//1处，当请求test1.jsp时正确输出test2.jsp中的内容。
a) <jsp:include page=”test2.jsp” />
b) <jsp:forword page=”test2.jsp” />
c) <%@ include file=”test2.jsp” %>
d) 由于pageContext对象的scope属性为page,所以test2.jsp不能访问test1.jsp定义的属性
解释：JSP中include的两种方法，1、属于动态引入/2、<%@ include file=”test2.jsp” %>属于静态引入。两者的区别如下：
1.执行时间上的区别
<%@ include file=”test2.jsp”%> 是在翻译阶段执行（将JSP页面转换成servlet的阶段）。通俗的话讲就是先合并在一起，然后再编译成一个Servlet文件。
在请求处理阶段执行。通俗的话讲就是先各自编译，然后在处理请求的时候结果再合并到一起。
2.引入内容的方式区别
<%@ include file=”test2.jsp”%>是纯粹的把部分代码写到了另一页面（或者说是共享），而那另一页面中不能有相同的变量名，但可以借用主页面的内容。
引入执行页面或servlet所生成的应答文本。
属于请求转发，由于pageContext对象的scope属性为page,所以如果请求转发了，那么test2.jsp就不能访问test1.jsp定义的属性了。所以该题选C。
129. 有关JSP隐式对象，以下（acd ）描述正确。a) 隐式对象是WEB容器加载的一组类的实例，可以直接在JSP页面使用
b) 不能通过config对象获取ServletContext对象
c) response对象通过sendRedirect方法实现重定向
d) 只有在出错处理页面才有exception对象
解释：jsp的九大内置对象分别是：config、request、response、out，page、pageContext、session、exception、application。其中exception是特殊的内置对象，只有当在jsp中添加isErrorPage="true"属性时如下配置时才可以使用。该属性一般出现在设定的错误界面。
<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
pageEncoding="ISO-8859-1" isErrorPage="true" %>
130. 考虑下面JSP文件代码片断：
<HTML>
<BODY>
<jsp:include page=”test2.jsp”>
<jsp:param name=”username”value=”svse”/>
</jsp:include>
</BODY>
</HTML>以下（c）代码片断放置在test2.jsp中不会导致错误。
a)<jsp:getParamname=”username”/>
b)<jsp:include param=”username”/>
c) <%=request.getParameter(“username”)%>
d) <%=request.getAttribute(“username”)%>
解释：属于动态调用test2.jsp界面，相当于动态去请求test2.jsp所生成的Servlet，在请求的同时携带了请求参数“username”，我们知道在Servlet中获取请求携带的参数就是通过request.getParameter(key)来获取的，因此C正确。
131. 以下是login.jsp文件的代码片断：
<%@ page isELIgnored="false"%>
<html>
<body>
<FORM action="login.jsp" method="GET">
<input type="text" name="name" value="${param['name']}">
<input type="submit" value="提交">
</FORM>
<P>
用户名为: ${param.name}</p>以下（C ）描述正确。
a) 发生运行错误
b) 页面会出现一文本框，并且文本框中内容为${param['name']}
c) 当用户输入名字并单击“提交”按钮时，在同一页面中的“用户名为：”字样后面会显示用户输入的内容
d) 当用户输入名字并单击“提交”按钮时，在同一页面中的“用户名为：”字样后面会显示${param.name}
132. doAfterBody()方法是在（ b ）接口中定义的。
a) Tag
b) IterationTag
c) BodyTag
d) TagSupport
解释：该知识点属于jsp自定义标签中的知识，比较生僻。如果想了解如何在jsp中使用自定义标签的可以参考下文。
133. 编写一个Filter，需要（ b）。a) 继承Filter 类
b) 实现Filter 接口
c) 继承HttpFilter 类
d) 实现HttpFilter接口
134. 有关MVC设计模式（b ）描述不正确。
a) 使用Servlet作为控制器
b) MVC设计模式增大了维护难度
c) MVC设计模式属于Model 2
d) 模型对象向客户端显示应用程序界面
补充知识：
Model 1
Model 1的基础是JSP文件，它由一些相互独立的JSP文件，和其他一些Java Class组成（不是必须的）。这些JSP从HTTP Request中获得所需要的数据，处理业务逻辑，然后将结果通过Response返回前端浏览器。
Model 2
采用面向对象技术实现MVC模式从而扩展JSP/Servlet的模式被成为是Model 2模式。Apache Jakarta项目中Struts是一个实现Model 2的很好的框架，它通过一些Custom Tag Lib处理表现层，用ActionFrom Bean表示数据，用自己提供的一个ActionServlet作为控制器实现页面的流转的控制功能。
说的直白一些，model1即为单纯的jsp+java，没有框架参与，通过response和request对象传送值域，而model2,则使用较为流行的struts2框架。
135. 在Linux中，可以使用命令（c）加挂计算机上的非Linux文件系统。
a) cat /proc/filesystems
b) ln
c) mount
d) df
136. 下面关于Linux中 shell 的说法错误的是（d）。
a) shell 是解释用户在终端键入的命令的一种中间程序
b) shell 可以读取并执行脚本文件中的命令
c) 用户可以使用参数将命令行的参数传递给shell 脚本，从而实现在 Linux 中的交互式编程
d) 默认情况下，Linux 中创建的所有文件都具有执行权限
137. 在Oracle中，当需要使用显式游标更新或删除游标中的行时，UPDATE或DELETE语句必须使用（c）子句。
a) WHERE CURRENT OF
b) WHERE CURSOR OF
c) FOR UPDATE
d) FOR CURSOR OF
138. 在Oracle中，使用下列的语句CREATE PUBLIC SYNONYM parts FOR Scott.inventory;完成的任务是（d）。
a) 将Scott.inventory对象的访问权限赋予所有用户
b) 指定了新的对象权限
c) 指定了新的系统权限
d) 给Scott.inventory对象创建一个公用同义词parts
139. 在Oracle中，执行如下PL/SQL语句后
CREATE TYPE car AS OBJECT ( id NUMBER, model VARCHAR2(25), color VARCHAR2(15) );
…
DECLARE
myvar car.model%TYPE;
BEGIN
…
END;a) NUMBER
b) car类型
c) VARCHAR2
d) OBJECT
解释：该知识点属于PL/SQL高级编程，中的对象类型（OBJECT TYPE）
140、下列说法正确的有（C）
A、class中的constructor不可忽略
B、constructor可以作为普通方法被调用
C、constructor在一个对象被new时被调用
D、一个class只能定义一个constructor
141、下列运算符合法的是（D）
A、&&
B、<>
C、If
D、:=
142、下列哪种说法不正确（ABC）
A、实例方法可以直接调用超类的实例方法
B、实例方法可以直接调用超类的类方法
C、实例方法可以直接调用其他类的实例方法
D、实例方法可以直接调用本类的类方法
143、执行如下程序代码后，c的值是（C）
int a=0;
int c=0;
do{
--c;
a=a-1;
}while(a>0); A、0 B、1 C、-1 D、死循环
144、（×）constructor必须与class同名，但是方法不能与class同名
145、（×）constructor可以被继承，因此可以重写Overriding，也可以被重载Overloading
146、（√）String类是final类 故不可以被继承
147、（×）数组的大小可以任意改变，又称动态数组
148、（×）try{}里有一个return语句，则紧跟在try后面的finally{}里的code将在return后执行
149、抽象类和接口有什么不同点？接口和抽象类的概念不一样。接口是对动作的抽象，抽象类是对根源的抽象。
抽象类表示的是，这个对象是什么。接口表示的是，这个对象能做什么。比如，男人，女人，这两个类（如果是类的话……），他们的抽象类是人。说明，他们都是人。
人可以吃东西，狗也可以吃东西，你可以把“吃东西”定义成一个接口，然后让这些类去实现它.
不同点：
参数抽象类接口
默认的方法实现它可以有默认的方法实现接口完全是抽象的。它根本不存在方法的实现
实现子类使用extends关键字来继承抽象类。如果子类不是抽象类的话，它需要提供抽象类中所有声明的方法的实现。子类使用关键字implements来实现接口。它需要提供接口中所有声明的方法的实现
构造器抽象类可以有构造器接口不能有构造器
与正常Java类的区别除了你不能实例化抽象类之外，它和普通Java类没有任何区别接口是完全不同的类型
访问修饰符抽象方法可以有public、protected和default这些修饰符接口方法默认修饰符是public。你不可以使用其它修饰符。
main方法抽象方法可以有main方法并且我们可以运行它接口没有main方法，因此我们不能运行它。
多继承抽象方法可以继承一个类和实现多个接口接口只可以继承一个或多个其它接口
速度它比接口速度要快接口是稍微有点慢的，因为它需要时间去寻找在类中实现的方法。
添加新方法如果你往抽象类中添加新的方法，你可以给它提供默认的实现。因此你不需要改变你现在的代码。如果你往接口中添加方法，那么你必须改变实现该接口的类。
150. 什么时候使用抽象类和接口
如果你拥有一些方法并且想让它们中的一些有默认实现，那么使用抽象类吧。
如果你想实现多重继承，那么你必须使用接口。由于Java不支持多继承，子类不能够继承多个类，但可以实现多个接口。因此你就可以使用接口来解决它。
如果基本功能在不断改变，那么就需要使用抽象类。如果不断改变基本功能并且使用接口，那么就需要改变所有实现了该接口的类。
151、sleep（）和wait（）有什么不同点？
主要区别在于：
sleep表示睡眠，wait表示等待 sleep需要手动唤醒线程，而wait不需要手动唤醒等待结束后自动执行。
152、TreeMap和HashMap有什么不同点？
第一点：HashMap：基于哈希表实现。使用HashMap要求添加的键类明确定义了hashCode()和equals()[可以重写hashCode()和equals()]，为了优化HashMap空间的使用，您可以调优初始容量和负载因子。
TreeMap：基于红黑树实现。TreeMap没有调优选项，因为该树总处于平衡状态。
第二点：HashMap通过hashcode对其内容进行快速查找。
TreeMap中所有的元素都保持着某种固定的顺序，如果你需要得到一个有序的结果你就应该使用TreeMap（HashMap中元素的排列顺序是不固定的）。
第三点：HashMap 非线程安全
TreeMap 线程安全
第四点：HashMap：适用于在Map中插入、删除和定位元素。
Treemap：适用于按自然顺序或自定义顺序遍历键(key)。
总结：HashMap通常比TreeMap快一点(树和哈希表的数据结构使然)，建议多使用HashMap，在需要排序的Map时候才用TreeMap
153、throws和throw有什么不同点？
throw是语句抛出一个异常。
语法：throw (异常对象);
throw e;
throws是方法可能抛出异常的声明。(用在声明方法时，表示该方法可能要抛出异常)
语法：[(修饰符)](返回值类型)(方法名)([参数列表])[throws(异常类)]{......}
public void doA(int a) throws Exception1,Exception3{......}
154、length（）和length有什么不同点？
java中的length属性是针对数组说的,比如说你声明了一个数组,想知道这个数组的长度则用到了length这个属性。
java中的length()方法是针对字符串String说的,如果想看这个字符串的长度则用到length()这个方法。
155、请编写一个jdbc查询任意一个数据库（如mysql、Oracle等），数据库名为test，表明为user，只有一个字段。import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class MysqlDemo {
public static void main(String[] args) throws Exception {
Connection conn = null;
ResultSet rs = null;
Statement stmt = null;
String sql;
// MySQL的JDBC URL编写方式：jdbc:mysql://主机名称：连接端口/数据库的名称?参数=值
// 避免中文乱码要指定useUnicode和characterEncoding
String url = "jdbc:mysql://localhost:3306/test?"
+ "user=root&password=root&useUnicode=true&characterEncoding=UTF8";
try {
// 之所以要使用下面这条语句，是因为要使用MySQL的驱动，所以我们要把它驱动起来，
// 可以通过Class.forName把它加载进去，也可以通过初始化来驱动起来，下面三种形式都可以
Class.forName("com.mysql.jdbc.Driver");// 动态加载mysql驱动
// or:
// com.mysql.jdbc.Driver driver = new com.mysql.jdbc.Driver();
// or：
// new com.mysql.jdbc.Driver();
System.out.println("成功加载MySQL驱动程序");
// 一个Connection代表一个数据库连接
conn = DriverManager.getConnection(url);
// Statement里面带有很多方法，比如executeUpdate可以实现插入，更新和删除等
stmt = conn.createStatement();
sql = "select * from user";
rs = stmt.executeQuery(sql);
while (rs.next()) {// 遍历user表中所有数据
String name = rs.getString("name");
System.out.println("姓名是：" + name);// 假如user表中的字段为name
}
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
if (rs != null)
rs.close();
// 关闭结果数据集
if (stmt != null)
stmt.close();
// 关闭执行环境
if (conn != null)
conn.close();
// 关闭数据库连接
} catch (SQLException e) {
e.printStackTrace();
}
}
}
}注意：连接oracle与mysql不同点为，url=jdbc:Oracle:thin:@localhost:1521:orcl
driver = oracle.jdbc.driver.OracleDriver
156、请编写一socket的程序，客户端向服务器端发送字符串，服务器端在返回相同的字符串。（类似echo功能）
public class Client { // 客户端
public static void main(String args[]) throws Exception{
String clientMessage;// 来自用户输入的的信息
String serverMessage; // 服务器端的信息
Socket ClientSocket = new Socket("127.0.0.0", 5557);// 参数是本机地址和端口,客户端套接字，发起TCP连接
BufferedReader fromUser = new BufferedReader(new InputStreamReader(System.in));// 字符读取流，获取从键盘输入的字符
BufferedReader fromServer = new BufferedReader(new InputStreamReader(ClientSocket.getInputStream()));// 获取从服务器端的流，建立套接字输入流
DataOutputStream toServer = new DataOutputStream(ClientSocket.getOutputStream());// 建立套接字输出流
clientMessage = fromUser.readLine();// 读取从用户的输入
toServer.writeBytes(clientMessage);// 写到服务器端
serverMessage = fromServer.readLine();// 从服务器端读取
ClientSocket.close();// 关闭套接字连接
}
}
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.net.ServerSocket;
import java.net.Socket;
public class Server {// 服务端
public static void main(String args[]) throws Exception{
String ClientMessage;
String ServerMessage = null;
ServerSocket serversocket = new ServerSocket(5557);// 端口要和客户端对应
System.out.println("正在监听5555端口");//
while (true){
Socket collection = serversocket.accept();// 调用accept()函数，建立TCP连接
DataInputStream fromClient = new DataInputStream(collection.getInputStream());
DataOutputStream toClient = new DataOutputStream(collection.getOutputStream());
ClientMessage = fromClient.readUTF();// 接收来自客户端的信息
toClient.writeBytes(ServerMessage);// 写到服务器端
System.out.println("成功建立TCP连接");
}
}
}157、写一个多线程程序，四个线程对一个int变量，2个加1，2个减1，输出。
public class TMain {
int j = 1;
public synchronized void inc() {
j++;
System.out.println(Thread.currentThread().getName() + "-inc:" + j);
}
class T1 implements Runnable {
public void run() {
inc();
}
}
public synchronized void dec() {
j--;
System.out.println(Thread.currentThread().getName() + "-dec:" + j);
}
class T11 implements Runnable {
public void run() {
dec();
}
}
public static void main(String[] args) {
TMain t = new TMain();
T1 t1 = t.new T1();
T11 t11 = t.new T11();
for (int i = 0; i < 2; i++) {
Thread thread = new Thread(t1);
thread.start();
Thread thread1 = new Thread(t11);
thread1.start();
}
}
}
158、说出常用的10个linux操作命令，至少5个，并简述命令的作用。
LS命令
－作用：显示目录内容，类似DOS下的DIR
－格式：LS【options】【filename】
－常用参数：
>-a:all，不隐藏任何以"."字符开始的文件
>-l：使用较长的格式列出信息
>-r:按照文件名的逆序打印输出
>-F:加上文件类型的指示符
ls -lF | grep / 过滤
man ls 查询ls的帮助文件
cat命令
－作用：显示文件内容，concatenate的缩写，类似dos的type命令。
－格式：cat【options】【fielname】
－常用参数：
>-n：显示文件内容的行号。
>-b：类似-n，但是不对空白行进行编号。
>-s：当遇到有连续两行以上的空白行时，就代换为一行的空白行。
mv命令
－作用：更改文件或者目录的名字。
－格式：mv[options]source destination
－常用参数：
>-f：强制模式，覆盖文件不提示。
>-i：交互模式，当要覆盖文件的时候给提示。
rm命令
－作用：删除文件命令，类似dos的del命令
－格式：rm【options】filenames
－常用参数：
>-f：强制模式，不给提示。
>-r,-R：删除目录，recursive
159、说出常见的5个linux系统日志，至少3个并做简述日志的用途。access-log 纪录HTTP/web的传输
acct/pacct 纪录用户命令
aculog 纪录MODEM的活动
btmp 纪录失败的纪录
lastlog 纪录最近几次成功登录的事件和最后一次不成功的登录
messages 从syslog中记录信息（有的链接到syslog文件）
sudolog 纪录使用sudo发出的命令
sulog 纪录使用su命令的使用
syslog 从syslog中记录信息（通常链接到messages文件）
utmp 纪录当前登录的每个用户
wtmp 一个用户每次登录进入和退出时间的永久纪录
xferlog 纪录FTP会话
160. 数据库试题
创建一张员工表，表明EMPLOYEES,有四个字段，
EMPLOYEE_ID:员工表（主键）、DEPT_ID:部门号、EMPLOYEE_NAME:员工姓名、EMPLOYEE_SALARY:员工工资。
问题1、写出建表语句
CREATE TABLE EMPLOYEES(
EMPLOYEE_ID int not null primary key,
DEPT_IDint,
EMPLOYEE_NAME char(40),
EMPLOYEE_SALARY double
);问题2、检索出员工工资最高的员工姓名和工资
select * from user where employee_salary= (select max(employee_salary) from user)问题3、检索出部门中员工最多的部门号和此部门员工数量
select dept_id,count(*) cno from user GROUP BY dept_id desc limit 11）Weblogic
2）Tomcat
3）JBoss
4）WebSphere
5）IIS
162、EJB程序与普通的java程序区别有哪些？EJB是sun的服务器端组件模型，最大的用处是部署分布式应用程序当然,还有许多方式可以实现分布式应用，类似微软的.net技术。凭借java跨平台的优势，用EJB技术部署的分布式系统可以不限于特定的平台。EJB (EnterpriseJavaBean)是J2EE的一部分，定义了一个用于开发基于组件的企业多重应用程序的标准。其特点包括网络服务支持和核心开发工具(SDK)。 在J2EE里，Enterprise Java Beans(EJB)称为Java 企业Bean，是Java的核心代码，分别是会话Bean（Session Bean），实体Bean（Entity Bean）和消息驱动Bean（MessageDriven Bean）。
简单来讲：比如做一个工程就和盖房子，如果，你会java，那么你就拥有了基本的技能，一步一步累砖，总能把房子盖好但是EJB就是一个框架，盖房子的时候，先有这个框架，然后你根据这个框架去累砖，房子就会盖的又快又好。java是基础，EJB是在java上发展出来的模型，框架。
163、请简述什么是集群？---了解就可以
（服务器集群就是指将很多服务器集中起来一起进行同一种服务，在客户端看来就象是只有一个服务器。集群可以利用多个计算机进行并行计算从而获得很高的计算速度，也可以用多个计算机做备份，从而使得任何一个机器坏了整个系统还是能正常运行。一旦在服务器上安装并运行了群集服务，该服务器即可加入群集。群集化操作可以减少单点故障数量，并且实现了群集化资源的高可用性。下述各节简要介绍了群集创建和群集操作中的节点行为。）
164. 字符串中有重复的内容去重例如：abbccccaaddaggb-->abvadagb
import java.util.ArrayList;
import java.util.List;
public class Demo_7 {
public static void main(String[] args) {
List<String> list = new ArrayList<String>();
list.add("测试1");
list.add("测试2");
list.add("测试3");
list.add("测试4");
list.add("测试4");
list.add("测试2");
list.add("测试5");
System.out.println("没有去重前的数据为>>>" + list.toString());
for (int i = 0; i < list.size(); i++) {
for (int j = list.size() - 1; j > i; j--) {
if (list.get(j).equals(list.get(i))) {
list.remove(j);
}
}
}
System.out.println("去重后的数据为>>>" + list.toString());
}
}165. javaScript字符串去重的方法
a)for遍历 function quchong1(str){
var newStr="";
var flag;
for(var i=0;i<str.length;i++){
flag=1;
for(var j=0;j<newStr.length;j++){
if(str[i]==newStr[j]){
flag=0;
break;
}
}
if(flag) newStr+=str[i];
}
return newStr;
} b) indexOf(无兼容问题)
function quchong1(str){
var newStr="";
var flag;
for(var i=0;i<str.length;i++){
flag=1;
for(var j=0;j<newStr.length;j++){
if(str[i]==newStr[j]){
flag=0;
break;
}
}
if(flag) newStr+=str[i];
}
return newStr;
} function quchong3(str){
var newStr="";
for(var i=0;i<str.length;i++){
if(newStr.search(str[i])==-1)
newStr+=str[i];
}
return newStr;
} d) 对象属性
function quchong4(str){
var obj={};
var newStr="";
for(var i=0;i<str.length;i++){
if(!obj[str[i]]){
newStr+=str[i];
obj[str[i]]=1;
}
}
return newStr;
} 166. 利用java面向对象的思路设计正方形.长方形.和圆的计算面积的类
import java.util.Scanner;
public class MianJi {
float r;
float pai = (float) 3.14;
// 圆的面积
void gongShi() {
Float s = pai * r * r;
System.out.println("圆的面积为" + s);
}
// 正方形的面积
void zhengFangXing(float bianChang) {
System.out.println("正方形的面积为" + bianChang * bianChang);
}
// 长方形的面积
void changFangXing(float chang, float kuan) {
System.out.println("长方形的面积为" + chang * kuan);
}
public static void main(String[] arg) {
MianJi c = new MianJi();
System.out.println("请输入圆的半径：");
Scanner scy = new Scanner(System.in);
c.r = scy.nextFloat();
c.gongShi();
System.out.println("请输入正方形的边长：");
Scanner scz = new Scanner(System.in);
float bian = scz.nextFloat();
c.zhengFangXing(bian);
System.out.println("请输入长方形的长和宽：");
Scanner scc = new Scanner(System.in);
float chang = scc.nextFloat();
float kuan = scc.nextFloat();
c.changFangXing(chang, kuan);
scy.close();
scz.close();
scc.close();
}
}167. 任何>=6的偶数都可以分解为两个质数之和，从键盘输入一个偶数，输出其分解的质数
import java.util.Scanner;
public class Demo_8 {
// 将偶数拆分成俩质数的和
public static void main(String[] args) {
int num = inPut();
outPut(num);
}
public static int inPut() {
// 输入数字并通过检验确定一个符合要求的数
Scanner sc = new Scanner(System.in);
System.out.println("请输入大于6的偶数：");
int num = sc.nextInt();
if (num % 2 != 0 || num <= 6) {
System.out.println("输入错误，请重新输入大于6的偶数：");
return inPut();// 错误则返回inPut()继续输入
}
return num;// 正确则返回num值
}
public static boolean isPrim(int num) {
// 判断是否是质数
for (int i = 2; i <= Math.sqrt((double) num); i++) {
if (num % i == 0) {
return false;
}
}
return true;
}
public static void outPut(int num) {
// 输出所有符合条件的质数对
for (int i = 2; i <= num / 2; i++) {
if (isPrim(i) == true && isPrim(num - i) == true) {
System.out.println(i + " " + (num - i));
}
}
}
}168. 什么叫对象？什么叫类？什么面向对象（OOP）？
答案：类的概念：类是具有相同属性和服务的一组对象的集合。它为属于该类的所有对象提供了统一的抽象描述，其内部包括属性和服务两个主要部分。在面向对象的编程语言中，类是一个独立的程序单位，它应该有一个类名并包括属性说明和服务说明两个主要部分。
对象的概念：对象是系统中用来描述客观事物的一个实体，它是构成系统的一个基本单位。一个对象由一组属性和对这组属性进行操作的一组服务组成。从更抽象的角度来说，对象是问题域或实现域中某些事物的一个抽象，它反映该事物在系统中需要保存的信息和发挥的作用；它是一组属性和有权对这些属性进行操作的一组服务的封装体。客观世界是由对象和对象之间的联系组成的。
类与对象的关系就如模具和铸件的关系，类的实例化结果就是对象，而对一类对象的抽象就是类.类描述了一组有相同特性（属性）和相同行为（方法）的对象。上面大概就是它们的定义吧， 也许你是刚接触面象对象的朋友， 不要被概念的东西搞晕了， 给你举个列子吧，如果你去中关村想买几台组装的PC机，到了那里你第一步要干什么， 是不是装机的工程师和你坐在一起，按你提供的信息和你一起完成一个装机的配置单呀， 这个配置单就可以想像成是类，它就是一张纸，但是它上面记录了你要买的PC机的信息，如果用这个配置单买10台机器，那么这10台机子，都是按这个配置单组成的，所以说这10台机子是一个类型的，也可以说是一类的。那么什么是对象呢，类的实例化结果就是对象, 用这个配置单配置出来（实例化出来）的机子就是对象， 是我们可以操作的实体， 10台机子， 10个对象。 每台机子都是独立的，只能说明他们是同一类的，对其中一个机做任何动作都不会影响其它9台机器，但是我对类修改， 也就是在这个配置单上加一个或少一个配件， 那么装出来的9个机子都改变了， 这是类和对象的关系(类的实例化结果就是对象) 。
169. 相对于JDK1.4，JDK1.5 有哪些新特性？
答案：泛型（Generics）
增强的“for”循环（Enhanced For loop）
自动装箱/ 自动拆箱（Autoboxing/unboxing）
类型安全的枚举（Type safe enums）
静态导入（Static import）
可变参数(Var args)
170. JAVA中使用final修饰符，对程序有哪些影响？
答案：
1、修饰类
当用final修饰一个类时，表明这个类不能被继承。也就是说，如果一个类你永远不会让他被继承，就可以用final进行修饰。final类中的成员变量可以根据需要设为final，但是要注意final类中的所有成员方法都会被隐式地指定为final方法。
在使用final修饰类的时候，要注意谨慎选择，除非这个类真的在以后不会用来继承或者出于安全的考虑，尽量不要将类设计为final类。
2、修饰方法
被final修饰的方法将不能被子类覆盖，主要用于1，把方法锁定，以防任何继承类修改它的含。2，在早期的Java实现版本中，会将final方法转为内嵌调用，所以效率能够提升
3、修饰变量
对于一个final变量，如果是基本数据类型的变量，则其数值一旦在初始化之后便不能更改；如果是引用类型的变量，则在对其初始化之后便不能再让其指向另一个对象。
当用final作用于类的成员变量时，成员变量（注意是类的成员变量，局部变量只需要保证在使用之前被初始化赋值即可）必须在定义时或者构造器中进行初始化赋值，而且final变量一旦被初始化赋值之后，就不能再被赋值了。
171. Java环境变量Unix/Linux下如何配置？
答案：修改/etc/profile文件当本机仅仅作为开发使用时推荐使用这种方法，因为此种配置时所有用户的shell都有权使用这些环境变量，可能会给系统带来安全性问题。用文本编辑器打开/etc/profile，在profile文件末尾加入：JAVA_HOME=/usr/share/jdk1.5.0_05
PATH=$JAVA_HOME/bin:$PATH
CLASSPATH=.:$JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
export JAVA_HOME
export PATH
export CLASSPATH重新登录即可
172. 写出5个你在JAVA开发中常用的包含（全名），并简述其作用。
常用的五个：
1）java.lang.*
提供利用 Java 编程语言进行程序设计的基础类。最重要的类是 Object（它是类层次结构的根）和 Class（它的实例表示正在运行的应用程序中的类）。
2）java.util.*
包含集合框架、遗留的 collection 类、事件模型、日期和时间设施、国际化和各种实用工具类（字符串标记生成器、随机数生成器和位数组、日期Date类、堆栈Stack类、向量Vector类等）。集合类、时间处理模式、日期时间工具等各类常用工具包
3）java.io.*
Java的核心库java.io提供了全面的IO接口。包括：文件读写、标准设备输出等。Java中IO是以流为基础进行输入输出的，所有数据被串行化写入输出流，或者从输入流读入。
4）java.net.*
并非所有系统都支持 IPv6 协议，而当 Java 网络连接堆栈尝试检测它并在可用时透明地使用它时，还可以利用系统属性禁用它。在 IPv6 不可用或被显式禁用的情况下，Inet6Address 对大多数网络连接操作都不再是有效参数。虽然可以保证在查找主机名时 java.net.InetAddress.getByName 之类的方法不返回 Inet6Address，但仍然可能通过传递字面值来创建此类对象。在此情况下，大多数方法在使用 Inet6Address 调用时都将抛出异常。
5）java.sql.*
提供使用 JavaTM 编程语言访问并处理存储在数据源（通常是一个关系数据库）中的数据的 API。此 API 包括一个框架，凭借此框架可以动态地安装不同驱动程序来访问不同数据源。
173. 写出5个常见的运行时异常（RuntimeException）。
1）ClassCastException(类转换异常)
2）IndexOutOfBoundsException(数组越界)
3）NullPointerException(空指针)
4）ArrayStoreException(数据存储异常，操作数组时类型不一致)
5）IO操作的BufferOverflowException异常
174. 方法重载（overload）需要满足什么条件，方法覆盖/方法重写（override）需要满足什么条件？（二选一）
答案：重载需要满足的条件：在同一类中定义的方法，方法名必须相同，返回类型必须相同，参数一定不同。
发生覆盖的条件：
“三同一不低”，子类和父类的方法名称，参数列表，返回类型必须完全相同，而且子类方法的访问修饰符的权限不能比父类低。
子类方法不能抛出比父类方法更多的异常。即子类方法所抛出的异常必须和父类方法所抛出的异常一致，或者是其子类，或者什么也不抛出；
被覆盖的方法不能是final类型的。因为final修饰的方法是无法覆盖的。
被覆盖的方法不能为private。否则在其子类中只是新定义了一个方法，并没有对其进行覆盖。
被覆盖的方法不能为static。所以如果父类中的方法为静态的，而子类中的方法不是静态的，但是两个方法除了这一点外其他都满足覆盖条件，那么会发生编译错误。反之亦然。即使父类和子类中的方法都是静态的，并且满足覆盖条件，但是仍然不会发生覆盖，因为静态方法是在编译的时候把静态方法和类的引用类型进行匹配。
重写规则：重写方法不能比被重写方法限制有更严格的访问级别。（但是可以更广泛，比如父类方法是包访问权限，子类的重写方法是public访问权限。）比如：Object类有个toString()方法，开始重写这个方法的时候我们总容易忘记public修饰符，编译器当然不会放过任何教训我们的机会。出错的原因就是：没有加任何访问修饰符的方法具有包访问权限，包访问权限比public当然要严格了，所以编译器会报错的。参数列表必须与被重写方法的相同。重写有个孪生的弟弟叫重载，也就是后面要出场的。如果子类方法的参数与父类对应的方法不同，那么就是你认错人了，那是重载，不是重写。返回类型必须与被重写方法的返回类型相同。
父类方法A：void eat(){} 子类方法B：int eat(){} 两者虽然参数相同，可是返回类型不同，所以不是重写。
父类方法A：int eat(){} 子类方法B：long eat(){} 返回类型虽然兼容父类，但是不同就是不同，所以不是重写。
175. 继承（inheritance）的优缺点是什么？
优点：
新的实现很容易，因为大部分是继承而来的 。很容易修改和扩展已有的实现
缺点：
打破了封装，因为基类向子类暴露了实现细节 ，白盒重用，因为基类的内部细节通常对子类是可见的 ，当父类的实现改变时可能要相应的对子类做出改变 ，不能在运行时改变由父类继承来的实现。由此可见，组合比继承具有更大的灵活性和更稳定的结构，一般情况下应该优先考虑组合。只有当下列条件满足时才考虑使用继承： 子类是一种特殊的类型，而不只是父类的一个角色 ，子类的实例不需要变成另一个类的对象子类扩展，而不是覆盖或者使父类的功能失效。
176. 为什么要使用接口和抽象类？
Java接口和Java抽象类代表的就是抽象类型，就是我们需要提出的抽象层的具体表现。OOP面向对象的编程，如果要提高程序的复用率，增加程序的可维护性，可扩展性，就必须是面向接口的编程，面向抽象的编程，正确地使用接口、抽象类这些太有用的抽象类型做为你结构层次上的顶层。
1、Java接口和Java抽象类最大的一个区别，就在于Java抽象类可以提供某些方法的部分实现，而Java接口不可以，这大概就是Java抽象类唯一的优点吧，但这个优点非常有用。 如果向一个抽象类里加入一个新的具体方法时，那么它所有的子类都一下子都得到了这个新方法，而Java接口做不到这一点，如果向一个Java接口里加入一个新方法，所有实现这个接口的类就无法成功通过编译了，因为你必须让每一个类都再实现这个方法才行.
2、一个抽象类的实现只能由这个抽象类的子类给出，也就是说，这个实现处在抽象类所定义出的继承的等级结构中，而由于Java语言的单继承性，所以抽象类作为类型定义工具的效能大打折扣。 在这一点上，Java接口的优势就出来了，任何一个实现了一个Java接口所规定的方法的类都可以具有这个接口的类型，而一个类可以实现任意多个Java接口，从而这个类就有了多种类型。
3、从第2点不难看出，Java接口是定义混合类型的理想工具，混合类表明一个类不仅仅具有某个主类型的行为，而且具有其他的次要行为。
4、结合1、2点中抽象类和Java接口的各自优势，具精典的设计模式就出来了：声明类型的工作仍然由Java接口承担，但是同时给出一个Java抽象类，且实现了这个接口，而其他同属于这个抽象类型的具体类可以选择实现这个Java接口，也可以选择继承这个抽象类，也就是说在层次结构中，Java接口在最上面，然后紧跟着抽象类，哈，这下两个的最大优点都能发挥到极至了。这个模式就是“缺省适配模式”。 在Java语言API中用了这种模式，而且全都遵循一定的命名规范：Abstract ＋接口名。
Java接口和Java抽象类的存在就是为了用于具体类的实现和继承的，如果你准备写一个具体类去继承另一个具体类的话，那你的设计就有很大问题了。Java抽象类就是为了继承而存在的，它的抽象方法就是为了强制子类必须去实现的。
使用Java接口和抽象Java类进行变量的类型声明、参数是类型声明、方法的返还类型说明，以及数据类型的转换等。而不要用具体Java类进行变量的类型声明、参数是类型声明、方法的返还类型说明，以及数据类型的转换等。
我想，如果你编的代码里面连一个接口和抽象类都没有的话，也许我可以说你根本没有用到任何设计模式，任何一个设计模式都是和抽象分不开的，而抽象与Java接口和抽象Java类又是分不开的。
接口的作用，一言以蔽之，就是标志类的类别。把不同类型的类归于不同的接口，可以更好的管理他们。把一组看如不相关的类归为一个接口去调用.可以用一个接口型的变量来引用一个对象,这是接口我认为最大的作用.
177. 什么叫对象持久化（OBJect PERSIstence），为什么要进行对象持久化？持久化的对象，是已经存储到数据库或保存到本地硬盘中的对象，我们称之为持久化对象。为了保存在内存中的各种对象的状态（也就是实例变量，不是方法），并且可以把保存的对象状态再读出来。虽然你可以用你自己的各种各样的方法来保存object states，但是Java给你提供一种应该比你自己好的保存对象状态的机制，那就是序列化。
简单说就是对象序列化是将对象状态转换为可保持或传输的格式的过程。
什么情况下需要序列化：
a）当你想把的内存中的对象状态保存到一个文件中或者数据库中时候；
b）当你想用套接字在网络上传送对象的时候；
c）当你想通过RMI传输对象的时候；
对象要实现序列化，是非常简单的，只需要实现Serializable接口就可以了。
public class Test implements Serializable
178. JavaScript 有哪些优缺点？
(1).javascript的优点：
javascript减少网络传输。
在javascript这样的用户端脚本语言出现之前，传统的数据提交和验证工作均由用户端浏览器通过网络传输到服务器开发上进行。如果数据量很大，这对于网络和服务器开发的资源来说实在是一种无形的浪费。而使用javascript就可以在客户端进行数据验证。
javascript方便操纵html对象。
javascript可以方便地操纵各种页面中的对象，用户可以使用javascript来控制页面中各个元素的外观、状态甚至运行方式，javascript可以根据用户的需要“定制”浏览器，从而使网页更加友好。
javascript支持分布式应用运算。
javascript可以使多种任务仅在用户端就可以完成，而不需要网络和服务器开发的参与，从而支持分布式应用 的运算和处理。
（2）javascript的局限性：
各浏览器厂商对javascript支持程度不同。
目前在互联网上有很多浏览器，如firefox、internet explorer、opera等，但每种浏览器支持javascript的程度是不一样的，不同的浏览器在浏览一个带有javascript脚本的主页时，由于对javascript的支持稍有不同，其效果会有一定的差距，有时甚至会显示不出来。
“web安全性”对javascript一些功能牺牲。
当把javascript的一个设计目标设定为“web安全性”时，就需要牺牲javascript的一些功能。因此，纯粹的javascript将不能打开、读写和保存用户计算机上的文件。其有权访问的唯一信息就是该javascript所嵌入开发 的那个web主页中的信息，简言之，javascript将只存在于它自己的小小世界—web主页里。
179. Jsp有什么特点？
JSP(Java Server Pages)是由Sun Microsystems公司倡导、许多公司参与一起建立的一种动态网页技术标准。 JSP技术是用JAVA语言作为脚本语言的，JSP网页为整个服务器端的JAVA库单元提供了一个接口来服务于HTTP的应用程序。
在传统的网页HTML文件(*.htm,*.html)中加入Java程序片段(Scriptlet)和JSP标记(tag)，就构成了JSP网页(*.jsp)。Web服务器在遇到访问JSP网页的请求时，首先执行其中的程序片段，然后将执行结果以HTML格式返回给客户。程序片段可以操作数据库、重新定向网页以及发送 email 等等，这就是建立动态网站所需要的功能。所有程序操作都在服务器端执行，网络上传送给客户端的仅是得到的结果，对客户浏览器的要求最低，可以实现无Plugin，无ActiveX，无Java Applet，甚至无Frame。
JSP的优点：
1)对于用户界面的更新，其实就是由 Web Server进行的，所以给人的感觉更新很快。
2)所有的应用都是基于服务器的，所以它们可以时刻保持最新版本。
3)客户端的接口不是很繁琐，对于各种应用易于部署、维护和修改。
180. 什么叫脏数据，什么叫脏读（Dirty Read）？
脏数据在临时更新（脏读）中产生。事务A更新了某个数据项X，但是由于某种原因，事务A出现了问题，于是要把A回滚。但是在回滚之前，另一个事务B读取了数据项X的值(A更新后)，A回滚了事务，数据项恢复了原值。事务B读取的就是数据项X的就是一个“临时”的值，就是脏数据。
脏读就是指当一个事务正在访问数据，并且对数据进行了修改，而这种修改还没有提交到数据库中，这时，另外一个事务也访问这个数据，然后使用了这个数据。因为这个数据是还没有提交的数据，那么另外一个事务读到的这个数据是脏数据，依据脏数据所做的操作可能是不正确的。
181. 什么是BOS？
ERP系统是企业资源计划(Enterprise Resource Planning )的简称。
BOSS(Business & Operation Support )指的是业务运营支撑系统。
BOS 是 ERP 的集成与应用平台。 BOS 遵循面向服务的架构体系，是一个面向业务的可视化开发平台；是一个 ERP 和第三方应用集成的技术平台。它有效的解决了 ERP 应用的最主要矛盾－－－用户需求个性化和传统 ERP 软件标准化之间的矛盾。
BOS 与 ERP 是什么关系？
ERP 是企业管理信息化的全面解决方案， ERP 是基于 BOS 构建的。 ERP 满足企业全面业务的标准应用；BOS 确保了企业 ERP 应用中的个性化需求完美实现。基于 BOS 的 ERP，可以为不同行业不同发展阶段的企业构建灵活的、可扩展的、全面集成的整体解决方案。
182. 什么是工作流？
（举个栗子）现在大多数公司的请假流程是这样的：员工打电话（或网聊）向上级提出请假申请——上级口头同意——上级将请假记录下来——月底将请假记录上交公司——公司将请假录入电脑。采用工作流技术的公司的请假流程是这样的：员工使用账户登录系统——点击请假——上级登录系统点击允许。就这样，一个请假流程就结束了。有人会问，那上级不用向公司提交请假记录？公司不用将记录录入电脑？答案是，用的。但是这一切的工作都会在上级点击允许后自动运行！这就是工作流技术。
Georgakopoulos 给出的工作流定义是： 工作流是将一组任务组织起来以完成某个经营过程：定义了任务的触发顺序和触发条件，每个任务可以由一个或多个软件系统完成，也可以由一个或一组人完成，还可以由一个或多个人与软件系统协作完。
183. 工作流技术的优点
从上面的例子，很容易看出，工作流系统实现了工作流程的自动化，提高了企业运营效率、改善企业资源利用、提高企业运作的灵活性和适应性、提高量化考核业务处理的效率、减少浪费（时间就是金钱）。而手工处理工作流程，一方面无法对整个流程状况进行有效跟踪、了解，另一方面难免会出现人为的失误和时间上的延时导致效率低下，特别是无法进行量化统计，不利于查询、报表及绩效评估。
184. 工作流生命周期
除了我们自行启动（start）或者结束（finish）一个 Activity，我们并不能直接控制一个 Activity 的生命状态，我们只能通过实现Activity 生命状态的表现——即回调方法来达到管理 Activity 生命周期的变化。
4010
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
