java笔试1

记录一下笔试题

以下哪种排序属于稳定排序（ ）
希尔排序
快速排序
堆排序
归并排序

不稳定算法口诀：学习好痛苦啊！心情不稳定呀！快（快速排序）些（希尔排序）选（选择排序）一堆（堆排序）朋友玩吧！

使用快速排序算法对序列9，1，3，8，23，5 ，6，10，29，19进行排序，基准树取9，则第一趟排序后的结果为（ ）
9 1 3 8 23 5 7 10 29 19
7 1 3 8 5 9 23 10 29 19
1 3 8 9 23 5 7 10 29 19
9 1 3 8 23 5 7 10 19 29

序列规模较大时，选择哪种排序算法效率最高（ ）
直接选择排序
直接插入排序
冒泡排序
希尔排序

以下函数的时间复杂度是多少（ ）

   int foo(int N){
        int result = 0;
        for (int i = 1; i <= N; i++) {
            for (int j = 1; j <= N; j++) {
                result += (i+j);
                return result;
            }
        }
    }

O(N)
O(NlogN)
**O(N的1.5次幂)**
O(N的2次幂)

下面关于进程和线程说法错误的是（ ）
进程是系统进行资源分配和调度的基本单位，而线程是CPU调度和分配的基本单位；
线程也拥有自己的系统资源；
一个线程可以创建和撤销另一个线程；
一个进程中的多个线程共享资源；

Linux中包括两种链接，硬链接和软链接，下列说法正确的是（ ）
软链接可以跨文件系统进行连接，硬链接不可以；
当删除源文件的时候硬链接文件仍然存在，且内容不变；
硬链接被删除，磁盘上的数据文件会同时被删除；
硬链接会重新建立一个inode，软链接不会；

链接：https://www.nowcoder.com/questionTerminal/1b695f9055ed4017a9fe578ef8b02c34
来源：牛客网

硬链接与软链接的区别；
硬连接是不会建立inode的，他只是在文件原来的inode link count域再增加1而已，也因此硬链接是不可以跨越文件系统的。相反都是软连接会重新建立一个inode，当然inode的结构跟其他的不一样，他只是一个指明源文件的字符串信息。一旦删除源文件，那么软连接将变得毫无意义。
而硬链接删除的时候，系统调用会检查inode link count的数值，如果他大于等于1，那么inode不会被回收。因此文件的内容不会被删除。硬链接实际上是为文件建一个别名，链接文件和原文件实际上是同一个文件。可以通过ls -i来查看一下，这两个文件的inode号是同一个，说明它们是同一个文件；而软链接建立的是一个指向，即链接文件内的内容是指向原文件的指针，它们是两个文件。
软链接可以跨文件系统，硬链接不可以；软链接可以对一个不存在的文件名(filename)进行链接（当然此时如果你vi这个软链接文件，linux会自动新建一个文件名为filename的文件）,硬链接不可以（其文件必须存在，inode必须存在）；软链接可以对目录进行连接，硬链接不可以。两种链接都可以通过命令 ln 来创建。ln 默认创建的是硬链接。使用 -s 开关可以创建软链接。

链表与数组的优缺点以下说明正确的是（ ）
数组动态分配内存，并在内存中连续，链表静态分配内存，但不连续；
查询时，数组的时间复杂度为O(n)，链表为O（1）；
插入或删除时，数组的时间复杂度O（1）,链表为O（n）;
数组元素在栈中，链表元素在堆中；

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class Main {
    public static void main(String[] args) {
        ThreadPoolExecutor executor = new ThreadPoolExecutor(5, //corePoolSize
                10, //maximumPoolSize
                15,  //keepAliveTime
                TimeUnit.SECONDS, //TimeUnit
                new ArrayBlockingQueue<Runnable>(5),//workQueue
                new ThreadPoolExecutor.CallerRunsPolicy());//RejectedExecutionHandler
    }
}

线程池exector在空闲状态下的线程个数为（ ）
0 5 10 15

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        for (int i = 0; i < 100; i++) {
            list.add("a");
        }
    }
}

JDK1.8中，执行以上程序后，该list进行了几次扩容（ ）
4 5 6 7

public class Main {
    public static void main(String[] args) {
        System.out.println(fun1());
    }

    private static String fun1() {
        try {
            System.out.println("A");
            return fun2();
        } finally {
            System.out.println("B");
        }
    }

    private static String fun2() {
        System.out.println("C");
        return "D";
    }
}

执行上述程序后，输出结果正确的是（ ）
ABCD
ACDB
ACBD
不确定

继承是JAVA语言的一个特性，针对类的继承，虚拟机会如何进行父类和子类的初始化加载呢？请阅读代码选择出该段代码的输出结果。

public class Test{
    public static void main(String[] args) {
        System.out.println(B.c);

    }
}
class A{
    public static String c = "C";
    static {
        System.out.println("A");
    }
}
class B extends A{
    static {
        System.out.println("B");
    }
}

执行结果（ ）
AC
ABC
C
BC

下面关于垃圾收集的描述哪个是错误的（ ）
使用垃圾收集的程序不需要明确释放对象；
现代垃圾收集能够处理循环引用问题；
垃圾收集能提高程序员效率；
使用垃圾收集的语言没有内在泄漏问题

下面关于B树和B+树的叙述中，不正确的结论是（ ）
B树和B+树都能有效地支持顺序检索
B树和B+树都能有效地支持随机检索
B树和B+树都可用于文件的索引结构
B树和B+树都是平衡的多分树

因为B树不支持顺序检索

java8中，忽略内部接口的情况，在接口中以下哪条定义是正确的（）？
A.void methoda();
B.public double methoda();
C.public final double methoda();
D.static void methoda(double d1);
E.protected void methoda(double d1);