对网上一些Java笔试题的总结,答案与自我理解(400道)

最新推荐文章于 2022-06-27 19:00:29 发布

VIP文章 weixin_42431912

最新推荐文章于 2022-06-27 19:00:29 发布

阅读量6.6k

点赞数

文章标签： Java 面试笔试题 2019

本文链接：https://blog.csdn.net/weixin_42431912/article/details/100164831

版权

对网上一些Java笔试题的总结,答案与自我理解

1… https://www.nowcoder.com/questionTerminal/48db39d722894c08907a8f613858672e
在Java中，对于不再使用的内存资源，如调用完成的方法，“垃圾回收器”会自动将其释放。（ b ）

正确
错误
GC垃圾回收器会自动识别无用的内存

2… https://www.nowcoder.com/questionTerminal/9d4c6e25554a42e68ce6fbe40ef79afd
下列有关JAVA异常处理的叙述中正确的是（a）
finally是为确保一段代码不管是否捕获异常都会被执行的一段代码
throws是用来声明一个成员方法可能抛出的各种非运行异常情况
final用于可以声明属性和方法，分别表示属性的不可变及方法的不可继承
throw是用来明确地抛出一个异常情况

try块必须和catch块或和finally同在,不能单独存在,二者必须出现一个.
finally块总会执行,不论是否有错误出现.但是若try语句块或会执行的catch语句块使用了JVM系统退出语句,finally块就不会被执行了. 一般我们把关闭资源的代码放在finally里面保证资源总是能关闭
B选项是因为抛出的是异常情况而不是非异常
C根本就跟异常处理没有关系，所以不选。就算有关系也错了
final用于声明属性、方法、类。分别表示属性不可更改、方法不能被覆盖、类不能被继承。
所以C选项说方法不能被继承错误，是不能覆盖
throw是用来明确地抛出一个异常情况。错误，throw不仅仅可以抛出异常，还可以抛出Error以及Throwable.

3… https://www.nowcoder.com/questionTerminal/2732166fc5aa4335ae0a4b2085da041c
下列说法错误的有（ a,c,d）
在类方法中可用this来调用本类的类方法
在类方法中调用本类的类方法时可直接调用
在类方法中只能调用本类中的类方法
在类方法中绝对不能调用实例方法

首先：
成员方法又称为实例方法
静态方法又称为类方法
其次：
a，静态方法中没有this指针
c，类方法是可以调用其他类的static方法的。
d，太绝对化了，在类中申请一个类对象或者参数传递一个对象或者指针都可以调用;

4… https://www.nowcoder.com/questionTerminal/fd323dab24dc4989b9322680bf43b9ce
以下哪些继承自 Collection 接口（a,b）
List
Set
Map
Array
5… https://www.nowcoder.com/questionTerminal/9b1fef54196f4d1e881804bb235fcd2c
DBMS
中实现事务持久性的子系统是(d)
安全性管理子系统
完整性管理子系统
并发控制子系统
恢复管理子系统

要想事物具有持久性，就得在事物出错时及时恢复。

6… https://www.nowcoder.com/questionTerminal/51123ddacab84a158e121bc5fe3917eb
下列Java代码中的变量a、b、c分别在内存的_c___存储区存放。
class A {
private String a = “aa”;
public boolean methodB() {
String b = “bb”;
final String c = “cc”;
}
}
堆区、堆区、堆区
堆区、栈区、堆区
堆区、栈区、栈区
堆区、堆区、栈区
静态区、栈区、堆区
静态区、栈区、栈区

堆区：只存放类对象，线程共享；
方法区：又叫静态存储区，存放class文件和静态数据，线程共享;
栈区：存放方法局部变量，基本类型变量区、执行环境上下文、操作指令区，线程不共享;

常量池：未经 new 的常量
堆区：成员变量的引用，new 出来的变量
栈区：局部变量的引用

成员变量的引用在堆区，是因为成员变量的所属对象在堆区，所以它也在堆区。见 https://blog.csdn.net/leunging/article/details/80599282。
局部变量的引用在栈区，是因为局部变量不属于某一个对象，在被调用时才被加载，所以在栈区。

7… https://www.nowcoder.com/questionTerminal/25deb8d21e7d442e86c90302d6e03133
public class NameList
{
private List names = new ArrayList();
public synchronized void add(String name)
{
names.add(name);
}
public synchronized void printAll() {
for (int i = 0; i < names.size(); i++)
{
System.out.print(names.get(i) + ””);
}
}
public static void main(String[]args)
{
final NameList sl = new NameList();
for (int i = 0; i < 2; i++)
{
new Thread()
{
public void run()
{
sl.add(“A”);
sl.add(“B”);
sl.add(“C”);
sl.printAll();
}
} .start();
}
}
}
Which two statements are true if this class is compiled and run? e,g
An exception may be thrown at runtime.
The code may run with no output, without exiting.
The code may run with no output, exiting normally(正常地).
The code may rum with output “A B A B C C “, then exit.
The code may rum with output “A B C A B C A B C “, then exit.
The code may ruin with output “A A A B C A B C C “, then exit.
The code may ruin with output “A B C A A B C A B C “, then exit.

8… https://www.nowcoder.com/questionTerminal/970cdaaa4a114cbf9fef82213a7dabca
对于JVM内存配置参数：
-Xmx10240m -Xms10240m -Xmn5120m -XXSurvivorRatio=3 初始堆大小
,其最小内存值和Survivor区总大小分别是（d）
5120m，1024m
5120m，2048m
10240m，1024m
10240m，2048m
D
-Xmx：最大堆大小
-Xms：初始堆大小
-Xmn:年轻代大小
-XXSurvivorRatio：年轻代中Eden区与Survivor区的大小比值
年轻代5120m， Eden：Survivor=3，Survivor区大小=1024m（Survivor区有两个，即将年轻代分为5份，每个Survivor区占一份），总大小为2048m。
-Xms初始堆大小即最小内存值为10240m

9… https://www.nowcoder.com/questionTerminal/2aa69f9816ac4cc4be8872861dca6d6e java单继承,构造方法不能继承
java中关于继承的描述正确的是（a,c,d）
一个子类只能继承一个父类
子类可以继承父类的构造方法
继承具有传递性
父类一般具有通用性，子类更具体

10… https://www.nowcoder.com/questionTerminal/97b40275377b478b87e3e1f35dc098b8
“==“和”!=“比较的是地址指第一个new()c出来的地址
以下程序段的输出结果为： b
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);
}
}
false，false
false，true
true，false
true，true
俩都是new出来的,肯定地址不是同一个

11… https://www.nowcoder.com/questionTerminal/593cc3972afe4b32a49cd9c518571221
Given the following code: b
public class Test {
private static int j = 0;
private static Boolean methodB(int k) {
j += k;
return true;
}
public static void methodA(int i) {
boolean b;
b = i < 10 | methodB(4);//中间为与计算符，执行完methodB(4)后，j = 4
b = i < 10 || methodB(8);//中间为或计算符，因为i < 10 已成立，不需要后续计算所以最后结果输出为4
}
public static void main(String args[]) {
methodA(0);
System.out.println(j);
}
}
What is the result?
The program prints”0”
The program prints”4”
The program prints”8”
The program prints”12”
The code does not complete.

12… https://www.nowcoder.com/questionTerminal/7d7814b41ded4364aeee6c671233ddb8
类Parent和Child定义如下：

    1) class  Parent{
      
    2) public    float  aFun(float a, float b) {   }

    3) }
    
    4)  class  Child    extends  Parent{
    
	5)
	
    6)  }

将以下哪种方法插入行5是不合法的。（ a ）
float aFun(float a, float b){ }
public int aFun(int a, int b) { }
public float aFun(float p, float q){ }
private int aFun(int a, int b){ }

A选项是重写，但是默认访问修饰符比父类小，插入第五行编辑器会报错。
B、D不是重写。因为形参列表和返回值类型不同，不满足“三同”。所以写在第五行以普通方法对待，插入第五行没有错误。
C选项满足重写的各项条件，是正确的重写，所以插入第五行没有错误。

13… https://www.nowcoder.com/questionTerminal/b730e61f1fc646a7a33b8700a20bb1c7
阅读以下 foo 函数，请问它的时间复杂度是：c int foo(intarray[], int n, int key) { int n1=0,n2=n-1,m; while(n1<=n2) { m=(n1+n2)/2; if(array[m]==key) return m; if(array[m]>key) n2=m-1; else n1=m+1; } return -1; }
O(n2)
O(n3)
O(log(n))
O(n)

二分查找时间复杂度为O（logn）

14… https://www.nowcoder.com/questionTerminal/2be86af464c04b9c9d7895d62dd46732
假设 a 是一个由线程 1 和线程 2 共享的初始值为 0 的全局变量，则线程 1 和线程 2 同时执行下面的代码，最终 a 的结果不可能是（d）

 boolean isOdd = false;  
for(int i=1;i<=2;++i)
 {
 if（i%2==1）isOdd = true； 
else isOdd = false； 
 a+=i*(isOdd?1:-1)；
  }

-1
-2
0
1

假设两线程为A、B，设有3种情况：
1.AB不并发：此时相当于两个方法顺序执行。A执行完后a=-1，B使用-1作为a的初值，B执行完后a=-2
2.AB完全并发：此时读写冲突，相当于只有一个线程对a的读写最终生效。相同于方法只执行了一次。此时a=-1
3.AB部分并发：假设A先进行第一次读写，得到a=1;之后A的读写被B覆盖了。B使用用1作为a的初值，B执行完后a=0

15… https://www.nowcoder.com/questionTerminal/48524c47dd924887be6684b17175fa40
往OuterClass类的代码段中插入内部类声明, 哪一个是错误的:a,b,c,d
public class OuterClass{
private float f=1.0f;
//插入代码到这里
}
class InnerClass{
public static float func(){return f;}
}
abstract class InnerClass{
public abstract float func(){}
}
static class InnerClass{
protected static float func(){return f;}
}
public class InnerClass{
static float func(){return f;}
}

主要考核了这几个知识点：
1.静态内部类才可以声明静态方法
2.静态方法不可以使用非静态变量
3.抽象方法不可以有函数体
静态方法不能访问非静态变量，A和C错；
抽象类中的抽象方法不能有方法体，B错；
一个类中有多个类声明时，只能有一个public类，D错

16… https://www.nowcoder.com/questionTerminal/fb463f20d1cc44e3b4476e5d5319e7e9
下列选项中是正确的方法声明的是？（a,b,c,d）
protected abstract void f1();
public final void f1() {}
static final void fq(){}
private void f1() {}

A：抽象方法只可以被public 和 protected修饰；
B：final可以修饰类、方法、变量，分别表示：该类不可继承、该方法不能重写、该变量是常量
C：static final 可以表达在一起来修饰方法，表示是该方法是静态的不可重写的方法
D：private 修饰方法（这太常见的）表示私有方法，本类可以访问，外界不能访问

17… https://www.nowcoder.com/questionTerminal/3175bb91e5974b97abb6317c247f1bfe
关于类的静态成员的不正确描述是（d）
静态成员不属于对象，是类的共享成员
静态成员要在类外定义和初始化
静态成员函数不拥有this指针，需要通过类参数访问对象成员
只有静态成员函数可以操作静态数据成员

A----------静态成员不属于对象，是类的共享成员。
B----------静态成员要在类外定义和初始化。
B显然是有问题的。静态成员变量存储在方法区，也是在类内定义和初始化的。
C----------静态成员函数不含有this指针，需要通过类参数访问对象成员。
因为静态成员函数被调用的时候，该静态成员函数所属的类很有可能还没有被初始化，所以静态成员函数是不含有this指针的。
D----------只有静态成员函数可以操作静态数据成员。
D显然也是有问题的，非静态成员函数也可以操作静态数据成员。

18… https://www.nowcoder.com/questionTerminal/1bbb41f39dff48d399ef31c5b000e33e
以下哪项陈述是正确的？e
垃圾回收线程的优先级很高，以保证不再使用的内存将被及时回收
垃圾收集允许程序开发者明确指定释放哪一个对象
垃圾回收机制保证了JAVA程序不会出现内存溢出
进入”Dead”状态的线程将被垃圾回收器回收
以上都不对

答案：E
A: 垃圾回收在jvm中优先级相当相当低。
B：垃圾收集器（GC）程序开发者只能推荐JVM进行回收，但何时回收，回收哪些，程序员不能控制。
C：垃圾回收机制只是回收不再使用的JVM内存，如果程序有严重BUG，照样内存溢出。
D：进入DEAD的线程，它还可以恢复，GC不会回收

19.https://www.nowcoder.com/questionTerminal/e75ac035e2d64fbf9989fea31abe0f4e
java8中，下面哪个类用到了解决哈希冲突的开放定址法 c
LinkedHashSet
HashMap
ThreadLocal
TreeMap

ThreadLocalMap中使用开放地址法来处理散列冲突，而HashMap中使用的是分离链表法。
之所以采用不同的方式主要是因为：在ThreadLocalMap中的散列值分散得十分均匀，很少会出现冲突。并且ThreadLocalMap经常需要清除无用的对象，使用纯数组更加方便。

20… https://www.nowcoder.com/questionTerminal/779a8f85397b46dcb98e3ccf299f331f
下列说法正确的有（a,c,d ）
环境变量可在编译source code时指定
在编译程序时，所能指定的环境变量不包括class path
javac一次可同时编译数个Java源文件
javac.exe能指定编译结果要置于哪个目录（directory）

1.环境变量可在编译source code时指定，java -d <目录> 指定放置生成的类文件的位置，A对B错；
2.javac *.java. 即可编译当前目录下的所有java文件，C对；
3.java -s <目录> 指定放置生成的源文件的位置,D对；

21.https://www.nowcoder.com/questionTerminal/bf65d2fb658642a5a959c11f6ce2d77a
public interface IService {String NAME=“default”;}
默认类型等价表示是哪一项: c
public String NAME=“default”;
public static String NAME=“default”;
public static final String NAME=“default”;
private String NAME=“default”;

接口中的成员包括：全局常量和抽象方法。接口中的成员都有固定的修饰符，成员变量：public static final 成员方法：public abstract
接口中的成员的访问权限都是公共的，接口中可以隐藏不写这些固定的修饰符。
接口不可以实例化，只有子类重写了接口中的所有方法后，子类才可以实例化，否则子类还是一个抽象类。
子类重写方法的访问权限都是public的。

22… https://www.nowcoder.com/questionTerminal/d0b72fbaf82c4c92a96b190908e2fbe6
在Struts框架中如果要使用Validation作验证的话，需要使用以下哪个Form？d
ActionForm
ValidatorActionForm
ValidatorForm
DynaValidatorActionForm

DynaValidatorActionForm 动态验证表单
Validation 确认的意思

23… https://www.nowcoder.com/questionTerminal/3dfd72f89070415185f09aebecd0e3f7
Servlet的生命周期可以分为初始化阶段，运行阶段和销毁阶段三个阶段，以下过程属于初始化阶段是（a,c,d）。
加载Servlet类及.class对应的数据
创建servletRequest和servletResponse对象
创建ServletConfig对象
创建Servlet对象

Servlet的生命周期一般可以用三个方法来表示：
init()：仅执行一次，负责在装载Servlet时初始化Servlet对象
service() ：核心方法，一般HttpServlet中会有get,post两种处理方式。在调用doGet和doPost方法时会构造servletRequest和servletResponse请求和响应对象作为参数。
destroy()：在停止并且卸载Servlet时执行，负责释放资源
初始化阶段：Servlet启动，会读取配置文件中的信息，构造指定的Servlet对象，创建ServletConfig对象，将ServletConfig作为参数来调用init()方法。所以选ACD。B是在调用service方法时才构造的

24… https://www.nowcoder.com/questionTerminal/15b1429e6c364c3bbe6e8134a519f2a3
byte b1=1,b2=2,b3,b6,b8;
final byte b4=4,b5=6,b7;
b3=(b1+b2); /语句1/
b6=b4+b5; /语句2/
b8=(b1+b4); /语句3/
b7=(b2+b5); /语句4/
System.out.println(b3+b6); 下列代码片段中，存在编译错误的语句是(a,c,d)
语句2
语句1
语句3
语句4

Java表达式转型规则由低到高转换：
1、所有的byte,short,char型的值将被提升为int型；
2、如果有一个操作数是long型，计算结果是long型；
3、如果有一个操作数是float型，计算结果是float型；
4、如果有一个操作数是double型，计算结果是double型；
5、被fianl修饰的变量不会自动改变类型，当2个final修饰相操作时，结果会根据左边变量的类型而转化。
--------------解析--------------
语句1错误：b3=(b1+b2);自动转为int，所以正确写法为b3=(byte)(b1+b2);或者将b3定义为int；
语句2正确：b6=b4+b5;b4、b5为final类型，不会自动提升，所以和的类型视左边变量类型而定，即b6可以是任意数值类型；
语句3错误：b8=(b1+b4);虽然b4不会自动提升，但b1仍会自动提升，所以结果需要强转，b8=(byte)(b1+b4);
语句4错误：b7=(b2+b5); 同上。同时注意b7是final修饰，即只可赋值一次，便不可再改变

25… https://www.nowcoder.com/questionTerminal/9dfb7470f3014166947cba07a69133c3
当您尝试编译并运行以下代码时会发生什么
What will happen when you attempt to compile and run the following code? d
public class Test{
static{
int x=5;
}
static int x,y;
public static void main(String args[]){
x–;
myMethod( );
System.out.println(x+y+ ++x);
}
public static void myMethod( ){
y=x++ + ++x;
}
}
compiletime error
prints:1
prints:2
prints:3
prints:7
prints:8

1.JVM加载class文件时，就会执行静态代码块，静态代码块中初始化了一个变量x并初始化为5，由于该变量是个局部变量，静态代码快执行完后变被释放。
2.申明了两个静态成员变量x，y，并没有赋初值，会有默认出值，int类型为0，
3.执行x–操作，变量单独进行自增或自减操作x–和--x的效果一样，此时x变为了-1
4.调用MyMethod()方法，在该方法中对x和y进行计算，由于x和y都是静态成员变量，所以在整个类的生命周期内的x和y都是同一个
5.y=x++ + ++x可以看成是y=(x++)+(++x)，当++或者–和其它变量进行运算时，x++表示先运算，再自增，++x表示先自增再参与运算
所以就时x为-1参与运算，然后自增，x此时为0，++x后x为1，然后参与运算，那么y=-1+1就为0，此时x为1
6.执行并打印x+y + ++x运算方式和第5步相同，最后计算结果就为3.

26…https://www.nowcoder.com/questionTerminal/ec83945fe29f44abbdd6d156fbeccdb1
（这个题不严谨，可以先不做，后面改正后再做）设有下面的两个类定义：
class Father{
public Father(){
System.out.println(“我是父类”);
}
}
class Child extends Father {
public Child(){
System.out.println(“我是子类”);
}
}
则顺序执行如下语句后输出结果为：（） Father a; Child b;
我是父类我是子类
我是子类我是父类
我是父类我是父类
我是子类我是子类

27… https://www.nowcoder.com/questionTerminal/146b3d53c337437fbf780114f18da3c7
要求匹配以下16进制颜色值，正则表达式可以为：b #ffbbad #Fc01DF #FFF #ffE
/#([0-9a-f]{6}|[0-9a-fA-F]{3})/g
/#([0-9a-fA-F]{6}|[0-9a-fA-F]{3})/g
/#([0-9a-fA-F]{3}|[0-9a-f]{6})/g
/#([0-9A-F]{3}|[0-9a-fA-F]{6})/g

28… https://www.nowcoder.com/questionTerminal/27abe0380cbb41a0a612e30e65024e14
下列关于JavaBean的说法正确的是：a
Java文件与Bean所定义的类名可以不同，但一定要注意区分字母的大小写
在JSP文件中引用Bean，其实就是用语句
被引用的Bean文件的文件名后缀为.java
Bean文件放在任何目录下都可以被引用

（1）懂得将 Bean 放在哪个目录下：在 Resin 中 JavaBean 放在 doc\web-inf\classes 目录中。
（2）懂得如何使用 JBuilder 定义一个 Bean；其中的语法规范不一定要记住，但要理解
其中的结构。
（3）Java 文件和 Bean所定义的类名一定要相同，并且是大小写敏感。
（4）Bean中要声明公共方法，与 Bean的名字相同。
（5）懂得如何在JSP 文件中引用JavaBean，其实就是jsp:useBean的语句。
（6）一定要紧记Java 是区分大小写的。

29…https://www.nowcoder.com/questionTerminal/8b992ee9de5e40bb84f6fd29e69d842d
存根（Stub）与以下哪种技术有关 b
交换
动态链接
动态加载
磁盘调度

stub 充当远程对象的客户端代理，有着和远程对象相同的远程接口，远程对象的调用实际是通过调用该对象的客户端代理对象stub来完成的。
这种方式符合等到程序要运行时将目标文件动态进行链接的思想
理解为适配器模式，继承该类则不需要实现一个接口全部方法

30… https://www.nowcoder.com/questionTerminal/47399c2d404c4808bc7914a0596bbdc2
下列各项说法中错误的是？b,
共享数据的所有访问都必须使用synchronized加锁
共享数据的访问不一定全部使用synchronized加锁
所有的对共享数据的访问都是临界区
临界区必须使用synchronized加锁

共享数据的所有访问一定要作为临界区，用synchronized标识，这样保证了所有的对共享数据的操作都通过对象锁的机制进行控制。

https://www.nowcoder.com/questionTerminal/049f3c3b41024630887a7f596e7b450f
设有下面两个赋值语句：
a = Integer.parseInt(“1024”);
b = Integer.valueOf(“1024”).intValue();
下述说法正确的是（d）
a是整数类型变量，b是整数类对象。
a是整数类对象，b是整数类型变量。
a和b都是整数类对象并且它们的值相等。
a和b都是整数类型变量并且它们的值相等。

intValue()是把Integer对象类型变成int的基础数据类型；
parseInt()是把String 变成int的基础数据类型；
Valueof()是把String 转化成Integer对象类型；（现在JDK版本支持自动装箱拆箱了。）
本题：parseInt得到的是基础数据类型int，valueof得到的是装箱数据类型Integer，然后再通过valueInt转换成int，所以选择D

https://www.nowcoder.com/questionTerminal/92620388e2754b72950ca939d6493300
变量a是一个64位有符号的整数，初始值用16进制表示为：0x7FFFFFFFFFFFFFFF;变量b是一个64位有符号的整数，初始值用16进制表示为：0x8000000000000000。则a+b的结果用10进制表示为多少？b
1
-1
2⁶³⁺²62+…+2²⁺²1+2^0
–(2⁶³⁺²62+…+2²⁺²1+2^0)

a+b=0xFFFFFFFFFFFFFFFF，十六进制的F对应十进制的15，再转换成二进制则为1111。
所以a+b得1111 1111 1111 1111，二进制的首尾为符号位，1位负数，0则为正数，这里为1所以a+b的结果是负数。
负数在内存中存储以补码的形式，所以求原码的步骤为：
1.补码-1得反码（变为1111 1111 1111 1110）
2.反码按位取反得原码（1000 0000 0000 0001）
3.转换成二进制结果为-1

https://www.nowcoder.com/questionTerminal/711badc732d84bd98e4ac684e09791b8
package Wangyi;
class Base
{
public void method()
{
System.out.println(“Base”);
}
}
class Son extends Base
{
public void method()
{
System.out.println(“Son”);
}

public void methodB()
{
System.out.println(“SonB”);
}
}
public class Test01
{
public static void main(String[] args)
{
Base base = new Son();
base.method();
base.methodB();
}
}
问这个程序的输出结果。d
Base SonB
Son SonB
Base Son SonB
编译不通过

Base base = new Son();
这句new 了一个派生类，赋值给基类，所以下面的操作编译器认为base对象就是Base类型的
Base类中不存在methodB()方法，所以编译不通过

https://www.nowcoder.com/questionTerminal/9438324d0fb4407ba96d20df09e90125
在Java中，以下关于方法重载和方法重写描述正确的是？d
方法重载和方法的重写实现的功能相同
方法重载出现在父子关系中，方法重写是在同一类中
方法重载的返回值类型必须一致，参数项必须不同
方法重写的返回值类型必须相同或相容。

重载（overload）：只要方法名一致，其他（参数列表、返回值）怎么折腾随便。重载是发生在同一类中
重写（overriding）：只有实现的功能代码不一致，其他的（函数名、参数列表、返回值类型）必须都一致。重写发生在子类与父类之间

https://www.nowcoder.com/questionTerminal/4cefb62973b149478bedc0ebcdbfb160
下列哪行会产生错误？
Which lines of the following will produce an error? a
byte a1 = 2, a2 = 4, a3;
short s = 16;
a2 = s;
a3 = a1 * a2;
Line 3 and Line 4
Line 1 only
Line 3 only
Line 4 only

short类型转为byte类型出错,short不能自动转成byte和char，必须强转

a1*a2结果为int类型，转为byte类型出错,
java中如果碰到char、byte和short参与运算时，会自动将这些值转换为int类型然后再进行运算。这里a1和a2就自动转为int类型了，结果也为Int类型。把一个int类型赋值给byte需要转型
byte+byte=int，低级向高级是隐式类型转换，高级向低级必须强制类型转换，byte<char<short<int<long<float<double

https://www.nowcoder.com/questionTerminal/f32600cdc2ad413082ea503f9496cadd
下列关于容器集合类的说法正确的是？c
LinkedList继承自List
AbstractSet继承自Set
HashSet继承自AbstractSet
WeakMap继承自HashMap

A.LinkedList是继承自AbstractSequentialList（抽象类，实现了List接口）的，并且实现了List接口。所以A错误。
B.AbstractSet是实现了Set接口的，本身是一个抽象类。继承自AbstractCollection（抽象类，实现了Collection接口）。所以B错误。
C.HashSet是继承自AbstractSet，实现了Set接口。所以C正确。
D.WeakMap不存在于java集合框架的。只有一个叫做WeakHashMap（继承自AbstractMap）。

https://www.nowcoder.com/questionTerminal/5ce602538d784f51a531bf9760592773
以下代码执行的结果显示是多少（0）？

505000
0
运行时错误
5050

for循环外面count=0,循环里面的count=count++;(count的值都等于count值，而后面count自加不影响count结果，因此这个式子无意义);循环count都为0（因count++是先返回count的本身值再自加1的）！
若是改为count=++count;（先自加，再返回自加后的值），结果就是5050101=510050了！
改为count++;结果就是5050101=510050了！

https://www.nowcoder.com/questionTerminal/695903546ba84d388fd80b1461a6141c
以下哪些方法可以取到http请求中的cookie值（a,d）?
request.getAttribute
request.getHeader
request.getParameter
request.getCookies
链接：https://www.nowcoder.com/questionTerminal/695903546ba84d388fd80b1461a6141c
来源：牛客网

(1) request.getAttribute:getAttribute是在服务器端的操作。
比如说 request.setAttribute(k,v),其行为动作在服务器端。
而在服务端放入cookies是通过response.addCookie(cookie)。因此，A错了
(2）String getHeader(String name)
以字符串形式返回指定的请求头的值。Cookie也是头的一种；

C.request.getParameter()方法获取从客户端中通过get 或者post方式传送到服务器端的参数。行为操作在服务器端。所以cookies明显不是通过url或者form表单提交过来的。C错

D.看方法名字就行了。

https://www.nowcoder.com/questionTerminal/795b066b67c84478aec4dc400b3d0153
以下哪些jvm的垃圾回收方式采用的是复制算法回收? a,d
新生代串行收集器
老年代串行收集器
并行收集器
新生代并行回收收集器
老年代并行回收收集器
cms收集器

两个最基本的java回收算法：复制算法和标记清理算法
复制算法：两个区域A和B，初始对象在A，继续存活的对象被转移到B。此为新生代最常用的算法
标记清理：一块区域，标记可达对象（可达性分析），然后回收不可达对象，会出现碎片，那么引出
标记-整理算法：多了碎片整理，整理出更大的内存放更大的对象
两个概念：新生代和年老代
新生代：初始对象，生命周期短的
永久代：长时间存在的对象
整个java的垃圾回收是新生代和年老代的协作，这种叫做分代回收。
P.S：Serial New收集器是针对新生代的收集器，采用的是复制算法
Parallel New（并行）收集器，新生代采用复制算法，老年代采用标记整理
Parallel Scavenge（并行）收集器，针对新生代，采用复制收集算法
Serial Old（串行）收集器，新生代采用复制，老年代采用标记整理
Parallel Old（并行）收集器，针对老年代，标记整理
CMS收集器，基于标记清理
G1收集器：整体上是基于标记整理，局部采用复制

综上：新生代基本采用复制算法，老年代采用标记整理算法。cms采用标记清理。

https://www.nowcoder.com/questionTerminal/a2230836563b4e26b3b32b108cfcf051
Hashtable 和 HashMap 的区别是： b,c,d,e

Hashtable 是一个哈希表，该类继承了 AbstractMap，实现了 Map 接口
HashMap 是内部基于哈希表实现，该类继承AbstractMap，实现Map接口
Hashtable 线程安全的，而 HashMap 是线程不安全的
Properties 类继承了 Hashtable 类，而 Hashtable 类则继承Dictionary 类
HashMap允许将 null 作为一个 entry 的 key 或者 value，而 Hashtable 不允许。

Hashtable继承自Dictionary类，而HashMap继承自AbstractMap类。但二者都实现了Map接口

Hashtable：
（1）Hashtable 是一个散列表，它存储的内容是键值对(key-value)映射。
（2）Hashtable 的函数都是同步的，这意味着它是线程安全的。它的key、value都不可以为null。
（3）HashTable直接使用对象的hashCode。
HashMap：
（1）由数组+链表组成的，基于哈希表的Map实现，数组是HashMap的主体，链表则是主要为了解决哈希冲突而存在的。
（2）不是线程安全的，HashMap可以接受为null的键(key)和值(value)。
（3）HashMap重新计算hash值

https://www.nowcoder.com/questionTerminal/34a92a7e42a84f048491e9339631891a
JVM内存不包含如下哪个部分(d )
Stacks
PC寄存器
Heap
Heap Frame
JVM内存区域分为五个部分，分别是堆(Heap)，方法区(Method Area)，虚拟机栈(VM Stacks)，本地方法栈(Native Method Stack)，程序计数器(PC寄存器(Program Counter Regist)，就是程序计数器)。
https://www.nowcoder.com/questionTerminal/f85fca7cda00483f896b9bf9267412f4
下面不属于HttpServletRequest接口完成功能的是？c
读取cookie
读取HTTP头
设定响应的content类型
读取路径信息

HttpServletRequest类主要处理：
1.读取和写入HTTP头标
2.取得和设置cookies
3.取得路径信息
4.标识HTTP会话
HttpServletResponse类主要处理:

向客户端写入Cookie
设置响应头信息；设定响应的content类型
发送响应的状态码。
设置响应正文；getWriter().print(“fdsfdsa”);
重定向：sendRedirect(“path”);

A: request.getCookies();
B: request.getHeader(String s);
C: response.setContentType(“text/html;charset=utf-8”);
C: request.getContextPath();/request.getServletPath();

https://www.nowcoder.com/questionTerminal/fa0749bc01754235b1607fb04889d705
哪些是Java中的关键字
Which are keywords in Java? d,e
null
true
sizeof
implements
instanceof

java中true ,false , null在java中不是关键字，也不是保留字，它们只是显式常量值，但是你在程序中不能使用它们作为标识符。
sizeof 是 C/C++ 中的方法，Java 中并没有这个方法，也没有该关键字或保留字
implements 和 instanceof 都是 Java 中的关键字

https://www.nowcoder.com/questionTerminal/ecbf77acda8645f3b79e0705a95fc880
给定下面的代码，输出是什么？
given the following code,what will be the output? a
class Value{
public int i=15;
}
public class Test{
public static void main(String argv[]){
Test t=new Test( );
t.first( );
}
public void first( ){
int i=5;
Value v=new Value( );
v.i=25;
second(v,i);
System.out.println(v.i);
}
public void second(Value v,int i){
i = 0;
v.i = 20;
Value val = new Value( );
v = val;
System.out.println(v.i+" "+i);
}
}
15 0 20
15 0 15
20 0 20
0 15 20

这题选A，考察的是值传递与引用传递，Java中原始数据类型都是值传递，传递的是值得副本，形参的改变不会影响实际参数的值，
引用传递传递的是引用类型数据，包括String,数组，列表, map,类对象等类型，形参与实参指向的是同一内存地址，因此形参改变会影响实参的值。

可能有人会选择B，包括我刚开始也是。总以为v不是已经指向了val了吗？？为什么还是20呢？不应该是15吗？
其实，原因很简单。现在我们把second（）换一下
publicvoidsecond(Value tmp,inti){
i = 0;
tmp.i = 20;
Value val = newValue( );
tmp = val;
System.out.println(tmp.i+" "+i);
}
这个tmp其实相当于是一个指向原来first中的V这个对象的指针，也就是对v对象的引用而已。但是引用是会改变所指的地址的值的。
所以在second中当tmp.i= 20的时候，就把原来first中的v的i值改为20了。接下来，又把tmp指向了新建的一个对象，所以在second中的tmp
现在指的是新的对象val，i值为15.
当执行完毕second后，在first中在此输出v.i的时候，应为前面second中已经把该位置的i的值改为了20，所以输出的是20.
至于疑惑v指向了val，其实只是名字的问题，在second中的v实践也是另外的一个变量，名字相同了而已，这个估计也是纠结的重点。

本题考查两个知识点：

局部变量名字会屏蔽点外作用域同名字变量
函数的参数传递问题

下面直接在代码上进行详细分析：

classValue{
publicinti=15;
}
publicclassTest{
publicstaticvoidmain(String argv[]){
Test t=newTest( );
t.first( );
}

publicvoidfirst( ){
inti=5;//注意这个i是局部变量
Value v=newValue( );
v.i=25;//创建了一个Value对象，并把此对象的属性i赋值25(默认值为15)
second(v,i);//v (v中的属性i值为25) 和局部变量i 传进函数second
System.out.println(v.i);//v的属性i在second函数中被改为了20
}

publicvoidsecond(Value v,inti){
i = 0;//second函数中的局部变量，和之前的i没关系
v.i = 20;//将传进的V的属性i改为20
Value val = newValue( );
v = val;//新创建的Value对象val,属性i值为15，并将v指向val对象，v已经和之前传进来的对象没关系了
System.out.println(v.i+" "+i);//此时v的属性i为15，先输出 15(v.i) 0(i)
}
}
所以，输出 15 0 20

https://www.nowcoder.com/questionTerminal/1a16b12b50e346b5aa1f9a681d056daf
下列关于计算机系统和Java编程语言的说法，正确的是（c）
计算机是由硬件、操作系统和软件组成，操作系统是缺一不可的组成部分。
Java语言编写的程序源代码可以不需要编译直接在硬件上运行。
在程序中书写注释不会影响程序的执行，可以在必要的地方多写一些注释。
Java的集成开发环境（IDE），如Eclipse，是开发Java语言必需的软件工具。

计算机是由软件和硬件组成的,操作系统非必须
还有别的开发环境,IDEA

https://www.nowcoder.com/questionTerminal/241062d4dd6e4d9dbff3bb45984af04a
关于struts框架，下面那些说法是正确的？B
Struts中无法完成上传功能
Struts框架基于MVC模式
Struts框架容易引起流程复杂、结构不清晰等问题
Struts可以有效地降低项目的类文件数目

A，structs可以进行文件上传
B，structs基于MVC模式，MVC是模型，视图，控制器，是一种设计模式
C，structs框架让流程结构更清晰
D，structs需要很多 action类，会增加类文件数目

Struts是最早的java开源框架之一，它是MVC设计模式的一个优秀实现。 Struts定义了通用的Controller(控制器)，通过配置文件(通常是 Struts -config.xml)隔离Model(模型)和View(视图)，
以Action的概念以对用户请求进行了封装，使代码更加清晰易读。 Struts还提供了自动将请求的数据填充到对象中以及页面标签等简化编码的工具。 Struts能够开发大型Java Web项目。

https://www.nowcoder.com/questionTerminal/0df1f90997014eb98fcf02dbcc61e0d9
ResultSet中记录行的第一列索引为？C
-1
0
1
以上都不是

ResultSet跟普通的数组不同，索引从1开始而不是从0开始
ResultSet数组是从1开始遍历。ResultSet是jsp，用来接收获取的数据库信息，查询时也是从第1列开始。

https://www.nowcoder.com/questionTerminal/b3b8a1f1a95e453e8fa38ee264191304
在各自最优条件下,对N个数进行排序,哪个算法复杂度最低的是? （a）
插入排序
快速排序
堆排序
归并排序

插入排序：最佳O（N）
快速排序：最佳O（NlogN）
堆排序：最佳O（NlogN）
归并排序：最佳O（NlogN）
因此选择插入排序。

https://www.nowcoder.com/questionTerminal/4c776177d2c04c2494f2555c9fcc1e49
定义栈的数据结构，请在该类型中实现一个能够得到栈中所含最小元素的min函数（时间复杂度应为O（1））。

import java.util.Stack;
import java.util.Arrays;
public class Solution {
/*借用辅助栈存储min的大小，自定义了栈结构
*/
private int size;
private int min = Integer.MAX_VALUE;
private Stack minStack = new Stack();
private Integer[] elements = new Integer[10];
public void push(int node) {
ensureCapacity(size+1);
elements[size++] = node;
if(node <= min){
minStack.push(node);
min = minStack.peek();
}else{
minStack.push(min);
}
// System.out.println(min+"");
}

private void ensureCapacity(int size) {
    // TODO Auto-generated method stub
    int len = elements.length;
    if(size > len){
        int newLen = (len*3)/2+1; //每次扩容方式
        elements = Arrays.copyOf(elements, newLen);
    }
}
public void pop() {
    Integer top = top();
    if(top != null){
        elements[size-1] = (Integer) null;
    }
    size--;
    minStack.pop();    
    min = minStack.peek();
//    System.out.println(min+"");
}

public int top() {
    if(!empty()){
        if(size-1>=0)
            return elements[size-1];
    }
    return (Integer) null;
}
public boolean empty(){
    return size == 0;
}

public int min() {
    return min;
}

}

https://www.nowcoder.com/questionTerminal/074fc24958e5487e849685fea6a2fb8e
以下哪个类包含方法flush()？（b）
InputStream
OutputStream
A 和B 选项都包含
A 和B 选项都不包含
flush（）函数强制将缓冲区中的字符流、字节流等输出，
目的是如果输出流输出到缓冲区完成后，缓冲区并没有填满，那么缓冲区将会一直等待被填满。所以在关闭输出流之前要调用flush（）。
https://www.nowcoder.com/questionTerminal/eee02717270a4519bf7d4c2a47f3d821
下面的程序将来打印什么?（a）
public class TestIncr {
public static void main(String args[]) {
int i = 0;
i = i++ + i;
System.out.println("I = "a + i);
}
}
I = 1
I = 2
I = 3
编译出错
a就没有被定义，编译肯定不通过呀
https://www.nowcoder.com/questionTerminal/529d3ae5a407492994ad2a246518148a
输入一个链表，输出该链表中倒数第k个结点。

时间复杂度O(n),一次遍历即可
public class Solution {
public ListNode FindKthToTail(ListNode head,int k) {
ListNode pre=null,p=null;
//两个指针都指向头结点
p=head;
pre=head;
//记录k值
int a=k;
//记录节点的个数
int count=0;
//p指针先跑，并且记录节点数，当p指针跑了k-1个节点后，pre指针开始跑，
//当p指针跑到最后时，pre所指指针就是倒数第k个节点
while(p!=null){
p=p.next;
count++;
if(k<1){
pre=pre.next;
}
k–;
}
//如果节点个数小于所求的倒数第k个节点，则返回空
if(count<a) return null;
return pre;

}

https://www.nowcoder.com/questionTerminal/d0267f7f55b3412ba93bd35cfa8e8035
输入一个链表，按链表值从尾到头的顺序返回一个ArrayList。
链接：https://www.nowcoder.com/questionTerminal/d0267f7f55b3412ba93bd35cfa8e8035
来源：牛客网

方法一：链表从尾到头输出，利用递归实现，不使用库函数直接printf输出的时候用递归比较好

/**

struct ListNode {
```
   int val;
```
```
   struct ListNode *next;
```
```
   ListNode(int x) :
```
```
         val(x), next(NULL) {
```
```
   }
```
};
/
class Solution {
public:
vector printListFromTailToHead(struct ListNode head) {
vector value;
if(head != NULL)
{
value.insert(value.begin(),head->val);
if(head->next != NULL)
{
vector tempVec = printListFromTailToHead(head->next);
if(tempVec.size()>0)
value.insert(value.begin(),tempVec.begin(),tempVec.end());
}
```
 }
 return value;
```
}
};

https://www.nowcoder.com/questionTerminal/deec39e906544bf788593b4a5ede42db
下列哪个选项是错误的。（a,d）
一个文件中只能有一个public class。
一个文件中可以有多个类。
一个类中可以有两个main方法。
若类中只含一个main方法，则必须是public的。

A.一个文件中，可以有多个public class
即，外部类为public，还可以有public的内部类。
B.一个文件中可以有多个类，可以是多个并列的类，也可以是外部类、内部类结合。
C.一个类中，可以有多个main方法，这是重载，但是public static void main(String[] args)的方法只能有一个。
D.类中，可以有main方法，也可以没有main方法，而有一个main()方法的时候，也可以是任意访问权限。因为这个类不一定要执行，可以只是辅助类。

https://www.nowcoder.com/questionTerminal/c6c7742f5ba7442aada113136ddea0c3
大家都知道斐波那契数列，现在要求输入一个整数n，请你输出斐波那契数列的第n项（从0开始，第0项为0）。 n<=39
用循环
public class Solution {
public int Fibonacci(int n) {
int preNum=1;
int prePreNum=0;
int result=0;
if(n0)
return 0;
if(n1)
return 1;
for(int i=2;i<=n;i++){
result=preNum+prePreNum;
prePreNum=preNum;
preNum=result;
}
return result;

}
}
https://www.nowcoder.com/questionTerminal/beb5aa231adc45b2a5dcc5b62c93f593
输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有的奇数位于数组的前半部分，所有的偶数位于数组的后半部分，并保证奇数和奇数，偶数和偶数之间的相对位置不变。

/两个思路吧，第一个思路：类似冒泡算法，前偶后奇数就交换：
class Solution {
public:
void reOrderArray(vector &array) {

    for (int i = 0; i < array.size();i++)
    {
        for (int j = array.size() - 1; j>i;j--)
        {
            if (array[j] % 2 == 1 && array[j - 1]%2 == 0) //前偶后奇交换
            {
                swap(array[j], array[j-1]);
            }
        }
    }
}

};

//第二个思路：再创建一个数组
class Solution{
public:
void reOrderArray(vector &array) {

    vector<int> array_temp;
    vector<int>::iterator ib1, ie1;
    ib1 = array.begin();


    for (; ib1 != array.end();){            //遇见偶数，就保存到新数组，同时从原数组中删除
        if (*ib1 % 2 == 0) {
            array_temp.push_back(*ib1);
            ib1 = array.erase(ib1);
        }
        else{
            ib1++;
        }

    }
    vector<int>::iterator ib2, ie2;
    ib2 = array_temp.begin();
    ie2 = array_temp.end();

    for (; ib2 != ie2; ib2++)             //将新数组的数添加到老数组
    {
        array.push_back(*ib2);
    }
}

};
57. https://www.nowcoder.com/questionTerminal/a1b2b9033b2f4dc5ac79ad2cd24772c1
关于ASCII码和ANSI码，以下说法不正确的是（d）？
标准ASCII只使用7个bit
在简体中文的Windows系统中，ANSI就是GB2312
ASCII码是ANSI码的子集
ASCII码都是可打印字符

A、标准ASCII只使用7个bit，扩展的ASCII使用8个bit。
B、ANSI通常使用 0x00~0x7f 范围的1 个字节来表示 1 个英文字符。超出此范围的使用0x80~0xFFFF来编码，即扩展的ASCII编码。不同 ANSI 编码之间互不兼容。在简体中文Windows操作系统中，ANSI 编码代表 GBK 编码；在繁体中文Windows操作系统中，ANSI编码代表Big5；在日文Windows操作系统中，ANSI 编码代表 Shift_JIS 编码。
C、ANSI通常使用 0x00~0x7f 范围的1 个字节来表示 1 个英文字符，即ASCII码
D、ASCII码包含一些特殊空字符

https://www.nowcoder.com/questionTerminal/9f3231a991af4f55b95579b44b7a01ba
把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。输入一个非减排序的数组的一个旋转，输出旋转数组的最小元素。
例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。 NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。
链接：https://www.nowcoder.com/questionTerminal/9f3231a991af4f55b95579b44b7a01ba
来源：牛客网

旋转之后的数组实际上可以划分成两个有序的子数组：前面子数组的大小都大于后面子数组中的元素

注意到实际上最小的元素就是两个子数组的分界线。本题目给出的数组一定程度上是排序的，因此我们试着用二分查找法寻找这个最小的元素。

思路：

（1）我们用两个指针left,right分别指向数组的第一个元素和最后一个元素。按照题目的旋转的规则，第一个元素应该是大于最后一个元素的（没有重复的元素）。

但是如果不是旋转，第一个元素肯定小于最后一个元素。

（2）找到数组的中间元素。

中间元素大于第一个元素，则中间元素位于前面的递增子数组，此时最小元素位于中间元素的后面。我们可以让第一个指针left指向中间元素。

移动之后，第一个指针仍然位于前面的递增数组中。

中间元素小于第一个元素，则中间元素位于后面的递增子数组，此时最小元素位于中间元素的前面。我们可以让第二个指针right指向中间元素。

移动之后，第二个指针仍然位于后面的递增数组中。

这样可以缩小寻找的范围。

（3）按照以上思路，第一个指针left总是指向前面递增数组的元素，第二个指针right总是指向后面递增的数组元素。

最终第一个指针将指向前面数组的最后一个元素，第二个指针指向后面数组中的第一个元素。

也就是说他们将指向两个相邻的元素，而第二个指针指向的刚好是最小的元素，这就是循环的结束条件。

到目前为止以上思路很耗的解决了没有重复数字的情况，这一道题目添加上了这一要求，有了重复数字。

因此这一道题目比上一道题目多了些特殊情况：

我们看一组例子：｛1，0，1，1，1｝和｛1，1， 1，0，1｝都可以看成是递增排序数组｛0，1，1，1，1｝的旋转。

这种情况下我们无法继续用上一道题目的解法，去解决这道题目。因为在这两个数组中，第一个数字，最后一个数字，中间数字都是1。

第一种情况下，中间数字位于后面的子数组，第二种情况，中间数字位于前面的子数组。

因此当两个指针指向的数字和中间数字相同的时候，我们无法确定中间数字1是属于前面的子数组（绿色表示）还是属于后面的子数组（紫色表示）。

也就无法移动指针来缩小查找的范围。

代码

#include
#include
#include
#include
#include
using namespace std;

class Solution {
public:
int minNumberInRotateArray(vector rotateArray) {
int size = rotateArray.size();
if(size == 0){
return 0;
}//if
int left = 0,right = size - 1;
int mid = 0;
// rotateArray[left] >= rotateArray[right] 确保旋转
while(rotateArray[left] >= rotateArray[right]){
// 分界点
if(right - left == 1){
mid = right;
break;
}//if
mid = left + (right - left) / 2;
// rotateArray[left] rotateArray[right] rotateArray[mid]三者相等
// 无法确定中间元素是属于前面还是后面的递增子数组
// 只能顺序查找
if(rotateArray[left] == rotateArray[right] && rotateArray[left] == rotateArray[mid]){
return MinOrder(rotateArray,left,right);
}//if
// 中间元素位于前面的递增子数组
// 此时最小元素位于中间元素的后面
if(rotateArray[mid] >= rotateArray[left]){
left = mid;
}//if
// 中间元素位于后面的递增子数组
// 此时最小元素位于中间元素的前面
else{
right = mid;
}//else
}//while
return rotateArray[mid];
}
private:
// 顺序寻找最小值
int MinOrder(vector &num,int left,int right){
int result = num[left];
for(int i = left + 1;i < right;++i){
if(num[i] < result){
result = num[i];
}//if
}//for
return result;
}
};

int main(){
Solution s;
//vector num = {0,1,2,3,4,5};
//vector num = {4,5,6,7,1,2,3};
vector num = {2,2,2,2,1,2};
int result = s.minNumberInRotateArray(num);
// 输出
cout<<result<<endl;
return 0;
}
59. https://www.nowcoder.com/questionTerminal/abc3fe2ce8e146608e868a70efebf62e
在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。
请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。

https://www.nowcoder.com/questionTerminal/471706f5ecb249778bf0ddf94c0b7ec6
当使包含
applet
程序的页面从最小化恢复时，以下选项中的哪个方法将被执行？（a）
paint()
start()
destroy()
stop()

applet页面刚打开时，程序调用init（）然后调用start（）再然后paint（）
用户离开applet页面，程序自动调用stop（），用户关闭浏览器，程序触发destroy（）
并且paint（）在每一次浏览器显示页面时被调用。
最小化点开–>页面重新显示，之前进程没丢，只有paint（）。

https://www.nowcoder.com/questionTerminal/47ffaf4670384e34a925e294fcd686c0
final、finally和finalize的区别中，下述说法正确的有？a,b
final用于声明属性，方法和类，分别表示属性不可变，方法不可覆盖，类不可继承。
finally是异常处理语句结构的一部分，表示总是执行。
finalize是Object类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法，可以覆盖此方法提供垃圾收集时的其他资源的回收，例如关闭文件等。
引用变量被final修饰之后，不能再指向其他对象，它指向的对象的内容也是不可变的。

c错，错在最后一句话：例如关闭文件。
finalize 并不是用来关闭文件的，关闭文件的操作由一些 native 本地方法处理，finalize 只负责内存中垃圾对象的回收。
d错,引用内容是可变的

https://www.nowcoder.com/questionTerminal/b4a4fb228d724d8a87b64f3a7311cd27
public interface IService {
String NAME=“default”;
} 与上面等价表示是哪一项（d）？
public String NAME=”default”;
public static String NAME=”default”;
private String NAME=”default”;
public static final String NAME=”default”;

为什么是public：因为接口必然是要被实现的，如果不是public，这个属性就没有意义了；
为什么是static：因为如果不是static，那么由于每个类可以继承多个接口，那就会出现重名的情况；
为什么是final：这是为了体现java的开闭原则，因为接口是一种模板，既然是模板，那就对修改关闭，对扩展开放。
接口是对一类事物的属性和行为更高层次的抽象。对修改关闭，对扩展开放，接口是对开闭原则的一种体现。所以接口的属性用 public static final 修饰。

https://www.nowcoder.com/questionTerminal/6051f858caf441809eaf5cdd6800e537
下面不是面向对象的基本原则的是？ c

单一职责原则（Single-Resposibility Principle）
开放封闭原则（Open-Closed principle）
抽象类原则（Abstract-Class principle）
依赖倒置原则（Dependecy-Inversion Principle）
接口隔离原则（Interface-Segregation Principle）

面向对象的五大基本原则
单一职责原则（SRP）
开放封闭原则（OCP）
里氏替换原则（LSP）
依赖倒置原则（DIP）
接口隔离原则（ISP）
64. https://www.nowcoder.com/questionTerminal/6047ef1f4cd345279a363580e6940547
下面哪些情况可以引发异常：a,b,c
数组越界
指定URL不存在
使用throw语句抛出
使用throws语句

1、throws出现在方法头，throw出现在方法体
2、throws表示出现异常的一种可能性，并不一定会发生异常；
throw则是抛出了异常，执行throw则一定抛出了某种异常。
3、两者都是消极的异常处理方式，只是抛出或者可能抛出异常，是不会由函数处理，真正的处理异常由它的上层调用处理。

https://www.nowcoder.com/questionTerminal/bb13c8d9729a4249b6456510e7f1cd70
以下关于集合类
ArrayList
、
LinkedList
、
HashMap
描述错误的是：c
HashMap实现Map接口，它允许任何类型的键和值对象，并允许将null用作键或值
ArrayList和LinkedList均实现了List接口
添加和删除元素时，ArrayList的表现更佳
ArrayList的访问速度比LinkedList快

Hashtable不允许 null 值(key 和 value 都不可以)，HashMap允许 null 值(key和value都可以)。 ArrayList和LinkedList均实现了List接口
ArrayList基于数组实现，随机访问更快
LinkedList基于链表实现，添加和删除更快

https://www.nowcoder.com/questionTerminal/cf28c596c6914d358361951d783c1634
以下代码结果是什么？c
public class foo {
public static void main(String sgf[]) {
StringBuffer a=new StringBuffer(“A”);
StringBuffer b=new StringBuffer(“B”);
operate(a,b);
System.out.println(a+”.”+b);
}
static void operate(StringBuffer x,StringBuffer y) {
x.append(y);
y=x;
}
}
代码可以编译运行，输出“AB.AB”。
代码可以编译运行，输出“A.A”。
代码可以编译运行，输出“AB.B”。
代码可以编译运行，输出“A.B”。

引用a指向对象A
引用b指向对象B
引用x指向对象A
引用y指向对象B
在operate方法中，引用x指向的对象A被连接了B，对象A也就被改变为AB
然后又把引用y指向了x所指向的对象地址，也就是此时引用a,x,y指向同一个对象AB
而引用b没有发生任何变化，依旧指向对象B。

https://www.nowcoder.com/questionTerminal/8be1ad1273b944128d04cf9e831cce16
在java7中，下列不能做switch()的参数类型是？d
int型
枚举类型
字符串
浮点型
switch语句后的控制表达式只能是short、char、int、long整数类型和枚举类型，不能是float，double和boolean类型。String类型是java7开始支持
https://www.nowcoder.com/questionTerminal/19b30ddb00d74eb1bf67d04e4a76f251
下列方法中哪个是线程执行的方法？（a）
run（）
start（）
sleep（）
suspend（）

答案是A
run()方法用来执行线程体中具体的内容
start()方法用来启动线程对象，使其进入就绪状态
sleep()方法用来使线程进入睡眠状态
suspend()方法用来使线程挂起，要通过resume()方法使其重新启动

https://www.nowcoder.com/questionTerminal/8d53f414b58b4c3cbc3e20c13facbeca
下面哪个语句是创建数组的正确语句？( a,b,d,e)
float f[][] = new float[6][6];
float []f[] = new float[6][6];
float f[][] = new float[][6];
float [][]f = new float[6][6];
float [][]f = new float[6][];
在Myeclipse中敲了一下，确实ABDE都可以。也就是说数组命名时名称与[]可以随意排列，但声明的二维数组中第一个中括号中必须要有值，它代表的是在该二维数组中有多少个一维数组
https://www.nowcoder.com/questionTerminal/82c0f04139f048f7826660624da84ead
以下叙述正确的是d
实例方法可直接

最低0.47元/天解锁文章

weixin_42431912

关注

0
点赞
踩
8

收藏

觉得还不错? 一键收藏
0
评论
对网上一些Java笔试题的总结,答案与自我理解(400道)

对网上一些Java笔试题的总结,答案与自我理解1… https://www.nowcoder.com/questionTerminal/48db39d722894c08907a8f613858672e在Java中，对于不再使用的内存资源，如调用完成的方法，“垃圾回收器”会自动将其释放。（ b ）正确错误GC垃圾回收器会自动识别无用的内存2… https://www.nowcoder.c...
复制链接

扫一扫