今天开始混搭

1、以下哪项是类实例化的语句？

A. varName ClassName=new varName();
B. ClassName varName=new ClassName(new ClassName);
C. ClassName varName=ClassName();
D. ClassName varName=new ClassName();

解析：

类名 变量名= new 类名（）； 由此可知B、C错误
ClassnName是类名，varName是变量名，类名在变量名之前，故选择D。

2、下列说法正确的是
A. java中包的主要作用是实现跨平台功能
B. package语句只能放在import语句后面
C. 包（package）由一组类（class）和接口（interface）组成
D. 可以用#include关键词来标明来自其它包中的类

解析：

把功能相似或相关的类或接口组织在同一个包中，方便类的查找和使用。如同文件夹一样，包也采用了树形目录的存储方式。同一个包中的类名字是不同的，不同的包中的类的名字是可以相同的，当同时调用两个不同包中相同类名的类时，应该加上包名加以区别。因此，包可以避免名字冲突。包也限定了访问权限，拥有包访问权限的类才能访问某个包中的类。
java中"包"的引入的主要原因是java本身跨平台特性的需求。实现跨平台的是JVM，故A错误；package语句是Java源文件的第一条语句。如果想在另一个类里面引用包里面的类，要把名字写全。或者用import导入。故B错误；java中没有#include关键词，故D错误。

3、以下java程序代码，执行后的结果是（）

java.util.HashMap map=new java.util.HashMap(); 
map.put("name",null);      
map.put("name","Jack");
System.out.println(map.size());

A. 0
B. null
C. 1
D. 2

解析：

java.util
类 HashMap<K,V>
java.lang.Object
继承者 java.util.AbstractMap<K,V>
继承者 java.util.HashMap<K,V>

类型参数：
K - 此映射所维护的键的类型
V - 所映射值的类型

所有已实现的接口：
Serializable, Cloneable, Map<K,V>

直接已知子类：
LinkedHashMap, PrinterStateReasons
基于哈希表的 Map 接口的实现。此实现提供所有可选的映射操作，并允许使用 null 值和 null 键。（除了非同步和允许使用 null 之外，HashMap 类与 Hashtable 大致相同。）此类不保证映射的顺序，特别是它不保证该顺序恒久不变。

此实现假定哈希函数将元素适当地分布在各桶之间，可为基本操作（get 和 put）提供稳定的性能。迭代 collection 视图所需的时间与 HashMap 实例的“容量”（桶的数量）及其大小（键-值映射关系数）成比例。所以，如果迭代性能很重要，则不要将初始容量设置得太高（或将加载因子设置得太低）。

HashMap 的实例有两个参数影响其性能：初始容量 和加载因子。容量 是哈希表中桶的数量，初始容量只是哈希表在创建时的容量。加载因子 是哈希表在其容量自动增加之前可以达到多满的一种尺度。当哈希表中的条目数超出了加载因子与当前容量的乘积时，则要对该哈希表进行 rehash 操作（即重建内部数据结构），从而哈希表将具有大约两倍的桶数。

通常，默认加载因子 (0.75) 在时间和空间成本上寻求一种折衷。加载因子过高虽然减少了空间开销，但同时也增加了查询成本（在大多数 HashMap 类的操作中，包括 get 和 put 操作，都反映了这一点）。在设置初始容量时应该考虑到映射中所需的条目数及其加载因子，以便最大限度地减少 rehash 操作次数。如果初始容量大于最大条目数除以加载因子，则不会发生 rehash 操作。

如果很多映射关系要存储在 HashMap 实例中，则相对于按需执行自动的 rehash 操作以增大表的容量来说，使用足够大的初始容量创建它将使得映射关系能更有效地存储。

注意，此实现不是同步的。如果多个线程同时访问一个哈希映射，而其中至少一个线程从结构上修改了该映射，则它必须 保持外部同步。（结构上的修改是指添加或删除一个或多个映射关系的任何操作；仅改变与实例已经包含的键关联的值不是结构上的修改。）这一般通过对自然封装该映射的对象进行同步操作来完成。如果不存在这样的对象，则应该使用 Collections.synchronizedMap 方法来“包装”该映射。最好在创建时完成这一操作，以防止对映射进行意外的非同步访问，如下所示：

Map m = Collections.synchronizedMap(new HashMap(…));
HashMap() --构造一个具有默认初始容量 (16) 和默认加载因子 (0.75) 的空 HashMap。

HashMap可以插入null的key或value，插入的时候，检查是否已经存在相同的key，如果不存在，则直接插入，如果存在，则用新的value替换旧的value，在本题中，第一条put语句，会将key/value对插入HashMap，而第二条put，因为已经存在一个key为name的项，所以会用新的value替换旧的vaue，因此，两条put之后，HashMap中只有一个key/value键值对。那就是（name，jack）。所以，size为1.

4、命令javac-d参数的用途是？（）

A. 指定编译后类层次的根目录
B. 指定编译时需要依赖类的路径
C. 指定编译时的编码
D. 没有这一个参数

解析：

5、有如下4条语句：()

Integer i01=59;
int i02=59;
Integer i03=Integer.valueOf(59);
Integer i04=new Integer(59);
以下输出结果为false的是:

A.

System.out.println(i01==i02);

B.

System.out.println(i01==i03);

C.

System.out.println(i03==i04);

D.

System.out.println(i02==i04);

解析：

Integer是引用类型，int是基本类型，Integer 类在JDK1.0的时候就有了，它是一个类，是 int 基本数据类型的封装类。
Integer 类和 int 的区别

①、Integer 是 int 包装类,final修饰，int 是八大基本数据类型之一（byte,char,short,int,long,float,double,boolean）

②、Integer 是类，默认值为null，int是基本数据类型，默认值为0；

③、Integer 表示的是对象，用一个引用指向这个对象，而int是基本数据类型，直接存储数值。

Integer 的自动拆箱和装箱
　　自动拆箱和自动装箱是 JDK1.5 以后才有的功能，也就是java当中众多的语法糖之一，它的执行是在编译期，会根据代码的语法，在生成class文件的时候，决定是否进行拆箱和装箱动作。
自动装箱
一般我们创建一个类的时候是通过new关键字，比如：
Object obj = new Object();
但是对于 Integer 类，我们却可以这样：
Integer a = 128;
为什么可以这样，通过反编译工具，我们可以看到，生成的class文件是：
Integer a = Integer.valueOf(128);
这就是基本数据类型的自动装箱，128是基本数据类型，然后被解析成Integer类。
自动拆箱
我们将 Integer 类表示的数据赋值给基本数据类型int，就执行了自动拆箱。
Integer a = new Integer(128);
int m = a;
反编译生成的class文件：
Integer a = new Integer(128);
int m = a.intValue();
简单来讲：自动装箱就是Integer.valueOf(int i);自动拆箱就是 i.intValue();
“==”比较的是地址，若都为基本类型，比较的是数值，当两边有包装类型。则先将包装类型转换为基本类型在进行比较Integer a = new Integer(1)和Integer b = 1不同是因为前者会创建对象，存储在堆中，而后者因为在-128到127的范围内，不会创建新的对象，而是从IntegerCache中获取，两者地址不同，所以C错误

6、默认RMI采用的是什么通信协议？

A. HTTP
B. UDP/IP
C. TCP/IP
D. Multicast

解析

7、关于下面的程序Test.java说法正确的是( )

public class Test {
    static String x="1";
    static int y=1;
    public static void main(String args[]) {
        static int z=2;
        System.out.println(x+y+z);
    }
}

A. 3
B. 112
C. 13
D. 程序有编译错误

解析：

被static修饰的变量称为静态变量，静态变量属于整个类，而局部变量属于方法，只在该方法内有效，所以static不能修饰局部变量，故选择D

8、在可以执行n个线程的类中，将哪个方法定义为新线程的起点

A. public void start()
B. public void run()
C. public void int()
D. public static void main(String args[])
E public void runnable()

解析：

实现线程的方法有三种：
第一种：继承Thread类覆盖父类的run()方法 创建子类对象 然后 对象.start();执行线程 run()方法执行
第二种：实现Runnable接口 覆盖接口的run()方法 创建线程对象将子类传入，然后线程对象.start();启动线程 run()方法执行
第三种：实现Callable接口 类似于Runnable接口
Callable与Runnable接口的区别是：
Callable规定的方法是call()，而Runnable规定的方法是run().
Callable的任务执行后可返回值，而Runnable的任务是不能返回值的
call()方法可抛出异常，而run()方法是不能抛出异常的。
运行Callable任务可拿到一个Future对象，Future表示异步计算的结果。它提供了检查计算是否完成的方法,以等待计算的完成,并检索计算的结果.通过Future对象可了解任务执行情况,可取消任务的执行,还可获取任务执行的结果，所以选择B。

9、以下表达式中，正确的是（）

A. byte i=128
B. boolean i=null
C. long i=0xfffL
D. double i=0.9239d

解析：

对于A，byte为一个字节，长度为-128~127，故A错误；null表示没有地址；null可以赋值给引用变量，不能将null赋给基本类型变量，例如int、double、float、boolean，所以B错误；C表示定义一个长整数型的值0xfff，正确；D是double型的值，所以D也正确。

10、以下那些代码段能正确执行

A. public static void main(String args[]) {
byte a = 3;
byte b = 2;
b = a + b;
System.out.println(b);
}

B. public static void main(String args[]) {
byte a = 127;
byte b = 126;
b = a + b;
System.out.println(b);
}

C. public static void main(String args[]) {
byte a = 3;
byte b = 2;
a+=b;
System.out.println(b);
}

D. public static void main(String args[]) {
byte a = 127;
byte b = 127;
a+=b;
System.out.println(b);
}

解析：

byte类型的变量在做运算时被会转换为int类型的值，故A、B左为byte，右为int，会报错；而C、D语句中用的是a+=b的语句，此语句会将被赋值的变量自动强制转化为相对应的类型。

11、以下叙述中正确的是（）

A. 函数名允许用数字开头

B. 函数调用时，不必区分函数名称的大小写

C. 调用函数时，函数名必须与被调用的函数名完全一致

D. 在函数体中只能出现一次return语句

解析：

B 中，函数调用时，函数名称是需要区分大小写的； A 中，函数名不允许以数字开头； D 中，在函数中允许有多个 return 语句，但每次调用只能有一个 return 语句被执行。因此 C 选项正确。

12、要表示10个学生的成绩，下列声明并初始化数组正确的是（）

A. int[] score=new int[ ]

B. int score[10]

C. int score[]=new int[9]

D. int score[]=new int[10]

解析：

数组初始化有三种方式：
动态初始化：数组定义与为数组分配空间和赋值的操作分开进行；
静态初始化：在定义数字的同时就为数组元素分配空间并赋值；
默认初始化：数组是引用类型，它的元素相当于类的成员变量，因此数组分配空间后，每个元素也被按照成员变量的规则被隐式初始化。 初始化的时候，new后面的数组括号内[]传入的是数组大小即最大存储个数而不是最大下标，所以选择D

13、分支限界法与回溯法的相同点是()

A. 都是一种在问题的解空间树T中搜索问题解的算法

B. 存储空间的要求相同

C. 搜索方式相同

D. 对扩展结点的扩展方式相同

解析：

相同点：二者都是一种在问题的解空间树T上搜索问题解的算法。
不同点：1.在一般情况下，分支限界法与回溯法的求解目标不同。
回溯法的求解目标是找出T中满足约束条件的所有解，而分支限界法的求解目标则是找出满足约束条件的一个解，或是在满足约束条件的解中找出使某一目标函数值达到极大或极小的解，即在某种意义下的最优解。
2.回溯法与分支-限界法对解空间的搜索方式不同，回溯法通常采用尝试优先搜索，而分支限界法则通常采用广度优先搜索。
3.对节点存储的常用数据结构以及节点存储特性也各不相同，除由搜索方式决定的不同的存储结构外，分支限界法通常需要存储一些额外的信息以利于进一步地展开搜索。

14、指出下列程序运行的结果（）

public class Example{
    String str = new String("good");
    char[ ] ch = { 'a' , 'b' , 'c' };
    public static void main(String args[]){
        Example ex = new Example();
        ex.change(ex.str,ex.ch);
        System.out.print(ex.str + " and ");
        System.out.print(ex.ch);
    }
    public void change(String str,char ch[ ]){
        str = "test ok";
        ch[0] = 'g';
    }
}

A. good and abc

B. good and gbc

C. test ok and abc

D. test ok and gbc

解析：

new出来的那个str地址传到方法中，即方法中的str也指向new String（”good”）这个对象，但是String是不可变类，所以“test ok”无法覆盖new String（”good”），所以C、D错误；
数组则不同，数组是可变类， “ch[0] = ‘g’”，是将“g”赋值给角标为0的变量，所以选择B。

15、 设某数据结构的二元组形式表示为 A=(D ， R) ， D={01 ， 02 ， 03 ， 04 ， 05 ， 06 ， 07 ， 08 ， 09} ， R={r} ， r={<01 ， 02> ， <01 ， 03> ， <01 ， 04> ， <02 ， 05> ， <02 ， 06> ， <03 ， 07> ， <03 ， 08> ， <03 ， 09>} ，则数据结构A是（）

A. 线性结构

B. 树型结构

C. 物理结构

D. 图型结构

解析：

16、在UNIX系统中，目录结构采用（ ）

A. 单级目录结构

B. 二级目录结构

C. 单纯树形目录结构

D. 带链接树形目录结构

解析：

UNIX的文件系统构成了一棵多级树，即采用分级树型结构，允许用户建立自己的子目录

17、现有一数列{3, 2, 5, 7, 6, 8}，要求按升序排序，下面说法正确的是：

A. 插入排序（从前向后）需要做6次比较

B. 快速排序，每次选择最后一个元素作为支点，需要比较5次

C. 快速排序，每次选择最后一个元素作为支点，需要比较9次

D. 快速排序，每次选择最后一个元素作为支点，需要比较12次

解析：

第一趟：从前往后扫描有序数组，将第二个数字2和3进行比较，3大于2，此时将2后移一个位置。此时已经扫描完有序数组中的数，将2插入到3的前面（有序数组的第一个位置），得到新数字序列2，3；
第二趟：从前往后扫描有序数组，先将第三个数字5和有序数组中的4进行比较，5大于3，此时不动；再将5和有序数组中的2进行比较，5大于2，此时不动。此时已经扫描完有序数组中的数，得到新数字序列2，3，5；
第三趟：从前往后扫描有序数组，先将第三个数字7和有序数组中的5进行比较，7大于5，此时不动；再将7和有序数组中的3进行比较，7大于3，此时不动，再将7和有序数组中的2进行比较，7大于2，此时不动。此时已经扫描完有序数组中的数，得到新数字序列2，3，5，7；
第四趟：从前往后扫描有序数组，先将第三个数字6和有序数组中的7进行比较，6小于7，此时将6前进一步；再将6和有序数组中的5进行比较，6大于5，此时不动，再将6和有序数组中的3进行比较，6大于3，此时不动，再将6和有序数组中的2进行比较，6大于2，此时不动。此时已经扫描完有序数组中的数，得到新数字序列2，3，5，6，7；
第五趟：从前往后扫描有序数组，先将第三个数字8和有序数组中的7进行比较，8大于7，此时不动；再将8和有序数组中的6进行比较，8大于6，此时不动，再将8和有序数组中的5进行比较，8大于5，此时不动，再将8和有序数组中的3进行比较，8大于3，此时不动，再将8和有序数组中的2进行比较，8大于2，此时不动。此时已经扫描完有序数组中的数，得到新数字序列2，3，5，6，7，8；所以A错误；

快速排序的基本思想是：

1、先从数列中取出一个数作为基准数

2、分区过程，将比这个数大的数全放到它的右边，小于或等于它的数全放到它的左边

3、再对左右区间重复第二步，直到各区间只有一个数

第一次：8是基数
3 2 5 7 6 分别跟8比较，共比较5次，比完的结果是 3 2 5 7 6 8
第二次：6是基数
3 2 5 7 分别跟6比较，共比较4次，比完的结果是 3 2 5 6 7 8
第三次：5是基数
3 2 分别跟5比较。共比较2次，比完的结果是 3 2 5 6 7 8
第四次：2是基数
3 跟2比较，共比较1次，结果是 2 3 5 6 7 8
总共比较 5 + 4 + 2 + 1 = 12 次 ，所以选择D

18、关于快速排序，下列说法正确的有（）

A. 快速排序是基于比较的排序

B. 快速排序使用了分治的思想

C. 在某些特殊数据中，快速排序的时间复杂度可以达到O(n)

D. 快速排序只能使用递归方式实现

解析：

快速排序可以用非递归实现，所以选择A,B

19、微型计算机采用总线结构( )

A. 提高了CPU访问外设的速度

B. 可以简化系统结构

C. 易于系统扩展

D. 使信号线的数量增加

E. 提高了系统成本

解析：

采用总线的结构主要有以下优点：

1、面向存储器的双总线结构信息传送效率较高，这是它的主要优点。但CPU与I/O接口都要访问存储器时，仍会产生冲突。

2、CPU与高速的局部存储器和局部I/O接口通过高传输速率的局部总线连接，速度较慢的全局存储器和全局I/O接口与较慢的全局总线连接，从而兼顾了高速设备和慢速设备，使它们之间不互相牵扯。

3、简化了硬件的设计。便于采用模块化结构设计方法，面向总线的微型计算机设计只要按照这些规定制作cpu插件、存储器插件以及I/O插件等，将它们连入总线就可工作，而不必考虑总线的详细操作。

4、简化了系统结构。整个系统结构清晰。连线少，底板连线可以印制化。

5、系统扩充性好。一是规模扩充，规模扩充仅仅需要多插一些同类型的插件。二是功能扩充，功能扩充仅仅需要按照总线标准设计新插件，插件插入机器的位置往往没有严格的限制。

6、系统更新性能好。因为cpu、存储器、I/O接口等都是按总线规约挂到总线上的，因而只要总线设计恰当，可以随时随着处理器的芯片以及其他有关芯片的进展设计新的插件，新的插件插到底板上对系统进行更新，其他插件和底板连线一般不需要改。

7、便于故障诊断和维修。用主板测试卡可以很方便找到出现故障的部位，以及总线类型。

20、以下变量命名哪一项是不规范的（）

A. mName

B. NAME

C. name

D. Name

解析：

A选项属于复合单词的小驼峰命名。
B选项大写字母一般用于“常量”定义。所以B错误。
C选项属于单个单词的小写命名规范，也是常用的。
D选项常用于“类名”命名方式，即首字母大写。所以D错误。

---

---

1、给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。

class Solution {
    public int[] twoSum(int[] nums, int target) {

    for (int i = 0; i < nums.length; i++) {
        for (int j = i + 1; j < nums.length; j++) {
            if (nums[j] == target - nums[i]) {
                return new int[] { i, j };
            }
        }
    }
    return null;
}

}

2、给出一个 32 位的有符号整数，你需要将这个整数中每位上的数字进行反转。

class Solution {
    public int reverse(int x) {
    int num = x;
        if (num < 0) {
            x = Math.abs(num);
        }
        if (x >= 0 && x < 10) {
            return x;
        }
        int numTmp = x;
        int count = 0;
        while (x > 0) {
            count++;
            x /= 10;
        }
        int[] arr = new int[count];
        for (int i = 0; i < count; i++) {
            arr[i] = numTmp % 10;
            numTmp /= 10;
        }
        long res = 0;
        for (int i = 0, j = count - 1; i < count; i++, j--) {
            res += arr[i] * (long) Math.pow(10, j);
            if (res>(long)Math.pow(2,31)-1){
                res=0;
                break;
            }
        }
        if (num >= 0) {
            return (int)res;
        }else {
            return -(int)res;
        }
    }
}

3、判断一个整数是否是回文数。回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。

class Solution {
    public boolean isPalindrome(int x) {
        if (x < 0) {
            return false;
        }
        int help = 1;
        int tmp = x;
        while (tmp >= 10) {
            help *= 10;
            tmp /= 10;
        }
        while (x != 0) {
            if (x % 10 != x / help) {
                return false;
            }
            x = x % help / 10;
            help /= 100;
        }
        return true;
    }
}

4、给定一个排序数组，你需要在原地删除重复出现的元素，使得每个元素只出现一次，返回移除后数组的新长度。

不要使用额外的数组空间，你必须在原地修改输入数组并在使用 O(1) 额外空间的条件下完成。

class Solution {
    public int removeDuplicates(int[] nums) {
    if(nums == null || nums.length == 0) return 0;
    int p = 0;
    int q = 1;
    while(q < nums.length){
        if(nums[p] != nums[q]){
            nums[p + 1] = nums[q];
            p++;
        }
        q++;
    }
    return p + 1;
}
}