笔试题卷2

选择

1、关于 java 的异常处理机制，以下说法正确的是：
A、当某个线程抛出 OutofMemoryError 时，其他线程可能不受影响
B、当大量抛出 RuntimeException，不会影响系统的吞吐量
C、java.lang.Exception 是 java.lang.Error 的父类
D、finally 块代码一定会被执行
答案：A
解析：
A、在程序内存溢出之后，溢出的内存的线程所占的内存会被快速释放，不会影响其它线程的运行。
B、当大量抛出运行时异常时，系统肯定存在问题，会影响系统吞吐量。
C、ry 块中如果有 System.exit(0); 代码就会不执行 finally 块代码。
D、java 异常继承结构：

2、函数 a 定义如下：
int a(int tab){
int n=tab-1;
n |= n >> 1;
n |= n >> 2;
n |= n >> 4;
n |= n >> 8;
n |= n >> 16;
return n;
}
调用函数 a(666) 返回的结果是：C
A、666
B、512
C、1023
D、511
答案：C
解析：

3、关于 mysql，下列说法不正确的是：
A、mysql 中的 “utf8” 类型最大只支持 3 个 bytes
B、desc 关键字可以作为 table 的字段名
C、filesort 是通过读取磁盘文件进行排序，会极大降低查询性能
D、smallint 占用 2 个 bytes 的存储空间
答案：C
解析：
A、utf-8 和 utf8有所区别，utf-8最大只支持4个bytes，utf8最大只支持3个bytes；
B、使用关键字作为 表名或列表，只需加上 ’ ’ 就行了；
C、filesort不是磁盘文件进行排序，只是进行了一个排序操作；
D、smallint 占用 2 个 bytes 的存储空间

4.查找表结构用以下哪一项( )
A、FIND
B、SELETE
C、ALTER
D、DESC
答案：D
解析：
desc tabl_name;
显示表结构，字段类型，主键，是否为空等属性，但不显示外键。

5.如何强制垃圾回收器立即回收一个对象？
A、调用System.gc()方法；
B、调用Runtime.gc()方法；
C、将对象赋值null；
D、无法强制垃圾回收器立即执行；
答案：D
解析：
没有方法可以强行回收垃圾，只能提高优先级；
system.gc可以提醒垃圾回收执行，不能强制；

6.关于sleep()和wait()，以下描述错误的一项是（ ）
A、sleep是线程类（Thread）的方法，wait是Object类的方法；
B、sleep不释放对象锁，wait放弃对象锁；
C、sleep暂停线程、但监控状态仍然保持，结束后会自动恢复；
D、wait后进入等待锁定池，只有针对此对象发出notify方法后获得对象锁进入运行状态
答案：D
解析：
wait后进入等待锁定池，只有针对此对象发出notify方法后获得对象锁进入就绪状态。

7.下列协议中，将MAC地址转为IP地址的协议是
A、ARP
B、RARP
C、ARQ
D、ICMP
答案：B
解析：
ARP（Address Resolution Protocol）地址解析协议，是根据IP地址获取物理地址的一个TCP/IP协议；
RARP（Reverse Address Resolution Protocol）反向地址转换协议
ARQ：数据链路层，自动重传请求
ICMP：ICMP协议是一种面向无连接的协议，用于传输出错报告控制信息

8.若某单处理器多进程系统中有多个就绪态进程，则下列关于处理机调度的叙述中，错误的是
A、在进程结束时能进行处理机调度
B、创建新进程后能进行处理机调度
C、在进程处于临界区时不能进行处理机调度
D、在系统调用完成并返回用户态时能进行处理机调
答案：C
解析：进程处于临界区时只要不破坏临界资源就可以进行处理机调度

9.有关C++程序运行时的函数地址，下列说法正确的是
A、每个函数的地址都是固定的，同一个程序重复运行多次，每次函数地址都一样
B、每个函数的地址是不固定的，但在操作系统版本、硬件版本不变的情况下是固定的，同一个程序重复在相同软硬件环境下运行多次，每次函数地址都一样
C、地址是否固定要看系统配置和编译选项，如果开启了地址随机化，那地址是每次都变的，如果没开启，那么地址每次都一样。
D、每个函数的地址都是不定的，同一个程序重复运行多次，每次地址都不同
答案：C

10.下列有关于关键字“堆”的描述中，错误的是
A、堆是优先级队列的底层实现形式，有N个元素的优先级队列进行一次结构调整的时间复杂度为logN
B、堆内存是一种动态分配的内存，其实际占用内存空间的大小随着程序的运行可以动态调整
C、堆栈是一种线性数据结构，其特点是先进后出
D、在C语言中，堆内存是线程隔离的，不同线程访问的是各自的堆空间，无法互相访问
答案：D

11.关于epoll和select的区别，哪个说法是错误的？
A、epoll和select都是I/O多路复用的技术，都可以实现同时监听多个I/O事件的状态。
B、epoll相比select效率更高，主要是基于其操作系统支持的I/O事件通知机制，而select是基于轮询机制。
C、epoll支持水平触发和边沿触发两种模式。
D、select能并行支持I/O比较小，且无法修改。
答案：D
解析：select默认的句柄数量为1024，但可通过修改宏定义或编译内核修改句柄数量

12.给定一个整型数组L，数组长度为n，数组元素取值范围[1,n],（n>2000)，请问最快速找出一个缺失值的时间复杂度是多少？
A、O(log(n))
B、O(n)
C、O(n*log(n))
D、O(n^2)
答案：B
解析：数组并非有序，所以只能通过遍历查找，时间复杂度为O(n)

13.已知一个线性表（38，25，74，63，52，48），假定采用散列函数h（key) = key%7计算散列地址，并散列存储在散列表A【0…6】中，若采用线性探测方法解决冲突，则在该散列表上进行等概率成功查找的平均查找长度为
A、1.5
B、1.7
C、2.0
D、2.3
答案：C
解析：
平均查找长度=总的查找次数/元素数
总的查找次数： 38%7=3 （第1次出现3，无冲突，放在位置3，查找次数为1）
25%7=4（第1次出现4，无冲突，放在位置4，查找次数为1）
74%7=4（第2次出现4，有冲突，放在位置5，查找次数为2）
63%7=0（第1次出现0，无冲突，放在位置0，查找次数为1）
52%7=3（第2次出现3，有冲突，发现冲突3,4,5，故只能放到6，查找次数为4）
48%7=6 （第1次出现6，有冲突，发现冲突6,0，故只能放到1，查找次数为3）
1+1+2+1+4+3=12
元素数=6
所以：平均查找长度=12/6=2

14.Linux 下用于创建新进程的系统调用是：（）。
A、fork
B、exit
C、pipe
D、kill
答案：A
解析：
exit：退出进程
pipe：和管道相关
kill：杀死进程

15.每个Unicode码占用（）个比特位
A、8
B、16
C、32
D、64
答案：B

简答

16.查看Linux系统下内存和CPU信息
内存：cat /proc/meminfo
CPU：cat /proc/cpuinfo

17.指定jvm使用最大内存

-Xms128m JVM初始分配的堆内存
-Xmx512m JVM最大允许分配的堆内存，按需分配
-XX:PermSize=64M JVM初始分配的非堆内存
-XX:MaxPermSize=128M JVM最大允许分配的非堆内存，按需分配

18.什么是跨域请求？如何解决跨域问题？

浏览器从一个域名的网页去请求另一个域名的资源时，域名、端口、协议任一不同，都是跨域
1、jsonp跨域
2、nginx反向代理：
3、修改header
4、document.domain
5、window.name
6、postMessage

19.常见的uncheck Exception

受检异常(checkedException)
除去RuntimeException和Error外的异常都属于受检异常，该异常需要强制处理(throws给方法调用者，或者在发生的方法中try/catch掉)。

常见受检异常如下：
Java.lang.ClassNotFoundException --找不到类异常
Java.lang.CloneNotSupportedException --clone异常-未实现Cloneable接口
Java.lang.IOException --IO流异常
Java.lang.SqlException --sql异常
Java.lang.IllegalAccessException --访问权限异常-private
Java.lang.DataFormatException --数据格式化异常
Java.lang.NoSuchFieldException --反射异常
Java.lang.NoSuchMethodException --方法未找到异常

非受检异常(uncheckedException)
RuntimeException是所有非受检异常类的基类，即所有非受检异常继承自该类。该类异常不强制处理，但通常开发人员为了代码健全会进行封装处理，该异常发生的原因也通常是程序员对逻辑的考虑不周而出现的。

常见非受检异常如下：
Java.lang.ClassCastException --类型转换异常
Java.lang.NumberFormatException --数字转换异常
Java.lang.NullPointerException --空指针异常
Java.lang.IndexOutOfBoundsException --索引越界异常
Java.lang.ArrayIndexOutOfBoundsException --数组下标越界异常
Java.lang.StringIndexOutOfBoundsException --字符串截取下标越界异常
Java.lang.NegativeArraySizeException --数组大小为负数异常
Java.lang.ArithmeticException --算术异常
Java.lang.ArrayStoreException --数组元素不匹配异常
Java.lang.EnumConstantNotPresentException --枚举常量不存在异常
Java.lang.IllegalArgumentException --非法参数异常
Java.lang.IllegalThreadStateException --线程异常
Java.lang.IllegalMonitorStateException --违法的监控状态异常
Java.lang.TypeNotPresentException --类型不存在异常

20.单例模式下，实例变量需不需要加volatile

一个变量被volatile修饰后具备两个特性：

1. 可见性：此变量对所有线程可见，当一个线程修改了这个变量的值，新值对其他线程是可以立即得知的，如果不是volatile修饰的变量的值在线程间传递均需要通过主内存来完成，比如线程A修改了普通变量的值，然后向主内存进行回写，另一条线程B在线程A回写完成之后再对主内存进行读取操作，新变量值才会对线程B可见。
2. 禁止指令重排序优化：普通的变量仅会保证该方法的执行过程中所有依赖赋值结果的地方都能获取到正确的结果，而不能保证变量赋值操作的顺序与程序代码中的执行顺序一致。

如果不加volatile会有什么问题？
当在多线程环境下，多个线程同时运行到代码if (instance == null)处时，instance 为null，这几个线程都会创建自己的单例，而不是使用的同一个单例对象。

解决方法：加锁

那么新的问题又出现了？
假设来两个线程会竞争锁。假如A线程获得了锁，A线程继续执行，直到A线程创建一个Singleton实例对象，A线程释放锁。这时B线程获取到锁，依然是继续执行，此时B线程仍然会创建一个Singleton实例对象。A,B两个线程就创建了两个不同的Singleton实例对象。

解决方法：代码块中再加一层check，check instance是否为null——双重验证

但是还有一个问题就是？
指令重排序，对象的创建不是原子性操作，所以有指令重排序的可能。也就是说在多个线程下，如果在加锁的情况下创建对象，但由于指令重排序会导致线程有可能会使用一个未完全初始化的对象，这样会出现安全性问题。

创建对象过程

1.申请内存，此时m的值是默认值0
3.调用构造方法，此时m值为8
3.建立关联, t 指向申请的内存

正常情况下：123的顺序是我们所想要的，但是重排序可能会导致其他顺序，如132；

为了禁止指令重排序，所以要引入volatile。

总结：对象的创建不是原子性操作，所以有指令重排序的可能。为了禁止指令重排序，所以要引入volatile。

编程

病毒检测
小明最近在做病毒自动检测，他发现，在某些library 的代码段的二进制表示中，
如果包含子串并且恰好有k个1，就有可能有潜在的病毒。library的二进制表示可能很大，
并且子串可能很多，人工分析不可能，于是他想写个程序来先算算到底有多少个子串满足条件。
如果子串内容相同，但是开始或者结束位置不一样，则被认为是不同的子串。
注：子串一定是连续的。例如"010"有6个子串，分别是 "0, “1”, “0”, “01”, “10”, “010”

public static int getNum(String s, int k){
        char []c = s.toCharArray();
        int res = 0;
        for(char cc : c){
            if(cc == '1'){
                res++;
            }
        }
        if(res < k){
            return 0;
        }
        res = 0;
        int n = c.length;
        for(int i = 0; i < n; i++){
            int idx = i;    // 滑动索引
            int count = 0;
            while(idx < n && count < k){
                if(c[idx] == '1' && ++count == k){
                    res++;
                    idx++;
                    break;
                }
                idx++;
            }
            // 满足k后继续右滑
            while(idx < n && c[idx] != '1'){
                res++;
                idx++;
            }
        }
        return res;
    }

考试成绩
现在你的班级刚刚参加了一个只有单选题的考试。
班级一共n个学生，考试有m个问题。每个题目都有5个可选答案（A，B，C，D，E）。
并且每个题目只有一个正确答案。每个题目的分数并不一样，第i个题目的分数用a[i]表示。如果题目没答对该题会获得0分。
考试结束后，每个学生都记得自己的答案，但是他们还不知道正确答案是什么。如果非常乐观的考虑，他们班级最多可能得到多少分呢？

public static void main(String []args){
        Scanner sc = new Scanner(System.in);
        int m = sc.nextInt(), n = sc.nextInt();
        String[] arr = new String[m];
        for(int i = 0; i < m; i++){
            arr[i] = sc.next();
        }
        int sum = 0;
        for(int i = 0; i < n; i++){
            int score = sc.nextInt();
            int max = 0;
            int []num = new int[5];
            for(String s : arr){
                int idx = (int)s.charAt(i) - (int)'A';
                num[idx]++;
                max = Math.max(max, num[idx]);
            }
            //print(num);
            System.out.println("max="+max);
            sum += (max * score);
        }
        System.out.println(sum);
    }

查找字符串
在目标字符串 s 中，查找是否存在子串 p

public static int indexOf (String s, String pattern) {
        int n1 = s.length(), n2 = pattern.length();
        if(n1 < n2){
            return -1;
        }
        char []c1 = s.toCharArray();
        char []c2 = pattern.toCharArray();
        for (int i = 0; i <= n1 - n2; i++){
            int j;
            for (j = 0; j < n2; j++){
                if (c1[i+j] != c2[j]){
                    break;
                }
            }
            if (j == n2){
                return i;
            }
        }
        return -1;
    }