Java试题-选择题（2）

Java试题-选择题（2）

题目

1. 下列语句创建对象的总个数是: String s=“a”+“b”+"c”+“d”+"e”
   A.4
   B.2
   C.3
   D.1

2. 关于下面的程序段的说法正确的是（）？
   File file1=new File(“e:\xxx\yyy\zzz");file1.mkdir();
   A.如目录e:\xxx\yyy\不存在,程序会抛出FileNotFoundException
   B.其他说法都不对
   C.如目录 e:\xxx\yyy\不存在,程序正常运行,不会抛出异常
   D.如目录 e:\xxx\yyy\不存在,程序会在创建zzz目录前,目动创建e:\xxx\yyy\目录

3. 下列哪个选项是合法的标识符（） ？
   A：123
   B：_name
   C：class
   D：first

4. 对于构造方法，下列叙述正确的是（ ） ？
   A：构造方法的优先级一般比代码块低。
   B：构造方法的返回类型只能是void型。
   C：构造方法的主要作用是完成对类的对象的初始化工作。
   D：一般在创建新对象时，系统会自动调用构造方法。

5. java中重写方法应遵循规则的包括（） ？
   A：访问修饰符的限制一定要大于被重写方法的访问修饰符
   B：可以有不同的访问修饰符
   C：参数列表必须完全与被重写的方法相同
   D：必须具有不同的参数列表

6. 下面几个关于Java里queue的说法哪些是正确的（）？
   A：LinkedBlockingQueue是一个可选有界队列，不允许null值
   B：PriorityQueue，LinkedBlockingQueue都是线程不安全的
   C：PriorityQueue是一个无界队列，不允许null值，入队和出队的时间复杂度是O（log(n)）
   D：PriorityQueue，ConcurrentLinkedQueue都遵循FIFO原则

7. java中 String str = "hello world"下列语句错误的是？
   A：str+=’ a’
   B：int strlen = str.length
   C：str=100
   D：str=str+100

8. 下列哪些操作会使线程释放锁资源 ？
   A：sleep()
   B：wait()
   C：join()
   D：yield()

9. 如果一个方法或变量是"private"访问级别，那么它的访问范围是 ？
   A：在当前类，或者子类中
   B：在当前类或者它的父类中
   C：在当前类，或者它所有的父类中
   D：在当前类中

10. ArrayList和LinkList的描述，下面说法错误的是 ？
    A：LinkedeList和ArrayList都实现了List接口
    B：ArrayList是可改变大小的数组，而LinkedList是双向链接串列
    C：LinkedList不支持高效的随机元素访问
    D：在LinkedList的中间插入或删除一个元素意味着这个列表中剩余的元素都会被移动；而在ArrayList的中间插入或删除一个元素的开销是固定的

11. 请问最后打印出来的是什么？（） ？
    A：2
    B：3
    C：4
    D：5

public class Test{private static int i=1;public int getNext(){return i++;}public static void main(String [] args){Test test=new Test();Test testObject=new Test();test.getNext();testObject.getNext();System.out.println(testObject.getNext());}
}

12. 下面Java代码下面结果输出是 ？
    A：The output is “Equal”
    B：The output in “Not Equal”
    C：An error at line 5 causes compilation to fall.
    D：The program executes but does not print a message.

public class IfTest{public static void main(String[]args){int x=3;int y=1;if(x=y)System.out.println("Not equal");elseSystem.out.println("Equal");}
}

13. 假设num已经被创建为一个ArrayList对象，并且最初包含以下整数值：[0，0，4，2，5，0，3，0]。 执行下面的方法numQuest()，数组num会变成？
    A：[3, 5, 2, 4, 0, 0, 0, 0]
    B：[0, 0, 0, 0, 4, 2, 5, 3]
    C：[0, 0, 4, 2, 5, 0, 3, 0]
    D：[0, 4, 2, 5, 3]

private List<Integer> nums;//precondition: nums.size() > 0
//nums contains Integer objects
public void numQuest() {int k = 0;Integer zero = new Integer(0);while (k < nums.size()) {if (nums.get(k).equals(zero))nums.remove(k);k++;}
}

14. 以下程序段的输出结果为： ？
    A：false，false
    B：false，true
    C：true，false
    D：true，true

public class EqualsMethod
{public static void main(String[] args){Integer n1 = new Integer(47);Integer n2 = new Integer(47);System.out.print(n1 == n2);System.out.print(",");System.out.println(n1 != n2);}
}

15. 若有下列定义，下列哪个表达式返回false ？
    A：s.equals(t);
    B：t.equals©;
    C：s==t;
    D：t.equals(new String(“hello”));

String s = "hello";
String t = "hello";
char c[] = {'h', 'e', 'l', 'l', 'o'} ;

16. J2EE中，当把来自客户机的HTTP请求委托给servlet时，会调用HttpServlet的（ ）方法 ？
    A：service
    B：doget
    C：dopost
    D：init

17. 下面这三条语句的输出结果分别是？ ( )
    A：is 1005, 1005 is, is 1005
    B：is 105, 105 is, is 105
    C：is 1005, 1005 is, is 105
    D：is 1005, 105 is, is 105

System.out.println(“is ”+ 100 + 5)；
System.out.println(100 + 5 +“ is”)；
System.out.println(“is ”+ (100 + 5))；

18. 下面哪个关键字可以用于Java的构造方法上 ？
    A：final
    B：static
    C：synchronized
    D：None of these.

19. 一个容器类数据结构，读写平均，使用锁机制保证线程安全。如果要综合提高该数据结构的访问性能，最好的办法是______ ？
    A：只对写操作加锁，不对读操作加锁
    B：读操作不加锁，采用copyOnWrite的方式实现写操作
    C：分区段加锁
    D：无法做到

20. 下列有关Servlet的生命周期，说法不正确的是？
    A：在创建自己的Servlet时候，应该在初始化方法init()方法中创建Servlet实例
    B：在Servlet生命周期的服务阶段，执行service()方法，根据用户请求的方法，执行相应的doGet()或是doPost()方法
    C：在销毁阶段，执行destroy()方法后会释放Servlet 占用的资源
    D：destroy()方法仅执行一次，即在服务器停止且卸载Servlet时执行该方法

答案与解析

1. D

对于语句 String s = “a” + “b” + “c” + “d” + “e”;，由于所有操作数均为编译时常量，Java 编译器在编译时会进行优化，直接将其转换为一个完整的字符串常量 “abcde”，因此只创建一个 String 对象。对象总个数为 1，对应选项 D。

2. C

选项A：如目录 e:\xxx\yyy\ 不存在, 程序会抛出 FileNotFoundException‌
该说法错误。FileNotFoundException 通常在尝试访问或打开文件时抛出（例如通过文件流操作），但 mkdir() 方法是创建目录的操作，它不会抛出此异常。即使父目录不存在，mkdir() 仅返回 false 表示失败，程序仍会正常执行而不中断。

选项C：如目录 e:\xxx\yyy\ 不存在, 程序正常运行, 不会抛出异常‌
该说法正确。mkdir() 方法仅尝试创建指定目录（此处为 zzz），如果父目录（如 e:\xxx\yyy\）不存在，该方法返回 false 但不会抛出任何异常，程序流程继续执行而不中断。这符合 Java 文件操作的设计：目录创建操作本身不触发异常，失败通过返回值处理。

选项D：如目录 e:\xxx\yyy\ 不存在, 程序会在创建 zzz 目录前, 自动创建 e:\xxx\yyy\ 目录‌
该说法错误。mkdir() 方法只创建单层目录（即 zzz），不会自动创建缺失的父目录（如 e:\xxx\yyy\）。如需递归创建所有缺失目录，应使用 mkdirs() 方法。

正确的说法是选项 ‌C‌。原因总结：
程序段使用 mkdir() 而非 mkdirs()，因此不会自动创建父目录。
mkdir() 在父目录缺失时返回 false 但不抛出异常，程序正常执行。
其他选项均与 Java 文件操作行为不符。

3. BD

在Java中，标识符的命名规则要求：不能以数字开头，不能使用关键字，可以由字母、数字、下划线（_）或美元符（$）组成。基于此规则分析选项：

A: 123‌：以数字开头，非法标识符。
B: _name‌：以下划线开头，其余为字母，符合规则，合法标识符。
C: class‌：是Java关键字，不能作为标识符，非法。
D: first‌：以字母开头且非关键字，符合规则。

4. ACD

A：构造方法的优先级一般比代码块低。‌
正确。在Java中，构造代码块（实例初始化块）的执行顺序优先于构造方法；例如，每次创建对象时，构造代码块先于构造方法执行，因此构造方法的优先级相对较低。

B：构造方法的返回类型只能是void型。‌
错误。构造方法没有返回类型，甚至不能声明为void，其方法名必须与类名完全相同。

C：构造方法的主要作用是完成对类的对象的初始化工作。‌
正确。构造方法的核心功能是在对象创建时初始化其状态，包括分配初始值及执行必要的设置逻辑。

D：一般在创建新对象时，系统会自动调用构造方法。‌
正确。当使用new关键字实例化对象时，Java虚拟机会自动调用相应的构造方法，无需显式调用。

5. BC

选项分析：
A：访问修饰符的限制一定要大于被重写方法的访问修饰符‌ — ‌错误‌。重写方法的访问修饰符不能比父类方法更严格（即不能缩小访问权限），但可以相同或更宽松（例如父类方法为protected，子类可重写为public或protected，但不能为private）。
B：可以有不同的访问修饰符‌ — ‌正确‌。只要访问修饰符不更严格（如父类为default，子类可为public或protected），即允许不同修饰符。
C：参数列表必须完全与被重写的方法相同‌ — ‌正确‌。重写方法的方法名、参数类型、顺序和数量必须与父类方法完全一致，否则不构成重写。
D：必须具有不同的参数列表‌ — ‌错误‌。参数列表必须相同，否则属于方法重载（overload），而非重写。
Java方法重写的主要规则总结：
方法签名相同‌：方法名和参数列表（类型、顺序、数量）必须完全一致。
访问修饰符限制‌：子类方法的访问权限不能比父类方法更严格（例如父类为public，子类不能为protected或更低）。
返回类型协变‌：子类方法的返回类型可以是父类方法返回类型的子类（Java 5+支持）。
异常限制‌：子类方法抛出的检查异常不能比父类方法抛出的异常更宽泛（可更具体或不抛出）。
其他约束‌：静态方法（static）、私有方法（private）和构造方法不能被重写。

6. AC

A：LinkedBlockingQueue是一个可选有界队列，不允许null值‌
正确‌。
LinkedBlockingQueue 的构造函数支持指定容量（有界），若不指定则默认容量为 Integer.MAX_VALUE（近似无界，但技术上可选有界）；同时，其实现明确禁止 null 值，因为 null 用于表示特殊状态（如队列空）。

B：PriorityQueue，LinkedBlockingQueue都是线程不安全的‌
错误‌。
PriorityQueue 是线程不安全的（未内置同步机制），但 LinkedBlockingQueue 是线程安全的（实现了 BlockingQueue 接口，使用锁保证并发操作）。因此，B 的表述不成立。

C：PriorityQueue是一个无界队列，不允许null值，入队和出队的时间复杂度是O(log(n))‌
正确‌。
PriorityQueue 默认无界（容量可动态增长），且不允许 null 值（会抛出 NullPointerException）；其底层基于堆实现，入队（offer）和出队（poll）操作的时间复杂度均为 O(log n)。

D：PriorityQueue，ConcurrentLinkedQueue都遵循FIFO原则‌
错误‌。
ConcurrentLinkedQueue 严格遵循 FIFO（先进先出）原则，但 PriorityQueue 根据元素优先级排序（自然顺序或比较器），不遵循 FIFO。

正确答案：A 和 C‌。

7. ABC

A：str+=’ a’‌
该语句错误，因为 ’ a’ 包含空格和字母 a，构成无效的字符字面量（char 类型只能表示单个字符），导致编译错误；字符串连接应使用双引号（如 " a"）表示字符串。
B：int strlen = str.length‌
该语句错误，因为 String 类使用 length() 方法（带括号）获取长度，而非属性 length；str.length 语法不正确，会导致编译错误。
C：str=100‌
该语句错误，Java 是强类型语言，不能直接将 int 值赋值给 String 变量；这会导致类型转换错误，需使用 String.valueOf(100) 或其他转换方式。

而 ‌D：str=str+100‌ 是正确的，因为 + 操作符会将 100 自动转换为字符串并拼接，结果变为 “hello world100”，无编译错误。

结论‌：错误的语句是 ‌A、B、C‌。

8. BC

B: wait()‌：调用此方法后，线程释放持有的锁并进入等待状态，需通过其他线程调用 notify() 或 notifyAll() 唤醒。
C: join()‌：此方法基于 wait() 实现，调用线程释放锁并阻塞，直到目标线程执行完毕。

以下操作不会释放锁资源：

A: sleep()‌：线程暂停执行指定时间，但不会释放任何锁。
D: yield()‌：线程主动让出CPU资源，但不会释放锁。

结论‌：‌B 和 C‌ 会使线程释放锁资源。

9. D

A：在当前类，或者子类中‌
错误。子类无法访问父类的private成员（例如，子类的方法不能直接使用父类的private变量或方法）。
B：在当前类或者它的父类中‌
错误。父类无法访问子类的private成员，且如果private成员在父类中定义，只能在父类内部访问（子类不可访问）。
C：在当前类，或者它所有的父类中‌
错误。父类（或祖先类）不能访问子类的private成员，且private成员仅局限于定义它的类。
D：在当前类中‌
正确。private成员仅在‌声明它的类内部‌可见和可访问。

10. D

D：在LinkedList的中间插入或删除一个元素意味着这个列表中剩余的元素都会被移动；而在ArrayList的中间插入或删除一个元素的开销是固定的‌
理由‌：
LinkedList基于双向链表实现，中间插入/删除只需修改相邻节点的指针（时间复杂度 ‌O(1)‌），‌不会移动其他元素‌。
ArrayList基于动态数组，中间插入/删除可能需移动后续元素（时间复杂度 ‌O(n)‌），‌开销随位置变化‌，并非固定。

11. B

关键代码逻辑：
private static int i=1;‌：
static 修饰符表明 i 是‌类级变量‌，被所有 Test 实例共享（非实例独立）。

return i++;‌
后置自增操作：先返回当前值，再自增（例如：调用时 i=1，返回 1 后 i 变为 2）。

执行过程：
调用顺序 操作 返回值 i 变化
test.getNext() 首次调用 1 1 → 2
testObject.getNext() 第二次调用（共享 i） 2 2 → 3
testObject.getNext() 第三次调用（共享 i） 3 3 → 4

最终输出结果为 ‌3‌（选项 ‌B‌）。

12. C

if(x = y) 是赋值操作，不是比较‌

在 Java 中，= 是赋值运算符，而 == 才是比较运算符。
if(x = y) 会将 y 的值（1）赋给 x，然后判断 x 的值是否为 true（非零）。
但 Java 不允许在 if 条件中使用 int 类型进行布尔判断，因此会报 ‌编译错误‌（Type mismatch: cannot convert from int to boolean）。

正确的比较写法应该是 if(x == y)‌

如果写成 if(x == y)，程序会输出 “Equal”（因为 3 != 1，执行 else 分支）。
但原代码写的是 =，所以无法通过编译。

13. D

遍历时若当前元素为 0，则调用 remove(k) 删除该元素，导致后续元素索引左移。
每次循环无论是否删除，k 都会递增，可能跳过后续需要检查的元素。

执行过程‌：
k=0‌：删除第一个 0，数组变为 [0, 4, 2, 5, 0, 3, 0]，k++ 后跳过第二个 0（原索引1）。
k=1‌：检查 4（非 0），继续。
k=4‌：删除第三个 0（原索引4），数组变为 [0, 4, 2, 5, 3, 0]，k++ 后跳过 3（原索引5）。
k=5‌：删除最后一个 0，最终数组为 [0, 4, 2, 5, 3]。

14. B

== 这个比较符号可用于基本类型和引用类型：
当用于基本类型时候，是比较值是否相同；
当用于引用类型的时候，是比较对象是否相同。
"==“和”!="比较的是地址，指一个new()出来的地址， 因为两次new() 出来的内存地址不同， 所以 System.out.print(n1 == n2);返回 false，!=返回true，所以 答案：B

15. B

A: s.equals(t)‌
s 和 t 均指向字符串常量池中的同一对象 “hello”，String.equals() 方法比较内容相同且地址一致，因此返回 true。
B: t.equals©
c 是 char[] 类型，而 String.equals() 方法要求参数为 String 对象。由于类型不匹配（char[] 与 String ），该方法直接返回 false。
C: s == t‌
s 和 t 因字符串驻留机制指向常量池中同一对象，地址相同，== 比较返回 true。
D: t.equals(new String(“hello”))‌
new String(“hello”) 创建新对象，但 String.equals() 仅比较字符串内容（内容均为 “hello”），因此返回 true。

16. A

调用流程：
请求委托入口‌
Servlet容器（如Tomcat）收到HTTP请求后，会调用目标Servlet的 service() 方法作为请求处理的入口点。
service方法的分发机制‌
service() 方法根据HTTP请求的类型（GET、POST等），自动分发给对应的 doGet()、doPost() 等方法处理具体逻辑。例如：
GET请求 → doGet()
POST请求 → doPost()
B. doGet / C. doPost‌：是 service() 内部调用的具体实现方法，非直接入口。
D. init‌：仅在Servlet初始化时执行一次，与请求处理无关。

流程图解：

graph LR
A[HTTP请求] --> B[Servlet容器]
B --> C[调用 service(HttpRequest, HttpResponse)]
C --> D{判断请求类型}
D -- GET --> E[调用 doGet()]
D -- POST --> F[调用 doPost()]

17. D

1、System.out.println("is " + 100 + 5);‌
"is " 是字符串，因此 + 操作符执行字符串连接。
先计算 "is " + 100，得到 “is 100”。
再计算 “is 100” + 5，整数 5 被转换为字符串 “5”，最终输出 “is 1005”。

2、System.out.println(100 + 5 + " is");‌
100 + 5 的两个操作数均为整数，因此先执行加法运算，结果为 105。
然后计算 105 + " is"，整数 105 被转换为字符串 “105”，连接后输出 “105 is”。

3、System.out.println("is " + (100 + 5));‌
括号 (100 + 5) 优先计算加法，结果为整数 105。
再执行 "is " + 105，整数 105 被转换为字符串 “105”，最终输出 “is 105”。

18. D

在Java中，构造方法的关键字使用限制如下：
A：final‌：构造方法不能被 final 修饰，因为 final 会阻止方法重写，而构造方法本身不可继承或重写。
B：static‌：构造方法不能被 static 修饰，静态方法属于类而非实例，而构造方法用于初始化对象实例。
C：synchronized‌：构造方法不能被 synchronized 修饰，同步锁用于多线程控制，而构造方法在对象创建时仅由单线程执行。

正确答案：D：None of these‌。
Java规范禁止在构造方法上使用 final、static、synchronized 等关键字，仅允许访问修饰符（如 public、protected、private）。

19. C

对于读写平均的容器类数据结构，在保证线程安全的前提下，综合提高访问性能的最佳方法是‌C：分区段加锁‌。理由如下：

选项A：只对写操作加锁，不对读操作加锁‌
此方案会导致读操作可能访问到中间状态数据（脏数据），引发线程安全问题，无法满足一致性要求。

选项B：读操作不加锁，采用copyOnWrite方式实现写操作‌
CopyOnWrite机制在写操作时复制整个数据结构，适用于读多写少的场景；但读写平均时，频繁的写操作会因复制开销导致性能下降，不适用当前需求。

选项C：分区段加锁‌
通过将数据结构划分为多个独立区段，每个区段使用单独的锁（如读写锁），可以显著减少锁竞争。
读/写操作仅需锁定相关区段，允许并发访问不同区段，从而在读写平均场景下提高吞吐量和响应速度。
此方法平衡了线程安全和性能，是综合优化的最优解。

选项D：无法做到‌
线程安全容器的性能可通过锁优化（如分区段）提升，此说法错误。

结论‌：分区段加锁（选项C）通过降低锁粒度提升并发效率，是读写平均场景下的最佳实践。

20. A

Servlet的生命周期包括初始化（init()）、服务（service()）和销毁（destroy()）三个阶段，均由容器（如Tomcat）管理。以下是对选项中各说法的分析：

A：在创建自己的Servlet时候，应该在初始化方法init()方法中创建Servlet实例‌
不正确‌。Servlet实例由容器自动创建（如首次请求或服务器启动时），而非在init()方法中创建；init()方法仅用于初始化配置或资源（如数据库连接），在实例创建后调用且仅执行一次。
B：在Servlet生命周期的服务阶段，执行service()方法，根据用户请求的方法，执行相应的doGet()或是doPost()方法‌
正确。service()方法处理请求，根据HTTP方法（如GET、POST）调用对应的doGet()或doPost()方法。
C：在销毁阶段，执行destroy()方法后会释放Servlet占用的资源‌
正确。destroy()方法用于释放资源（如关闭文件句柄或网络连接），在Servlet卸载前调用。
D：destroy()方法仅执行一次，即在服务器停止且卸载Servlet时执行该方法‌
正确。destroy()在Servlet生命周期中仅调用一次，通常发生在服务器停止或Servlet被卸载时。

综上，‌说法不正确的是A‌。