牛客网校招全国统一模拟笔试（二月场）- Java方向

1、请问下面关于与wait()一起使用的方法notify()的各种陈述，哪个正确？

A 多个线程同时等待某个条件，则只有等待时间最长的哪个线程被通知

B 多个线程同时等待某条件，则没有办法预测哪个线程被通知

C notify()方法，在任何方法中都能调用

D notify()方法只能从while循环中调用

解析：https://www.cnblogs.com/zsh-blogs/p/10429184.html

2、下面哪个行为被打断不会导致InterruptedException：（ ）？

A Thread.join

B Thread.sleep

C Object.wait

D CyclicBarrier.await

E Thread.suspend

解析：抛InterruptedException的代表方法有：

• java.lang.Object 类的 wait 方法

• java.lang.Thread 类的 sleep 方法

• java.lang.Thread 类的 join 方法

3、Java数据库连接库JDBC用到哪种设计模式?

A 生成器　　B 桥接模式　　C 抽象工厂　　D 单例模式

4、能单独和 finally 语句一起使用的块是

A try　　B throws　　C throw　　D catch

5、如果相邻的两区域不能涂上同样的颜色，下图需要几种不同的颜色？

A 2 　　B 3 　　C 4 　　D 5

6、由甲地到乙地有一条线路的巴士，全程行驶时间为42分钟，到达总站后，司机至少休息10分钟，巴士就调头行驶.如果这条线路甲、乙两边总站每隔8分钟都发一辆 （不必是同一时间），则这条线路至少需多少辆巴士？

A 12 　　 B 13　　 C 14　　 D 15

解析：根据题意可知，需要的巴士辆数要满足在从出发至回站这段进间内能够每八分钟开出一辆，回来一辆．因此，要先求出一辆巴士从出发到回站再出发需要多少时间：在路上单程需要42分钟，每站休息10分钟，所以需要（42+10）×2=104（分钟），又每隔8分钟都发一辆，由此可知，这段线路需要104÷8=13（辆）车．

7、有部门和职工关系，如图所示。

执行下列语句，在职工关系中插入新的数据：

能正确执行的语句是

A Ⅰ、Ⅱ 　　B III、Ⅳ 　　C Ⅰ、Ⅱ、III 　　D Ⅰ、Ⅱ、III、Ⅳ

解析：职工表中，职工号是主键，排除I。所以选B

8、下列不是进程间的通信方式的是

A 信号量（semaphore）

B 回调（call back）

C 共享内存 (shared memory)

D 消息队列 (message queue )

解析：

# 管道( pipe )：管道是一种半双工的通信方式，数据只能单向流动，而且只能在具有亲缘关系的进程间使用。进程的亲缘关系通常是指父子进程关系。

# 信号量( semophore ) ： 信号量是一个计数器，可以用来控制多个进程对共享资源的访问。它常作为一种锁机制，防止某进程正在访问共享资源时，其他进程也访问该资源。因此，主要作为进程间以及同一进程内不同线程之间的同步手段。

# 消息队列( message queue ) ： 消息队列是由消息的链表，存放在内核中并由消息队列标识符标识。消息队列克服了信号传递信息少、管道只能承载无格式字节流以及缓冲区大小受限等缺点。

# 共享内存( shared memory )
：共享内存就是映射一段能被其他进程所访问的内存，这段共享内存由一个进程创建，但多个进程都可以访问。共享内存是最快的 IPC 方式，它是针对其他进程间通信方式运行效率低而专门设计的。它往往与其他通信机制，如信号两，配合使用，来实现进程间的同步和通信。

# 套接字( socket ) ： 套解口也是一种进程间通信机制，与其他通信机制不同的是，它可用于不同及其间的进程通信。

# 回调：
是一种编程机制。

9、对于下面几种存储介质（1：SSD固态硬盘、2：L3高速缓存、3：7200转硬盘、4：内存）按存取速度从快到慢，正确的顺序应该是：

A 3>2>4>1 　　B 2>4>1>3 　　C 4>1>2>3 　　D 3>1>2>4

解析：我们可以将存储系统分为三级：高速缓存、内存和外存。SSD固态硬盘>7200转机械硬盘

10、以下关于进程和线程的描述中，正确的一项是（ ）

A 一个进程就是一个独立的程序

B 进程间是互相独立的，同一进程的各线程间也是独立的，不能共享所属进程拥有的资源

C 每个线程都有自己的执行堆线和程序计数器为执行上下文

D 进程的特征包括动态性、并发性、独立性、同步性

解析：一个进程包含一个或多个线程。进程的特征包括动态性、并发性、独立性、异步性。

11、cron 后台常驻程序 (daemon) 用于 ( )

A 跟踪管理系统信息和错误

B 负责文件在网络中的共享

C 管理系统日常任务的调度

D 管理打印子系统

解析：Linux试题

12、Linux中，提供TCP/IP包过滤功能的软件叫什么？ ( )

A route 　　B iptables 　　C rarp 　　D filter

解析：Linux试题

13、HTTPS协议通过什么实现安全访问？

A PGP 　　B SSL 　　C IPsec 　　D SET

14、linux 下使用 write 函数发送网络数据，函数返回 n(n>0),下面哪个说法正确

A 本地已经发送n个字节到系统缓冲

B 对端已经收到n个字节

C 本地已经发送n个字节到网络

D 本地发送失败

解析：

TCP发送方式：

1.先写入n个数据到系统缓冲区

2.若写入的数据大于缓冲区大小，则write会阻塞或失败。

3.直到接收到对方的确认号，系统才会把缓冲区的对应数据删除，然后通知应用程序缓冲区可用。

UDP发送方式：

UDP是以报文的形式发送的，若有一个完整的报文则立即发送，不需要对方回应，所以发送后数据就会被删除，不需要缓冲区。

15、FTP协议属于那一层

A 物理层 　　B 数据链路层 　　C 传输层 　　D 网络层 　　E 应用层

解析：目前，应用层协议主要有以下几种：
①远程登录协议（Telnet）;
②文件传送协议(file transfer protocol,FTP);
③简单邮件传送协议(simple mail ttransfer protocol,SMTP);
④域名系统(domain name system,DNS);
⑤简单网络管理协议(simple network management protocol,SNMP);
⑥超文本传送协议(hyper text transfer protocol,HTTP).

16、下面一段代码的时间复杂度是

A O(n)　　 B O(n的2次方) 　　C O(n的3次方) 　　D O(nlog2n).

解析：外层循环为N，里层循环为N*N，所以时间复杂度为N*N*N。

17、对于字符串"ABCDADA"的二进制哈夫曼编码有多少位?

A 11 　　B 12 　　C 13　　 D 14

解析：

18、如下的无向图中有多少个不同的最小生成树（ ）

A 4 　　B 5 　　C 6 　　D 7

解析：最小生成树定义：在一给定的无向图G = (V, E) 中，(u, v) 代表连接顶点 u 与顶点 v 的边（即），而 w(u, v) 代表此边的权重，若存在 T 为 E 的子集（即）且为无循环图，使得的 w(T) 最小，则此 T 为 G 的最小生成树。

19、设线性表(59，53，46，48，37，31，25)采用散列(Hash)法进行存储和查找，散列函数为H(Key)=Key MOD 7(MOD表示整除取余运算)。若用 链地址法解决冲突(即将相互冲突的元素存储在同一个单链表中)构造散列表，则散列表中与哈希地址______对应的单链表最长。

A 2 　　B 3 　　C 4 　　D 6

解析：这道题其实就是求余。

20、对长度为n的有序表进行二分(折半)查找时，无论查找指定的一个元素是否成功，最多只与表中的______个元素进行比较即可。

A 

B 

C n/2

D n-1

解析：https://www.cnblogs.com/zsh-blogs/p/10387028.html

21、【独立的牛牛】

　　小牛牛为了向他的父母表现他已经长大独立了,他决定搬出去自己居住一段时间。 一个人生活增加了许多花费: 牛牛每天必须吃一个水果并且需要每天支付x元的房屋租金。 当前牛牛手中已经有f个水果和d元钱,牛牛也能去商店购买一些水果,商店每个水果售卖p元。 牛牛为了表现他独立生活的能力,希望能独立生活的时间越长越好,牛牛希望你来帮他计算一下他最多能独立生活多少天。

　

 package niuKeWrittenTest_2;

 import java.util.Scanner;

 /**
  * @author zsh
  * @company wlgzs
  * @create 2019-02-25 15:54
  * @Describe 【独立的牛牛】
  * 小牛牛为了向他的父母表现他已经长大独立了,他决定搬出去自己居住一段时间。
  * 一个人生活增加了许多花费: 牛牛每天必须吃一个水果并且需要每天支付x元的房屋租金。
  * 当前牛牛手中已经有f个水果和d元钱,牛牛也能去商店购买一些水果,商店每个水果售卖p元。
  * 牛牛为了表现他独立生活的能力,希望能独立生活的时间越长越好,牛牛希望你来帮他计算一下他最多能独立生活多少天。
  * 输入描述：
  * 输入包括一行,四个整数x, f, d, p(1 <= x,f,d,p <= 2 * 10^9),以空格分割
  * 输出描述：
  * 输出一个整数, 表示牛牛最多能独立生活多少天。
  * 示例1：
  * 输入
  * 3 5 100 10
  * 输出
  * 11
  */
 public class Main1 {
     public static void main(String[] args) {
         Scanner scanner = new Scanner(System.in);
         int x = scanner.nextInt();
         int f = scanner.nextInt();
         int d = scanner.nextInt();
         int p = scanner.nextInt();
         //如果水果足够
         if (d / x < f){
             System.out.println(d / x);
         }else {
             System.out.println((d - x * f)/(p + x) + f);
         }
     }
 }

22、【牛牛吃雪糕】

　　最近天气太热了，牛牛每天都要吃雪糕。雪糕有一盒一份、一盒两份、一盒三份这三种包装，牛牛一天可以吃多盒雪糕，但是只能吃六份，吃多了就 会肚子疼，吃少了就会中暑。而且贪吃的牛牛一旦打开一盒雪糕，就一定会把它吃完。请问牛牛能健康地度过这段高温期么？

输入描述：

 package niuKeWrittenTest_2;

 import java.util.Scanner;

 /**
  * @author zsh
  * @company wlgzs
  * @create 2019-02-25 19:11
  * @Describe 【牛牛吃雪糕】
  * 最近天气太热了，牛牛每天都要吃雪糕。雪糕有一盒一份、一盒两份、一盒三份这三种包装，牛牛一天可以吃多盒雪糕，但是只能吃六份，吃多了就
  * 会肚子疼，吃少了就会中暑。而且贪吃的牛牛一旦打开一盒雪糕，就一定会把它吃完。请问牛牛能健康地度过这段高温期么？
  * 输入描述：
  * 每个输入包含多个测试用例。
  * 输入的第一行包括一个正整数，表示数据组数T(1<=T<=100)。
  * 接下来N行，每行包含四个正整数，表示高温期持续的天数N(1<=N<=10000)，一盒一份包装的雪糕数量A(1<=A<=100000)，一盒两份包装的雪糕数量B(1<=B<=1
  * 00000)，一盒三份包装的雪糕数量C(1<=A<=100000)。
  * 输出描述：
  * 对于每个用例，在单独的一行中输出结果。如果牛牛可以健康地度过高温期则输出"Yes"，否则输出"No"。
  *
  * 示例1：
  * 输入
  * 4
  * 1 1 1 1
  * 2 0 0 4
  * 3 0 2 5
  * 4 24 0 0
  * 输出
  * Yes
  * Yes
  * No
  * Yes
  */
 public class Main2 {
     public static void main(String[] args) {
         Scanner scanner = new Scanner(System.in);
         int T = scanner.nextInt();
         while (T-- != 0) {
             int s = scanner.nextInt();
             int one = scanner.nextInt();
             int two = scanner.nextInt();
             int three = scanner.nextInt();
             boolean res = getResult(s, one, two, three);
             System.out.println(res ? "Yes" : "No");
         }
     }

     private static boolean getResult(int s, int one, int two, int three) {
         int sum = one + two * 2 + three * 3;
         s *= 6;
         if (sum < s) return false;
         if (sum - s == 1) {
             return one >= 1;
         }
         return true;
     }
 }

23、【牛牛取快递】

　　牛牛的快递到了，他迫不及待地想去取快递，但是天气太热了，以至于牛牛不想在烈日下多走一步。他找来了你，请你帮他规划一下，他最少要走多 少距离才能取回快递。

输入描述：

 public class Main3 {

     public static class Item {
         int index;
         int weight;

         public Item(int index, int weight) {
             this.index = index;
             this.weight = weight;
         }
     }

     public static void main(String[] args) {
         Scanner sc = new Scanner(System.in);
         while (sc.hasNext()) {
             int len = sc.nextInt();
             int times = sc.nextInt();
             int start = sc.nextInt();
             int end = sc.nextInt();
             List<List<Item>> lists = new ArrayList<List<Item>>();
             for (int i = 0; i <= len; i++) {
                 lists.add(new ArrayList<Item>());
             }
             for (int i = 0; i < times; i++) {
                 int s = sc.nextInt();
                 int e = sc.nextInt();
                 int v = sc.nextInt();
                 lists.get(s).add(new Item(e, v));
             }
             int res = helper(lists, len, start, end) + helper(lists, len, end, start);
             System.out.println(res);
         }
         sc.close();
     }

     public static int helper(List<List<Item>> lists, int len, int start, int end) {
         boolean[] visited = new boolean[len + 1];
         int[] dis = new int[len + 1];
         Arrays.fill(dis, Integer.MAX_VALUE);
         dis[start] = 0;
         PriorityQueue<Item> queue = new PriorityQueue<>(new Comparator<Item>() {
             public int compare(Item o1, Item o2) {
                 return o1.weight - o2.weight;
             }

         });
         queue.offer(new Item(start, 0));
         while (!queue.isEmpty()) {
             Item item = queue.poll();
             int index = item.index;
             if (visited[index]) {
                 continue;
             }
             visited[index] = true;
             List<Item> list = lists.get(index);
             for (int j = 0; j < list.size(); j++) {
                 Item temp = list.get(j);
                 if (!visited[temp.index] && dis[index] + temp.weight < dis[temp.index]) {
                     dis[temp.index] = dis[index] + temp.weight;
                     queue.offer(new Item(temp.index, dis[index] + temp.weight));
                 }
             }
         }
         return dis[end];
     }
 }