1. 引用传递的问题（记住java里面是没有指针的，只有值拷贝和引用拷贝）

引用拷贝拷贝的实际是地址，当引用传递过程中改变地址中的属性参数，那么最后
输出这个引用时可以看到它的属性也发生了变化。

public class Test {
    public static void main(String[] args) {
        // new 对象生成一个 student地址
        Student student = new  Student();
        student.setName("张三");
        test(student);
        System.out.println(student);
    }
    // 传递的是引用的拷贝
    public static void  test(Student student) {
        student.setName("李四");
        
    }
}

结果：

控制台输出.png

2. String str1= "张三" 和 String str2 = new String("张三")的区别

（1）String str1 = “张三”;可能创建一个或者不创建对象，如果”张三”这个字符串在java String池里不存在，会在java String池里创建一个创建一个String对象(“张三”)，然后str1指向这个内存地址，无论以后用这种方式创建多少个值为”张三”的字符串对象，始终只有一个内存地址被分配，之后的都是String的拷贝，Java中称为“字符串驻留”，所有的字符串常量都会在编译之后自动地驻留。

（2）String str2 = new String(“张三”);至少创建一个对象，也可能两个。因为用到new关键字，肯定会在heap中创建一个str2的String对象，它的value是“张三”。同时如果这个字符串再java常量池里不存在，会在java常量池里创建这个String对象“张三”。

public class TestStr {
public static void main(String[] args) {
        // 这里堆中会创建一个String对象，
        String string = new String("张三");
        test(string);
              // 所以最后打印的引用依然是new 对象时的引用
        System.out.println(string);
    }
    // 由于String 整个类是被final修饰的不可变
    public static void  test(String string) {
        string="李四";
        
    }

}

控制台输出.png

3. Integer a = new Integer(1); 和 Integer b = 1 的区别

Integer b = 1 实际上是Intger b = Integer.valueOf(1), 两种方式生成引用的在堆中地址是不同的；但是Integer b = 1生成的地址都是一样的，而new Integer生成的引用地址却不同。

public static void main(String[] args) {
        Integer a = 1;
        Integer b = 1;
        Integer c = new Integer(1);
        Integer d = new Integer(1);
        System.out.println(a==b);
        System.out.println(a==c);
        System.out.println(a.equals(c));
        System.out.println(c==d);
}

控制台输出：

QQ截图20180530150740.png

4. == 和 equals的区别(==比的是栈中值或者堆中地址，equals比的是否同一个对象的引用以及对象的内容是否相等)

(1)   ==操作比较的是两个变量的值是否相等栈中值是否相同，对于引用型变量表示的是两个变量在堆中存储的地址是否
相同。
(2)   equals操作表示的两个变量是否是对同一个对象的引用，即堆中的内容是否相同。
(3)  ==比较的是2个对象的地址，而equals比较的是2个对象的内容，显然，当equals为true时，==不一定为true。

5.memcached，redis和MongoDb的区别

1）redis不仅仅支持简单的k/v类型的数据，同时还提供list,set,hash等数据结构的存
储
2)内存使用使用效率对比:
使用简单的key-value存储的话，memcached的内存利用率会更高一点，如果redis采
用hash结构来做key-value存储，由于其组合式的压缩，内存的利用率更高。
3）性能对比：
由于redis只使用单核，而memcached使用多核，所以平均在每一个核上redis在存储
小数据时比memcached性能更高，而在100Ks=以上的时候memcached性能要高于
redis
4）内存管理机制的不同:
在redis中,并不是所有的数据都一一直存储在内存中的，这是和memcached相比最大
的一个区别Redis只会缓存所有的key端的信息，如果redis发现内存的使用量超过某
一个值，将触发swap的操作，redis根据相应的表达式计算出那些key对应value需要
swap到磁盘，然后再将这些这些key对应的value持久化到磁盘中，同时再内存清
除。同时由于redis将内存中的数据swap到磁盘的时候，提供服务的主线程和进行
swap操作的子进程会共享这部分内存，所以如果更新需要swap的数据，redis将阻塞
这个操作，直到子线程完成swap操作后才可以进行修改
5）数据持久化的支持
虽然redis是基于内存的存储系统，但是他本身是支持内存数据的持久化，而且主要提
供两种主要的持久化策略，RDB快照和AOF日志，而memcached是不支持数据持久
化的操作的。
RDB持久化通过保存了数据库的健值对来记录数据库状态的不同，AOF持久化是通过
保存reds服务器所执行的命令来保存记录数据库的状态的，RDB持久化保存数据库状
态的方法是将msg,fruits,numbers三个健的健值对保存到RDB文件中，而AOF持久化
保存数据库的状态则是将服务器执行的SET，SADD，RPUSH三个命令保存到AOF
文件中的

6.HashMap以及LinkedList实现原理

（1）HashMap的实现原理
在Java编程语言中，最基本的结构就是两种，一个是数组，另外一个是模拟指针（引
用），所有的数据结构都可以用这两个基本结构来构造的，HashMap也不例外。
HashMap实际上是一个“链表散列”的数据结构，即数组和链表的结合体。
可以看到HashMap的put函数：
  public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
    }
// 可以看到里面既有数组的结构也有链表的结构：
 final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {
            Node<K,V> e; K k;
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
            else if (p instanceof TreeNode)
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            else {
                for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        break;
                    }
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }

//这里的内部静态类Node<K,V>是Map.Entry<K,V>的实现类：
static class Node<K,V> implements Map.Entry<K,V> {
        final int hash;
        final K key;
        V value;
        Node<K,V> next;

        Node(int hash, K key, V value, Node<K,V> next) {
            this.hash = hash;
            this.key = key;
            this.value = value;
            this.next = next;
        }

        public final K getKey()        { return key; }
        public final V getValue()      { return value; }
        public final String toString() { return key + "=" + value; }

        public final int hashCode() {
            return Objects.hashCode(key) ^ Objects.hashCode(value);
        }

        public final V setValue(V newValue) {
            V oldValue = value;
            value = newValue;
            return oldValue;
        }

        public final boolean equals(Object o) {
            if (o == this)
                return true;
            if (o instanceof Map.Entry) {
                Map.Entry<?,?> e = (Map.Entry<?,?>)o;
                if (Objects.equals(key, e.getKey()) &&
                    Objects.equals(value, e.getValue()))
                    return true;
            }
            return false;
        }
    }



（2）LinkedList实现原理
LinkedList实际上双向链表结构，内部静态私有类Node，定义元素E，前一个节点，后一个节点共3个属性
    private static class Node<E> {
        E item;
        Node<E> next;
        Node<E> prev;

        Node(Node<E> prev, E element, Node<E> next) {
            this.item = element;
            this.next = next;
            this.prev = prev;
        }
    }
从它的源码中可以看到链表长度，初始节点，后一个节点，被transient 修饰无法被序列化
transient int size = 0;
transient Node<E> first;
transient Node<E> last;

调用push方法，看到其调用了addFirst
public void push(E e) {
        addFirst(e);
    }
而addFirst调用了linkFirst
 public void addFirst(E e) {
        linkFirst(e);
    }
/**
 如果LinkedList中初始节点f为null，那么把定义好的节点属性赋给后一个，如果初始
节点f不是null，那么就把它赋给f.prev
*/
 private void linkFirst(E e) {
        final Node<E> f = first;
        final Node<E> newNode = new Node<>(null, e, f);
        first = newNode;
        if (f == null)
            last = newNode;
        else
            f.prev = newNode;
        size++;
        modCount++;
    }

7.springboot优缺点

优势：
（1）使用 Spring 项目引导页面可以在几秒构建一个项目
（2）方便对外输出各种形式的服务，如 REST API、WebSocket、Web、Streaming、Tasks
（3）非常简洁的安全策略集成支持关系数据库和非关系数据库
（4）支持运行期内嵌容器，如 Tomcat、Jetty强大的开发包
（5）支持热启动自动管理依赖自带应用监控支持各种 IED，如 IntelliJ IDEA 、NetBeans缺点是集成度较高
劣势：
使用过程中不太容易了解底层。

8.dubbo实现原理

一款分布式服务框架
高性能和透明化的RPC远程服务调用方案
SOA服务治理方案
阿里巴巴公司开源的一个高性能优秀的服务框架，使得应用可通过高性能的 RPC 实
现服务的输出和输入功能，可以和Spring框架无缝集成

dubbo原理.png

9.消息队列MQ

消息队列（Message Queue），是分布式系统中重要的组件，其通用的使用场景可以简单地描述为：
(1)当不需要立即获得结果，但是并发量又需要进行控制的时候，差不多就是需要使用消息队列的时候。
消息队列主要解决了应用耦合、异步处理、流量削锋等问题。
(2)当前使用较多的消息队列有RabbitMQ、RocketMQ、ActiveMQ、Kafka、ZeroMQ、MetaMq等，而部分 
数据库如Redis、Mysql以及phxsql也可实现消息队列的功能。

这里用表格形式说明各mq的差异

QQ截图20180530105541.png

10.tomcat有哪几种线程模型

配置方法：在tomcat conf 下找到server.xml

在<Connector port="8080" protocol="HTTP/1.1"/>

BIO: protocol =" org.apache.coyote.http11.Http11Protocol"

NIO: protocol ="org.apache.coyote.http11.Http11NioProtocol"

AIO: protocol ="org.apache.coyote.http11.Http11Nio2Protocol"

APR: protocol ="org.apache.coyote.http11.Http11AprProtocol"

BIO.png

NIO.png