MetaAPP部分笔试题

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

        A. 8

        B. 6

        C. 7

        D. 5
    */
    public static String qn2 = "D";
[见链接](https://www.cnblogs.com/timecloud/p/6555868.html)


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

        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 9

        C. Line 12

        D. Line 2
    */
    public static String qn3 = "C";
	定义了有参构造方法后，默认构造方法就失效了。


    /* qn4:
        下面代码会分别输出怎样的结果:
          public static void main(String[] args) {
              Thread t = new Thread() {
              //匿名类，即thread类包含run方法
                  public void run() {
                      cnn();
                  }
              };
              t.run();//按顺序，先执行这个普通run方法
              System.out.print("FakeNews ");//输出
          System.out.print("; ");
              t.start();//t线程开始后，现在有两个线程，一个是主线程main，一个是t线程，t线程执行start()方法后，等待时间片执行run方法，因此不一定是先输出主线程的第二个FakeNews还是先输出t线程的cnn
              System.out.print("FakeNews ");
          }
          static void cnn() {
              System.out.print("CNN ");
          }

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

        B. CNN FakeNews ; CNN FakeNews

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

        D. CNN FakeNews 和FakeNews CNN 都有可能 ; CNN FakeNews 和FakeNews CNN 都有可能
    */
    public static String qn4 = "A";
[见链接](https://www.cnblogs.com/yangrongkuan/p/12023843.html)


    /* qn5:
        main()方法如下，try中可以捕获两种类型的异常，如果在该方法运行中产生了一个IOException，将会输出怎样的结果:
          public static void main(String[] args) {
              System.out.print(method(0));
          }
          private static Integer method(Integer i){
              try{
                  if(i++ > 0)//++优先级大于>，因此无论是i++还是++i都把i加上再判断>
                      throw new IOException();
                  return i++;
              }catch (IOException e){
                  i++;
                  return i++;
              }catch (Exception e){
                  i++;
                  return i++;
              }finally {
                  return i++;
              }
          }

        A. 4

        B. 会抛错 没有输出

        C. 2

        D. 3
    */
    public static String qn5 = "c";



    /* qn6:
        下面代码会分别输出怎样的结果:
          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指向了obj，因此改变new_obj则map里的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 qn6 = "A";



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

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

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

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

        D. 以上说法都不对
    */
    public static String qn7 = "B";



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

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

            private static String GetVal() {
                try {
                //1.9之后不能用了，因为只能调用无参构造,
                    return Inner.class.newInstance().v1;
                } catch (Exception e) {
                //java.lang.InstantiationException 是指不能实例化某个对象，一般在我们使用java反射机制去创建某个对象的时候实例化到了一个抽象类或者接口（java中抽象类和接口是不能被实例化）
                    try {//1.9之后采用这个来实例化对象,这里要注意不是getDeclaredConstructors
                        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, Go ahead

        B. Fake News

        C. 以上都不对

        D. Go ahead
    */
    public static String qn8 = "D";



    /* qn9:
        下面这段程序当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) {
      11         n++;
      12     }
      13     n++;
      14     return n++;//先返回n再++

        A. 0

        B. 14

        C. 抛出异常

        D. 12

        E. 13
    */
    public static String qn9 = "E";





    /* qn11:
        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;//入队：送值到队尾，然后rear+1；出队：取出队头值，然后front+1
          }
      }
      int MaxSize=10;
      Quene q = new Queue(MaxSize);

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

        A. q.front - q.rear == MaxSize;

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

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

        D. q.front == q.rear;
    */
    public static String qn11 = "A";



    /* qn12:
        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_3

        B. SQL_2

        C. SQL_5

        D. SQL_1

        E. SQL_4
    */
    public static String qn12 = "ABCE";





    /* qn14:
        下面代码会分别输出怎样的结果:
        String s = new String(new char[] {'没','人','比','我','更','懂','j','a','v','a'});
        String si = "没人比我更懂java";
        System.out.println(s == si);
        System.out.println(s.intern() == "没人比我更懂java");
        System.out.println(s == si.intern());

        A. false true false

        B. false true true

        C. true true true

        D. true false true
    */
    public static String qn14 = "A";



    /* qn15:
        下列代码的输出结果不可能是:
        //被volatile修饰的变量能够保证每个线程能够获取该变量的最新值，从而避免出现数据脏读的现象。
        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++);//()->5表示不需要参数，返回值为5
            }
            Thread.sleep(5000L);
            System.out.println(s);
        }

        A. 10000

        B. 10001

        C. 9999

        D. 9998
    */
    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) {
        if (nums == null || nums.length == 0 || nums[0].length == 0) {
            return false;
        }
        int rows = nums.length, columns = nums[0].length;
        int row = 0, column = columns - 1;
        while (row < rows && column >= 0) {
            int num = nums[row][column];
            if (num == x) {
                return true;
            } else if (num > x) {
                column--;
            } else {
                row++;
            }
        }
        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) {
        int a=0;
        HashSet<String> strings = new HashSet<>();
        for (String s : map.keySet()) {
            StringBuilder stringBuilder = new StringBuilder();
            stringBuilder.append(s);
            Object obj = map.get(s);
            if (obj instanceof String || obj instanceof Number){
                stringBuilder.append("=").append(obj);
                strings.add(stringBuilder.toString());
            }else if(obj instanceof Object[]){
                showArray(strings, stringBuilder, (Object[]) obj);
            }else {
                showMap(strings,stringBuilder,(Map<String, Object>) obj);
            }

            a++;
        }
        return strings;
    }
    
    private static void showArray(HashSet<String> strings, StringBuilder stringBuilder, Object[] obj) {
        Object[] objects= obj;
        String str="";
        for (int i = 0; i < objects.length; i++) {
            str=stringBuilder.toString();
            stringBuilder.append("[").append(i).append("]");
            Object object = objects[i];
            if (object instanceof String || object instanceof Number || object==null){
                stringBuilder.append("=").append(object);
                strings.add(stringBuilder.toString());
            }else if (object instanceof Map){
                showMap(strings, stringBuilder, (Map<String, Object>) object);
            }else {
                showArray(strings,stringBuilder,(Object[]) object);
            }
            stringBuilder=new StringBuilder(str);
        }
    }

    private static void showMap(HashSet<String> strings, StringBuilder stringBuilder, Map<String, Object> hashMap) {
        for (String ss : hashMap.keySet()) {
            stringBuilder.append(".").append(ss);
            Object object = hashMap.get(ss);
            if (object instanceof String || object instanceof Number){
                stringBuilder.append("=").append(object);
                strings.add(stringBuilder.toString());
            }else if (object instanceof Object[]){
                showArray(strings,stringBuilder,(Object[]) object);
            }else{
                showMap(strings,stringBuilder,(Map<String, Object>) object);
            }
        }
    }

/**
     * 给定一个二叉树, 检查它是否是镜像对称的
     * 例如以下是镜像对称的
     *      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) {
        return root == null ? true : recur(root.left, root.right);
    }
    public static boolean recur(TreeNode L, TreeNode R) {
        if(L == null && R == null) return true;
        if(L == null || R == null || L.val != R.val) return false;
        return recur(L.left, R.right) && recur(L.right, R.left);
    }
}