20190908练习题总结

20190908练习题总结

编程题

• 题目：
  给定长度为 2n 的数组, 你的任务是将这些数分成 n 对, 例如 (a1, b1), (a2, b2), …, (an, bn) ，使得从1 到 n 的 min(ai, bi) 总和最大。
  示例 1:
  输入: [1,4,3,2]
  输出: 4
  解释: n 等于 2, 最大总和为 4 = min(1, 2) + min(3, 4).
  提示:
  n 是正整数,范围在 [1, 10000].
  数组中的元素范围在 [-10000, 10000].

• 分析：乍一看这道题是属于数组的拆分，通过给出的实例可以看出"n 等于 2, 最大总和为 4 = min(1, 2) + min(3, 4)"分成了两对，（1，2），（3，4）从而可以推出[1，4，3，2]------>[1，3，2，4],由此可见可以先进行一次冒泡排序。

• 代码如下：

     //冒泡排序
        for (int i = 0; i < nums.length; i++) {
            for (int j = 0; j < nums.length - 1 - i; j++) {
                if (nums[j] > nums[j + 1]) {
                    int temp = nums[j];
                    nums[j] = nums[j + 1];
                    nums[j + 1] = temp;
                }
            }
        }
        int sum = 0;
        for (int i = 0; i < nums.length; i += 2) {
            sum += nums[i];
        }
        return sum;

选择题

• 正确
• 已知 声明并初始化二维数组 int a[ ][ ]={{1,2},{3,4},{5,6}} ，则 a[1][1] 的值为（）
  1
  2
  4
  5
  答案：4
  解析：很明显为二维数组的简单计算，数组下标从0开始
• 覆盖（重写）与重载的关系是（）。
  覆盖（重写）只有出现在父类与子类之间，而重载可以出现在同一个类中
  覆盖（重写）方法可以有不同的方法名，而重载方法必须是相同的方法名
  final修饰的方法可以被覆盖（重写），但不能被重载
  覆盖（重写）与重载是同一回事
  答案：覆盖（重写）只有出现在父类与子类之间，而重载可以出现在同一个类中
  分析：方法的重写和重载是Java 多态性的不同表现。重写是父类与子类之间多态性的一种表现，重载是一个 类中多态性的一种表现。如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写。子类的对象使用这个方法时，将调用 子类中的定义，对它而言，父类中的定义如同被“屏蔽”了。如果在一个类中定 义了多个同名的方法，它们或有不同的参数个数或有不同的参数类型，则称为方法的重载。重载 的方法是可以改变返回值的类型。
• 下面关于依赖注入(DI)的说法不正确的是()
  只有通过Spring才能实现依赖注入(DI)
  依赖注入的主要目的是解耦合
  常见的依赖注入方式有Setter和构造方法
  答案：只有通过Spring才能实现依赖注入(DI)
  分析：依赖注入主要通过反射来实现，与Spring无关
• 有程序片段如下，以下表达式结果为 true 的是（ ）

Float s=new Float(0.1f);

Float t=new Float(0.1f);

Double u=new Double(0.1);

s==t
s.equals(t)
u.equals(s)
t.equals(u)
答案：s.equals(t)
分析：==比较的是地址 equals比较的是内容

• A 派生出子类 B ， B 派生出子类 C ，并且在 Java 源代码中有如下声明：

 A  a0=new  A();

A  a1 =new  B();

A  a2=new  C();

问以下哪个说法是正确的？ （ ）

只有第1行能通过编译
第1、2行能通过编译，但第3行编译出错
第1、2、3行能通过编译，但第2、3行运行时出错
第1行、第2行和第3行的声明都是正确的
答案：第1行、第2行和第3行的声明都是正确的
分析：继承是具有传递性的，A是B的父类，也算是C的父类

• 在java7中,下列哪个说法是正确的:
  ConcurrentHashMap使用synchronized关键字保证线程安全
  HashMap实现了Collection接口
  Arrays.asList方法返回java.util.ArrayList对象
  SimpleDateFormat对象是线程不安全的
  答案：SimpleDateFormat对象是线程不安全的

• Math.floor(-8.5)=( )
  (float)-8.0
  (long)-9
  (long)-8
  (double)-9.0
  答案：(double)-9.0
  分析：floor: 求小于参数的最大整数。返回double类型
  ceil: 求大于参数的最小整数。返回double类型
  round: 对小数进行四舍五入后的结果。返回int类型

• What will happen when you attempt to compile and run the following code?

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

答案：prints:3
分析：题目意思是执行以下代码会出现什么情况？compiletime error（编译错误）prints（打印）
静态语句块中x为局部变量，不影响静态变量x的值，x和y为静态变量，默认初始值为0，属于当前类
main方法中：
执行x–后 x=-1
调用myMethod方法，x执行x++结果为-1(后++)，但x=0，++x结果1，x=1 ，则y=0
x+y+ ++x,先执行x+y，结果为1，执行++x结果为2，得到最终结果为3

• JavaWEB中有一个类，当会话种邦定了属性或者删除了属性时，他会得到通知，这个类是：( )
  HttpSessionAttributeListener
  HttpSessionBindingListener
  HttpSessionObjectListener
  HttpSessionListener;
  HttpSession
  HttpSessionActivationListener
  答案：HttpSessionAttributeListener
  分析:
  HttpSessionAttributeListener：可以实现此侦听器接口获取此web应用程序中会话属性列表更改的通知；
  HttpSessionBindingListener：当该对象从一个会话中被绑定或者解绑时通知该对象，这个对象由HttpSessionBindingEvent对象通知。这可能是servlet程序显式地从会话中解绑定属性的结果，可能是由于会话无效，也可能是由于会话超时；
  HttpSessionListener：当web应用程序中的活动会话列表发生更改时通知该接口的实现类，为了接收该通知事件，必须在web应用程序的部署描述符中配置实现类；
  HttpSessionActivationListener：绑定到会话的对象可以侦听容器事件，通知它们会话将被钝化，会话将被激活。需要一个在虚拟机之间迁移会话或持久会话的容器来通知所有绑定到实现该接口会话的属性。

• 错题：

• 以下代码执行的结果是多少（）？

 public class Demo {
 public static void main(String[] args) {
  Collection[] collections = 
{new HashSet(), new ArrayList(), new HashMap().values()};
                Super subToSuper = new Sub();
                for(Collection collection: collections) {
    System.out.println(subToSuper.getType(collection));
}
}
abstract static class Super {
    public static String getType(Collection collection) {
        return “Super:collection”;
}
public static String getType(List list) {
        return “Super:list”;
}
public String getType(ArrayList list) {
        return “Super:arrayList”;
}
public static String getType(Set set) {
        return “Super:set”;
}
public String getType(HashSet set) {
        return “Super:hashSet”;
}
}
static class Sub extends Super {
    public static String getType(Collection collection) {
            return "Sub"; }
}
}

Sub:collection
Sub:collection
Sub:collection

Sub:hashSet
Sub:arrayList
Sub:collection

Super:collection
Super:collection
Super:collection

Super:hashSet
Super:arrayList
Super:collection

答案：
Super:collection
Super:collection
Super:collection
分析：

1. 静态方法，不存在重写，重写只对可见的实例方法有效。
2. 重载是根据形参的静态类型确定调用的方法，重写是根据调用者在运行期的实际类型来确定调用的方法。

  Collection[] collections =
            { new HashSet(),new ArrayList(),new HashMap().values()};
            //map.values()方法的返回值是Collection ， collections数组的静态类型是Collection的。
       Super subToSuper = new Sub();//静态类型是Super，实际类型是Sub
     for(Collection collection: collections) {
        System.out.println(subToSuper.getType(collection));
        //静态方法不存在重写，这里调用的是父类的getType方法
        }