专项练习三

1.关于以下代码的说明，正确的是（ C）

class StaticStuff{
static int x=10;
static {
x+=5;
}
public static void main（String args[ ]）{
System.out.println(“x=” + x);
}
static { x/=3;}
}

3行与9行不能通过编译，因为缺少方法名和返回类型
9行不能通过编译，因为只能有一个静态初始化器
编译通过，执行结果为：x=5
编译通过，执行结果为：x=3

java初始化的加载顺序为： 父类静态成员变量 父类静态代码块 子类静态成员变量 子类静态代码块
父类非静态成员变量，父类非静态代码块，父类构造函数，子类非静态成员变量，子类非静态代码块，子类构造函数

2.下面的排序方法中，关键字比较次数与记录的初始排列无关的是__D__。
希尔排序
冒泡排序
直接插入排序
直接选择排序

3.下面有关SPRING的事务传播特性，说法错误的是？B
PROPAGATION_SUPPORTS：支持当前事务，如果当前没有事务，就以非事务方式执行
PROPAGATION_REQUIRED：支持当前事务，如果当前没有事务，就抛出异常
PROPAGATION_REQUIRES_NEW：新建事务，如果当前存在事务，把当前事务挂起
PROPAGATION_NESTED：支持当前事务，新增Savepoint点，与当前事务同步提交或回滚

Spring的API设计很不错，基本上根据英文翻译就能知道作用:Required:必须的。说明必须要有事物，没有就新建事物。supports:支持。说明仅仅是支持事务，没有事务就非事务方式执行。mandatory:强制的。说明一定要有事务，没有事务就抛出异常。required_new:必须新建事物。如果当前存在事物就挂起。not_supported:不支持事物，如果存在事物就挂起。never:绝不有事务。如果存在事物就抛出异常

4.如果一个算法的时间复杂度T(n)的可以表示为A
，则T(n) = ?
O((n^2)*(lgn))
O(n^2)
O(logn)
O(n^3)

T(n) = 25T(n/5)+n^2 = 25(25T(n/25)+n^2/25)+n2
= 625T(n/25)+n²⁺ⁿ2 = 625T(n/25) + 2n^2
= 25^2 * T( n/ ( 5^2 ) ) + 2 * nn
= 625(25T(n/125)+n^2/625) + 2n^2
= 62525T(n/125) + 3n^2
= 25^3 * T( n/ ( 5^3 ) ) + 3 * nn
= …
= 25 ^ x * T( n / 5^x ) + x * n^2
T(n) = 25T(n/5)+n^2
T(0) = 25T(0) + n^2 ==> T(0) = 0
T(1) = 25T(0)+n^2 ==> T(1) = 1
x = lg 5 n
25 ^ x * T( n / 5^x ) + x * n^2
= n^2 * 1 + lg 5 n * n^2
= n^2*(lgn)

5.在不知道数据分布的情况下，下列哪个排序算法的最好、最差复杂度是相同的？A
归并排序
插入排序
希尔排序
快速排序

都是nlogn

6.ArrayList和Vector主要区别是什么？A
Vector与ArrayList一样，也是通过数组实现的，不同的是Vector支持线程的同步
Vector与ArrayList一样，也是通过数组实现的，不同的是ArrayList支持线程的同步
Vector是通过链表结构存储数据，ArrayList是通过数组存储数据
上述说法都不正确

Vector & ArrayList 的主要区别
1） 同步性:Vector是线程安全的，也就是说是同步的 ，而ArrayList 是线程序不安全的，不是同步的 数2。
2）数据增长:当需要增长时,Vector默认增长为原来一倍 ，而ArrayList却是原来的50% ，这样,ArrayList就有利于节约内存空间。
如果涉及到堆栈，队列等操作，应该考虑用Vector，如果需要快速随机访问元素，应该使用ArrayList 。
扩展知识：1. Hashtable & HashMap
Hashtable和HashMap它们的性能方面的比较类似 Vector和ArrayList，比如Hashtable的方法是同步的,而HashMap的不是。2. ArrayList & linkedList
ArrayList的内部实现是基于内部数组Object[],所以从概念上讲,它更象数组，但linkedList的内部实现是基于一组连接的记录，所以，它更象一个链表结构，所以，它们在性能上有很大的差别：
从上面的分析可知,在ArrayList的前面或中间插入数据时,你必须将其后的所有数据相应的后移,这样必然要花费较多时间，所以,当你的操作是在一列数据的后面添加数据而不是在前面或中间,并且需要随机地访问其中的元素时,使用ArrayList会提供比较好的性能； 而访问链表中的某个元素时,就必须从链表的一端开始沿着连接方向一个一个元素地去查找,直到找到所需的元素为止，所以,当你的操作是在一列数据的前面或中间添加或删除数据，并且按照顺序访问其中的元素时，就应该使用linkedList了。

7.假设以行序为主序存储二维数组A=array[100][100]，设每个数据元素占2个存储单元，基地址A[0][0]为10，则A[5][5]的地址为（A）。
1,020
818
808
1,010

A=array[100][100]的行列的下标应该都是0到99 A[5，5]是从A[0，0]开始
A[5][5]的难道不是位于第6行第6个元素吗，所以第一眼 觉得A[5][5]的地址为：51002+62+10=1022
仔细想了一下，发现不对
基地址：10
第一行末尾元素地址：992+10
…
第五行末尾元素地址：4002+992+10
第六行第六个元素地址：4002+992+10+6*2=1020

8.如果定义一种表达式结构：(+ 6 3)的值为9，(- 6 3)的值为3，(* 6 3)的值为18，(/ 6 3)的值为2；那么对于表达式(* (- 16 (* 3 2 2 )) (+ 5 (/ 6 (- 5 3))))输出的结果为__D__。
44
40
40
32
24
21

这个和学过数据结构没有太大关系，当然做过这类题的人一瞬间就懂了，我数据结构已经很多年没看了。有的人之所以没看懂，我也是看了好久才明白，是因为没看懂题目的逻辑关系。下面我来通俗的讲一下： 题目中规定(+6 3)=9何解？其真实含义就是往栈中存了三个值，符号为加，于是6+3就等于9了。以此类推(*6 3)自然就是18了。

9.正则表达式语法中 d 匹配的是？（A）
数字
非数字
字母
空白字符

d 匹配一个数字字符。等价于 [0-9]。
D 匹配一个非数字字符。等价于 [^0-9]。
f 匹配一个换页符。等价于 x0c 和 cL。
n 匹配一个换行符。等价于 x0a 和 cJ。
r 匹配一个回车符。等价于 x0d 和 cM。
s 匹配任何空白字符，包括空格、制表符、换页符等等。等价于 [ fnrtv]。
S 匹配任何非空白字符。等价于 [^ fnrtv]。
t 匹配一个制表符。等价于 x09 和 cI。
v 匹配一个垂直制表符。等价于 x0b 和 cK。
w 匹配字母、数字、下划线。等价于’[A-Za-z0-9_]’。
W 匹配非字母、数字、下划线。等价于 ‘[^A-Za-z0-9_]’。

10.程序文件名必须与公共外部类的名称完全一致（包括大小写）.正确

公共外部类必须与源文件名一致，且一个源文件只能有一个公共外部类。

11.设有序序列长度为 n ，在最坏情况下，时间复杂度为O(log_2n)的算法是（A）
二分法查找
顺序查找
分块查找
哈希查找

【解析】对长度为 n 的线性表排序，最坏情况下时间复杂度，二分法查找为 ；顺序查找法为 O （ n ）；分块查找时间复杂度与分块规则有关；哈希查找时间复杂度为 O(1) ，因其通过计算 HashCode 来定位元素位置，所以只需一次即可。故正确答案为 A 选项。

12.下列关于队列的叙述中正确的是（C）
在队列中只能插入数据
在队列中只能删除数据
队列是先进先出的线性表
队列是先进后出的线性表

队列是只允许在一端进行插入另一端进行删除的线性表，简称FIFO，只允许删除的一端叫做队头，只允许插入的一端叫做队尾。是先进先出的线性表。。

13.对链表进行插入和删除操作时不必移动链表中结点。 ( 正确)

表插入和删除只是改变了相应节点的指针指向，地址并没有改变，所以不必移动

14.字符串的长度是指 （ C）。
串中不同字符的个数
串中不同字母的个数
串中所含字符的个数
串中不同数字的个数

15.下面有关值类型和引用类型描述正确的是（A.C.B）？
值类型的变量赋值只是进行数据复制，创建一个同值的新对象，而引用类型变量赋值，仅仅是把对象的引用的指针赋值给变量，使它们共用一个内存地址。
值类型数据是在栈上分配内存空间，它的变量直接包含变量的实例，使用效率相对较高。而引用类型数据是分配在堆上，引用类型的变量通常包含一个指向实例的指针，变量通过指针来引用实例。
引用类型一般都具有继承性，但是值类型一般都是封装的，因此值类型不能作为其他任何类型的基类。
值类型变量的作用域主要是在栈上分配内存空间内，而引用类型变量作用域主要在分配的堆上。

16.在java中重写方法应遵循规则的包括（BC）
访问修饰符的限制一定要大于被重写方法的访问修饰符
可以有不同的访问修饰符
参数列表必须完全与被重写的方法相同
必须具有不同的参数列表

方法重写
参数列表必须完全与被重写方法的相同；
返回类型必须完全与被重写方法的返回类型相同；
访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类的一个方法被声明为public，那么在子类中重写该方法就不能声明为protected。
父类的成员方法只能被它的子类重写。
声明为final的方法不能被重写。
声明为static的方法不能被重写，但是能够被再次声明。
子类和父类在同一个包中，那么子类可以重写父类所有方法，除了声明为private和final的方法。
子类和父类不在同一个包中，那么子类只能够重写父类的声明为public和protected的非final方法。
重写的方法能够抛出任何非强制异常，无论被重写的方法是否抛出异常。但是，重写的方法不能抛出新的强制性异常，或者比被重写方法声明的更广泛的强制性异常，反之则可以。
构造方法不能被重写。
如果不能继承一个方法，则不能重写这个方法。
方法重载
被重载的方法必须改变参数列表(参数个数或类型或顺序不一样)；
被重载的方法可以改变返回类型；
被重载的方法可以改变访问修饰符；
被重载的方法可以声明新的或更广的检查异常；
方法能够在同一个类中或者在一个子类中被重载。
无法以返回值类型作为重载函数的区分标准。

17.现有N条词以及对应的拼音串，对其排序，排序规则：首先按拼音串的字母序排序，如果拼音串相同，则按当前词所在的顺序排序，下列哪些排序算法符合条件？（ AD ）
插入排序
快速排序
堆排序
冒泡排序

按当前词所在顺序排序即排序算法要稳定。
选择排序，快速排序，希尔排序，堆排序 都不稳定
冒泡排序，插入排序，归并排序，基数排序 都稳定

18.下列哪个是合法的 Java 标识符？（BC ）
Tree&Glasses
FirstJavaApplet
First_Applet
273.5

记住标识符只有英文，数字，下划线和$，而且数字不能做开头~

19. 在一长度为 N 的有序数列中寻找两个数，使得两数之和等于某指定值的最快的算法的平均时间复杂度是 （A）
    O(N)
    O(N^2)
    O(N * log(N))
    O(log(n))

//双指针法
/ if (a[i]%2== _________ ) { a[j]=a[i]; _________; } return _________; } main( ) { int b[N]={9,1,4,2,3,6,5,8,7}, i, n; printf("nThe original data:n"); for(i=0; i

0 j++ j
1 j++ j+1
0 j++ j+1
1 j++ j

注意for循环的最后一次已经j++了，所以最后返回j即可

22.若有 18 个元素的有序表存放在一维数组 A[19] 中，第一个元素放 A[1] 中，现进行二分查找，则查找 A ［ 3 ］的比较序列的下标依次为 ( D )
1，2，3
9，5，2，3
9，5，3
9，4，2，3

第一次：high1=18,low1=1,medium1=(high1+low1)/2=9
A[3] 第二次：high2=medium1-1=8,low2=1,medium2=(high2+low2)/2=4
A[3] 第三次：high3=medium2-1=3，low3=1,medium3=(high3+low3)/2=2
A[3]>A[2],进行下一轮比较
第四次：由于A[4],A[2]都比较与A[3]比较了，A[2]

23.下列关于包（package）的描述，正确的是（D）
包（package）是Java中描述操作系统对多个源代码文件组织的一种方式。
import语句将所对应的Java源文件拷贝到此处执行。
包（package）是Eclipse组织Java项目特有的一种方式。
定义在同一个包（package）内的类可以不经过import而直接相互使用。

1、为了更好地组织类，Java提供了包机制。包是类的容器，用于分隔类名空间。如果没有指定包名，所有的示例都属于一个默认的无名包。Java中的包一般均包含相关的类，java是跨平台的，所以java中的包和操作系统没有任何关系，java的包是用来组织文件的一种虚拟文件系统。A错
2、import语句并没有将对应的java源文件拷贝到此处仅仅是引入，告诉编译器有使用外部文件，编译的时候要去读取这个外部文件。B错
3、Java提供的包机制与IDE没有关系。C错
4、定义在同一个包（package）内的类可以不经过import而直接相互使用

24.下列叙述中，错误的是（ B）
File类能够存储文件属性
File类能够读写文件
File类能够建立文件
File类能够获取文件目录信息

File类的一下常用方法和说明
1.访问文件名相关方法：
String getName(); 返回此File对象所表示的文件名和路径名（如果是路径，则返回最后一级子路径名）。
String getPath(); 返回此File对象所对应的路径名。
File getAbsolutePath(); 返回此File对象所对应的绝对路径名。
String getParent(); 返回此File对象所对应目录（最后一级子目录）的父路径名。
boolean renameTo(File newName); 重命名此File对象所对应的文件或目录，如果重命名成功，则返回true:否则返回false.（A）
2.文件检测相关方法
boolean exists(); 判断File对象所对应的文件或目录是否存在。
boolean canWrite(); 判断File对象所对应的目录或文件是否可写。
boolean canRead(); 判断File对象所对应的目录或文件是否可读。
boolean isFile(); 判断File对象所对应的是否是文件，而不是目录。
boolean isDirectory(); 判断File对象所对应的是否是目录，而不是文件。
boolean isAbsolute(); 判断File对象所对应的文件或目录是否是绝对路径。该方法消除了不同平台的差异，可以直接判断File对象是否为绝对路径。在UNIX/Linux/BSD等系统上，如果路径名开头是一条斜线（/）,则表明该File对象对应一个绝对路径；在Windows等系统上，如果路径开头是盘符，则说明它是绝对路径。
3.获取常规文件信息
long lastModified(); 返回文件最后修改时间。
long length(); 返回文件内容的长度。
4.文件操作相关的方法
boolean createNewFile(); 当此File对象所对应的文件不存在时，该方法将新建的一个该File对象所指定的新文件，如果创建成功则返回true；否则返回false.©
boolean delete(); 删除File对象所对应的文件或路径。
static File CreateTempFile(String prefix,String suffix);在默认的临时文件目录创建一个临时空文件，使用给定前缀、系统生成的随机数和给定后缀作为文件名。这是一个静态方法，可以直接通过File来调用。preFix参数必须至少是3个字节长。建议前缀使用一个短的、有意义的字符串。建议前缀使用一个短的、有意义的字符串，比如”hjb“ 或”main”. suffix参数可以为null,在这种情况下，将使用默认的后缀”.tmp”.
static File CreateTempFile(String prefix,String suffix,File directory);在directory所指定的目录中创建一个临时空文件，使用给定前缀、系统生成的随机数和给定后缀作为文件名。这是一个静态方法，可以直接通过File来调用。
void deleteonExit(); 注册一个删除钩子，指定当Java虚拟机退出时，删除File对象随对应的文件和目录。
5.目录操作相关方法（D）
boolean mkdir(); 试图创建一个File对象所对应的目录，如果创建成功，则返回true;否则返回false. 调用该方法时File对象必须对应一个路径，而不是一个文件。
String[] list(); 列出File对象的所有子文件名和路径名，返回String数组。
File[] listFiles(); 列出File对象的所有子文件和路径，返回File数组。
static File[] listRoots(); 列出系统所有的根路径。这是一个静态方法，可以直接通过File类来调用

25.What is the result of compiling and executing the following fragment of code:C
Boolean flag = false; if (flag = true) { System.out.println("true"); } else { System.out.println("false"); }

The code fails to compile at the “if” statement.
An exception is thrown at run-time at the “if” statement.
The text“true” is displayed.
The text“false”is displayed.
Nothing is displayed.

Boolean修饰的变量为包装类型，初始化值为false,进行赋值时会调用Boolean.valueOf(boolean b)方法自动拆箱为基本数据类型，因此赋值后flag值为true，输出文本true。 如果使用==比较,则输出文本false。if的语句比较，除boolean外的其他类型都不能使用赋值语句，否则会提示无法转成布尔值。

26.对数列 (25,84,21,47,15,27,68,35,20) 进行（ ）排序，元素序列的变化情况如下：A

(1)25,84,21,47,15,27,68,35,20

(2)20,15,21,25,47,27,68,35,84

(3)15,20,21,25,35,27,47,68,84

(4)15,20,21,25,27,35,47,68,84

从（1）到（2）:取第一个数25，放到它应该在的位置，25左边的数都比25小，右边的都比25大；
从（2）到（3）:对25左边的数列和25右边的数列{20,15,21},{47,27,68,35,84}分别进行快速排序，同样先取各数列的第一个数20和47，使其分别放到应该在的位置,即左边的数都比它小，右边的都比它大；
从（3）到（4）:对{15}，{21}，{35,27}，{68,84}四个子序列进行排序，最终排序完成；
从整个过程分析，是一个快速排序的过程。

27.假设以数组Data[0…m-1]存放循环队列的元素，其头尾指针分别为front和rear，则当前队列中的元素个数为(A)
(rear-front+m) % m
rear-front+1
(front-rear+m) % m
(rear-front) % m

循环队列的相关条件和公式：
队尾指针是rear,队头是front，其中QueueSize为循环队列的最大长度
1.队空条件：rearfront
2.队满条件：(rear+1) %QueueSIzefront
3.计算队列长度：（rear-front+QueueSize）%QueueSize
4.入队：（rear+1）%QueueSize
5.出队：（front+1）%QueueSize

28.下列循环语句序列执行完成后，i的值是（C）

int i;
for(i=2;i<=10;i++){
System.out.println(i);
}

2
10
11
不确定

选C
ok，来说一下for循环的执行顺序：
for（表达式1;表达式2;表达式3）
{
//循环体
}1. 表达式1执行一次，判断表达式2是否成立，如果成立执行循环体；2. 循环体结束，表达式3执行一次，判断表达式2是否成立，如果成立执行循环体；3. 依次进行2的操作。直到表达式2不成立，退出循环。
所以，这个题最后依次执行体是i++；i这个时候已经是11了，判断11大于10，退出循环。

29.执行如下代码段后，变量s1引用的字符串值是( A )。`

String s1 = "ABCD";

String s2 = "1234";

System.out.println(s1 + s2);`

ABCD
1234
ABCD1234
1234ABCD

30.设有递归算法如下，最终打印结果是（A）

#include
 int foo(int a ,int b)
 {
     if (b == 0) return 0;
     if (b %2 == 0) return foo(a+a,b/2);
     return foo(a+a,b/2)+a;    
 }
 void main()
 { 
   printf("%d"，foo(1,3));
 }

3
4
5
6

计算foo(1,3)：此时a=1,b=3; 跳过两个if语句进入return foo(1+1,3/2)+1,即foo(2,1)+1；
计算foo(2,1)： 同样，跳过两个if语句进入return foo(2+2,1/2)+2,即foo(4,0)+2;
计算foo(4,0): 进入第一个if语句，return 0； 逐层返回，得foo(2,1)=0+2=2;
再返回上一层，得foo(1,3)=2+1=3； 返回结果，foo(1,3)=3;

31.具有 n 个整数的数组 A=[29,6,28,20,2,24] 使用插入排序（ Insertion Sort ）算法排序，算法伪代码如下：

经过三趟排序后，数组 A 的排列状态将是（C）
6,29,28,20,2,24
6,28,20,2,24,29
6,20,28,29,2,24
2,6,20,24,28,29

此题关键是知道数组下标从0开始
第一趟6 29 28 20 2 24
第二趟6 28 29 20 2 24
第三趟6 20 28 29 2 2

32以下代码段执行后的输出结果为D
.`public class Test {

public static void main(String args[]) {

    int x = -5;
    int y = -12;
    System.out.println(y % x);
}}`

-1
2
1
-2

Y(被除数) % X(除数) 当除数与被除数的符号相同时，取余和取模的结果是完全相同的； 当除数与被除数的符号不相同时，结果不同。 　　具体说，取余结果的符号与被除数相同；取模结果的符号与除数相同。 通常取模运算也叫取余运算，他们都遵循处罚法则，返回结果都是余数； 1.取余 　　 rem(3,2)=1 　　 rem(-3,-2)=-1 　　 rem(3,-2)=1 　　 rem(-3,2)=-1 　　 2.取模 　　 mod(3,2)=1 　　 mod(-3,-2)=-1 　　 mod(3,-2)=-1 　　 mod(-3,2)=1

33.算法分析的目的是(C )。
找出数据结构的合理性
研究算法中输入和输出的关系
分析算法的效率以求改进
分析算法的易懂性和文档性
34.从未排序序列中选择一个元素，该元素将当前参加排序的那些元素分成前后两个部分，前一部分中所有元素都小于等于所选元素，后一部分中所有元素都大于等于所选元素，而所选元素处在排序的最终位置。这种排序法称为（）

正确答案: D )
插入排序法
泡排序法
谢尔排序法
快速排序法

快速排序是选择一个中间数值，将小于中间数值的数放在左边，大于中间数值的数放在右边

35.关于Java语言的内存回收机制，下列选项中最正确的一项是
正确答案: C
Java程序要求用户必须手工创建一个线程来释放内存
Java程序允许用户使用指针来释放内存
内存回收线程负责释放无用内存
内存回收线程不能释放内存对象

java虚拟机中的垃圾回收机制是一个类，当该对象没有更多的应用指向它时，就会被垃圾回收器给回收，从而释放资源。该机制不可以程序员手动调用去回收某个对象，系统自动回去调用，当然程序员可以建议垃圾回收器回收某个对象。所以java中无需程序员手动释放内存，系统自动释放无用内存。

36.栈和队列是一种非线性数据结构(错误)

数据元素间有线性关系——线性结构（所谓线性关系：除第一个元素外，其他元素有且只有一个前驱；除最后一个元素外，其他元素有且只有一个后继！）
常用的线性结构：线性表、栈、队列、双队列、数组、串
常用的非线性结构：二维数组、***数组、树（二叉树等）、图、广义表

37.以下各类中哪几个是线程安全的？( )
正确答案: B C D
ArrayList
Vector
Hashtable
Stack

线程同步：喂，SHE
喂（Vector）
S（Stack）
H（hashtable）
E（enumeration）

38.ArrayLists和linkedList的区别，下述说法正确的有？
正确答案: A B C D
ArrayList是实现了基于动态数组的数据结构，linkedList基于链表的数据结构。
对于随机访问get和set，ArrayList觉得优于linkedList，因为linkedList要迭代器。
对于新增和删除操作add和remove，linkedList比较占优势，因为ArrayList要移动数据。
ArrayList的空间浪费主要体现在在list列表的结尾预留一定的容量空间，而linkedList的空间花费则体现在它的每一个元素都需要消耗相当的空间。

A. ArrayList是实现了基于动态数组的数据结构，linkedList基于链表的数据结构。 //正确，这里的所谓动态数组并不是那个“ 有多少元素就申请多少空间 ”的意思，通过查看源码，可以发现，这个动态数组是这样实现的，如果没指定数组大小，则申请默认大小为10的数组，当元素个数增加，数组无法存储时，系统会另个申请一个长度为当前长度1.5倍的数组，然后，把之前的数据拷贝到新建的数组。
B. 对于随机访问get和set，ArrayList觉得优于linkedList，因为linkedList要移动指针。//正确，ArrayList是数组，所以，直接定位到相应位置取元素，linkedLIst是链表，所以需要从前往后遍历。
C. 对于新增和删除操作add和remove，LinedList比较占优势，因为ArrayList要移动数据。//正确，ArrayList的新增和删除就是数组的新增和删除，linkedList与链表一致。
D. ArrayList的空间浪费主要体现在在list列表的结尾预留一定的容量空间，而linkedList的空间花费则体现在它的每一个元素都需要消耗相当的空间。//正确，因为ArrayList空间的增长率为1.5倍，所以，最后很可能留下一部分空间是没有用到的，因此，会造成浪费的情况。对于linkedList的话，由于每个节点都需要额外的指针，所以，你懂的。

39.对于JVM内存配置参数：

-Xmx10240m -Xms10240m -Xmn5120m -XXSurvivorRatio=3

其最小内存值和Survivor区总大小分别是（）
正确答案: D
5120m，1024m
5120m，2048m
10240m，1024m
10240m，2048m

-Xmx10240m：代表最大堆
-Xms10240m：代表最小堆
-Xmn5120m：代表新生代
-XXSurvivorRatio=3：代表Eden:Survivor = 3 根据Generation-Collection算法(目前大部分JVM采用的算法)，一般根据对象的生存周期将堆内存分为若干不同的区域，一般情况将新生代分为Eden ，两块Survivor； 计算Survivor大小， Eden:Survivor = 3，总大小为5120,3x+x+x=5120 x=1024
新生代大部分要回收，采用Copying算法，快！
老年代 大部分不需要回收，采用Mark-Compact算法

40.对于初始关键字(67,66,77,82,78,51,58),使用二路归并排序,第一趟归并之后其序列变为（ ）
正确答案: B
66,67,77,82,51,58,78
66,67,77,82,51,78,58
51,58,66,67,77,78,82
67,66,77,78,82,51,58

按照顺序两两组合，每个组里两个元素进行排序，最后一个元素落单不去管

41.请找出下面代码中的所有错误。说明：以下代码的功能是把一个字符串倒序，如“abcd”倒序后变为“dcba”。

1 #include "string.h"
2 int main() 
3 {
4    char *src = "hello,world";
5    char *dest = NULL;
6    int len = strlen(src);
7    dest = (char *)malloc(len);
8    char *d = dest;
9    char *s = src[len];
10   while (len-- != 0)
11      *d++ = *s--;
12   printf("%s", dest);
13   return 0;

> 正确答案: A B C D    第7行要为''分配一个空间 第9行改成char * s = &src[len-1]
> 第12行前要加上*d = '' 第13行前不加free(dest)，程序结束时也会释放空间
> 
> > strlen所作的仅仅是一个计数器的工作，它从内存的某个位置（可以是字符串开头，中间某个位置，甚至是某个不确定的内存区域）开始扫描，直到碰到第一个字符串结束符''为止，然后返回计数器值(长度不包含'')

42.下面哪些赋值语句是正确的（）

正确答案: A B D
long test=012
float f=-412
int other =(int)true
double d=0x12345678
byte b=128
添加

java中不需要强制向下转型的合法数字类型转换图：core java书中有记载

43.下面哪些Java中的流对象是字节流?

正确答案: A B C D
FileInputStream
BufferedInputStream
PushbackInputStream
ByteArrayInputStream

stream结尾都是字节流，reader和writer结尾都是字符流 两者的区别就是读写的时候一个是按字节读写，一个是按字符。 实际使用通常差不多。 在读写文件需要对内容按行处理，比如比较特定字符，处理某一行数据的时候一般会选择字符流。 只是读写文件，和文件内容无关的，一般选择字节流。

44.下列关于while循环、do-while循环和for循环说法错误的是

正确答案: B C
while循环先执行条件判断，do-while循环执行循环体
do-while循环结束的条件是关键字while后的条件表达式成立
for循环结构中的3个表达式缺一不可
while循环能够实现的操作，for循环也能实现

strongbb头像strongbb A.while只有在满足条件时执行 而do-while会先执行一次 再看条件是否满足 满足再次循环
不满足跳出 所以B也就错了 应该是 do-while循环结束的条件是关键字while后的条件表达式不成立 C. 三个都为空也是可以的
最简洁形式：for(;; D. 我们使用while 就是为了他的循环次数的不一定的 而for循环一般限定了循环次数

45.关于快速排序算法的说法中，哪几个是正确的：（）
正确答案: B C
时间复杂度最坏是（nlogn)
时间复杂度均摊是(nlogn)
排序是不稳定的

快速排序的是不稳定的。
快速排序最优的情况下时间复杂度为：O( nlogn )
快速排序最差的情况下时间复杂度为：O( n^2 )

46.对文件名为Test.java的java代码描述正确的是()

class Person {
	String name = "No name";
	public Person(String nm) {
		name = nm;
	}
}
class Employee extends Person {
	String empID = "0000";
	public Employee(String id) {
		empID = id;
	}
}
public class Test {
	public static void main(String args[]) {
		Employee e = new Employee("123");
		System.out.println(e.empID);
	}
}

正确答案: C
输出：0000
输出：123
编译报错
输出：No name

47.给出一个由 n 个数组成的序列 A[1…n] ，要求找出它的最长单调上升子序列，设 m[i] （ 1 ≤ i ≤ n ），表示以 A[i] 结尾的最长单调上升子序列的长度，则 m[1] = 1 ， m[i] （ 1 < i ≤ n ）为（ ）。

正确答案: A
m[i] = 1 + max{0，m[k]（A[k] < A[i]，1≤k < i ）}
m[i] = 1 + m[k] （k = i - 1 && i > 1）
m[i] = 1 + max{-1，m[k] （A[k] ≤ A[i]，1≤k < i ）}
m[i] = max{0，m[k]（A[k] < A[i]，1≤k < i ）}

48.Java1.8之后，Java接口的修饰符可以为（）
正确答案: D
private
protected
final
abstract

接口是一种特殊的抽象类，先说明抽象类中的抽象方法，再说明接口
抽象类中的抽象方法(其前有 abstract1修饰)不能用 private、 static、 synchronized、na
tive访回修饰符修饰。原因如下:1. private抽象方法没有方法体,是用来被继承的,所以不能用 private修饰;2.static
static修饰的方法可以通过类名来访间该方法(即该方法的方法体),抽象方法用sttic修饰没有意义;3. synchronized
该关键字是为该方法加一个锁。而如果该关键字修饰的方法是 static方法。则使用的锁就是class变量的锁。如果是修饰类方法。则用this变量锁。
但是抽象类不能实例化对象,因为该方法不是在该抽象类中实现的。是在其子类实现的。所以，锁应该归其子类所有。所以，抽象方法也就不能用 synchronized关键字修饰了;3. native
native这个东西本身就和 abstract冲突,他们都是方法的声明,只是一个把方法实现移交给子类,另一个是移交给本地操作系统。如果同时出现,就相当于即把实现移交给子类,又把实现移交给本地操作系统,那到底谁来实现具体方法呢
终于说到了接口！
接口是一种特殊的抽象类,接口中的方法全部是抽象方法(但其前的 abstract可以省略),所以抽象类中的抽象方法不能用的访间修饰符这里也不能用。同时额外说明一下protect关键词4. protect
protected访同修饰符也不能使用,因为接口可以让所有的类去实现(非继承),不只是其子类,但是要用public去修饰。接口可以去继承一个已有的接口。
参考链接：http://www.360doc.com/content/16/0406/21/26211242_548419991.shtml

49.在程序设计中，要对两个16K×16K的多精度浮点数二维数组进行矩阵求和时，行优先读取和列优先读取的区别是（）
正确答案: B
没区别
行优先快
列优先快
2种读取方式速度为随机值，无法判断

分析:若在内存中,则数据可以”随机存取”,但内存数据被读取或写入时,所需要的时间与这段信息所在的位置无关.但是在读取和写入磁盘时,其所需要的时间与位置就会有关系.因为在BASIC,PASCAL和C/C++语言中,数组的存放是按照行优先来存放的,按行号第一行第二行…以此类推.本体关键是考察内存抖动的问题,如果按列访问则需要跳过一大串内存地址,这样可能需求的内存地址不在当前页中则需要进行页置换,这样便需要硬盘IO,减低速度.

50.以下 b 的值是： byte b = (byte)129;

正确答案: B
-126
-127
-128
-129

都写的啥几把玩意，我来正解，上面没看到完全正确的，所以实在忍不了写出正确的解答
这题考察的就两个知识点：一、强制转换（主要涉及各个类型占几个字节，这里我只简单说一下byte型占一个字节，也就是8位，int型4个字节，32位）；二、在计算机系统中，数值一律用补码来表示（存储）
正数：补码=反码=原码（当然以二进制形式表达）
129 int类型（4个字节）二进制： 00000000 00000000 00000000 10000001
强制转换byte型后，只有一个字节即 10000001（注意这里从二进制角度看，第一位是符号位，即求负数的补码接下来）
只要求出上面原码对应的补码就行了，然后再转换对应的int型数值（因为题干所给的答案都是比较int型）
10000001（原码） 对应的反码为1111 1110
又补码等于反码+1
即1111 1111 该二进制转换int型刚好是-127（1+2+4+8+16+32+64）
普及一下：正数原码，反码，补码相同
负数反码除了符号位不变，其他位取反，补码=反码+1；