【Java】Java选择题错题集（三）

J2EE中，当把来自客户机的HTTP请求委托给servlet时，会调用HttpServlet的（    ）方法
正确答案: A   你的答案: D (错误)
service
doget
dopost

init

1.初始化阶段  调用init()方法
2.响应客户请求阶段　　调用service()方法

3.终止阶段　　调用destroy()方法

ServletConfig接口默认是哪里实现的？
正确答案: B   你的答案: C (错误)
Servlet
GenericServlet
HttpServlet

用户自定义servlet

下面哪一项不是加载驱动程序的方法？
正确答案: A   你的答案: B (错误)
通过DriverManager.getConnection方法加载
调用方法 Class.forName
通过添加系统的jdbc.drivers属性

通过registerDriver方法注册

DriverManager.getConnection方法返回一个Connection对象，这是加载驱动之后才能进行的

经过强制类型转换以后，变量a, b的值分别为（ ）short a = 128; byte b = (byte) a;
正确答案: B   你的答案: A (错误)
128  127
128  -128
128  128

编译错误

128为正数，补码为10000000（前面24个0省略），变成byte，只剩下10000000（byte为1个字节），因为开头是1，所以为负数。即1个负数的补码是10000000。反码是01111111，原码是1000000。是128.因为是负数，所以是-128。

以下哪项不属于java类加载过程？
正确答案: B   你的答案: D (错误)
生成java.lang.Class对象
int类型对象成员变量赋予默认值
执行static块代码

类方法解析

选项A：生成java.lang.Class对象是在加载时进行的。生成Class对象作为方法区这个类的各种数据的访问入口。
选项B：既然是对象成员，那么肯定在实例化对象后才有。在类加载的时候会赋予初值的是类变量，而非对象成员。
选项C：这个会调用。可以用反射试验。
选项D：类方法解析发生在解析过程。

BufferedReader的父类是以下哪个？
正确答案: D   你的答案: B (错误)
FilterReader
InputStreamReader
PipedReader

Reader

假设如下代码中，若t1线程在t2线程启动之前已经完成启动。代码的输出是（）
public static void main(String[]args)throws Exception {
    final Object obj = new Object();
    Thread t1 = new Thread() {
        public void run() {
            synchronized (obj) {
                try {
                    obj.wait();
                    System.out.println("Thread 1 wake up.");
                } catch (InterruptedException e) {
                }
            }
        }
    };
    t1.start();
    Thread.sleep(1000); //We assume thread 1 must start up within 1 sec.
    Thread t2 = new Thread() {
        public void run() {
            synchronized (obj) {
                obj.notifyAll();
                System.out.println("Thread 2 sent notify.");
            }
        }
    };
    t2.start();
}
正确答案: B   你的答案: C (错误)
Thread 1 wake up
Thread 2 sent notify.

Thread 2 sent notify.
Thread 1 wake up

A、B皆有可能

程序无输出卡死

执行obj.wait();时已释放了锁，所以t2可以再次获得锁，然后发消息通知t1执行，但这时t2还没有释放锁，所以肯定是执行t2，然后释放锁，之后t1才有机会执行。

notify()就是对对象锁的唤醒操作。但有一点需要注意的是notify()调用后，并不是马上就释放对象锁的，而是在相应的synchronized(){}语句块执行结束，自动释放锁后，JVM会在wait()对象锁的线程中随机选取一线程，赋予其对象锁，唤醒线程，继续执行。这样就提供了在线程间同步、唤醒的操作。

java中 String str = "hello world"下列语句错误的是？
正确答案: A B C   你的答案: C (错误)
str+='  a'
int strlen = str.length
str=100

str=str+100

String有length()方法

对于JVM内存配置参数：
-Xmx10240m -Xms10240m -Xmn5120m -XXSurvivorRatio=3
,其最小内存值和Survivor区总大小分别是（）
正确答案: D   你的答案: 空 (错误)
5120m，1024m
5120m，2048m
10240m，1024m

10240m，2048m

-Xmx：最大堆大小
-Xms：初始堆大小
-Xmn:年轻代大小
-XXSurvivorRatio：年轻代中Eden区与Survivor区的大小比值
年轻代5120m， Eden：Survivor=3，Survivor区大小=1024m（Survivor区有两个，即将年轻代分为5份，每个Survivor区占一份），总大小为2048m。

-Xms初始堆大小即最小内存值为10240m

Java 语言中，负责并发管理的机制是（ ）
正确答案: D   你的答案: C (错误)
垃圾回收
虚拟机
代码安全

多线程

选项A，Java语言中，垃圾回收机制对系统中不使用的内存进行回收，从而使程序员从繁忙的内存管理中解放出来。
选项B，Java编写好的程序首先由编译器转换为标准字节代码，然后由虚拟机执行。虚拟机把字节代码程序与各操作系统和硬件分开，使Java程序独立于平台。
选项C，Java的代码安全检测体现在多个层次上，在编译层、解释层、平台层分别作不同的安全检查。

选项D，多线程是Java程序的并发机制，它能同步共享数、处理不同的事件。

下面有关JSP内置对象的描述，说法错误的是？
正确答案: C   你的答案: A (错误)
session对象：session对象指的是客户端与服务器的一次会话，从客户连到服务器的一个WebApplication开始，直到客户端与服务器断开连接为止
request对象：客户端的请求信息被封装在request对象中，通过它才能了解到客户的需求，然后做出响应
application对象：多个application对象实现了用户间数据的共享，可存放全局变量

response对象：response对象包含了响应客户请求的有关信息

其实解释就一句话，application服务器就创建了一个，C选项后面错误了，不是多个

从运行层面上来看，从四个选项选出不同的一个。
正确答案: B   你的答案: 空 (错误)
JAVA
Python
objectC
C#

答案：B
A，C，D都是类C语言，B不是

Python是解释执行的，其他语言都需要先编译

下列命令中，用来运行 Java 程序的是（）
正确答案: A   你的答案: D (错误)
java
javadoc
jar
javac

A. java用来运行一个.class文件
B.javadoc用来生成api文档
C.jar用来生成jar包

D.javac用来把.java文件编译为.class文件

关于继承的说法正确的是（）。
正确答案: A   你的答案: B (错误)
子类将继承父类所有的数据域和方法。
子类将继承父类的其可见的数据域和方法。
子类只继承父类public方法和数据域

子类只继承父类的方法，而不继承数据域

私有方法谁说不能继承了?只是不能直接调用罢了.

下面哪个标识符是合法的？
正确答案: D   你的答案: B (错误)
"9HelloWorld"
"_Hello World"
"Hello*World"

"Hello$World"

标识符是以字母开头的字母数字序列：
数字是指0~9，字母指大小写英文字母、下划线（_)和美元符号（$），也可以是Unicode字符集中的字符，如汉字；
字母、数字等字符的任意组合，不能包含+、- *等字符；
不能使用关键字；

大小写敏感

以下Java程序运行的结果是:
public class Tester{
public static void main(String[] args){
   Integer var1=new Integer(1);
   Integer var2=var1;
   doSomething(var2);
   System.out.print(var1.intValue());
   System.out.print(var1==var2);
}
public static void doSomething(Integer integer){
    integer=new Integer(2);
    }
}
正确答案: A   你的答案: C (错误)
1true
2true
1false

2false

java中下面哪些是Object类的方法（）
正确答案: A B D   你的答案: A B (错误)
notify()
notifyAll()
sleep

wait()

Object的方法

Sleep是Thread的类方法

以下 json 格式数据，错误的是


正确答案: A C   你的答案: 空 (错误)
{company：4399}
{"company":{"name":[4399,4399,4399]}}
{[4399,4399,4399]}
{"company":[4399,4399,4399]}

{"company":{"name":4399}}

 应该是需要加引号，并且是一对一对出现的。

volatile关键字的说法错误的是
正确答案: A   你的答案: D (错误)
能保证线程安全
volatile关键字用在多线程同步中，可保证读取的可见性
JVM保证从主内存加载到线程工作内存的值是最新的

volatile能禁止进行指令重排序

Java中的volatile关键字的功能


volatile是java中的一个类型修饰符。它是被设计用来修饰被不同线程访问和修改的变量。如果不加入volatile，基本上会导致这样的结果：要么无法编写多线程程序，要么编译器 失去大量优化的机会。


1，可见性


    可见性指的是在一个线程中对该变量的修改会马上由工作内存（Work Memory）写回主内存（Main Memory），所以会马上反应在其它线程的读取操作中。顺便一提，工作内存和主内存可以近似理解为实际电脑中的高速缓存和主存，工作内存是线程独享的，主存是线程共享的。


2，禁止指令重排序优化


    禁止指令重排序优化。大家知道我们写的代码（尤其是多线程代码），由于编译器优化，在实际执行的时候可能与我们编写的顺序不同。编译器只保证程序执行结果与源代码相同，却不保证实际指令的顺序与源代码相同。这在单线程看起来没什么问题，然而一旦引入多线程，这种乱序就可能导致严重问题。volatile关键字就可以从语义上解决这个问题。

    注意，禁止指令重排优化这条语义直到jdk1.5以后才能正确工作。此前的JDK中即使将变量声明为volatile也无法完全避免重排序所导致的问题。所以，在jdk1.5版本前，双重检查锁形式的单例模式是无法保证线程安全的。因此，下面的单例模式的代码，在JDK1.5之前是不能保证线程安全的。

出于运行速率的考虑，java编译器会把经常经常访问的变量放到缓存（严格讲应该是工作内存）中，读取变量则从缓存中读。但是在多线程编程中,内存中的值和缓存中的值可能会出现不一致。volatile用于限定变量只能从内存中读取，保证对所有线程而言，值都是一致的。但是volatile不能保证原子性，也就不能保证线程安全。

下列说法错误的有（ ）
正确答案: B C D   你的答案: B (错误)
能被java.exe成功运行的java class文件必须有main()方法
J2SDK就是Java API
Appletviewer.exe可利用jar选项运行.jar文件

能被Appletviewer成功运行的java class文件必须有main()方法

选BCD

A：大家可以想一想刚开始学java的时候，在命令行执行用javac和java命令编译和执行java文件的情况， java class中没有main方法，javac编译能通过，但是程序不知道入口，在执行的时候(也就是调用java.exe的时候)就会报错。 我做了一个测试，如下图所示：

                                                   

                                                                        图1.java程序A

                            

                                                                     图2.执行程序A情况

B：来自百度百科： 在JDK5之后，J2SDK 改名为 Java SE DK(简称依然是JDK) ，它是java开发编程的工具，提供了编译功能和运行环境等，包含jdk和jre。但它不是java编程开发的平台。Java API 是Java应用程序编程接口，它和JDK不是一回事。

C:   appletviewer.exe执行选项参数中并没有jar选项 。如下如所示：

                          

D：  appletviewer(小程序浏览器) ：一种执行HTML文件上的Java小程序类的Java浏览器，就是用来解释执行java  applet应用程序的, 简单理解就是没有main函数的继承applet类的 java 类。类似于WEB上开发的java类，不需要写main函数 。

下列程序的运行结果
public static void main(String args[]) {
   Thread t = new Thread() {
            public void run() {
                pong();
            }
        };
        t.run();
        System.out.print("ping");
    }
    static void pong() {
        System.out.print("pong");
    }
正确答案: B   你的答案: A (错误)
pingpong
pongping
pingpong和pongping都有可能

都不输出

该题考察的是线程的启动。
在第7行的时候，调用的是t.run();方法，之间调用run方法就是普通的方法调用而已，所以肯定是先执行pong()再执行System.out.print("ping");

如果第7行换成t.start()方法，答案就应该选择c，因为t.start()后，线程变为就绪状态，什么时候开始执行时不确定的，可能是主程序先继续执行，也可能是新线程先执行。

下面有关java threadlocal说法正确的有？
正确答案: A B C D   你的答案: B (错误)
ThreadLocal存放的值是线程封闭，线程间互斥的，主要用于线程内共享一些数据，避免通过参数来传递
线程的角度看，每个线程都保持一个对其线程局部变量副本的隐式引用，只要线程是活动的并且 ThreadLocal 实例是可访问的；在线程消失之后，其线程局部实例的所有副本都会被垃圾回收
在Thread类中有一个Map，用于存储每一个线程的变量的副本。

对于多线程资源共享的问题，同步机制采用了“以时间换空间”的方式，而ThreadLocal采用了“以空间换时间”的方式

考虑下面这个简单的例子，让我们看看reflection是如何工作的。
import java.lang.reflect.*;
public class DumpMethods{
    public static void main(String[] args) {
        try {
            Class c=Class.forName(args[0]);
            Method m[]=c.getDeclaredMethods();
            for (int i = 0; i < m.length; i++) {
                System.out.println(m[i].toString());
            }
        } catch (Throwable e) {
            System.err.println(e);
        }
    }
}
其中"c.getDeclaredMethods"的作用是:
正确答案: D   你的答案: B (错误)
取得类的公有方法对象
取得类的所有公有方法名称
取得类的所有方法对象

以上选项都不正确

public Method[] getDeclaredMethods() 返回类或接口声明的所有方法 ，包括public, protected, default (package) 访问和private方法的Method对象， 但不包括继承的方法。当然也包括它所实现接口的方法 。

public Method[] getMethods() 返回类的所有public方法，包括其继承类的公用方法，当然也包括它所实现接口的方法 。

Which are keywords in Java?
正确答案: D E   你的答案: A B C D E (错误)
null
true
sizeof
implements

instanceof

关键字列表 (依字母排序 共50组)：

abstract, assert, boolean, break, byte, case, catch, char, class,  const（保留关键字）, continue, default, do, double, else, enum, extends, final, finally, float, for,  goto（保留关键字）, if, implements, import, instanceof, int, interface, long, native, new, package, private, protected, public, return, short, static, strictfp, super, switch, synchronized, this, throw, throws, transient, try, void, volatile, while

保留字列表 (依字母排序 共14组)，Java保留字是指现有Java版本尚未使用，但以后版本可能会作为关键字使用：

byValue, cast,  false, future, generic, inner, operator, outer, rest,  true, var,  goto （保留关键字） ,  const （保留关键字） ,  null

设三个整型变量 x = 1 , y = 2 , z = 3，则表达式 y＋＝z－－/＋＋x 的值是(      )。
正确答案: A   你的答案: B (错误)
3
3.5
4
5

因为x,y,z都是int型的，所以最后的返回值只能是int

下面有个hibernate延迟加载，说法错误的是？
正确答案: C   你的答案: 空 (错误)
Hibernate2延迟加载实现：a)实体对象 b)集合（Collection）
Hibernate3 提供了属性的延迟加载功能
get支持延迟加载，load不支持延迟加
hibernate使用Java反射机制，而不是字节码增强程序来实现透明性

  load方法来得到一个对象时，此时hibernate会使用延迟加载的机制来加载这个对象，即：当 我们使用session.load()方法来加载一个对象时，此时并不会发出sql语句，当前得到的这个对象其实是一个代理对象，这个代理对象只保存了实 体对象的id值，只有当我们要使用这个对象，得到其它属性时，这个时候才会发出sql语句，从数据库中去查询我们的对象。
    相对于load的延迟加载方式，get就直接的多，当我们使用session.get()方法来得到一个对象时，不管我们使不使用这个对象，此时都会发出sql语句去从数据库中查询出来。

Model-View-Controller(MVC) is an architectural pattern that frequently used in web applications. Which of the following statement(s) is(are) correct?
正确答案: A B C   你的答案: A C (错误)

Models often represent data and the business logics needed to manipulate the data in the application

A view is a (visual) representation of its model. It renders the model into a form suitable for interaction, typically a user interface element

A controller is the link between a user and the system. It accepts input from the user and instructs the model and a view to perform actions based on that input

The common practice of MVC in web applications is, the model receives GET or POST input from user and decides what to do with it, handing over to controller and which hand control to views(HTML-generating components)

None of the above

...the  controller  receives GET or POST input from user and decides what to do with it, handing over to model and which hand control to views...

往OuterClass类的代码段中插入内部类声明, 哪一个是错误的:
public class OuterClass{
    private float f=1.0f;
    //插入代码到这里
}
正确答案: A B C D   你的答案: A C (错误)
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.抽象方法不可以有函数体

下列关于包（package）的描述，正确的是（）
正确答案: D   你的答案: D (正确)
包（package）是Java中描述操作系统对多个源代码文件组织的一种方式。
import语句将所对应的Java源文件拷贝到此处执行。
包（package）是Eclipse组织Java项目特有的一种方式。

定义在同一个包（package）内的类可以不经过import而直接相互使用。

1、为了更好地组织类，Java提供了包机制。包是类的容器，用于分隔类名空间。如果没有指定包名，所有的示例都属于一个默认的无名包。Java中的包一般均包含相关的类，java是跨平台的，所以java中的包和操作系统没有任何关系，java的包是用来组织文件的一种虚拟文件系统。A错
2、import语句并没有将对应的java源文件拷贝到此处仅仅是引入，告诉编译器有使用外部文件，编译的时候要去读取这个外部文件。B错
3、Java提供的包机制与IDE没有关系。C错

4、定义在同一个包（package）内的类可以不经过import而直接相互使用。

下面程序的输出结果是？
package algorithms.com.guan.javajicu; 
public class TestDemo { 
    public static String output =""; 
    public static void foo(int i){ 
       try{ 
           if(i == 1){ 
              throw new Exception(); 
           } 
       }catch(Exception e){ 
           output += "2"; 
           return ; 
       }finally{ 
           output += "3"; 
       } 
       output += "4"; 
    } 
    
    public static void main(String[] args) { 
       foo(0); 
       foo(1); 
       System.out.println(output);
    } 
}
正确答案: D   你的答案: C (错误)
出错
342
34234

3423

catch到异常后先执行finally块在执行catch中的return语句

关于下列程序段的输出结果，说法正确的是：（ ） 
public class MyClass{
static int i;
public static void main(String argv[]){
System.out.println(i);
}
}
正确答案: D   你的答案: A (错误)
有错误，变量i没有初始化。
null
1

0

类变量在不设置初始值时，会进行默认值赋值，而局部方法中声明的变量则必须进行初始化，他不会进行默认值赋值。

结构型模式中最体现扩展性的模式是（）
正确答案: A   你的答案: C (错误)
装饰模式
合成模式
桥接模式

适配器

A
结构型模式是描述如何将类对象结合在一起，形成一个更大的结构，结构模式描述两种不同的东西：类与类的实例。故可以分为类结构模式和对象结构模式。
在GoF设计模式中，结构型模式有：


1.适配器模式 Adapter
  适配器模式是将一个类的接口转换成客户希望的另外一个接口。适配器模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。
  两个成熟的类需要通信，但是接口不同，由于开闭原则，我们不能去修改这两个类的接口，所以就需要一个适配器来完成衔接过程。
2.桥接模式 Bridge
  桥接模式将抽象部分与它的实现部分分离，是它们都可以独立地变化。它很好的支持了开闭原则和组合锯和复用原则。实现系统可能有多角度分类，每一种分类都有可能变化，那么就把这些多角度分离出来让他们独立变化，减少他们之间的耦合。
3.组合模式 Composite
  组合模式将对象组合成树形结构以表示部分-整体的层次结构，组合模式使得用户对单个对象和组合对象的使用具有一致性。
4.装饰模式 Decorator
装饰模式动态地给一个对象添加一些额外的职责，就增加功能来说，它比生成子类更灵活。也可以这样说，装饰模式把复杂类中的核心职责和装饰功能区分开了，这样既简化了复杂类，有去除了相关类中重复的装饰逻辑。 装饰模式没有通过继承原有类来扩展功能，但却达到了一样的目的，而且比继承更加灵活，所以可以说装饰模式是继承关系的一种替代方案。
5.外观模式 Facade
 外观模式为子系统中的一组接口提供了同意的界面，外观模式定义了一个高层接口，这个接口使得这一子系统更加容易使用。
外观模式中，客户对各个具体的子系统是不了解的，所以对这些子系统进行了封装，对外只提供了用户所明白的单一而简单的接口，用户直接使用这个接口就可以完成操作，而不用去理睬具体的过程，而且子系统的变化不会影响到用户，这样就做到了信息隐蔽。
6.享元模式 Flyweight
 享元模式为运用共享技术有效的支持大量细粒度的对象。因为它可以通过共享大幅度地减少单个实例的数目，避免了大量非常相似类的开销。
      享元模式是一个类别的多个对象共享这个类别的一个对象，而不是各自再实例化各自的对象。这样就达到了节省内存的目的。
7.代理模式 Proxy   

为其他对象提供一种代理，并由代理对象控制对原对象的引用，以间接控制对原对象的访问。

下面有关servlet service描述错误的是？
正确答案: B   你的答案: B (正确)
不管是post还是get方法提交过来的连接，都会在service中处理
doGet/doPost 则是在 javax.servlet.GenericServlet 中实现的
service()是在javax.servlet.Servlet接口中定义的
service判断请求类型，决定是调用doGet还是doPost方法

doGet/doPost 则是在 javax.servlet.http.HttpServlet 中实现的

GenericServlet 抽象类 给出了设计 servlet 的一些骨架，定义了 servlet 生命周期，还有一些得到名字、配置、初始化参数的方法，其设计的是和应用层协议无关的

在 JAVA 编程中， Java 编译器会将 Java 程序转换为（ ）
正确答案: A   你的答案: B (错误)
字节码
可执行代码
机器代码

以上都不对

编译器将Java源代码编译成字节码class文件
类加载到JVM里面后，执行引擎把字节码转为可执行代码

执行的过程，再把可执行代码转为机器码，由底层的操作系统完成执行

下列在Java语言中关于数据类型和包装类的说法，正确的是（）
正确答案: B   你的答案: A (错误)
基本（简单）数据类型是包装类的简写形式，可以用包装类替代基本（简单）数据类型
long和double都占了64位（64bit）的存储空间。
默认的整数数据类型是int，默认的浮点数据类型是float。

和包装类一样，基本（简单）数据类型声明的变量中也具有静态方法，用来完成进制转化等。

浮点数默认double

JSP分页代码中，哪个步骤次序是正确的？
正确答案: A   你的答案: B (错误)
先取总记录数，得到总页数，最后显示本页的数据。
先取所有的记录，得到总页数，再取总记录数，最后显示本页的数据。
先取总页数，得到总记录数，再取所有的记录，最后显示本页的数据。

先取本页的数据，得到总页数，再取总记录数，最后显示所有的记录。

下面有关servlet中init,service,destroy方法描述错误的是？
正确答案: D   你的答案: C (错误)
init()方法是servlet生命的起点。一旦加载了某个servlet，服务器将立即调用它的init()方法
service()方法处理客户机发出的所有请求
destroy()方法标志servlet生命周期的结束

servlet在多线程下使用了同步机制，因此，在并发编程下servlet是线程安全的

servlet在多线程下其本身并不是线程安全的。

如果在类中定义成员变量，而在service中根据不同的线程对该成员变量进行更改，那么在并发的时候就会引起错误。最好是在方法中，定义局部变量，而不是类变量或者对象的成员变量。由于方法中的局部变量是在栈中，彼此各自都拥有独立的运行空间而不会互相干扰，因此才做到线程安全。

下面哪个不属于HttpServletResponse接口完成的功能？
正确答案: C   你的答案: B (错误)
设置HTTP头标
设置cookie
读取路径信息

输出返回数据

HttpServletResponse完成：设置http头标，设置cookie，设置返回数据类型，输出返回数据；读取路径信息是HttpServletRequest做的

A：设置HTTP头标  

1	response.setHeader( "Refresh" , "3" );  //三秒刷新页面一次

B：设置cookie

1 2	Cookie c1 =  new Cookie( "username" , "only" ); response.addCookie(c1);

C（错误）：读取路径信息,request读取路径信息

1 2 3 4 5

从request获取各种路径总结 request.getRealPath( "url" );  // 虚拟目录映射为实际目录 request.getRealPath( "./" );     // 网页所在的目录 request.getRealPath( "../" );  // 网页所在目录的上一层目录 request.getContextPath();     // 应用的web目录的名称

D：输出返回数据

1	HttpServleteResponse.getOutputStream().write();

下面有关 java 类加载器,说法正确的是?()
正确答案: A B C D   你的答案: A B C (错误)
引导类加载器(bootstrap class loader):它用来 加载 Java 的核心库,是用原生代码来实现的
扩展类加载器(extensions class loader):它用来 加载 Java 的扩展库。
系统类加载器(system class loader):它根据 Java 应用的类路径(CLASSPATH)来加载 Java 类

tomcat 为每个 App 创建一个 Loader,里面保存着此 WebApp 的 ClassLoader。需要加载 WebApp 下的类时,就取出 ClassLoader 来使用

在java中，下列标识符不合法的有（ ）
正确答案: A C D   你的答案: A B C D (错误)
new
$Usdollars
1234

car.taxi

Java标识符由数字，字母和下划线（_），美元符号（$）组成。在Java中是区分大小写的，而且还要求首位不能是数字。

关于volatile关键字，下列描述不正确的是？
正确答案: B D   你的答案: B C (错误)
用volatile修饰的变量，每次更新对其他线程都是立即可见的。
对volatile变量的操作是原子性的。
对volatile变量的操作不会造成阻塞。

不依赖其他锁机制，多线程环境下的计数器可用volatile实现。

所谓 volatile的措施，就是
1. 每次从内存中取值，不从缓存中什么的拿值。这就保证了用 volatile修饰的共享变量，每次的更新对于其他线程都是可见的。
2. volatile保证了其他线程的立即可见性，就没有保证原子性。

3.由于有些时候对 volatile的操作，不会被保存，说明不会造成阻塞。不可用与多线程环境下的计数器，多线程下计数器必须使用锁保护

关键字super的作用是？
正确答案: D   你的答案: C (错误)
用来访问父类被隐藏的非私有成员变量
用来调用父类中被重写的方法
用来调用父类的构造函数

以上都是

super代表父类对应的对象，所以用super访问在子类中无法直接使用的父类成员和方法

下列哪种说法是正确的（ ）
正确答案: D   你的答案: A (错误)
实例方法可直接调用超类的实例方法（私有就不可以）
实例方法可直接调用超类的类方法（私有就不可以）
实例方法可直接调用其他类的实例方法

实例方法可直接调用本类的类方法

一般用()创建InputStream对象,表示从标准输入中获取数据,用()创建OutputStream对象，表示输出到标准输出设备中。
正确答案: A   你的答案: C (错误)
System.in System.out
System.out System.in
System.io.in System.io.out
System.io.out System.io.in

System.in 和 System.out 是java中的标准输入输出流，一般情况下代表从控制台输入和输出到控制台

标准输入指键盘输入；标准输出指输出到屏幕上。

以下哪几种方式可用来实现线程间通知和唤醒：( )
正确答案: A C   你的答案: D (错误)
Object.wait/notify/notifyAll
ReentrantLock.wait/notify/notifyAll
Condition.await/signal/signalAll

Thread.wait/notify/notifyAll

wait()、notify()和notifyAll()是  Object类   中的方法  ；
Condition是在java 1.5中才出现的，它用来替代传统的Object的wait()、notify()实现线程间的协作，相比使用Object的wait()、 notify()，使用 Condition1的await()、signal()这种方式实现线程间协作更加安全和高效 。

Thread类对线程执行控制的的方法是sleep

jvm中垃圾回收分为scanvenge gc和full GC，其中full GC触发的条件可能有哪些
正确答案: C D E   你的答案: A B C D (错误)
栈空间满
年轻代空间满
老年代满
持久代满

System.gc()

1，新生代：（1）所有对象创建在新生代的Eden区，当Eden区满后触发新生代的Minor GC，将Eden区和非空闲Survivor区存活的对象复制到另外一个空闲的Survivor区中。（2）保证一个Survivor区是空的，新生代Minor GC就是在两个Survivor区之间相互复制存活对象，直到Survivor区满为止。
2，老年代：当Survivor区也满了之后就通过Minor GC将对象复制到老年代。老年代也满了的话，就将触发Full GC，针对整个堆（包括新生代、老年代、持久代）进行垃圾回收。

3，持久代：持久代如果满了，将触发Full GC。

full GC触发的条件
除直接调用System.gc外，触发Full GC执行的情况有如下四种。
1. 旧生代空间不足
旧生代空间只有在新生代对象转入及创建为大对象、大数组时才会出现不足的现象，当执行Full GC后空间仍然不足，则抛出如下错误：
java.lang.OutOfMemoryError: Java heap space 
为避免以上两种状况引起的FullGC，调优时应尽量做到让对象在Minor GC阶段被回收、让对象在新生代多存活一段时间及不要创建过大的对象及数组。
2. Permanet Generation空间满
PermanetGeneration中存放的为一些class的信息等，当系统中要加载的类、反射的类和调用的方法较多时，Permanet Generation可能会被占满，在未配置为采用CMS GC的情况下会执行Full GC。如果经过Full GC仍然回收不了，那么JVM会抛出如下错误信息：
java.lang.OutOfMemoryError: PermGen space 
为避免Perm Gen占满造成Full GC现象，可采用的方法为增大Perm Gen空间或转为使用CMS GC。
3. CMS GC时出现promotion failed和concurrent mode failure
对于采用CMS进行旧生代GC的程序而言，尤其要注意GC日志中是否有promotion failed和concurrent mode failure两种状况，当这两种状况出现时可能会触发Full GC。
promotionfailed是在进行Minor GC时，survivor space放不下、对象只能放入旧生代，而此时旧生代也放不下造成的；concurrent mode failure是在执行CMS GC的过程中同时有对象要放入旧生代，而此时旧生代空间不足造成的。
应对措施为：增大survivorspace、旧生代空间或调低触发并发GC的比率，但在JDK 5.0+、6.0+的版本中有可能会由于JDK的bug29导致CMS在remark完毕后很久才触发sweeping动作。对于这种状况，可通过设置-XX:CMSMaxAbortablePrecleanTime=5（单位为ms）来避免。
4. 统计得到的Minor GC晋升到旧生代的平均大小大于旧生代的剩余空间
这是一个较为复杂的触发情况，Hotspot为了避免由于新生代对象晋升到旧生代导致旧生代空间不足的现象，在进行Minor GC时，做了一个判断，如果之前统计所得到的Minor GC晋升到旧生代的平均大小大于旧生代的剩余空间，那么就直接触发Full GC。
例如程序第一次触发MinorGC后，有6MB的对象晋升到旧生代，那么当下一次Minor GC发生时，首先检查旧生代的剩余空间是否大于6MB，如果小于6MB，则执行Full GC。
当新生代采用PSGC时，方式稍有不同，PS GC是在Minor GC后也会检查，例如上面的例子中第一次Minor GC后，PS GC会检查此时旧生代的剩余空间是否大于6MB，如小于，则触发对旧生代的回收。

除了以上4种状况外，对于使用RMI来进行RPC或管理的Sun JDK应用而言，默认情况下会一小时执行一次Full GC。可通过在启动时通过- java-Dsun.rmi.dgc.client.gcInterval=3600000来设置Full GC执行的间隔时间或通过-XX:+ DisableExplicitGC来禁止RMI调用System.gc。

下列说法正确的有（）
正确答案: A   你的答案: C (错误)
能被java.exe成功运行的java class文件必须有main()方法
J2SDK就是Java API
Appletviewer.exe可利用jar选项运行.jar文件

能被Appletviewer成功运行的java class文件必须有main()方法

A：正确main方法是入口 
B：J2SDK当然不仅仅包含java API 
C：jar选项是java.exe 的选项 

D：Appletviewer是运行applet的， applet 不用main方法，继承applet类即可。

定义有StringBuffer s1=new StringBuffer(10);s1.append(“1234”)则s1.length()和s1.capacity()分别是多少?
正确答案: A   你的答案: B (错误)
4　10
4　　4
10　　10

10　　4

length 返回当前长度
如果字符串长度没有初始化长度大，capacity返回初始化的长度

如果append后的字符串长度超过初始化长度，capacity返回增长后的长度

java语言的下面几种数组复制方法中，哪个效率最高？
正确答案: B   你的答案: D (错误)
for 循环逐一复制
System.arraycopy
Array.copyOf

使用clone方法

效率：System.arraycopy > clone > Arrays.copyOf > for循环

关于Spring MVC的核心控制器DispatcherServlet的作用，以下说法错误的是（ ）？
正确答案: C   你的答案: A (错误)
它负责处理HTTP请求
加载配置文件
实现业务操作
初始化上下应用对象ApplicationContext

DispatcherServlet作为springMVC的前端控制器，负责接收用户的请求并根据用户的请求返回相应的视图给用户。

实现业务操作时在service层，所以C答案错误。

下列代码执行结果为（）
public static void main(String args[])throws InterruptedException{
            Thread t=new Thread(new Runnable() {
                public void run() {
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    System.out.print("2");
                }
            });
            t.start();
             
            t.join();
            System.out.print("1");
        }


正确答案: A   你的答案: C (错误)
21
12
可能为12，也可能为21
以上答案都不对

thread.Join把指定的线程加入到当前线程，可以将两个交替执行的线程合并为顺序执行的线程。比如在线程B中调用了线程A的Join()方法，直到线程A执行完毕后，才会继续执行线程B。
t.join();      //使调用线程 t 在此之前执行完毕。 

t.join(1000);  //等待 t 线程，等待时间是1000毫秒

因为子线程的休眠时间太长，因此主线程很有可能在子线程之前结束也就是输出结果是12，但是子线程用了join函数，因此主线程必须等待子线程执行完毕才结束因此输出结果只能是21

下面几个关于Java里queue的说法哪些是正确的（）？
正确答案: A C   你的答案: D (错误)
LinkedBlockingQueue是一个可选有界队列，不允许null值
PriorityQueue，LinkedBlockingQueue都是线程不安全的
PriorityQueue是一个无界队列，不允许null值，入队和出队的时间复杂度是O（log(n)）

PriorityQueue，ConcurrentLinkedQueue都遵循FIFO原则

A、LinkedBlockingQueue是一个基于节点链接的可选是否有界的阻塞队列，不允许null值。
B、LinkedBlockingQueue是一个线程安全的阻塞队列，实现了先进先出等特性。
C、PriorityQueue是一个无界队列，不允许null值，入队和出队的时间复杂度是O（log(n)）。

D、PriorityQueue是不同于先进先出队列的另一种队列。每次从队列中取出的是具有最高优先权的元素。ConcurrentLinkedQueue是一个基于链接节点的无界线程安全队列，该队列的元素遵循FIFO原则。

JDK提供的用于并发编程的同步器有哪些？
正确答案: A B C   你的答案: 空 (错误)
Semaphore
CyclicBarrier
CountDownLatch

Counter

A，Java 并发库 的Semaphore 可以很轻松完成信号量控制，Semaphore可以控制某个资源可被同时访问的个数，通过 acquire() 获取一个许可，如果没有就等待，而 release() 释放一个许可。
B，CyclicBarrier 主要的方法就是一个：await()。await() 方法没被调用一次，计数便会减少1，并阻塞住当前线程。当计数减至0时，阻塞解除，所有在此 CyclicBarrier 上面阻塞的线程开始运行。
C，直译过来就是倒计数(CountDown)门闩(Latch)。倒计数不用说，门闩的意思顾名思义就是阻止前进。在这里就是指 CountDownLatch.await() 方法在倒计数为0之前会阻塞当前线程。
D，Counter不是并发编程的同步器

在运行时，由java解释器自动引入，而不用import语句引入的包是()。
正确答案: A   你的答案: B (错误)
java.lang
java.system
java.io

java.util

java.lang包是java语言的核心包，lang是language的缩写

java.lang包定义了一些基本的类型，包括Integer,String之类的，是java程序必备的包，有解释器自动引入，无需手动导入system是属于java.lang.system

java.lang包是java语言包，是自动导入的。
java.util包是java的工具包，需要手动导入。
java.sql包，JDBC接口类，需要手动导入。

java.io;各种输入输入流，需要手动导入。

以下哪一个不是赋值符号？
正确答案: C   你的答案: 空 (错误)
+=
<<=
<<<=

>>>=

<<表示左移位
>>表示带符号右移位
>>>表示无符号右移

但是没有<<<运算符

>>为带符号右移，右移后左边的空位被填充为符号位
>>>为不带符号右移，右移后左边的空位被填充为0

没有<<< 因为<<后右边总是补0

以下代码的输出结果是？

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

public class B {      public static B t1 =  new B();      public static B t2 =  new B();      {          System.out.println( "构造块" );      }      static      {          System.out.println( "静态块" );      }      public static void main(String[] args)      {          B t =  new B();      } } 正确答案: C   你的答案: D (错误) 静态块 构造块 构造块 构造块 构造块 静态块 构造块 构造块 构造块 构造块 静态块 构造块 构造块 构造块 构造块 静态块 静态块：用static申明，JVM加载类时执行，仅执行一次 构造块：类中直接用{}定义，每一次创建对象时执行 执行顺序优先级：静态块>main()>构造块>构造方法 本题注意如下几点： 1、每调用一次构造方法，则执行一次构造块 2、静态块只在类加载的时候加载一次 3、有多个静态变量或块时，按声明顺序加载 链接：https://www.nowcoder.com/questionTerminal/ab6eb06face84c4e81ab5bc6f0f7f258 来源：牛客网 public static B t1 = new B();  public static B t2 = new B(); 所以会打印两个“构造块” 接着在执行静态代码块 打印“静态块”， 最后执行 B t = new B(); 打印“构造块” new 你个对象 只需要调用构造方法 ，静态块是类加载的时候执行的 静态变量和静态代码块的执行顺序就是代码前后的顺序 对于java类型变量char c,short s,float f,double d,表达式c*s+f+d的结果类型为（） 正确答案: D   你的答案: D (正确) float char short double 下列Java代码中的变量a、b、c分别在内存的____存储区存放。 class A {     private String a = “aa”;     public boolean methodB() {         String b = “bb”;         final String c = “cc”;     } } 正确答案: C   你的答案: C (正确) 堆区、堆区、堆区 堆区、栈区、堆区 堆区、栈区、栈区 堆区、堆区、栈区 静态区、栈区、堆区 静态区、栈区、栈区 堆区：只存放类对象，线程共享； 方法区：又叫静态存储区，存放class文件和静态数据，线程共享; 栈区：存放方法局部变量，基本类型变量区、执行环境上下文、操作指令区，线程不共享 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); 下列代码片段中，存在编译错误的语句是() 正确答案: B C D   你的答案: D (错误) 语句2 语句1 语句3 语句4 本题答案应为：B、C、D ------------知识点------------ Java表达式转型规则由低到高转换： 1、所有的byte,short,char型的值将被提升为int型； 2、如果有一个操作数是long型，计算结果是long型； 3、如果有一个操作数是float型，计算结果是float型； 4、如果有一个操作数是double型，计算结果是double型； 5、被final修饰的变量不会自动改变类型，当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修饰，即只可赋值一次，便不可再改变。 下列代码的执行结果是：（ ）  1 2 3 4 5 6 public class Test3{   public static void main(String args[]){      System.out.println( 100 % 3 );      System.out.println( 100 % 3.0 );   } } 正确答案: B   你的答案: A (错误) 1和1 1和1.0 1.0和1 1.0和1.0 多种混合计算时，自动将所有数据类型转换为容量最大的一种数据类型。所以都转为float类型。 下列说法正确的是 正确答案: B   你的答案: D (错误) 在类方法中可用this来调用本类的类方法 在类方法中调用本类的类方法可直接调用 在类方法中只能调用本类的类方法 在类方法中绝对不能调用实例方法 下面不是面向对象的基本原则的是？ 正确答案: C   你的答案: C (正确) 单一职责原则（Single-Resposibility Principle） 开放封闭原则（Open-Closed principle） 抽象类原则（Abstract-Class principle） 依赖倒置原则（Dependecy-Inversion Principle） 接口隔离原则（Interface-Segregation Principle） s( Single-Resposibility Principle ): 单一职责原则 o( Open-Closed principle ): 开放封闭原则 l( Liskov-Substituion Principle ): 里氏原则 i( Interface-Segregation Principle ): 接口隔离原则 d( Dependecy-Inversion Principle ): 依赖倒置原则 一个单词：立方体(solid),很好记!!! 以下代码输出的是：

1 2 3 4 5 6 7 8 9 10 11

public class SendValue{      public String str= "6" ;      public static void main(String[] args) {          SendValue sv= new SendValue();          sv.change(sv.str);          System.out.println(sv.str);      }      public void change(String str) {          str= "10" ;      } } 正确答案: A   你的答案: B (错误) 6 10 都不对 16

java中的方法传递都是值传递 ，java中的数据类型有基本类型和引用类型，他们都是值传递方式。 基本类型传递的是它的值，因此方法中的改变参数的值，不会影响方法外。 引用类型传递的是一个地址，因为引用类型在生成对象实例时，里面的值是一个地址，指向了对象实例。在传值的时候实际上传的是一个地址，他们指向了同一块地址，所以在方法内的改变会影响方法外的参数。 这里比较乱人心的是包装类型，因为包装类型也是引用类型，这里应该就是和包装类型的实现有关了，在包装类型中，比如Integer a=1，有一个自动装箱的操作。其实a=1，如果现在令a=2，不会令2覆盖1（即1本身是不会变的），真正改变的是a被赋给了一个新地址，这个地址指向了2。 因此方法内的改变包装类型的值就相当于改变了形参里面的地址，相当于重新new了一遍。而方法外面的实参仍旧指向含1的那个地址，一次方法内的改变不会影响方法外的实参。

下面代码的运行结果是（）
public static void main(String[] args){
    String s;
    System.out.println("s="+s);
}
正确答案: C   你的答案: A (错误)
代码编程成功，并输出”s=”
代码编译成功，并输出”s=null”
由于String s没有初始化，代码不能编译通过。

代码编译成功，但捕获到NullPointException异常

局部变量没有默认值

下面哪种情况会导致持久区jvm堆内存溢出？
正确答案: C   你的答案: A (错误)
循环上万次的字符串处理
在一段代码内申请上百M甚至上G的内存
使用CGLib技术直接操作字节码运行，生成大量的动态类

不断创建对象

正常编程时不会溢出，只有修改类加载器，生成大量的字节码文件对象，才会溢出。

下面有关java的一些细节问题，描述错误的是？
正确答案: B   你的答案: A (错误)
构造方法不需要同步化
一个子类不可以覆盖掉父类的同步方法

定义在接口中的方法默认是public的容器保存的是对象的引用

如果父类中的某个方法使用了 synchronized关键字，而子类中也覆盖了这个方法，默认情况下子类中的这个方法并不是同步的，必须显示的在子类的这个方法中加上 synchronized关键字才可。

What is displayed when the following is executed;

double d1=-0.5;
System.out.println("Ceil d1="+Math.ceil(d1));
System.out.println("floor d1="+Math.floor(d1));

正确答案: A   你的答案: B (错误)
Ceil d1=-0.0
floor d1=-1.0
Ceil d1=0.0
floor d1=-1.0
Ceil d1=-0.0
floor d1=-0.0
Ceil d1=0.0
floor d1=0.0
Ceil d1=0
floor d1=-1

这里主要是有一点：

1	Math.ceil(d1)

ceil 方法上有这么一段注释：If the argument value is less than zero but greater than -1.0, then the result is negative zero

如果参数小于0且大于-1.0，结果为 -0

1	Math.floor(d1)

ceil 和 floor 方法 上都有一句话：If the argument is NaN or an infinity or positive zero or negative zero, then the result is the same as the argument， 意思为：如果参数是 NaN、无穷、正 0、负 0，那么结果与参数相同，

如果是 -0.0，那么其结果是 -0.0

如下代码的输出是

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

package Test; public class Test {      private static void test( int [] arr) {          for ( int i =  0 ; i < arr.length; i++) {              try {                  if (arr[i] %  2 ==  0 ) {                      throw new NullPointerException();                  }  else {                      System.out.print(i);                  }              }  finally {                  System.out.print( "e" );              }          }      }        public static void main(String[]args) {          try {              test( new int [] { 0 ,  1 ,  2 ,  3 ,  4 ,  5 });          }  catch (Exception e) {              System.out.print( "E" );          }      }   }

可以得到的结论是（ ）

正确答案: B   你的答案: D (错误)
编译出错
eE
Ee
eE1eE3eE5

Ee1Ee3Ee5

这题主要是2点:1.finally中的语句一定会执行。 2.是catch捕获到异常后程序结束。

Given:

1 2 3 4 5 6 7 8 9 10

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

What is the result?

正确答案: C   你的答案: C (正确)
The output is “Equal”
The output in “Not Equal”
An error at line 5 causes compilation to fall.

The program executes but does not print a message.

1、Java中， 赋值是有返回值的 ，赋什么值，就返回什么值。 比如这题，x=y，返回y的值，所以括号里的值是1。

2、 Java跟C的区别，C中赋值后会与0进行比较，如果大于0，就认为是true； 而Java不会与0比较，而是直接把赋值后的结果放入括号 。

下面有关java classloader说法正确的是（）？
正确答案: A C D   你的答案: D (错误)
ClassLoader就是用来动态加载class文件到内存当中用的
JVM在判定两个class是否相同时，只用判断类名相同即可，和类加载器无关
ClassLoader使用的是双亲委托模型来搜索类的
Java默认提供的三个ClassLoader是Boostrap ClassLoader，Extension ClassLoader，App ClassLoader
以上都不正确

JVM根据两个方面判断两个类是否相同: 一是类的全称;另一个是类加载器 .
即使类的全称相同,而使用的加载器不同那Class对象也是不同的.

设有以下代码 
String s=”hello”;
String t=”hello”;
Char c[] ={‘h’,’e’,’l’,’l’,’o’};
下列选项中返回false的语句是：

正确答案: B   你的答案: C (错误)
s.equals(t);
t.equals(c);
s==t;
t.equals(new String(“hello”));

s和t两个变量都是指向字符串常量池中的同一个内存区域，所以地址值相等，值当然也相等 ，AC正确

关于OutOfMemoryError，下面说法正确的是（）？
正确答案: A B C   你的答案: 空 (错误)
java.lang.OutOfMemoryError: PermGen space 增加-XX:MaxPermSize这个参数的值的话，这个问题通常会得到解决。
java.lang.OutOfMemoryError: Requested array size exceeds VM limit当你正准备创建一个超过虚拟机允许的大小的数组时，这条错误将会出现
java.lang.OutOfMemoryError: Java heap space 一般情况下解决这个问题最快的方法就是通过-Xmx参数来增加堆的大小
java.lang.OutOfMemoryError: nativeGetNewTLA这个异常只有在jRockit虚拟机时才会碰到

A：属于 运行时常量池导致的溢出，设置-XX：MaxPermSize 可以解决这个问题，
B：属于 堆空间不足导致的错误，问题比较少见，解决方式和C 相同，
C：属于 java堆内存 问题，一般的手段是通过内存映像分析工具，对Dump出来的堆转储存快照进行分析，重点是确认内存中的对象是否是有必要的，也就是要判断是出现了内存泄漏，还是出现了内存溢出，如果是内存列楼，通过工具检查泄露对象打GC Roots的引用链信息，可以准确的确定出泄露代码的位置，不存在泄露，就应该检查虚拟机的堆参数，如果可以继续调大，可以 设置-Xmx解决问题
D： java.lang.OutOfMemoryError: nativeGetNewTLA指当虚拟机不能分配新的线程本地空间(Thread Local Area）的时候错误信息 ，此错误是线程申请一个新的TLA时产生的，这个异常一般只会发生在jRockit虚拟机，只有过于绝对。

截止JDK1.8版本,java并发框架支持锁包括?
正确答案: A B D   你的答案: A E (错误)
读写锁
自旋锁
X锁
乐观锁
排他锁

1、自旋锁
2、自旋锁的其他种类
3、阻塞锁
4、可重入锁
5、读写锁
6、互斥锁
7、悲观锁
8、乐观锁
9、公平锁
10、非公平锁
11、偏向锁
12、对象锁
13、线程锁
14、锁粗化
15、轻量级锁
16、锁消除
17、锁膨胀
18、信号量

list是一个ArrayList的对象，哪个选项的代码填到//todo delete处，可以在Iterator遍历的过程中正确并安全的删除一个list中保存的对象？（）

1 2 3 4 5 6 7 8 9 10 11

Iterator it = list.iterator(); int index =  0 ; while (it.hasNext()) {      Object obj = it.next();      if (needDelete(obj))   //needDelete返回boolean，决定是否要删除      {          //todo delete      }      index ++; }

正确答案: A   你的答案: B (错误)
it.remove();
list.remove(obj);
list.remove(index);
list.remove(obj,index);

Iterator  支持从源集合中安全地删除对象 ，只需在 Iterator 上调用 remove() 即可。这样做的好处是可以避免 ConcurrentModifiedException ，当打开 Iterator 迭代集合时，同时又在对集合进行修改。 有些集合不允许在迭代时删除或添加元素，但是调用 Iterator 的remove() 方法是个安全的做法 。 

下列说法正确的是（）
正确答案: A B   你的答案: A C (错误)
JAVA程序的main方法必须写在类里面
JAVA程序中可以有多个名字为main方法
JAVA程序中类名必须与文件名一样
JAVA程序的main方法中，如果只有一条语句，可以不用{}（大括号）括起来

A，java是强类型语言， 所有的方法必须放在类里面，包括main
B ,java中 可以有多个重载的main方法，只有public static void main(String[] args){}是函数入口
C， 内部类的类名一般与文件名不同
D， 函数都必须用{}括起来 ，不管是一条语句还是多条语句