2019 /04/18 面试题 及答案

1.可以简单的按照速度将通用数据结构划分为：数组和链表（最慢），树（较快），哈希表（最快）。

2.

• GET在浏览器回退时是无害的，而POST会再次提交请求。

• GET产生的URL地址可以被Bookmark，而POST不可以。

• GET请求会被浏览器主动cache，而POST不会，除非手动设置。

• GET请求只能进行url编码，而POST支持多种编码方式。

• GET请求参数会被完整保留在浏览器历史记录里，而POST中的参数不会被保留。

• GET请求在URL中传送的参数是有长度限制的，而POST么有。

• 对参数的数据类型，GET只接受ASCII字符，而POST没有限制。

• GET比POST更不安全，因为参数直接暴露在URL上，所以不能用来传递敏感信息。

• GET参数通过URL传递，POST放在Request body中。

3.

 　　　　String a = "dadasd";
        String aa = null;
        try {
            aa = new String(a.getBytes("GBK"),"utf-8");
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        //dadasd
        System.out.println(aa);

4.

import java.util.List;

/**
 * @author:zhukaixin
 * @create 2019-04-18-18:35
 * @descrption:一个整数的List集合索引为偶数索引的元素值求和
 */
public class Demo5 {
    public static void main(String[] args) {

        List<Integer> list = new ArrayList();
        int num = 0;
        list.add(1);
        list.add(2);
        list.add(3);
        for (int i = 0; i < list.size(); i++) {
            if (i % 2 == 0) {
                num = (int) (num + list.get(i));
            }

        }
        //4
        System.out.println(num);
    }
}

5. 1）通过反射机制来创建对象;

2)调用对象的clone方法，需要以下几个步骤才能使用clone方法：

（1）实现clone的类首先需要继承Cloneable接口实质上是一个标识接口，没有任何的接口方法，这一点和序列化接口Serializable（）很类似。

（2）在类中重写Object类的clone方法。

（3）在clone方法中调用super.clone()。无论clone类的继承结构是什么，super.clone()都会直接或间接的调用Java.long.Object类中的clone（）方法。

3)通过反序列化的方式创建对象，

参考博客：

6.没有做

7.

/**
 * @author:zhukaixin
 * @create 2019-04-18-19:02
 * @descrption:
 */
public class Demo6 {
    public static void main(String... args) {
        //Error:(8, 9) java: 非法的表达式开始
        private int x = 4;
        System.out.println("answer is" + plusOne(4));
    }

    public Double plusOne(final int x) {
        x = x + 1;
        //类型转换有问题
        return x;
    }
}

8.

import java.io.UnsupportedEncodingException;
import java.util.HashMap;
import java.util.Map;

/**
 * @author:zhukaixin
 * @create 2019-04-18-18:17
 * @descrption:
 */
public class Demo3 {
    public static void main(String[] args) {
        Map<byte[],String> m = new HashMap<byte[],String>();
        byte[] key = "yz".getBytes();
        m.put(key,"yz");
        //true
        //false
        //false
        System.out.println(m.containsKey(key));
        System.out.println(m.containsKey("yz"));
        System.out.println(m.containsKey("yz".getBytes()));

    
    }
}

9.

import javax.xml.transform.Result;

/**
 * @author:zhukaixin
 * @create 2019-04-18-18:09
 * @descrption:
 */
public class Demo2 {
    public static void main(String[] args) {
        String s = "1\//2\//3\//4";
        //\\//
        String []result = s.split("\\//");
        for(String r : result){
            System.out.print(r);
        }
    }
}

10.

/**
 * @author:zhukaixin
 * @create 2019-04-18-18:21
 * @descrption:
 */
public class Demo4 {
    public static void main(String[] args) {
        Thread t = new Thread();
        //Error:(9, 9) java: 非法的表达式开始
        //Error:(9, 16) java: 非法的表达式开始
        public void run () {
            fun();
        }
        ;
        t.run();
        System.out.print("Y");
    }
    static void fun() {
        System.out.print("Z");
    }
    }
}

11.

/**
 * @author:zhukaixin
 * @create 2019-04-18-18:21
 * @descrption:
 */
public class Demo4 {
    public static void main(String[] args) {
        Thread t = new Thread();
        //Error:(9, 9) java: 非法的表达式开始
        //Error:(9, 16) java: 非法的表达式开始
        public void run () {
            fun();
        }
        ;
        t.run();
        System.out.print("Y");
    }
    static void fun() {
        System.out.print("Z");
    }
    }
}