面试汇总

参加了几场宣讲会，也算是有所收获，也在笔试现场发现了自己薄弱的地方，下面是几个笔试的问题
租租车：第一题：手写HashMap的get,put,并且支持扩容，冲突解决。

1.先写一个map接口，并且内嵌一个entry接口

	package Collections;

public interface myMap<K,V> {
    public V put(K k,V v);
    public V get(K k);
    interface Entry<K,V>{
        public K getKey();
        public V getValue();
    }
}

2.写一个hashmap类继承map接口，并且实现接口中的方法

package Collections;

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

public class myHashMap<K,V> implements myMap<K,V> {
    private static final int Default_Initial_Capacity=1<<4;//容器默认大小
    private static final float Default_Initial_Load_Factor=0.75f;//加载因子默认大小
    private int defaultInitialSize;
    private float defaultInitialFactor;
    private int entryUseSize;//数组使用大小
    private Entry<K,V>[] table=null;//数组大小

    public myHashMap() {
    //门面模式
        this(Default_Initial_Capacity,Default_Initial_Load_Factor);
    }
    public myHashMap(int Default_Initial_Capacity, float Default_Initial_Load_Factor) {
    //判断是否符合实际
        if(Default_Initial_Capacity<0)
         {throw new IllegalArgumentException("defaultInitialSize<0 error");}
        if(Default_Initial_Load_Factor<0 ||Default_Initial_Load_Factor>=1) 
        {throw new IllegalArgumentException("defaultInitialFactor error");}
        this.defaultInitialSize = Default_Initial_Capacity;
        this.defaultInitialFactor = Default_Initial_Load_Factor;
        table=new Entry[this.defaultInitialSize];
    }

    @Override
    public V put(K k, V v) {
        V oldValue=null;
        if(entryUseSize>=defaultInitialSize*defaultInitialFactor){
        //扩容
            resize(2*defaultInitialSize);
        }
        //找下标（简化）
        int index=k.hashCode()&(defaultInitialSize-1);
        if(table[index]==null){
            table[index]=new Entry<>(k,v,null);
            ++entryUseSize;
        }else {
        //用单链表实现冲突问题   
            Entry<K,V> entry=table[index];
            Entry<K,V> e=entry;
            while(e!=null){
                if(k==e.getKey()||k.equals(e.getKey())){
                    oldValue=e.value;
                    e.value=v;
                    return oldValue;
                }
                e=e.next;
            }
            table[index]=new Entry<K,V>(k,v,entry);
            ++entryUseSize;
        }
        return oldValue;
    }

    @Override
    public V get(K k) {
        int index=k.hashCode()&(defaultInitialSize-1);
        if(table[index]==null){
            return null;
        }else {
        //冲突存放查找key对应value
            Entry<K,V> entry=table[index];
            do{
                if(k==entry.getKey() ||k.equals(entry.getKey())){
                    return entry.getValue();
                }
                entry=entry.next;
            }while ((entry!=null));
        }
        return null;
    }

    private void resize(int i){
        Entry<K,V>[] newtbale=new Entry[i];
        defaultInitialSize=i;
        entryUseSize=0;
        rehash(newtbale);
    }
//扩容调用
    private  void rehash(Entry<K,V>[] newtable){
        List<Entry<K,V>> entrylist=new ArrayList<Entry<K,V>>();
        for (Entry<K,V> entry :table){
            if(entry!=null){
                do{
                    entrylist.add(entry);
                    entry=entry.next;
                }while (entry!=null);
            }
        }
        if(newtable.length>0){
            table=newtable;//指定新的地址位置
        }
        for (Entry<K,V> entry: entrylist){
            put(entry.getKey(),entry.getValue());//重写存入键值对
        }

    }
//接口重写，实现单链表
    class Entry<K,V> implements myMap.Entry<K,V> {
        private K key;
        private V value;
        private Entry<K,V> next;
        public Entry() { }
        private Entry(K key, V value, Entry<K, V> next) {
            this.key = key;
            this.value = value;
            this.next = next;
        }
        @Override
        public K getKey() {
            return key;
        }
        @Override
        public V getValue() {
            return value;
        }
    }
}

租租车第二题：实现一个线程池（基本的添加任务等功能即可）
1.先定义一个接口，可实现线程池的基本功能

package ThreadPool;
public interface pool {
    void execute(Runnable runnable);
    void shutDown();
    void addWorker(int num);
    void removeWorker(int num);
    int poolSize();
    void shutDownNow();
}

2.实现类实现接口中的方法

package ThreadPool;

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingDeque;

public class ThreadPoolExecutor implements pool {
    /***工作队列，利用BlockingQueue可以实现阻塞作用，生产者消费者问题的解决方案*/
    private final BlockingQueue<Runnable> task=new LinkedBlockingDeque<>();
    /*** 任务队列*/
    private final BlockingQueue<Worker> workers=new LinkedBlockingDeque<>();

    public ThreadPoolExecutor(int num) {
        initpool(num);
    }
    private void initpool(int num){
        for(int i=0;i<num;i++){
            //工作线程
            Worker worker = new Worker();
            workers.add(worker);
            worker.start();
        }
    }
    @Override
    public void execute(Runnable runnable) {
        if(runnable!=null){
            task.add(runnable);
        }
    }
    @Override
    public void shutDown() {
        /**
         * 通过不断的循环来判断,任务队列是否已经清空,
         * 如果队列任务清空了,将工作者队列的线程停止
         * 打破循环,清空工作者队列
         */
        while(true){
            if(task.size()==0){
                for (Worker worker : workers) {
                    worker.stopRunning();
                }
                break;
            }
        }
        workers.clear();
    }

    @Override
    public void addWorker(int num) {
        /**
         *  添加新的工作者到工作者队列尾部
         */
        for (int i = 0; i < num; i++) {
            Worker worker = new Worker();
            workers.offer(worker);
            worker.start();
        }
    }

    @Override
    public void removeWorker(int num) {
        /**
         * 移除工作者阻塞队列头部的线程
         */
        for (int i = 0; i < num; i++) {
            try {
                workers.take().stopRunning();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    @Override
    public int poolSize() {
        return workers.size();
    }

    @Override
    public void shutDownNow() {
        /**
         * 清空任务队列,然后调用停止线程池的方法
         */
        task.clear();
        shutDown();
    }

    private class Worker extends Thread{

        //通过 volatile修饰的变量,保证变量的可见性,从而能让线程马上得知状态
        private volatile boolean isRunning = true;


        @Override
        public void run() {
            //通过自旋不停的从任务队列中获取任务,
            while (isRunning){
                Runnable runnable = null;
                try {
                    //如果工作队列为空,则紫色
                    runnable = task.take();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                if(runnable!=null){
                    System.out.print(getName()+"-->");
                    runnable.run();
                }
                // 睡眠 100毫秒,验证 shutdown 是否是在任务执行完毕后才会关闭线程池
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println(getName()+"销毁...");
        }

        public void stopRunning(){
            this.isRunning = false;
        }
    }
}

租租车第三题：.用俩个栈实现一个队列（插入栈，取值栈）

可以直接插入栈插入数据，当取数据时，去取值栈中取数据，如果取值栈为空了，就把插入栈的值全部取出放入取值栈中，再从取值栈获取数据