面试查漏补缺2

网易2020开发面试题

第二题：
题目描述：
答案：
解析：
Java 中泛型在编译时会进行类型擦除，因此l1和 l2 类型擦除后的结果都是 java.util.ArrayList ，进而
l1.getClass() == l2.getClass() 的结果是 true。

第四题：
答案：解析：
确认段中的通告的接收窗口大小为2000B，当H1连续发送了两个最大段后，接收窗口大小变为0。在成功接收到主机H2发送的第一段的确认段后，接收窗口大小变为1000B。故此时主机H1还可以向主机H2发送的最大字节数为1000B。

第六题：
题目描述：

解析：此题考查森林转为二叉树，步骤如下。
第九题：
题目描述：解析：linux不熟悉，看看就行。

第十题：
题目描述：
答案：

解析：在Demo类的内部有一个静态内部类，静态内部类只有在被外部类调用的时候才会加载。故在外部类调用的时候内部类才会进行加载并且实例化，在这里保证了是懒加载。

第十一题：
题目描述：
对象的浅拷贝和深拷贝区别是什么？在JAVA中如何实现？

解答：
首先不管是浅拷贝还是深拷贝，被拷贝的对象都要实现Cloneable接口，并且重写clone方法。

浅拷贝：在拷贝的时候只考虑被拷贝的对象，对被拷贝对象的引用数据类型不考虑，即从某种意义上来说克隆出的对象和原对象之前还存在一些关联。也就是说，原始对象中对引用数据进行修改，克隆对象中的引用数据也会改变。

深拷贝：在复制的时候不只考虑被复制的对象，也考虑到了被复制对象的引用数据类型，需要其内部的引用数据类型也要实现Cloneable接口，并且重新clone方法。如果内部的引用数据类型的内部还有引用别的数据类型，那么也需要实现Cloneable接口重新clone方法。还有的某些方法通过将原对象序列化输出后又读取进内存，这样读进来的对象就是原对象的一个深拷贝。又或者在重写clone方法的时候，进行以下操作：

public class DeepCloneExample implements Cloneable {

    private int[] arr;

    public DeepCloneExample() {
        arr = new int[10];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = i;
        }
    }

    public void set(int index, int value) {
        arr[index] = value;
    }

    public int get(int index) {
        return arr[index];
    }

    @Override
    protected DeepCloneExample clone() throws CloneNotSupportedException {
        DeepCloneExample result = (DeepCloneExample) super.clone();
        result.arr = new int[arr.length];
        for (int i = 0; i < arr.length; i++) {
            result.arr[i] = arr[i];
        }
        return result;
    }
}

（注：基本数据类型是不存在引用的问题）

clone() 的替代方案
使用 clone() 方法来拷贝一个对象即复杂又有风险，它会抛出异常，并且还需要类型转换。Effective Java 书上讲到，最好不要去使用 clone()，可以使用拷贝构造函数或者拷贝工厂来拷贝一个对象。

public class CloneConstructorExample {

    private int[] arr;

    public CloneConstructorExample() {
        arr = new int[10];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = i;
        }
    }

    public CloneConstructorExample(CloneConstructorExample original) {
        arr = new int[original.arr.length];
        for (int i = 0; i < original.arr.length; i++) {
            arr[i] = original.arr[i];
        }
    }

    public void set(int index, int value) {
        arr[index] = value;
    }

    public int get(int index) {
        return arr[index];
    }
}

第十二题：
题目描述：
使用Thread类和Runnable方法来创建一个线程的区别是什么？

解答：
两种方式创建的线程本质上没有区别，主要是创建方式不同。
Thread类：通过继承Thread类并重写run()方法实现；

Runnable方法：通过实现Runnable接口并重写run()方法实现；

由于Java是单继承，多实现的，后者的可扩展性更高；同时通过Runnable实现的线程类能够实现某些资源的共享。

第十三题：
题目描述：代码：

import java.util.*;
public class Main{

    public static void main(String args[]){

        Scanner input=new Scanner(System.in);
        int n=input.nextInt();
        for(int i=0;i<n;i++){

            long A = input.nextLong();//可以将 A 变成 A + p
            long B = input.nextLong();//操作后使得 B <= A
            long p = input.nextLong();//可以将 p 变成 p * q
            int q = input.nextInt();
            System.out.println(findMixTimes(A,B,p,q,0));
        }
    }

    public static int findMixTimes(long A, long B, long p, long q,int time){
        if(B <= A){
            return time;
        }
        else{
            if(B <= (A+p)){
                return time+1;
            }
            return findMixTimes(A,B,p*q,q,time+1);
        }
    }
}

第十六题：
题目描述：

import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

/**
 * @Author: LiQian
 * @Description:
 * @Date: Created in 15:09 2020/4/21
 */
public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        //人数P
        int P = scanner.nextInt();
        //提问的次数
        int Q = scanner.nextInt();
        //存储每个人的工资
        Integer[] salary = new Integer[P];
        for(int i=0;i<P;i++){
            salary[i] = scanner.nextInt();
        }
        Map<Integer, Integer> checkTable = find(salary);
        for(int j=0;j<Q;j++){
            int num = scanner.nextInt();
            if(checkTable.containsKey(num)){
                System.out.println(checkTable.get(num));
            }else {
                System.out.println(0);
            }
        }
    }

    //查询方法
    public static Map<Integer, Integer> find(Integer[] salary){

        Map<Integer, Integer> table = new HashMap<>();

        for(int i=0;i<salary.length;i++){
            if(table.containsKey(salary[i])){
                table.put(salary[i],table.get(salary[i])+1);
            }else {
                table.put(salary[i],1);
            }
        }
        return table;
    }

}