2021-07-09

原创于 2021-07-09 16:04:01 发布 · 1.1k 阅读

6 ·

CC 4.0 BY-SA版权

文章标签：

#java

DaHua笔试

一、选择题
二、编程题

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档
面试

文章目录

一、选择题
二、编程题

一、选择题

关于JVM的类加载过程,下面哪个描述是正确的(B)
A.加载—>准备—>解析—>初始化一>验证—>使用一>卸载
B.加载一>验证一>准备一>解析一>使用一>卸载
C.加载一>验证一>解析一>准备一>初始化一>使用一>卸载
D.加载一>初始化一>验证一>准备一>解析一>使用一>卸载

以下java程序代码,执行后的结果是(D)

 class A{
 static{
 System.out.print("a");
 }
 public A(){
 System.out.print("b");
}
 class B extends A{
 static{
 System.out.print("c");
 }
 public B(){
 System.out.print(d");
 }
 }
 public class Dahua{
 public static void main(Stringl args)(
A b = new B():
b=new B();
}
}

A.abcdabcd
B.abcdbd
C.acbdd
D.acbdbd

以下创建了几个对象(B)

	String A,B,C
	A=a";
	B="b":
	A=A+B;
	Stringbuffer D=new Stringbuffer(abc");
   D=D.append(567");

A.6
B.4
C.3
D.5

以下哪些叙述是正确的(AD)
A.String类不可以有子类
B.abstract类只可以有abstract方法
C.abstract类可以有非abstract方法
D.不可以同时用final和abstract修饰同一个方法
E.允许使用static修饰abstrac方法
以下的方法在抽象类中正确的是(D)
A.private final void sleep(){}
B.private abstract void eat();
C.public final abstract void play();
D.protected void work();

下面的程序输出的结果是（B）

class Test{
 String str = new String("dahua");
 char[] ch = {'a',b','c'};
 public static void main(String args[]){
 Test ex = new Test();
 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 success";
 ch[0] = 'g';
 }
 }

A.dahua and abc
B.dahua and gbc
C.test success and abc
D.test success and gbc

下面哪个不是Map接口的实现类(C)
A.HashMap
B.Hashtable
C.HashSet
D.LinkedHashMap
.在 Servletis过滤器的生命周期方法中,每当传递请求或响应时,web容器会调用(C)方法
A.init
B.service
C.doFilter
D.destroy
java集合类里面最基本的接口描述错误的是(D)
A.Collection:代表一组对象,每一个对象都是它的子元素
B.Set不包含重复元素的collection
C.List:有顺序的 collection并且可以包含重复元素
D.Map:可以把(key)映射到值value)的对象,键值不能重复
如下的Java程序
```
public class Test{
	public static void main(String[] args){
	System.out.printin(args[0]);
```
若采用命令行"java Test one two three"调用,则程序输出的结果为:(B)
A.Test
B.one
C.two
D.java
要创建一个新目录,可以用下面(D)类实现
A.Filelnputstream
B.Fileoutputstream
C.Randomaccessfile
D.File
在操作系统中,Wait(s)和Signal(s)操作是一种（D）
A.机器指令
B.作业控制命
C.系统调用命
D.低级进程通信原语
下列哪些语句关于内存回收的说明是正确的（B）
A.程序员必须创建一个线程来释放内存
B.内存回收程序负责释放无用内存
C.内存回收程序允许程序员直接释放内存
D.内存回收程序可以在指定的时间释放内存对象
编译运行以下程序后,关于输出结果的说明正确的是(C):

public class Conditional{
	 public static void main(String args[]){
	 int x=4;
	 System.out.printin( "value is "+((x>4)?99.: 9));
	 }
	 }

	A.输出结果为: value is99.99
	B.输出结果为: value is9
	C.输出结果为: value is9.0
	D.错误

下列说法正确的有（C）
A.class中的constructor不可省略
B.constructor必须与class同名,但方法不能与 class同名
C.constructor在一个对象被new时执行
D.一个class只能定义一个constructor
从下列选项中选择正确的Java表达式(B)
A.int k = new String(“test”);
B.String str= new String(“test”);
C.char c=74;
D.long j = 123;
下面的说法正确的是（A）
A.Java中IO流的处理通常分为输入和输出两个部分
B.Readerwriter与类是用来处理字符流,也就是纯文本文件
C.file类是输入输出流类的子类
D.Inputstreamoutputstream与类通常是用来处理字节流,也就是二进制文件
以下选项中关于 HashMap和Hashtable和描述正确的是（ABC）
A.两者都实现了Map接口
B.Hashtable是线程安全的, Hashmap不是线程安全的
C.Hashmapt提供了可供应用选代的键的集台
D.Hashmap不许建和值是null, Hashtable许键或者值为null
下面关于 HashMap和Hashtable的区别,说法正确的是(CD)
A.Hashtable线程不安全,效率高
B.Hashmap线程安全效率低
C.Hashmap许nul和值
D.Hashtable不许null健和值
下面的哪些声明是错误的?（ACD）
int i= 4L
double d = 34.4
float f = 1.1
long a = 1384865444229
有关线程的叙述(B)是对的
A.一旦一个线程被创建,它就立即开始运行
B.使用 start()方法可以使一个线程成为可运行的,但是它不一定立即开始运行
C.如果复用个线程,可以调用再次调用star方法,使已经结束的线程复活
D.join方法可使当前线程阻塞,直到thread线程运行结束
关于索引(idex)的说法哪些是正确的?(BCD)
A.创建索引能提高数据插入的性能
B.索引应该根据具体的检索需求来创建,在选择性好的列上创建索引
C.索引并非越多越好
D.建立索引可使检索操作更迅速
E.索引创建过程中不影响表的增删改操作
关于lterator,正确的有(BC)
A.Iterator可以双向遍历
B.Iterater可以用来遍历Set和List集合
C.Iterater可以用来遍历Map
D.用 lterater遍历Set和List遍历时,如果删除元素,会改变元素顺序
不能用来修饰interface的有（ACD）
A.private
B.public
C.protected
D.static
Java中的集合类包括 Arraylist、Linkedlist、HashMap等类，下列关于集合类描述正确的是（ABD）
A.Arraylist和Linkedlist均实现了List接口
B.Arraylist的查询速度比Linkedlist快
C.添加和删除元素时, Arraylist的表现更佳
D.HashMap实现Map接口,它允许任何类型的键和值对象,并允许将nul作键或值
以下哪些属于java线程的状态（ACDE）
A.新建
B.结束
C.阻塞
D.运行
E.就绪
关于 ThreadLocal的说法错误的是(AB)
A.ThreadLocal能够实现多线程间的数据共享
B.ThreadLocal实现了Runnable接口
C.ThreadLocal为每一个线程提供某个变量的副本
D.ThreadLocal保证各个线程的数据不会被另外线程访问和破坏,进而实现线程安全
关于数组错误的是(BCDE)
A.数组是一种对象
B.数组属于一种原生类
C.数组有 length方法
D.数组的大小可以任意改变
E.数组下标长度没有限制
List集合的遍历方式有如下哪几种（ABC）
A.Iterator代器实现
B.增强for循环实现
C.get()和size()方法结合实现
D.get()和 length()方法结合实现
HashSet去重复,在 HashSet内部需要调用Object的哪些方法(AD)
A.hashcode方法
B.tostring方法
C.clone方法
D.equals方法

二、编程题

1.题目：假如有Thread1、Thread2、Thread3、Thread4四条线程分别统计C、D、E、F四个盘的大小，所有线程都统计完毕交给Thread5线程去做汇总，应当如何实现？

DiskMemory类如下:

public class DiskMemory {

	// 记录磁盘的总大小
	private int totalSize;
	
	// 获取一个磁盘的大小，采用随机数生成
	public int getSize() {
    	//加一是为了防止获取磁盘大小为0，不符合常理
    	return (new Random().nextInt(3) + 1) * 100;
	}
	
	//统计磁盘空间的大小
	public synchronized void setSize(int size) {
    	totalSize += size;
	}
}

根据给出的代码，补全剩余代码，实现该功能。

参考答案：

import java.util.*;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * @Author: iqqcode
 * @Date: 2020-10-01 23:09
 * @Description: 有4个线程分别获取C、D、E、F盘的大小, 第5个线程统计总大小
 */
 
public class DiskMemory {
    // 记录磁盘的总大小
    private int totalSize;

    // 获取一个磁盘的大小，采用随机数生成
    public int getSize() {
        //加一是为了防止获取磁盘大小为0，不符合常理
        return (new Random().nextInt(3) + 1) * 100;
    }

    //统计磁盘空间的大小
    public synchronized void setSize(int size) {
        totalSize += size;
    }

    // 获得总磁盘空间的大小
    public int getTotalSize() {
        return totalSize;
    }

    public static void main(String[] args) throws InterruptedException {
        // 创建线程池，初始化大小为 4
        ExecutorService service = Executors.newFixedThreadPool(4);
        CountDownLatch countDownLatch = new CountDownLatch(4);
        DiskMemory diskMemory = new DiskMemory();
        for (int i = 0; i < 4; i++) {
            service.execute(() -> {
                int timer = new Random().nextInt(5);
                try {
                    Thread.sleep(timer * 1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                int diskSize = diskMemory.getSize();
                System.out.printf("完成磁盘的统计任务,耗费%d秒. 磁盘大小为%d.\n", timer, diskSize);
                diskMemory.setSize(diskSize);

                // 任务完成，计数器减一
                countDownLatch.countDown();
                System.out.println("count num = " + countDownLatch.getCount());
            });
        }
        // 主线程一直被阻塞,直到count的计数器被置为0
        countDownLatch.await();
        System.out.printf("全部磁盘都统计完成,所有磁盘总大小为 " + ", 【 totalSize = " + diskMemory.getTotalSize() + " 】");
        service.shutdown();
    }
}

转载：可参考此链接：代码具体实现过程

2.题目:beginAdress是开始抓拍的路口编码。endAdress是结束抓拍的路口编码，shootCars是所有抓拍路口抓拍车辆信息（每个车辆在每个路口仅被抓拍一次）；求路段平均旅行时间，结果保留两位小数

//车辆抓拍信息
class shootCar{
    //抓拍路口编码
    private int adrId;
    //车牌号
    private String carNum;
    //抓拍时间
    private Date shootTime;
}
public class ShootCarService{
    public float getAvgTravel(int beginAdress, int endAdress, List<shootCar> shootCars){
        //请补充完成具体的业务代码
    }
}

参考答案：

import java.util.Date;
import java.util.Objects;

//车辆抓拍信息
public class shootCar {
    private  int adrld;
    private  String scarNum;
    //private Date shootTime;
    private int shootTime;

    public shootCar() {
    }

    public shootCar(int adrld, String scarNum, int shootTime) {
        this.adrld = adrld;
        this.scarNum = scarNum;
        this.shootTime = shootTime;
    }

    public int getAdrld() {
        return adrld;
    }

    public void setAdrld(int adrld) {
        this.adrld = adrld;
    }

    public String getScarNum() {
        return scarNum;
    }

    public void setScarNum(String scarNum) {
        this.scarNum = scarNum;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        shootCar shootCar = (shootCar) o;
        return adrld == shootCar.adrld &&
                shootTime == shootCar.shootTime &&
                Objects.equals(scarNum, shootCar.scarNum);
    }

    @Override
    public int hashCode() {
        return Objects.hash(adrld, scarNum, shootTime);
    }
    //    public Date getShootTime() {
//        return shootTime;
//    }
//
//    public void setShootTime(Date shootTime) {
//        this.shootTime = shootTime;
//    }

    public int getShootTime() {
        return shootTime;
    }

    public void setShootTime(int shootTime) {
        this.shootTime = shootTime;
    }
}

import javax.swing.text.html.HTMLDocument;
import java.util.ArrayList;
import java.util.Date;
import java.util.Iterator;
import java.util.List;

public class ShootCarService {
    public float getAvgTravel(int beginAdress, int endAdress, List <shootCar> shootCars){
        Iterator it=shootCars.iterator();
        List beginCars=new ArrayList();
        List endCars=new ArrayList();
        while(it.hasNext()){
            shootCar car=new shootCar();
            car= (shootCar) it.next();


            if(car.getAdrld()==beginAdress){
                beginCars.add(car);
            }
            if(car.getAdrld()==endAdress){
                endCars.add(car);
            }

        }
        System.out.println(beginCars.size());
        System.out.println(endCars.size());
        Iterator it2=beginCars.iterator();
        shootCar car2=new shootCar();
        shootCar car3=new shootCar();
        long sum=0;
        int num=0;
        float avgTime;
        while (it2.hasNext()){
            car2= (shootCar) it2.next();
            Iterator it3=endCars.iterator();

            while (it3.hasNext()){
                car3= (shootCar) it3.next();
                if((car3.getScarNum()).equals(car2.getScarNum()) ){
                    //sum=(car2.getShootTime()).getTime()-(car3.getShootTime()).getTime();
                    sum+=(car3.getShootTime())-(car2.getShootTime());
                    num++;
                }
        }
        }
        avgTime=(float) sum/ num;
        System.out.println(sum);
        System.out.println(num);
        return  avgTime;
    }
}

import java.util.ArrayList;
import java.util.List;

public class Text {
    public static void main(String[] args) {
        int beginAdress=4;
        int endAdress=6;

        shootCar car1=new shootCar(4,"101",1);
        shootCar car2=new shootCar(6,"101",9);
        shootCar car3=new shootCar(4,"102",2);
        shootCar car4=new shootCar(6,"102",7);
        List cars=new ArrayList();
        cars.add(car1);
        cars.add(car2);
        cars.add(car3);
        cars.add(car4);
        ShootCarService carService=new ShootCarService();
        System.out.println(carService.getAvgTravel(beginAdress,endAdress,cars));
    }
}

3.题目：教室里有一堆香蕉，五个小朋友来分。第一个小朋友把这堆香蕉平均分为五份，多了一个，这个小朋友把多的一个吃掉了，再拿走了一份。第二个小朋友把剩下的香蕉又平均分成五份，又多了一个，他同样把多的一个吃掉了，再拿走了一份，第三、第四、第五个小朋友都是这样做的，问教室里原来最少有多少个香蕉? (使用递归方法实现）

参考答案
方案1：

public int banana(int index, int count) {
        // 5个猴子，个数num==0，返回即可
        if (index == 5) {
            return 1;
        }
        // 桃子总数count，第num个猴子吃掉一个，余下的肯定能被5均分，如果不能被5取余，肯定不满足条件，返回-1
        if ((count - 1) % 5 != 0) {
            return -1;
        }
        // 剩count个桃子，第num个猴子吃掉一个，均分成5份，自己拿走1份，剩下4份桌子上，供其他猴子来进行下一轮分桃子
        count = (count - 1) / 5 * 4;
        // 除5代表均分5份，*4代表，吃了一份，余下4分
        return banana(index + 1, count);
    }

    @Test
    public void test() {
        int num = 0;

        int total = 0;  // 桃子总数
        while (true) {
            // 桃子的数目肯定是5的倍数+1
            total = num * 5 + 1;
            // 返回1，即就是最终5个猴子的结果
            if (banana(0, total) == 1) {
                break;
            }
            // 最终每一份的桃子数目
            num += 1;
        }
        System.out.println(num);
        System.out.println(total);

    }