java笔试题

最新推荐文章于 2024-04-23 15:07:47 发布

hsw815773943

最新推荐文章于 2024-04-23 15:07:47 发布

阅读量2.5k

点赞数

文章标签： java 开发语言

本文链接：https://blog.csdn.net/hsw815773943/article/details/131629872

版权

1，下列说法正确的是（C）

A.一个文件里可以同时存在两个public修饰的类

B.构造函数可以被重写（override）

C.子类不能访问父类非public和protected修饰的属性

D.final修饰的类可以被继承

重写方法只能存在于具有继承关系中，重写方法只能重写父类非私有的方法。

2.下列for循环语句的执行次数是 for(intx=0，y=0；(y!=0) ＆＆ x<4)；x++ (D)

A.无限次

B.执行4次

C.执行3次

D.一次也不执行

Java堆的结构：**JVM的堆是运行时数据区，所有类的实例和数组都是在堆上分配内存。**它在JVM启动的时候被创建。对象所占的堆内存是由自动内存管理系统也就是垃圾收集器回收。堆内存是由存活和死亡的对象组成的。存活的对象是应用可以访问的，不会被垃圾回收。死亡的对象是应用不可访问尚且还没有被垃圾收集器回收掉的对象。一直到垃圾收集器把这些对象回收掉之前，他们会一直占据堆内存空间。

3，下列说法错误的是___

A.所有类的实例和数组都是在堆上分配内存的

B.对象所占的堆内存是由自动内存管理系统回收

C.堆内存由存活和死亡的对象，空闲碎片区组成

D.数组是分配在栈中的

答案：D

A.在子类构造方法中使用super（）显示调用父类的构造方法；super（）必须写在子类构造方法的第一行，否则编译不通过

B.super（）和this（）不一定要放在构造方法内第一行

C.this（）和super（）可以同时出现在一个构造函数中

D.this（）和super（）可以在static环境中使用，包括static方法和static语句块

Java关键字this只能用于方法方法体内。当一个对象创建后，Java虚拟机（JVM）就会给这个对象分配一个引用自身的指针，这个指针的名字就是this。因此，this只能在类中的非静态方法中使用，静态方法和静态的代码块中绝对不能出现this。

super关键和this作用类似，是被屏蔽的成员变量或者成员方法或变为可见，或者说用来引用被屏蔽的成员变量和成员成员方法。

不过super是用在子类中，目的是访问直接父类中被屏蔽的成员，注意是直接父类（就是类之上最近的超类）

————————————————

5，下列语句哪一个正确（B）

A．Java程序经编译后会产生machine code

B．Java程序经编译后会产生byte code

C．Java程序经编译后会产生DLL

D．以上都不正确

答案：B

Java字节码是Java源文件编译产生的中间文件

java虚拟机是可运行java字节码的假想计算机 java的跨平台性也是相对与其他编程语言而言的。

先介绍一下c语言的编译过程：c的文件经过C编译程序编译后生成windows可执行文件exe文件然后在windows中执行。

再介绍java的编译过程：java的文件由java编译程序将java字节码文件就是class文件在java虚拟机中执行。机器码是由CPU来执行的；Java编译后是字节码。

电脑只能运行机器码。Java在运行的时候把字节码变成机器码。C/C++在编译的时候直接编译成机器码
————————————————
6，下列哪一种叙述是正确的（）

A．abstract修饰符可修饰字段、方法和类

B．抽象方法的body部分必须用一对大括号{ }包住

C．声明抽象方法，大括号可有可无

D．声明抽象方法不可写出大括号

答案：D

abstract修饰符用来修饰类和成员方法，不能修饰字段

用abstract修饰的类表示抽象类，抽象类位于继承树的抽象层，抽象类不能被实例化。

用abstract修饰的方法表示抽象方法,抽象方法没有方法体。抽象方法用来描述系统具有什么功能，但不提供具体的实现。

Abstract是Java中的一个重要关键字，可以用来修饰一个类或者一个方法。

修饰一个方法时，表示该方法只有特征签名（signature），没有具体实现，而是把具体实现留给继承该类的子类，所以不能有大括号。
————————————————

7，下列说法正确的有（C）

A．class中的constructor不可省略

B．constructor必须与class同名，但方法不能与class同名

C．constructor在一个对象被new时执行

D．一个class只能定义一个constructor

答案：C

这里可能会有误区，其实普通的类方法是可以和类名同名的，和构造方法唯一的区分就是，构造方法没有返回值。
————————————————

8，GC线程是否为守护线程（）

答案：是

线程分为守护线程和非守护线程（即用户线程）。

只要当前JVM实例中尚存在任何一个非守护线程没有结束，守护线程就全部工作；只有当最后一个非守护线程结束时，守护线程随着JVM一同结束工作。

守护线程最典型的应用就是 GC (垃圾回收器)
————————————————
9、有个特殊的餐厅，对客人的要求是如果要离开餐厅一定要看下餐厅内有没有比你迟进来的人，一定要所有比你迟进来的人离开后你才能离开，有一天甲，乙，丙，丁四个客人先后进入了这家餐厅，那么他们离开的顺序不可能是

A：丙，乙，甲，丁
B：甲，乙，丙，丁
C：乙，甲，丙，丁
D：乙，丙，甲，丁
E：丁，丙，甲，乙
F：丁，丙，乙，甲

解析：本题考查的是元素入栈出栈的顺序问题。但要小心一个思维误区：并不是要等到甲、乙、丙、丁全部按序进入餐厅后才开始有人离开。答案：E。

10、在关系型数据库中，有两个不同的事务同时操作数据库中同一表的同一行，不会引起冲突的是：

   A：其中一个DELETE操作，一个是SELECT操作
   B：其中两个都是UPDATE
   C：其中一个是SELECT，一个是UPDATE
   D：其中一个是DELETE，另一个是UPDATE
   E：两个都是DELETE

当要删除的记录在数据库中不存在的时候，是不会报错的。答案：E。
————————————————

11、设一组初始关键字为（ 12，15，1，18，2，35，30，11 ），则以 12 为基准记录的一趟快速排序结束后的结果为：

   A：11，1，2，12，35，18，30，15
   B：11，2，1，12，15，18，35，30
   C：1，2，11，12，15，18，35，30
   D：11，2，1，12，18，35，30，15
   E：1，2，11，12，15，18，30，35

快速排序里的挖坑填补法：以12为标准值，从右开始找比12小的值，首先是11，把11放在12的位置，把12放在11的位置，再从左找比12大的值15，把15放在12的新位置（原11的位置）之后变成 11，12，1，18，2，35，30，15。
在新的一轮开始，从右开始找比12 小的数是2，把2放在12的位置，12放在2的位置，在从左找比12大的数18，
把18放在12的新位置上（原2的位置）变成11，2，1，12，18，35，30，15。答案：D。

————————————————

12、以下程序的运行结果是？

public class TestThread{
	public static void main(String args[]){
		Runnable runner = new Runnable(){
		@Override
		public void run(){
			System.out.print('foo');
		   }
		};
		Thread t = new Thread(runner);
		t.run();
		System.out.print("bar");
	}
}

A：foobar
B：barfoo
C：foobar或者barfoo都有可能
D：Bar
E：Foo
F：程序无法正常运行

这道题是考线程的调用情况，线程的启动方式只能通过start这种方式启动才能真正的实现多线程的效果，如果是手动调用run方法和普通方法调用没有区别，所以这个还是按照顺序执行首先执行run方法之后，执行输出语句所以最终得到结果foobar。答案：A。

13、一个二叉树有100个子节点数为2的节点，100个子节点数为1的节点，那么子节点数为0的节点（叶节点）的个数为：

A：101
B：100
C：200
D：300
E：99
F：1

度数(边数) = 所有节点数-1，这里度数=2*100+100=300，节点数=100+100+叶子节点数。所以叶子节点数=度数+1-非叶子节点数=101。答案：A。

14、现有1G数据需要排序，计算资源只有1G内存可用，下列排序方法中最可能出现性能问题的是。

A：堆排序
B：插入排序
C：归并排序
D：快速排序
E：选择排序
F：冒泡排序

7、某开发团队有6位开发同学，需参加5个项目，每个项目都有人做，每位同学需要恰好参加1个项目，那么总共有____ 种不同的分配方案。

   A：3600
   B：3600
   C：2700
   D：1800
   E：900
   F：30

C6 2 *A5 5，先对人分组，也就是6个人分5组，则必有1个组有两个人，其他组1人。然后每组对应一个项目。答案：D 。
————————————————

8、建立和关闭一个 tcp ，一共会产生的握手次数是（）

A：7 B：6 C：3 D：5

建立的三次握手加关闭的四次握手。答案：A。

9、学校图书馆共有 300 万册图书，想统计其中 Computer 、Science、计算机、科学这几个词出现的次数，并按照自然年度分类，如 2016 年出版的书籍中这几个词各自出现的次数， 2015 年……依次类推。

   将每本书都存在hdfs里作为一个文件，文件名为 时间（4位年份）+书的id+书的名称。使用mapreduce进行运算，map输出为<日期，computer次数；science次数；计算机次数；科学次数>，reduce输出同样，不过作为value的字符串中的次数为总次数。代码如下：

   public static class MyMapper extends Mapper<LongWritable，Text，Text，Text>{       
        
        private static Text outputKey = new Text();
        private static Text outputValue = new Text();
   
        @Override
        protected void map(LongWritable key， Text value， Context context)
                throws IOException， InterruptedException { 
        //得到hdfs文件名
        String filename = ((FileSplit) context.getInputSplit()).getPath().getName();
        String date = filename.substring(0， 4);
       
        //分别统计computer，science，计算机，科学出现的次数
        int computer = 0;
        int science = 0;
        int jisuanji = 0;
        int kexue = 0;
       
        String line = value.toString();
        String[] words = line.split(" ");
        for(String s：words){
        if(s.equals("computer")) computer++;
        if(s.equals("science")) science++;
        if(s.equals("计算机")) jisuanji++;
        if(s.equals("科学")) kexue++;
        }
       
        String outputVal = "" + computer + ";" + science + ";" + jisuanji + ";" + kexue;
        outputKey.set(date);
        outputValue.set(outputVal);
        context.write(outputKey， outputValue);
                             
        }
  }
    
    public static class MyReducer extends Reducer<Text， Text， Text， Text> {

    @Override
protected void reduce(Text key， Iterable<Text> values，Context context)
throws IOException， InterruptedException {
    int allComputer = 0;
    int allScience = 0;
    int allJisuanji = 0;
    int allKexue = 0;
   
    for(Text value：values){
    String val = value.toString();
    String[] str = val.split(";");
    allComputer += Integer.parseInt(str[0]);
    allScience += Integer.parseInt(str[1]);
    allJisuanji += Integer.parseInt(str[2]);
    allKexue += Integer.parseInt(str[3]);
    }
   
    String finalVal = "" + allComputer + ";" + allScience + ";" + allJisuanji + ";" + allKexue;
    context.write(key， new Text(finalVal));    
    } 
  }

10、以字符串的形式读入两个数字，编写一个函数计算它们的乘积，以字符串形式返回。（字符串长度不大于10000，保证字符串仅由’0’~'9’这10种字符组成）。

import java.util.*;

public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     * 
     * @param s string字符串 第一个整数
     * @param t string字符串 第二个整数
     * @return string字符串
     */
    public String solve (String s， String t) {
        int len1 = s.length();
        int len2 = t.length();
        
        int[] nums1 = new int[len1];
        int[] nums2 = new int[len2];
        
        for(int i = 0; i < len1; i++){
            nums1[i] = s.charAt(i) - '0';
        }
        for(int i = 0; i < len2; i++){
            nums2[i] = t.charAt(i) - '0';
        }
        
        int[] result = new int[len1 + len2];
        
        // 1. 逐位相乘
        for(int i = 0; i < len1; i++){
            for(int j = 0; j < len2; j++){
                result[i + j] += nums1[i] * nums2[j];
            }
        }
        
        // 2. 从后往前进位
        for(int k = result.length - 1; k > 0; k--){
            result[k - 1] += result[k] / 10;
            result[k] = result[k] % 10;
        }
        
        // 输出字符串
        StringBuilder stringBuilder = new StringBuilder();
        for(int i = 0; i < result.length - 1; i++){
            stringBuilder.append(result[i]);
        }
        return stringBuilder.toString();
    }
}

1.以下程序输出结果是____

class A{
  public:
    A ():m_iVal(0){test();}
    virtual void func() { std::cout<<m_iVal<<‘ ’;}
    void test(){func();}
  public:
      int m_iVal;
};
class B : public A
{
  public:
    B(){test();}
    virtual void func()
    {
      ++m_iVal;
      std::cout<<m_iVal<<‘ ’;
      }
};
int main(int argc ,char* argv[])
{
  A*p = new B;
  p->test();
  return 0;
}

1.App运行时发生OOM的原因你知道哪几种？如何避免？

1.资源对象没关闭造成的内存泄露
    1.使用流，未关闭
    2.Bitmap使用后未调用回收利用
    3.Cursor游标
2.作用域不一样，导致对象不能被垃圾回收器回收
3.内存压力过大

如何避免内存泄露：
1.使用缓存技术，比如LruCache、DiskLruCache、对象重复并且频繁调用可以考虑对象池
2.对于引用生命周期不一样的对象，可以用软引用或弱引用SoftReferner WeakReferner
3.对于资源对象使用finally 强制关闭
4.内存压力过大就要统一的管理内存

3.写段代码，定义一个字符串常量，字符串中只有大小写字母和整数，输出字符串中的出现最多的数字的和？例如 ” 9fil3dj11P0jAsf11j ” 中出现最多的是11两次，输出22.

    public static void main(String[] args) {
        String s = "9fil3dj11P0jAsf11j";
        int maxCount = 0;
        int maxVal = 0;
        String[] strs = s.split("[^0-9]");
        String[] split = s.split("[a-zA-z]");
        System.out.println(split);
        HashMap<Integer,Integer> map = new HashMap<Integer,Integer>();
        for(int i = 0; i < strs.length; i++) {
            if(!"".equals(strs[i])) {
                int key = Integer.valueOf(strs[i]);
                if(map.containsKey(key)) {
                    map.put(key, map.get(key) + 1);
                } else {
                    map.put(key, 1);
                }
                if(maxCount < map.get(key)) {
                    maxCount = map.get(key);
                    maxVal = key;
                }
            }
        }
        Integer a = maxVal * maxCount;
        System.out.println(a);
    }

2.在Android客户端上，用java实现一个线程池（可以使用java的数据结构），需要满足可以往前或者往后插入task，可配置最大同时执行的线程数，并对线程池中当前同一个类型的连续task进行合并执行（假设同一类型的task可以合并成一次执行）

队列可以从头部或者尾部插入数据

\1. 可以往前或者往后插入task：使用LinkedBlockingQueue阻塞队列，该阻塞队列结构为双向链表，满足前后插入task

\2. 配置最大同时执行的线程数：提供一对外设置的方法即可。

5.以下关于子查询和Group By的描述正确的有( A B C D )

A.没有出现在Group By子句后面的列名不能出现在Select字句非合计函数表达式中

B.在Select子句的后面，只能有两种类型的表达式，一种是合计函数，一种是出现在Group By子句后面的列名

C.不能在子查询中包含Order By 子句

D.如果子查询的结果为空，那么外查询条件始终不会成立

解析：group by：在select子句中只能有两种类型表达式，一种是合计函数，一种是出现在group by子句后面的列名，没有出现在group by子句后面的列名不可以出现在select 子句的非合计函数表达式中。如果在select语句中没有出现group by子句，则不能在select子句中同时出现单个列名和合计函数的混合现象。如果要限制分组中的数据，则可以使用having子句而不能使用where子句
————————————————

6.以下选项属于进程间通信的是（ ABD ）

A.管道

B.套接字

C.内存

D.消息队列

解析：进程中的几种通信方式：

1）管道：管道是一种半双工的通信方式，数据只能单向流动。而且只能在具有血缘关系（父子进程之间）的的进程间使用。

2）信号量：信号量是一个计数器，可以用来控制多个进程对共享资源的访问

3）消息队列：消息队列是由消息组成的链表，存放在内核中，并由消息队列标识符标识

4）信号：信号是有一种比较复杂的通信方式，用于通知接收进程某一事件已经发生

5）共享内存：共享内存就是映射一段能被其他进程所访问的内存，这段共享内存由一个进程创建，但多个进程都可以访问

6）套接字：即Socket，是一种通信机制，凭借这种机制，客户/服务器系统的开发工作既可以在本地单机上进行，也可以跨网络进行
————————————————

9.下列说法错误的有（ ACD ）

A．在类方法中可用this来调用本类的类方法

B．在类方法中调用本类的类方法时可直接调用

C．在类方法中只能调用本类中的类方法

D．在类方法中绝对不能调用实例方法

解答：ACD 类方法就是静态方法

A.在类方法中不能使用this关键字

C．在类方法中可以调用其它类中的类方法

D．在类方法中可以通过实例化对象调用实例方法
————————————————

10.下面能让线程停止执行的有（多选）( ABDEF )

A. sleep();

B. stop();

C. notify();

D. synchronized();

E. yield();

F. wait();

G. notifyAll();

解答：ABDEF

sleep：导致此线程暂停执行指定时间

stop: 这个方法将终止所有未结束的方法，包括run方法。

synchronized():对象锁

yield：当前正在被服务的线程可能觉得cpu的服务质量不够好，于是提前退出，这就是yield。

wait：当前正在被服务的线程需要睡一会，醒来后继续被服务
————————————————

填空题（每题2分，共20分）
1 Java语言的各种数据类型之间提供两种转换，自动转换和强制转换
2 Java 中使用关键字定义抽象类 abstract
3 java方法中参数传递的原则有2种，一种是按值传递，另一种是按引用传递
4 用static修饰的方法，称为静态方法。它们不是对象的方法，而是整个类的方法。静态方法只能处理用关键字 static 修饰的数据。

5 在Java中有一种叫作构造函数特殊方法，我们在程序中用它来对类的对象成员进行初始化。
6 被关键字___final___修饰的方法是不能被当前类的子类重新定义的方法
7 Java程序中整数常量默认是 int 类型，浮点数默认的是 double 类型
8 main方法的声明格式 public static void main(String[] args)
9 Java中所有类都是 java.lang.object 的子类。
10 定义接口的关键字是 interface
————————————————

*3.Activiti和Shiro的作用*

*Shiro：*

用户认证登录拦截器

资源授权资源表示系统中所有的可访问的菜单

*Activiti：*

解决多个任务人共同完成复杂的业务流。他是一个业务框架

4.TCP和UDP协议的区别，什么是三次握手。

1.基于连接与无连接；
2.对系统资源的要求（TCP较多，UDP少）；
3.UDP程序结构较简单；
4.流模式与数据报模式；
5.TCP保证数据正确性，UDP可能丢包，TCP保证数据顺序，UDP不保证。

所谓的“三次握手”：为了对每次发送的数据量进行跟踪与协商，确保数据段的发送和接收同步，根据所接收到的数据量而确认数据发送、接收完毕后何时撤消联系，并建立虚连接。

为了提供可靠的传送，TCP在发送新的数据之前，以特定的顺序将数据包的序号，并需要这些包传送给目标机之后的确认消息。TCP总是用来发送大批量的数据。当应用程序在收到数据后要做出确认时也要用到TCP。

5.多线程同步有几种方法。

多线程的实现方法有继承Thread类，实现Runnable接口，实现Callable接口。

同步可以使用Synchronized关键字，也可以使用可重入锁ReentrantLock，ThreadLocal同步机制也可以实现同步。

6.RPC服务和restful服务的区别（建议加深对rpc和restful的了解）

1、从本质区别上看，RPC是基于TCP实现的，RESTFUL是基于HTTP来实现的。

2、从传输速度上来看，因为HTTP封装的数据量更多所以数据传输量更大，所以RPC的传输速度是比RESTFUL更快的。

3、因为HTTP协议是各个框架都普遍支持的。在toC情况下，因为不知道情况来源的框架、数据形势是什么样的，所以在网关可以使用Restful利用http来接收。而在微服务内部的各模块之间因为各协议方案是公司内部自己定的，所以知道各种数据方式，可以使用TCP传输以使各模块之间的数据传输更快。所以可以网关和外界的数据传输使用RESTFUL，微服务内部的各模块之间使用RPC。

4、RESTFUL的API的设计上是面向资源的，对于同一资源的获取、传输、修改可以使用GET、POST、PUT来对同一个URL进行区别，而RPC通常把动词直接体现在URL上
————————————————
7.输入某年某月某日，判断这一天是这一年的第几天？

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-H1Qbovda-1688919916689)(D:\1study\1study notes\学习笔记及工作文档\mybatis\image-20230702013733003.png)]$

1. 请以任何语言实现1+2+3+…+100

    public static Integer getSum(){
        Integer sum= 0;
        for (int i = 1; i <=100 ;i++) {
            sum += i;
        }
        return sum;
    }

用java求出1-100内所有的质数/素数

    public void getPrimeNum(){
        int count = 0;      // 换行计数用
        for(int n = 2; n <= 100; n++){
            boolean flag = true;    //flag为true时，该数为质数
            for(int i = 2; i < n; i++){
                if(n % i == 0){
                    flag = false;   // 能被 i 整除后flag变为false ，该数不是质数
                    break;  // 提高代码效率
                }
            }
            if(flag){           // 当flag还为true时，打印出n的值
                System.out.print(n + "\t");
                if(++count % 5 == 0){       // 输出数据5个换行
                    System.out.println();
                }
            }
        }
    }

6。问：门外三个开关分别对应室内三盏灯，线路良好，在门外控制开关时候不能看到室内灯的情况，现在只允许进门一次，确定开关和灯的对应关系？

解答：首先在门外开开两个灯，等待5分钟后关掉其中一个。进屋后亮着的灯对应开着的开关，灭着但摸着有些温度的灯对应刚刚关掉的那个开关。

单例模式

package thread.example;
//饿汉模式
public class HungrySingle {
//在类加载的时候就实例化了，类加载只有一次，所以值实例化出了一份该实例对象
    private static HungrySingle instance = new HungrySingle();
    public static HungrySingle getInstance() {
        return instance;
    }
}

//单线程的懒汉模式
public class LazySingle {
    private static LazySingle instance = null;
    //只有在调用该方法的时候才实例化
    public static LazySingle getInstance() {
        if(instance == null) {
            instance = new LazySingle();
        }
        return instance;
    }
}
static class Singleton {
    private static Singleton instance = null;
 
    public static Singleton getInstance1() {
        if(instance == null){
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }

hsw815773943

关注

0
点赞
踩
10

收藏

觉得还不错? 一键收藏
1
评论
java笔试题

不能修饰字段用abstract修饰的类表示抽象类，抽象类位于继承树的抽象层，抽象类不能被实例化。用abstract修饰的方法表示抽象方法,抽象方法没有方法体。抽象方法用来描述系统具有什么功能，但不提供具体的实现。Abstract是Java中的一个重要关键字，可以用来修饰一个类或者一个方法。修饰一个方法时，表示该方法只有特征签名（signature），没有具体实现，而是把具体实现留给继承该类的子类，所以不能有大括号。
复制链接

扫一扫