2.13Java专项测试复盘

• HashMap的数据结构是怎样的？
  A. 数组
  B. 链表
  C. 数组+链表
  D. 二叉树

  解析：HashMap 由数组+链表组成的，数组是 HashMap 的主体，链表则是主要为了解决哈希冲突而存在的
  答案：C

• 下面有关maven和ant的描述，描述错误的是？
  A. Ant 没有正式的约定如一个一般项目的目录结构，你必须明确的告诉 Ant 哪里去找源代码
  B. Maven 拥有约定，因为你遵循了约定，它已经知道你的源代码在哪里
  C. maven和ant都有“生命周期”的概念，当你输入一个命令后，maven或者ant会执行一系列的有序的步骤，直到到达你指定的生命周期
  D. Ant构建文件默认命名为build.xml，Maven默认构建文件为pom.xml

  解析：Ant和Maven都是基于Java的构建(build)工具。理论上来说，有些类似于（Unix）C中的make ，但没有make的缺陷。Ant是软件构建工具，Maven的定位是软件项目管理和理解工具。
  Ant特点 ：
  没有一个约定的目录结构 ：必须明确让ant做什么，什么时候做，然后编译，打包
  没有生命周期，必须定义目标及其实现的任务序列
  没有集成依赖管理
  Maven特点：
  拥有约定，知道你的代码在哪里，放到哪里去
  拥有一个生命周期，例如执行 mvn install 就可以自动执行编译，测试，打包等构建过程
  只需要定义一个pom.xml,然后把源码放到默认的目录，Maven帮你处理其他事情
  拥有依赖管理，仓库管理
  答案：C

• String s = new String("xyz");创建了几个StringObject？
  A. 两个或一个都有可能
  B. 两个
  C. 一个
  D. 三个

  解析：如果常量池中存在“xyz”就只会创建一个对象，如果没有就会创建两个！
  答案：A

• 关于访问权限说法正确 的是 ？ ( )
  A. 外部类前面可以修饰public,protected和private
  B. 成员内部类前面可以修饰public,protected和private
  C. 局部内部类前面可以修饰public,protected和private
  D. 以上说法都不正确

  解析：1.类指外部类，最大的类，修饰符有public(表示该类在项目所有类中可以被导入），default(该类只能在同一个package中使用）,abstract,final
  2.内部类指位于类内部但不包括位于块、构造器、方法内，且有名称的类，修饰符有public,private,protected访问控制符，也可以用static,final关键字修饰，public和private比较简单，一个表示所有可以被所有类访问，一个表示只能被自身访问，protected修饰的成员类可以被同一个包中的类和子类访问。而default修饰的成员类只能被同一个包中的类访问。
  3.局部内部类指位于块、构造器、方法内的有名称类，最多只能有abstract 和 final修饰
  答案：B

• 关于运行时常量池，下列哪个说法是正确的
  A. 运行时常量池大小受栈区大小的影响
  B. 运行时常量池大小受方法区大小的影响
  C. 存放了编译时期生成的各种字面量
  D. 存放编译时期生成的符号引用

  解析：运行时常量池是方法区的一部分。Class 文件中除了有类的版本、字段、方法、接口等描述信息外，还有常量池信息（用于存放编译期生成的各种字面量和符号引用）。
  答案：

• character流和byte流的区别不包括（）
  A. 每次读入的字节数不同
  B. 前者带有缓冲，后者没有。
  C. 前者是字符读入，后者是字节读入。
  D. 二者没有区别，可以互换。

  解析：字符流和字节流每次读入的字节数是不确定的，可能相同也可能不相同；字符流和字节流都有缓冲流。
  答案：ABD

• volatile关键字的说法错误的是
  A. 能保证线程安全
  B. volatile关键字用在多线程同步中，可保证读取的可见性
  C. JVM保证从主内存加载到线程工作内存的值是最新的
  D. volatile能禁止进行指令重排序

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

• JSP分页代码中，哪个步骤次序是正确的？
  A. 先取总记录数，得到总页数，最后显示本页的数据。
  B. 先取所有的记录，得到总页数，再取总记录数，最后显示本页的数据。
  C. 先取总页数，得到总记录数，再取所有的记录，最后显示本页的数据。
  D. 先取本页的数据，得到总页数，再取总记录数，最后显示所有的记录。

  **解析：1、count(*)得到总记录数
  2、计算总页数
  3、获取所有记录(可以直接获取指定页数数据)
  4、过滤显示本页数据**
  答案：A

• 下列代码执行结果为（）

    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. 21
  B. 12
  C. 可能为12，也可能为21
  D. 以上答案都不对

  解析：join()的作用是：“等待该线程终止”，这里需要理解的就是该线程是指的主线程等待子线程的终止。也就是在子线程调用了join()方法后面的代码，只有等到子线程结束了才能执行。
  答案：A

• jre 判断程序是否执行结束的标准是（）
  A. 所有的前台线程执行完毕
  B. 所有的后台线程执行完毕
  C. 所有的线程执行完毕
  D. 和以上都无关

  解析：使用Thread建立的线程默认情况下是前台线程，在进程中，只要有一个前台线程未退出，进程就不会终止。主线程就是一个前台线程。而后台线程不管线程是否结束，只要所有的前台线程都退出（包括正常退出和异常退出）后，进程就会自动终止。
  答案：A

• 以下那些代码段能正确执行
  A. public static void main(String args[]) {
  byte a = 3;
  byte b = 2;
  b = a + b;
  System.out.println(b);
  }
  B. public static void main(String args[]) {
  byte a = 127;
  byte b = 126;
  b = a + b;
  System.out.println(b);
  }
  C. public static void main(String args[]) {
  byte a = 3;
  byte b = 2;
  a+=b;
  System.out.println(b);
  }
  D. public static void main(String args[]) {
  byte a = 127;
  byte b = 127;
  a+=b;
  System.out.println(b);
  }

  解析：byte类型的变量在做运算时被会转换为int类型的值，故A、B左为byte，右为int，会报错；而C、D语句中用的是a+=b的语句，此语句会将被赋值的变量自动强制转化为相对应的类型。
  答案：CD

• 下面哪些描述是正确的：（ ）

    public class Test {
        public static class A {
            private B ref;
            public void setB(B b) {
            ref = b;
            }
        }
        public static Class B {
            private A ref;
            public void setA(A a) {
            ref = a;
            }
        }
        public static void main(String args[]) {
            …
            start();
            ….
            }
            public static void start() { A a = new A();
            B b = new B();
            a.setB(b);
            b = null; //
            a = null;
            …
        }
    }

  A. b = null执行后b可以被垃圾回收 B. a = null执行后b可以被垃圾回收 C. a = null执行后a可以被垃圾回收 D. a,b必须在整个程序结束后才能被垃圾回收 E. 类A和类B在设计上有循环引用，会导致内存泄露

  F. a, b 必须在start方法执行完毕才能被垃圾回收

  解析：内存如下：
  a -> "a(b)"
  b -> "b"
  a引用指向一块空间，这块空间里面包含着b对象
  b引用指向一块空间，这块空间是b对象
  A选项，b = null执行后b可以被垃圾回收。这里"b可以被垃圾回收"中的b指的是引用b指向的内存。这块内存即使不被引用b指向，还是被引用a指向着，不会被回收。
  B选项，a = null执行后b可以被垃圾回收。从代码中可以看到，a = null是在b = null后执行的，该行执行后，引用a和b都没有指向对象，对象会被回收。
  C选项，同理。
  答案：BC