java面试题

/* qn1:
        下面代码会分别输出怎样的结果:
          public static void main(String[] args) {
              Map<String, Object> map = new HashMap<>();
              String str = "没人比我更懂java";
              StrObject obj = new StrObject("没人比我更懂java");
              map.put("str", str);
              map.put("obj", obj);

              str = "真的没人比我更懂java";
              System.out.printf(map.get("str").toString()+"; ");

              StrObject new_obj = (StrObject) map.get("obj");
              new_obj.setStr("真的没人比我更懂java");
              System.out.printf(map.get("obj").toString()+"; ");
          }
          static class StrObject{
              String str;
              public StrObject(String str){
                  this.str = str;
              }
              public void setStr(String str){
                  this.str = str;
              }
              @Override
              public String toString() {
                  return str;
              }
          }

        A. 没人比我更懂java; 没人比我更懂java;

        B. 真的没人比我更懂java; 没人比我更懂java;

        C. 没人比我更懂java; 真的没人比我更懂java;

        D. 真的没人比我更懂java; 真的没人比我更懂java;
    */
    public static String qn1 = "C";



    /* qn2:
        下面代码会分别输出怎样的结果:
          public static void main(String[] args) {
              Thread t = new Thread() {
                  public void run() {
                      cnn();
                  }
              };
              t.run();
              System.out.print("FakeNews ");
          System.out.print("; ");
              t.start();
              System.out.print("FakeNews ");
          }
          static void cnn() {
              System.out.print("CNN ");
          }

        A. CNN FakeNews 和FakeNews CNN 都有可能 ; CNN FakeNews 和FakeNews CNN 都有可能

        B. CNN FakeNews ; CNN FakeNews 和FakeNews CNN 都有可能

        C. CNN FakeNews ; CNN FakeNews

        D. CNN FakeNews 和FakeNews CNN 都有可能 ; CNN FakeNews
    */
    public static String qn2 = "A";
    //输出:   CNN FakeNews ; FakeNews CNN
    /*
    线程通常都有五种状态，创建、就绪、运行、阻塞和死亡。
　　第一是创建状态。在生成线程对象，并没有调用该对象的start方法，这是线程处于创建状态。
　　第二是就绪状态。当调用了线程对象的start方法之后，该线程就进入了就绪状态，但是此时线程调度程序还没有把该线程设置为当前线程，此时处于就绪状态。
        在线程运行之后，从等待或者睡眠中回来之后，也会处于就绪状态。
　　第三是运行状态。线程调度程序将处于就绪状态的线程设置为当前线程，此时线程就进入了运行状态，开始运行run函数当中的代码。
　　第四是阻塞状态。线程正在运行的时候，被暂停，通常是为了等待某个时间的发生(比如说某项资源就绪)之后再继续运行。sleep,suspend，wait等方法都可以导致线程阻塞。
　　第五是死亡状态。如果一个线程的run方法执行结束或者调用stop方法后，该线程就会死亡。对于已经死亡的线程，无法再使用start方法令其进入就绪。

    start()用来启动一个线程，当调用start方法后，系统才会开启一个新的线程，进而调用run()方法来执行任务，而单独的调用run()就跟调用普通方法是一样的，已经失去线程的特性了。
    因此在启动一个线程的时候一定要使用start()而不是run()。

    线程不是马上执行的；准确来说，调用start( )方法后，线程的状态是“READY（就绪）”状态，而不是“RUNNING（运行中）”状态
    （关于线程的状态详细。线程要等待CPU调度，不同的JVM有不同的调度算法，线程何时被调度是未知的。因此，start（）方法的被调用顺序不能决定线程的执行顺序
     */


    /* qn3:
        main()方法如下，try中可以捕获两种类型的异常，如果在该方法运行中产生了一个IOException，将会输出怎样的结果:
          public static void main(String[] args) {
              System.out.print(method(0));
          }
          private static Integer method(Integer i){
              try{
                  if(i++ > 0)
                      throw new IOException();
                  return i++;
              }catch (IOException e){
                  i++;
                  return i++;
              }catch (Exception e){
                  i++;
                  return i++;
              }finally {
                  return i++;
              }
          }

        A. 4

        B. 3

        C. 会抛错 没有输出

        D. 2
    */
    public static String qn3 = "D";



    /* qn4:
        以下代码编译时哪一行会出错？

        1 package com.metaapp.solution;
        2 public class Solution {
        3     int p1 = 0;
        4     int p2 = 0;
        5     public Solution(int arg){
        6         p1 = arg;
        7     }
        8     public static void main(String args[]){
        9         Solution s1,s2;
       10         int m,n;
       11         m=1;n=2;
       12         s1 = new Solution();
       13         s2 = new Solution(n);
       14     }
       15 }

        A. Line 6

        B. Line 12

        C. Line 2

        D. Line 9
    */
    public static String qn4 = "A";
    /* 不应该选B？
    不过当你尝试通过一个无参的构造函数来构建（new）时，此时编译器才会报错，因为找不到这个无参的构造函数。
    也就是说当一个类你没有给他构造函数，则编译器会自动补上一个无参的，若有的话就不会，你需要显示将此无参的构造函数写出来。
     */



    /* qn5:
        method()方法如下，method()如果调用下面5个不同的update()方法，哪些SQL会被回滚 (多选):
        @Service
        public class TestService {
            @Resource
          TestService testService;

          public void method() {
            1. update1();
            ======================
            2. testService.update2();
            ======================
            3. testService.update3();
            ======================
            4. testService.update4();
            ======================
            5. testService.update5();
          }
          @Transactional
          public void update1() {
            //SQL_1
            throw new Exception();
          }
          @Transactional
          public void update2() {
            //SQL_2
            throw new Exception();
          }
          @Transactional
          private void update3() {
            //SQL_3
            throw new Exception();
          }
          @Transactional
          public void update4() {
            //SQL_4
            throw new Error();
          }
          @Transactional
          public void update5() {
            //SQL_5
            throw new IOException();
          }
        }

        A. SQL_1

        B. SQL_4

        C. SQL_2
        D. SQL_3
        E. SQL_5
    */
    public static String qn5 = "ACD";
    //任何的RuntimeExcetipn将触发回滚，任何的checkedException不触发回滚。
    /*
    1.Error是无法处理的异常，比如OutOfMemoryError，一般发生这种异常，JVM会选择终止程序，因此我们编写程序时无需担心这类异常。
    2.Exception，也就是我们常见到的一些异常，这些异常是我们可以处理的，是所有异常的父类。
    3.unchecked exception（非受查异常），包括Error和RuntimeException，比如常见的NullpointException、IndexOutOfBoundsException，
        对于RuntimeException，java编译器不要求必须进行异常捕获处理或者抛出声明，由程序员自行决定。
    4.checked exception（受查异常），也成非运行时异常（运行时异常以外的都叫非运行时异常），由代码能力之外的因素导致的运行时错误。
        java编译器强制程序员必须进行捕获处理，如果不捕获或者抛出声明处理，编译都不会通过。比如常见的有IOException、SQLException，
     */


    /* qn6:
        下面代码会分别输出怎样的结果:
        //使用char数组来初始化s，避免在s被创建之前字符串池中已经存在了值为"没人比我更懂java"的对象
        String s = new String(new char[] {'没','人','比','我','更','懂','j','a','v','a'});
        String si = "没人比我更懂java";
        System.out.println(s == si); //对象地址的判断 而这两种声明方式的存储形式是不同的，因此他们的地址不同
        System.out.println(s.intern() == "没人比我更懂java");  //s.intern()是把对象的引用加到方法区的常量池，并返回该引用，两个引用指向同一个对象。为true
        //si.intern()是把这个对象拷贝到方法区的常量池，并返回该引用，两个引用指向不同对象。si.intern()指向常量池里的对象，s指向堆里的对象。为false。
        System.out.println(s == si.intern());

        A. true false true
        B. false true true
        C. true true true
        D. false true false
    */

    public static String qn6 = "D";


    /* qn7:
        一棵二叉树后序遍历的节点顺序是: 6 4 5 2 7 3 1 ，中序遍历是: 6 4 2 5 1 3 7 ，则前序遍历结果为:
        A. 1 2 4 6 5 3 7
        B. 1 2 3 4 5 6 7
        C. 1 2 4 6 5 7 3
        D. 1 2 4 5 6 3 7
    */
    public static String qn7 = "A";


    /* qn8:
        public class Queue {
          private int size;
          private int[] data;
          private int front, rear;

          public Queue(int size) {
              this.size = size;
              data = new int[size];
              front = 0; rear = 0;
          }
      }
      int MaxSize=10;
      Quene q = new Queue(MaxSize);

      对于q来说，以下能判断队列满的条件是()

        A. q.front == (q.rear+1) % MaxSize;

        B. q.front + q.rear == MaxSize;

        C. q.front == q.rear;

        D. q.front - q.rear == MaxSize;
    */
    public static String qn8 = "A";
    /*
              front
    0    1     2    3    4    5    6
        rear

     循环队列如果头指针在数组的下标为2的位置，尾指针在下标为1的位置，maxSize=7.此时队列满，但是Q.front-Q.rear==MaxSize是不满足的， 而 Q.front==(Q.rear+1) % MaxSize是满足的。
     */



    /* qn9:
        下面的代码在java(jdk8)最终会产生几个String对象:
        String a = "没人";
        String b = "比我";
        String c = "更懂";
        String d = "java";
        String s = a + b + c + d;

        A. 5

        B. 8

        C. 7

        D. 6
    */
    public static String qn9 = "B";
    /*
    String s = a + b + c + d;
    StringBuilder builder = new StringBuilder();
    builder.append(a);
    builder.append(b);
    builder.append(c);
    builder.append(d);
    String s = builder.toString();
    // JVM是会创建一个StringBuilder对象，
       public StringBuilder() {
         super(16);
        }
    // StringBuilder构造方法还创建了一个 char[]数组
        AbstractStringBuilder(int capacity) {
            value = new char[capacity];
        }
    // 然后toString()方法创建一个String对象
    public String toString() {
        // Create a copy, don't share the array
        return new String(value, 0, count);
      }
    // 所以String s = a + b + c + d;这段是创建了3+1=4个对象 加上前面4个应该是8
    个对象
     */



    /* qn10:
        下面这段程序当n=10的输出是()
      1 public int calc(int n) {
      2     try {
      3         n+=1;
      4         if(n/0 > 0) {
      5             n+=1;
      6         } else {
      7             n-=10;
      8         }
      9         return n;
      10     } catch(Exception e) {        //java.lang.ArithmeticException: / by zero
      11         n++;
      12     }
      13     n++;
      14     return n++;

        A. 抛出异常

        B. 12

        C. 14

        D. 13

        E. 0
    */
    public static String qn10 = "D";



    /* qn11:
        若进栈序列为a，b，c，d，e，f，进栈和出栈可以穿插进行，则不可能出现的出栈序列是()

        A. b，c，e，a，f，d

        B. d，c，b，a，e，f

        C. c，b，d，a，f，e

        D. b，d，c，a，e，f
    */
    public static String qn11 = "A";



    /* qn12:
        "没人比我更懂java".toCharArray(), 在java(jdk8)中关于这个字符数组char[], 以下说法正确的是:

        A. 以上说法都不对

        B. 这个字符串在内存中总共占用 16 byte

        C. 这个字符串在内存中总共占用 20 byte

        D. 这个字符串在内存中总共占用 10 byte
    */
    public static String qn12 = "D";
    /*
        char[] s = {'没','人','比','我','更','懂','j','a','v','a'}
        s.length;
     */



    /* qn13:
        下面代码会输出怎样的结果:
        public class A {

            class Inner {
                public String  v1 = "Fake News";
                public String v2 = "Go ahead";
            }

            private static String GetVal() {
                try {
                    return Inner.class.newInstance().v1;
                } catch (Exception e) {
                    try {
                        return Inner.class.getDeclaredConstructor(A.class).newInstance((A)null).v2;
                    } catch (Exception ee) {
                        ee.printStackTrace();
                        return "Fake News, Go ahead";
                    }
                }
            }
            public static void main(String[] args) {

                System.out.println(GetVal());
            }
        }

        A. Fake News

        B. Go ahead

        C. Fake News, Go ahead

        D. 以上都不对
    */
    public static String qn13 = "B";
    /*
    Class.newInstance()只能反射无参的构造器；
    Constructor.newInstance()可以反任何构造器；

    Class.newInstance()需要构造器可见(visible)；
    Constructor.newInstance()可以反私有构造器；

    Class.newInstance()对于捕获或者未捕获的异常均由构造器抛出;
    Constructor.newInstance()通常会把抛出的异常封装成InvocationTargetException抛出；
    因为以上差异，所以很多框架使用的都是构造器反射的方式获取对象，像Spring, Guava, Zookeeper, Jackson, Servlet 等。
    getDeclaredConstructor()获取的是构造器  .newInstance()实例化获取类对象
     */



    /* qn14:
        已知一个完全二叉树的第6层有3个叶子结点，则整个二叉树的结点数最多有

        A. 34

        B. 122

        C. 121

        D. 45
    */
    public static String qn14 = "A";
   // 完全二叉树从根节点到倒数第2层是一棵满二叉树
   // 满二叉树一定是完全二叉树，完全二叉树不一定是满二叉树
    //前5层结点数最多为 2的5次方 -1 = 31 （满二叉树）  31+3= 34




    /* qn15:
        下列代码的输出结果不可能是:
        private static volatile int s = 0;
        private static final ThreadPoolExecutor async = new ThreadPoolExecutor(
                0, Integer.MAX_VALUE,
                60L, TimeUnit.SECONDS, new SynchronousQueue<>());
        public static void main(String[] args) throws InterruptedException {
            for (int i = 0; i < 10000; i++) {
                async.execute(()-> s++);
            }
            Thread.sleep(5000L);
            System.out.println(s);
        }

        A. 9998

        B. 9999

        C. 10001

        D. 10000
    */
    public static String qn15 = "B";




    /*
     * 以下是实现题
     */
    /**
     * <b>注意! 本题不要遍历二维数组. 要求时间复杂度严格低于n^2, 否则视为不得分 </b>
     *
     * 现有一个n*n的二维正整数数组nums，每行元素保证递增，每列元素保证递增，求某正整数x是否存在于该二维数组中，需要尽量优化时间和空间复杂度；
     * @param int[][] nums
     * @param int x 目标数
     * @return boolean
     */
    public static boolean searchMatrix(int[][] nums, int x) {
        // Todo your code goes here...
        if (nums == null || nums[0] == null) return false;
        // 从最右侧的最大值开始判断，小于直接跳行，大于，则依次递减查找
        int i = 0, j = nums[0].length - 1;
        while (i < nums.length && j >= 0) {
            if (nums[i][j] == x) return true;
            else if (nums[i][j] > x) --j;
            else ++i;
        }
        return false;
    }
    /**
     * 对任意一个Map<String, Object>, 其 key 为 String,
     * 其 value 为 Map<String, Object> Object[] Number String 中的任意一种,
     * 显然叶子节点是 value 类型为 Number 或 String的节点,
     * 将 Map 转为多条字符串, 每条字符串表达其中一个叶子节点,
     * 比如:
     * {"a":{"b":["v",2,{"c":0}]},"d":[1,null,3]}
     * 将转化为以下这些字符串
     * a.b[0] = v
     * a.b[1] = 2
     * a.b[2].c = 0
     * d[0] = 1
     * d[1] = null
     * d[2] = 3
     *
     * @param map 上述的 map
     * @return 所有的字符串
     */
    public static Set<String> showMap(Map<String, Object> map) {
        //TODO your code goes here...
        return null;
    }
    /**
     * 给定一个二叉树, 检查它是否是镜像对称的
     * 例如以下是镜像对称的
     *      1
     *     / \
     *    2   2
     *   / \ / \
     *  3  4 4  3
     *
     * 下面这个则不是镜像对称的
     *      1
     *     / \
     *    2   2
     *     \   \
     *      3   3
     *
     * TreeNode类的定义:
     *
     * @param TreeNode 一颗二叉树
     * @return boolean 是否是对称的
     */

    // 以下给出TreeNode类, 请勿修改
    static class TreeNode {
        int val;
        TreeNode left;
        TreeNode right;
        TreeNode(int x) { val = x; }
    }

    public static boolean isTreeSymmetric(TreeNode root) {
        //TODO your code goes here...
        return isSame(root.left, root.right);
    }
    public static boolean isSame(TreeNode t1,TreeNode t2){
        if (t1 == null && t2 == null) return true;
        if (t1 == null || t2 == null) return false;
        // 根节点值的比较，左节点和右节点比较，右节点和左节点比较
        return t1.val == t2.val && isSame(t1.left,t2.right) && isSame(t1.right,t2.left);
    }