双非小伙暑期实习斩获腾讯WXG offer，这不比博人传燃？

public class ShallowClone implements Cloneable{

	public int id;
	public String name;

	public ShallowClone(int id, String name){
		this.id = id;
		this.name = name;
	}

	public Object clone(){
		Object sc = null;
		try {
			sc = super.clone();
		} catch (Exception e) {
			System.out.println(e.toString());
		}
		return sc;
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		ShallowClone sc1 = new ShallowClone(1, "sc1Name");
		ShallowClone sc2 = (ShallowClone)sc1.clone();
		System.out.println("sc1's id: " + sc1.id + "\tsc2's id: " + sc2.id);
		System.out.println("sc1's name: " + sc1.name + "\tsc2's name: " + sc2.name);
		System.out.println(sc1.name == sc2.name);
		System.out.println(sc1.name.equals(sc2.name));
	}
}

sc1's id: 1	sc2's id: 1
sc1's name: sc1Name	sc2's name: sc1Name
true
true

package algorithm.Interview;

import java.util.HashMap;

public class LRUCache {
    private Node firstNode;
    private Node lastNode;
    private int initialCapacity;

    private HashMap<String, Node> hashMap;

    public LRUCache(int initialCapacity) {
        if (initialCapacity <= 0) {
            throw new IllegalArgumentException("initialCapacity must > 0");
        }
        this.initialCapacity = initialCapacity;
        hashMap = new HashMap<>();
    }

    public String get(String key) {
        Node node = hashMap.get(key);
        if (node == null) {
            return null;
        }
        //元素被查询，则移动元素到链表尾部
        removeNodeToTail(node);
        return node.value;
    }

    public void put(String key, String value) {
        Node node = hashMap.get(key);
        if (node == null) {
            //大于内存容量，需要删除最不常用节点
            if (hashMap.size() >= initialCapacity) {
                // 删除最不常用的
                String oldKey = removeNode(firstNode);
                hashMap.remove(oldKey);
            }
            Node newNode = new Node(key, value);
            addNode(newNode);
            hashMap.put(key, newNode);
        } else {
            node.value = value;
            //再次被赋值，移动到链表尾部
            removeNodeToTail(node);
        }
    }

    /**
     * 移动元素到链表尾部
     * @param node
     */
    private void removeNodeToTail(Node node) {
        if (node == lastNode) {
            return;
        }
        //先删除
        removeNode(node);
        //再添加到尾部
        addNode(node);
    }

    /**
     * 尾插法，链表元素越靠前越旧
     * @param node
     */
    private void addNode(Node node) {
        if (lastNode != null) {
            lastNode.next = node;
            node.prev = lastNode;
        }
        //尾结点指向新插入的node
        lastNode = node;
        //链表为空，则同时为首节点
        if (firstNode == null) {
            firstNode = node;
        }
        node.next = null;
    }

    /**
     * 移除指定元素，并返回移除元素的key
     * @param node
     * @return
     */
    private String removeNode(Node node) {
        if (node == lastNode) {
	    lastNode = lastNode.prev;//尾结点指向原尾结点的前驱节点
	    lastNode.next =null;
	} else if (node == firstNode) {
	    firstNode = firstNode.next;//首结点指向原首结点的后继节点
	    firstNode.prev = null;
	} else {
            node.prev.next = node.next;//当前节点的前驱节点的后继节点指向当前节点的后继节点
            node.next.prev = node.prev;//当前节点的后继节点的前驱节点指向当前节点的前驱节点
        }
        return node.key;
    }

    private class Node {
        Node prev; //前驱节点
        Node next; //后继节点
        String key;
        String value;

        Node(String key, String value) {
            this.key = key;
            this.value = value;
        }
    }

    @Override
    public String toString() {
        StringBuilder ret = new StringBuilder();
        Node p = firstNode;
        while (p!=null){
            ret.append("key:").append(p.key).append(",value:").append(p.value).append(";    ");
            p = p.next;
        }
        return ret.toString();
    }
}

	public static int random5() {
		return (int) (1+Math.random()*5);
	}
	public static int random7() {
		int a=random5();
		int b=random5();
		int rand=10*a+b;
		if(rand<14) {
			return 1;//11 12 13
		}else if(rand<22) {
			return 2;//14 15 21
		}else if(rand<25) {
			return 3;//22 23 24
		}else if(rand<33) {
			return 4;//25 31 32
		}else if(rand<36) {
			return 5;//33 34 35
		}else if(rand<44) {
			return 6;//41 42 43
		}else if(rand<52) {
			return 7;//44 45 51
		} else
			return random7();//52 53 54 55
	}

	public static void main(String[] args) {
		HashMap<Integer,Integer> map5=new HashMap<Integer,Integer>();

		for(int i=0;i<10000000;i++) {
			int key = random5();
			if(map5.get(key)==null) {
				map5.put(key, 1);
			}else
				map5.put(key, map5.get(key)+1);

		}
		System.out.println("random5:");
		map5.entrySet().forEach(e->{
			System.out.println(e+"\t"+1.0*e.getValue()/10000000);
		});

		System.out.println();

		HashMap<Integer,Integer> map7=new HashMap<Integer,Integer>();

		for(int i=0;i<10000000;i++) {
			int key = random7();
			if(map7.get(key)==null) {
				map7.put(key, 1);
			}else
				map7.put(key, map7.get(key)+1);
		}

		System.out.println("random7:");
		map7.entrySet().forEach(e->{
			System.out.println(e+"\t"+1.0*e.getValue()/10000000);
		});

	}