牛客网java基础知识刷题记录-02

1. try块后必须有catch块。（）

• 正确
• 错误

考察内容：
	try的形式有三种：
		1. try-catch
		2. try-finally
		3. try-catch-finally
	但catch和finally语句不能同时省略

2. 下面程序的运行结果：()

public static void main(String args[]) {
    Thread t=new Thread(){
	    public void  run(){
	        dianping();
	    }
    };
    t.run();
    System.out.print("dazhong");
}
static void dianping(){
    System.out.print("dianping");
}

• dazhongdianping
• dianpingdazhong
• a和b都有可能
• dianping循环输出，dazhong夹杂在中间

考察内容：
	1. t.run()：只是一个简单的方法调用，并没有开启新的线程
	2. t.start()：开启一个新的线程，此时答案选c

3. 以下代码执行的结果显示是多少（）？

publi class Demo{
	public static void main(String args[]){
		int count = 0;
		int num = 0;
		for(int i = 0;i <= 100; i++){
			num = num + i;
			count = count++;
		}
		System.out.println("num * count = " + (num * count));
	}
}

• num * count = 505000
• num * count = 0
• 运行时错误
• num * count = 5050

考察内容：
	count = count++原理：
		temp = count;
		count = count + 1;
		count = temp;

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

public class Demo {
    public static void main(String[] args) {
        Collection<?>[] collections = {new HashSet<String>(), 
        							   new ArrayList<String>(), 
        							   new HashMap<String, String>().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

考察内容：
	1. 重载是静态分配
	2. 重写是动态分配

5. 在各自最优条件下,对N个数进行排序,哪个算法复杂度最低的是? （）

• 插入排序
• 快速排序
• 堆排序
• 归并排序
  

6. DBMS 中实现事务持久性的子系统是()

• 安全性管理子系统
• 完整性管理子系统
• 并发控制子系统
• 恢复管理子系统

考察内容：
	1. 原子性：事务是一组不可分割的操作单元，这组单元要么同时成功要么同时失败（由DBMS的事务管理子系统来实现）；
	2. 一致性：事务前后的数据完整性要保持一致（由DBMS的完整性子系统执行测试任务）；
	3. 隔离性: 多个用户的事务之间不要相互影响，要相互隔离（由DBMS的并发控制子系统实现）；
	4. 持久性: 一个事务一旦提交，那么它对数据库产生的影响就是永久的不可逆的，如果后面再回滚或者出异常，都不会影响已提交的事务（由DBMS的恢复管理子系统实现的）

7. ArrayList list = new ArrayList(20);中的list扩充几次

• 0
• 1
• 2
• 3

考察内容：
	1. Arraylist默认数组大小是10，扩容后的大小是扩容前的1.5倍，最大值小于Integer 的最大值减8
	2. 新创建的集合有带初始值，默认就是传入的大小，也就不会扩容

8. java8中，下面哪个类用到了解决哈希冲突的开放定址法

• LinkedHashSet
• HashMap
• ThreadLocal
• TreeMap

考察内容：
	1. ThreadLocal使用开放定址法解决hash冲突
	2. HashMap使用链地址法解决hash冲突

9. 以下代码的输出结果是？

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();
    }
}

• 静态块 构造块 构造块 构造块
• 构造块 静态块 构造块 构造块
• 构造块 构造块 静态块 构造块
• 构造块 构造块 构造块 静态块

考察内容：
	1. 程序入口main方法要执行首先要加载类B 
	2. 静态域：分为静态变量，静态方法，静态块。这里面涉及到的是静态变量和静态块，当执行到静态域时，按照静态域的顺序加载。并且静态域只在类的第一次加载时执行 
	3. 每次new对象时，会执行一次构造块和构造方法，构造块总是在构造方法前执行（当然，第一次new时，会先执行静态域，静态域〉构造块〉构造方法） 注意：加载类时并不会调用构造块和构造方法，只有静态域会执行 
	4. 根据前三点，首先加载类B，执行静态域的第一个静态变量，static b1=new B，输出构造块和构造方法（空）。

10. 下列代码片段中，存在编译错误的语句是()

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);

• 语句2
• 语句1
• 语句3
• 语句4

考察内容：
	1、所有的byte,short,char型的值将被提升为int型；
	2、如果有一个操作数是long型，计算结果是long型；
	3、如果有一个操作数是float型，计算结果是float型；
	4、如果有一个操作数是double型，计算结果是double型；
	5、被fianl修饰的变量不会自动改变类型，当2个final修饰相操作时，结果会根据左边变量的类型而转化。