Java基础总结

以前总结的一些知识:

1.Spring的优势:
        通过Spring的IOC特性，将对象之间的依赖关系交给了Spring控制，方便解耦，简化了开发
        通过Spring的AOP特性，对重复模块进行集中，实现事务，日志，权限的控制

        提供了对其他优秀开源框架的集成支持

2.Spring MVC的优势:
        SpringMVC是使用了MVC设计思想的轻量级web框架，对web层进行解耦，使我们开发更简洁
        与Spring无缝衔接
        灵活的数据验证，格式化，数据绑定机制

3.Mybatis的优势:
            数据库的操作(sql)采用xml文件配置，解除了sql和代码的耦合
            提供映射标签，支持对象和和数据库orm字段关系的映射，支持对象关系映射标签，支持对象关系的组建
            提供了xml标签，支持动态的sql

1.一个.java源文件中是否可以包括多个类？有什么限制？
    可以有多个类，但只能有一个public的类，并且public的类名必须与文件名相一致。
2.java有没有goto？
    java中的保留字，现在没有在java中使用。
3.说说&&和&的区别？
    &和&&都可以用作逻辑与的运算符，表示逻辑与（and），当运算符两边的表达式的结果都为true时，整个
    运算结果才为true，否则，只要有一方为false，则结果为false。
    &&还具有短路的功能，即如果第一个表达式为false，则不再计算第二个表达式。&还可以用作位运算符。
4.在java中如何跳出当前的多重嵌套循环？
    可以在外面的循环语句前定义一个标号，然后在里层循环体的代码中使用带有标号的break语句。
    我们常用的时让外层的循环条件表达式的结果可以受到里层循环体代码的控制。
5.switch语句能否作用在byte上，能否作用在long上，能否作用在String上？
    在switch（e）中，e只能是一个整数表达式或者枚举常量，整数表达式可以是int基本类型或Integer包装类型，
    由于byte，short，char都可以隐式转换为int，所以，这些类型以及这些类型的包装类型，也是可以的。
    显然long和String类型都不符合switch的语句规定，但是java1.7之后String已经可以用于switch中。
6.char型变量中能不能存储一个中文汉字？为什么？
    char型变量是用来存储Uniocode编码的字符的，unicode编码字符集中包含了汉字，所以，char型变量中当然
    可以存储汉字。不过，如果某个特殊的汉字没有被包含在unicode编码字符集中，那么，这个char型变量中就不能
    存储这个特殊汉字。
7.使用final关键字修饰一个变量时，是引用不能变，还是引用的对象不能变？
    使用final关键字修饰一个变量时，是指引用变量不能变，引用变量所指向的对象的内容还是可以改变的。
8.静态变量和实例变量的区别?
    在语法定义上的区别：静态变量前要加static关键字，而实例变量前则不加。
    在程序运行时的区别：实例变量属于某个对象的属性，必须创建了实例对象，其中的实例变量才会被分配空间，
    才能使用这个实例变量。静态变量不属于某个实例对象，而是属于类，所以也称为类变量，只要程序加载了类的
    字节码，不用创建任何实例对象，静态变量就会被分配空间，静态变量就可以被使用了。总之，实例变量必须创建
    对象后才可以通过这个对象来使用，静态变量则可以直接使用类名来引用。
9.是否可以从一个static方法内部发出对非static方法的调用？
    不可以。因为非static方法是要与对象关联在一起的，必须创建一个对象后，才可以在该对象上进行方法调用，
    而static方法调用时不需要创建对象，可以直接调用。也就是说，当一个static方法被调用时，可能还没有创建
    任何对象。逻辑上是无法成立的。
10.Integer与int的区别？
    int是java提供的8种原始数据类型之一。java为每个原始类型提供了封装类，Integer是java为int提供的封装类，
    int的默认值是0，而Integer的默认值为null，即Integer可以区分出未赋值和值为0区别，int则无法表达出未赋值的情况。
    另外Integer提供了多个与整数相关的操作方法，例如，将一个字符串转换成整数，Integer中还定义了表示整数的最大值和最小值的常量。
11.Math.round(11.5)等於多少?Math.round(-11.5)等於多少?
    Math类中提供了三个与取整有关的方法：ceil、floor、round，这些方法的作用与它们的英文名称的含义相对应。
    例如，ceil的英文意义是天花板，该方法就表示向上取整，Math.ceil(11.3)的结果为12,Math.ceil(-11.3)的结果是-11；floor的英文意义是地板，
    该方法就表示向下取整，floor的英文意义是地板，该方法就表示向下取整，Math.floor(11.6)的结果为11,Math.floor(-11.6)的结果是-12；最难掌握的是round方法，它表示“四舍五入”，
    算法为Math.floor(x+0.5)，即将原来的数字加上0.5后再向下取整，所以，Math.round(11.5)的结果为12，Math.round(-11.5)的结果为-11。
12.Overload和Override的区别？Overloaded的方法是否可以改变返回值的类型？
    Overload是重载的意思，Override是覆盖的意思，也就是重写。
    重载overload表示同一个类中可以有多个名称相同的方法，但这些方法的参数列表各不相同（即参数个数或类型不同）；
    重写override表示子类中的方法可以与父类中的某个方法的名称和参数完全相同，通过子类创建的实例对象调用这个方法时，将调用子类中的定义方法，
    这相当于把父类中定义的那个完全相同的方法给覆盖了，这也是面向对象编程的多态性的一种表现。子类覆盖父类的方法时，只能比父类抛出更少的异常，或者是
    抛出父类抛出的异常的子异常，因为子类可以解决父类的一些问题，不能比父类有更多的问题。子类方法的访问权限只能比父类的更大，不能更小。如果父类的方法
    是private类型，那么，子类则不存在覆盖的限制，相当于子类中增加了一个全新的方法。
    如果两个方法的参数列表完全一样，是否可以让他们的返回值不同来实现重载？这是不可能的，因为有时候我们可以不关注返回的结果。
    override可以翻译为覆盖，从字面就可以知道，它是覆盖了一个方法并且对其重写，以求达到不同的作用。对我们来说最熟悉的覆盖就是对接口方法的实现，
    在接口中一般只是对方法进行了声明，而我们在实现时，就需要实现接口声明的所有方法。除了这个典型的用法以外，我们在继承中也可能会在子类覆盖父类中的方法。
    覆盖的方法的标志必须要和被覆盖的方法的标志完全匹配，才能达到覆盖的效果；覆盖的方法的返回值必须和被覆盖的方法的返回一致。
    覆盖的方法所抛出的异常必须和被覆盖方法的所抛出的异常一致，或者是其子类；被覆盖的方法不能为private，否则在其子类中知识新定义了一个方法，并没有对其进行覆盖。
13.接口是否可继承接口？抽象类是否可以实现接口？抽象类是否可继承具体类？抽象类中是否可以有静态的main方法？
    接口可以继承接口。抽象类可以实现接口，抽象类可以继承具体类。抽象类中可以有静态的main方法。
    抽象类与普通类的唯一区别就是不能创建实例对象和允许有abstract方法。
14.java中实现多态的机制是什么？
    靠的是父类或接口定义的引用变量可以指向子类或具体实现类的实例对象，而程序调用的方法在运行期才动态绑定，就是引用变量所指向的具体实例对象的方法，也就是
    内存里正在运行的那个对象的方法，而不是引用变量的类型中定义的方法。
15.abstractclass和interface语法上有什么区别？
    抽象类可以有构造方法，接口中不能有构造方法。抽象类中可以有普通成员变量，接口中没有普通成员变量。抽象类中可以包含非抽象的普通方法，接口中的所有方法必须都是抽象的，
    不能有非抽象的普通方法。抽象类中的抽象方法的访问类型可以是public，后者默认的protected，但接口中的抽象方法只能是public类型的，并且默认即为public abstract类型。
    抽象类的接口中都可以包含静态成员变量，抽象类中的静态成员变量的访问类型可以任意，但接口中定义的变量只能是public static final类型，并且默认即为public static final类型。
    一个类能实现多个接口，但只能继承一个抽象类。
16.String s = "Hello";s = s + "world!";这两行代码执行后，原始的String对象中的内容到底变了没有？
    没有改变，只是s不再指向它了，而是指向另一个变量。
    对于字符串常量，如果内容相同，java认为他们代表同一个String对象，而用关键字new调用构造器，总是会创建一个新的对象，无论内容是否相同。
    为什么要把String设计为不可变类：在开发一系统的时候，我们有时候也需要设计不可变类，来传递一组相关的值，这也是面向对象的思想的体现。不可变类有一些优点，比如因为
    它的对象是只读的，所以多线程并发访问也不会有任何问题。当然也有一些缺点，比如每个不同的状态都要一个对象来代表，可能会造成性能上的问题。所以java还提供了一个可变的版本
    ，StringBuffer（线程安全），StringBuild（线程不安全）；
17.ArrayList和Vector的区别
    这两个类都实现了List接口（List接口继承了Collection接口），他们都是有序集合，即存储在这两个集合
    中的元素的位置都是有顺序的，相当于一种动态的数组，我们以后可以按位置索引号取出某个元素，并且
    其中的数据是允许重复的，这是与HashSet之类的集合的最大不同处，HashSet之类的集合不可以按索引号
    去检索其中的元素，也不允许有重复的元素。
    区别：
    同步性：Vector是线程安全的，也就是说是它的方法之间是线程同步的，而ArrayList是线程不安全的，它的
    方法之间是线程不同步的。如果只有一个线程会访问到集合，那最好是使用ArrayList，因为它不考虑线程安全，
    效率会高些；如果有多个线程会访问到集合，那最好是使用Vector，因为不需要我们再去考虑和编写线程安全的代码。
    数据增长：Vector每次增长原来的一倍，ArrayList增加原来的0.5倍。
18.Hashmap和HashTable的区别
    HashMap是HashTable的轻量级实现（非线程安全的实现），他们都完成了Map接口，主要区别在于HashMap
    允许空键值，由于非线程安全，在只有一个线程访问的情况下，效率要高于HashTable。
    最大的不同是，HashTable的方法时Synchronize的，而HashMap不是，在多线程访问的时候，Hashtable不需要
    我们实现同步，而Hashmap就必须为止提供同步。
19.List和Map的区别
    一个是存储单列数据的集合，另一个存储键值对这样的双列数据的集合，List中存储的数据是有顺序，并且允许重复，
    Map中存储的数据是没有顺序的，其键是不能重复的，它的值是可以有重复的。
20.List，Map，Set三个接口，存取元素时，各有什么特点？
    首先，List和set具有相似性，他们都是单列元素的集合，所以他们有一个公共的父接口，叫Collection。Set里面不允许
    有重复的元素，即不能有两个相等的对象，即假设set集合中有了一个A对象，现在我们要向set集合再存入一个B对象，
    但B对象与A对象equals相等，则B对象存储不进去，所以，Set集合的add方法有一个boolean的返回值，当集合中没有
    某个元素，此时add方法可成功加入该元素时，则返回true，否则返回false。set取元素时不能细说要去第几个，只能以
    Iterator接口取得所有的元素，在逐一遍历各个元素。
    list是一种有序集合。List以特定次序来持有元素，可有重复元素。Set无法拥有重复元素，内部排序。Map保存键值对，value可多值。
21.说出ArrayList，Vector，LinkedList的存储性能和特性
    ArrayList和Vector都是使用数组方式存储数据，此数据元素数大于实际存储的数据以便增加和插入元素，他们都允许直接按序列号
    索引元素，但是插入元素要涉及数组元素移动等内存操作，所以索引数据快而插入数据慢，Vector由于使用了synchronized方法（线程安全），
    通常性能上较ArrayList差，而LinkedList使用双向链表实现存储，按序号索引数据需要进行前向或后向遍历，索引就变慢了，但是插入数据时
    只需要记录本项的前后项即可，所以插入速度较快。
    LinkedList也是线程不安全的，LinkedList提供了一些方法，使得LinkedLIst可以被当作堆栈和队列来使用。
22.Collection和Collections的区别
    Collection是集合类的上级接口，继承他的接口主要有set和list；
    Collectios是针对集合类的一个帮助类，它提供一系列静态方法实现对各种集合的搜索，排序，线程安全化等操作。
23.set里的元素是不能重复的，那么用什么方法来区分重复与否呢？是用==还是equals（），他们的区别
    set使用equals判断，==是判断值是否相等，equals是用于比较两个独立对象的内容是否相同。
24.String s = new String("xyz");创建了几个StringObject？是否可以继承String类?
    两个或一个都有可能，”xyz”对应一个对象，这个对象放在字符串常量缓冲区，常量”xyz”不管出现多少遍，
    都是缓冲区中的那一个。NewString每写一遍，就创建一个新的对象，它使用常量”xyz”对象的内容来
    创建出一个新String对象。如果以前就用过’xyz’，那么这里就不会创建”xyz”了，直接从缓冲区拿，
    这时创建了一个StringObject；但如果以前没有用过"xyz"，那么此时就会创建一个对象并放入缓冲区，
    这种情况它创建两个对象。至于String类是否继承，答案是否定的，因为String默认final修饰，
    是不可继承的。
25.简单说说Java中的异常处理机制的简单原理和应用。
    异常是指java程序运行时（非编译）所发生的非正常情况或错误，与现实生活中的事件很相似，
    现实生活中的事件可以包含事件发生的时间、地点、人物、情节等信息，可以用一个对象来表示，
    Java使用面向对象的方式来处理异常，它把程序中发生的每个异常也都分别封装到一个对象来表示的，
    该对象中包含有异常的信息。
    Java对异常进行了分类，不同类型的异常分别用不同的Java类表示，所有异常的根类为java.lang.Throwable，Throwable下面又派生了两个子类：
        Error和Exception，Error表示应用程序本身无法克服和恢复的一种严重问题，程序只有奔溃了，例如，说内存溢出和线程死锁等系统问题。
        Exception表示程序还能够克服和恢复的问题，其中又分为系统异常和普通异常：
        系统异常是软件本身缺陷所导致的问题，也就是软件开发人员考虑不周所导致的问题，软件使用者无法克服和恢复这种问题，但在这种问题下
    还可以让软件系统继续运行或者让软件挂掉，例如，数组脚本越界（ArrayIndexOutOfBoundsException），空指针异常（NullPointerException）、
    类转换异常（ClassCastException）；
        普通异常是运行环境的变化或异常所导致的问题，是用户能够克服的问题，例如，网络断线，硬盘空间不够，发生这样的异常后，程序不应该死掉。
    java为系统异常和普通异常提供了不同的解决方案，编译器强制普通异常必须try..catch处理或用throws声明继续抛给上层调用方法处理，所以普通异常也称为checked异常，
    而系统异常可以处理也可以不处理，所以，编译器不强制用try..catch处理或用throws声明，所以系统异常也称为unchecked异常。
26.Java 中堆和栈有什么区别？
    JVM 中堆和栈属于不同的内存区域，使用目的也不同。栈常用于保存方法帧和局部变量，而对象总是在堆上分配。栈通常都比堆小，也不会在多个线程之间共享，而堆被整个 JVM 的所有线程共享。
    栈：在函数中定义的一些基本类型的变量和对象的引用变量都是在函数的栈内存中分配，当在一段代码块定义一个变量时，Java 就在栈中为这个变量分配内存空间，当超过变量的作用域后，Java 会自动释放掉为该变量分配的内存空间，该内存空间可以立即被另作它用。
        堆：堆内存用来存放由 new 创建的对象和数组，在堆中分配的内存，由 Java 虚拟机的自动垃圾回收器来管理。在堆中产生了一个数组或者对象之后，还可以在栈中定义一个特殊的变量，让栈中的这个变量的取值等于数组或对象在堆内存中的首地址，
    栈中的这个变量就成了数组或对象的引用变量，以后就可以在程序中使用栈中的引用变量来访问堆中的数组或者对象，引用变量就相当于是为数组或者对象起的一个名称。
27.字节流与字符流的区别
    底层设备永远只接受字节数据，有时候要写字符串到底层设备
28.什么是java序列化，如何实现java序列化？或者请解释Serializable接口的作用。
    我们有时候将一个java对象编程字节流的形式传出去或者从一个字节流中恢复成一个java对象，例如：
    要将java对象存储到硬盘或者传输给网络上的其他计算机，这个过程我们可以自己写代码去把一个java对象
    变成某个格式的字节流在传输。
    但是jre本身就提供了这种支持，我们可以调用OutputStream的writeObject方法来做，如果要让java帮我们
    做，要被传输的对象必须实现serializable接口，这样，javac编译时就会进行特殊处理，编译的类才可以被
    writeObject方法操作，这就是所谓的序列化。需要被序列化的类必须实现Serializable接口，该接口是一个
    mini接口，其中没有需要实现方法，implements Serializable只是为了标注该对象是可被序列化的。
    例如，在web开发中，如果对象被保存在了Session中，tomcat在重启时要把Session对象序列化到硬盘，这个对象就
    必须实现Serializable接口。如果对象要经过分布式系统进行网络传输，被传输的对象就必须实现Serializable接口。
29.java中会存在内存泄漏吗，请简单描述。
    解释什么是内存泄漏：所谓内存泄露就是指一个不再被程序使用的对象或变量一直被占据在内存中。java中有垃圾回收机制，
    它可以保证当对象不再被引用的时候，对象将自动被垃圾回收器从内存中清除掉。
     java中的内存泄露的情况：长生命周期的对象持有短生命周期对象的引用就很可能发生内存泄露，尽管短生命周期对象已经不再需要，
     但是因为长生命周期对象持有它的引用而导致不能被回收，这就是java中内存泄露的发生场景，通俗地说，就是程序员可能创建了一个对象，
     以后一直不再使用这个对象，这个对象却一直被引用，即这个对象无用但是却无法被垃圾回收器回收的，这就是java中可能出现内存泄露的情况，
     例如，缓存系统，我们加载了一个对象放在缓存中(例如放在一个全局map对象中)，然后一直不再使用它，这个对象一直被缓存引用，但却不再被使用。
30.说一说Servlet的生命周期?
    Servlet有良好的生存期的定义，包括加载和实例化、初始化、处理请求以及服务结束。这个生存期由javax.servlet.Servlet接口的init(),service()和destroy方法表达。
    Servlet被服务器实例化后容器运行其init方法，请求到达时运行其service方法，service方法自动派遣
    运行与请求对应的doget或dopost，当服务器决定将实例销毁的时候调用其destory方法。
31.servlet API中forward（）与redirect（）的区别
    1.从地址栏显示来说
        forward是服务器请求资源,服务器直接访问目标地址的URL,把那个URL的响应内容读取过来,然后把这些内容再发给浏览器.浏览器根本不知道服务器发送的内容从哪里来的,所以它的地址栏还是原来的地址.
        redirect是服务端根据逻辑,发送一个状态码,告诉浏览器重新去请求那个地址.所以地址栏显示的是新的URL.所以redirect等于客户端向服务器端发出两次request，同时也接受两次response。
    2.从数据共享来说
        forward:转发页面和转发到的页面可以共享request里面的数据.
        redirect:不能共享数据.
        redirect不仅可以重定向到当前应用程序的其他资源,还可以重定向到同一个站点上的其他应用程序中的资源,甚至是使用绝对URL重定向到其他站点的资源.
        forward方法只能在同一个Web应用程序内的资源之间转发请求.forward 是服务器内部的一种操作.
        redirect 是服务器通知客户端,让客户端重新发起请求.
    所以,你可以说 redirect 是一种间接的请求, 但是你不能说"一个请求是属于forward还是redirect "
    3.从效率来说
        forward:高.
        redirect:低.
32.request.getAttribute()和 request.getParameter()有何区别?
    1，request.getParameter()取得是通过容器的实现来取得通过类似post，get等方式传入的数据。
            request.setAttribute()和getAttribute()只是在web容器内部流转，仅仅是请求处理阶段。
        2，getAttribute是返回对象,getParameter返回字符串
        3，getAttribute()一向是和setAttribute()一起使用的，只有先用setAttribute()设置之后，才能够通过getAttribute()来获得值，
    它们传递的是Object类型的数据。而且必须在同一个request对象中使用才有效。,而getParameter()是接收表单的get或者post提交过来的参数
33.MVC的各个部分都有那些技术来实现?如何实现?
    MVC是Model－View－Controller的简写。Model代表的是应用的业务逻辑（通过JavaBean，EJB组件实现），
    View是应用的表示面（由JSP页面产生），Controller是提供应用的处理过程控制（一般是一个Servlet），
    通过这种设计模型把应用逻辑，处理过程和显示逻辑分成不同的组件实现。这些组件可以进行交互和重用。
34.jsp有哪些内置对象?作用分别是什么?
    JSP共有以下9个内置的对象：
        1，request 用户端请求，此请求会包含来自GET/POST请求的参数
        2，response 网页传回用户端的回应
        3，pageContext 网页的属性是在这里管理
        4，session 与请求有关的会话期
        5，application servlet 正在执行的内容
        6，out 用来传送回应的输出
        7，config  servlet的构架部件
        8，page JSP网页本身
        9，exception 针对错误网页，未捕捉的例外
35.jsp和servlet的区别、共同点、各自应用的范围？
    JSP是Servlet技术的扩展，本质上就是Servlet的简易方式。JSP编译后是“类servlet”。    
     Servlet和JSP最主要的不同点在于：Servlet的应用逻辑是在Java文件中，并且完全从表示层中的HTML里分离开来。
     而JSP的情况是Java和HTML可以组合成一个扩展名为.jsp的文件。
    JSP侧重于视图，Servlet主要用于控制逻辑。
36.tomcat容器是如何创建servlet类实例？用到了什么原理？
    当容器启动时，会读取在webapps目录下所有的web应用中的web.xml文件，然后对xml文件进行解析，
    并读取servlet注册信息。然后，将每个应用中注册的servlet类都进行加载，并通过反射的方式实例化。
37.JDBC访问数据库的基本步骤是什么？
    1，加载驱动
    2，通过DriverManager对象获取连接对象Connection
    3，通过连接对象获取会话
    4，通过会话进行数据的增删改查，封装对象
    5，关闭资源
38.说说preparedStatement和Statement的区别
    效率：preparedStatement预编译会话继承自Statement普通会话，效率会比较高。因为数据库系统不会对相同的sql语句进行再次编译。
    安全性：预编译的安全性可以有效的防止sql注入。
39.说说事务的概念，在JDBC编程中处理事务的步骤。
    事务是作为单个逻辑工作单元执行的一系列操作。
    一个逻辑工作单元必须有四个属性，称为原子性，一致性，隔离性和持久性属性，只有这样才能成为一个事务。
    事务处理的步骤：conn.setAutoComit（false）：设置提交方式为手动提交。conn.commit（）提交事务；出现异常，回滚conn.rollback（）；
40.数据库连接池的原理，为什么要使用连接池。
    数据库连接是一件费时的操作，连接池可以使用多个操作共享一个连接。
    数据库连接池的基本思想就是为数据库建立一个缓冲池，提高对数据库连接资源的管理。
41.JDBC的脏读是什么？哪种数据库隔离级别能防止脏读？
    当我们使用事务时，有可能会出现这样的情况，有一行数据刚更新，与此同时另一个查询读到了这个刚更新的值。这样就导致了脏读，
    因为更新的数据还没有进行持久化，更新这行数据的业务可能会进行回滚，这样这个数据就是无效的。
42.什么是幻读，哪种隔离级别可以防止幻读？
    幻读是指一个事务多次执行一条查询返回的却是不同的值。假设一个事务正根据某个条件进行数据查询，然后另一个事务插入了一行满足这个查询条件的数据。
    之后这个事务再次执行了这条查询，返回的结果集中会包含刚插入的那条新数据。这行新数据被称为幻行，而这种现象就叫做幻读。
43.JDBC的DriverManager是用来做什么的？
    JDBC的DriverManager是一个工厂类，我们通过它来创建数据库连接。当JDBC的Driver类被加载进来时，它会自己注册到DriverManager类里面
    然后我们会把数据库配置信息传成DriverManager.getConnection()方法，DriverManager会使用注册到它里面的驱动来获取数据库连接，并返回给调用的程序。
44.JDBC的ResultSet是什么？
    在查询数据库后会返回一个ResultSet，它就像是查询结果集的一张数据表。
    ResultSet对象维护了一个游标，指向当前的数据行。开始的时候这个游标指向的是第一行。如果调用了ResultSet的next()方法游标会下移一行，如果没有更多的数据了，
    next()方法会返回false。可以在for循环中用它来遍历数据集。

面向对象的三个特征：封装，继承，多态。

多态的好处：
可代替性：多态对已存在代码具有可替代性。
可扩展性：增加新的子类不影响已经存在的类结构。
接口性：多态是超类通过方法签名，向子类提供一个公共接口，由子类来完善或者重写它来实现的。
灵活性，简化性。

ArrayList是实现了基于动态数组的数据结构，LinkedList是基于链表结构。 2.对于随机访问的get和set方法，
ArrayList要优于LinkedList，因为LinkedList要移动指针。 3.对于新增和删除操作add和remove，LinkedList比较占优势，因为ArrayList要移动数据。

对ArrayList和LinkedList而言，在列表末尾增加一个元素所花的开销都是固定的。对 ArrayList而言，
主要是在内部数组中增加一项，指向所添加的元素，偶尔可能会导致对数组重新进行分配；而对LinkedList而言，
这个开销是 统一的，分配一个内部Entry对象。 2.在ArrayList集合中添加或者删除一个元素时，当前的列表所所有的元素都会被移动。
而LinkedList集合中添加或者删除一个元素的开销是固定的。 3.LinkedList集合不支持 高效的随机随机访问（RandomAccess），因为可能产生二次项的行为。
4.ArrayList的空间浪费主要体现在在list列表的结尾预留一定的容量空间，而LinkedList的空间花费则体现在它的每一个元素都需要消耗相当的空间

如何实现多态：
接口实现，继承父类重写方法，同一类中进行方法重载。

接口的意义：规范，扩展，对调。
抽象类的意义：为其他子类提供一个公共的类型，封装子类中重复定义的内容，定义抽象方法，子类虽然有不同的实现，但是定义时一致。

抽象类和接口的区别：
接口：java8之前，接口中不存在方法的实现，子类使用implements来实现接口，需要提供接口中所有声明的实现。
    接口中不能有构造器，接口默认是public，不能使用其他修饰符，一个子类可以存在多个接口，如果接口中添加新方法，
    接口的子类需要实现该方法。
抽象类：抽象类可以有默认的方法实现，子类使用extends关键字来继承抽象类，如果子类不是抽象类，子类需要提供抽象类中所声明方法的实现。
    抽象类中可以有构造器，抽象类不能被实例化，抽象方法可以有public，protected，default等修饰，一个子类只能存在一个父类，
    抽象类中添加新方法，可以提供默认的实现，因此可以不修改子类现有的代码。
父类的静态方法能否被子类重写：
不能，重写只适用于实例方法，不能用于静态方法，而子类当中含有和父类相同签名的静态方法，我们一般称之为隐藏。
什么是不可变对象：
不可变对象指对象一旦被创建，状态就不能再改变。任何修改都会创建一个新的对象，如string，integer及其他的包装类。
静态变量和实例变量的区别：
静态变量存储在方法区，属于类所有。实例变量存储在堆当中，其引用存在当前线程栈。
能否创建一个包含可变对象的不可变对象？
当然可以创建，我们只需要谨慎一点，不要共享可变对象的引用，如果需要变化时，就返回原对象的一个拷贝。最常见的
例子就是对象中包含一个日期对象的引用。
java创建对象的几种方法：
采用new，通过反射，采用clone，通过序列化机制。
前两者都需要显式地调用构造方法。造成耦合性最高的恰好是第一种，因此我们发现无论什么框架，只要涉及到解耦必先减少new的使用。
String s1=”ab”, String s2=”a”+”b”, String s3=”a”, String s4=”b”, s5=s3+s4请问s5==s2返回什么？
s2会直接优化为ab，将其放置在常量池当中，s5则是被创建在堆区中。相当于s5=new String（"ab"）；
String对象的intern（）方法会首先从常量池中查找是否存在该常量值，如果常量池中不存在则现在常亮池的创建，如果存在则直接返回。
Object中有哪些公共方法：equals（），clone（），getClass（），notify（），notifyAll（），wait（），toString（）；
java当中的四种引用：
强引用：如果一个对象具有强引用，它就不会被垃圾回收期回收，即使当前内存空间不足，JVM也不会回收它，而是抛出outofmemoryerror错误，是程序异常终止。
    如果想中断强引用和某个对象之间的关联，可以显示地将引用赋值为null，这样一来的话，JVM在合适的时间就会回收该对象。
弱引用：具有弱引用的对象拥有的声明周期更短暂，因为当JVM进行垃圾回收，一旦发现弱引用对象，无论当前内存空间是否充足，都会讲弱引用回收，不过由于垃圾回收器是一个优先级较低的线程，多以并不一定能迅速的发现弱引用对象。
软引用:在使用软引用时，如果内存的空间足够，软引用就能继续被使用，而不会被垃圾回收器回收，只有在内存不足时，软引用才会被垃圾回收器回收
虚引用：顾名思义，就是形同虚设，如果一个对象仅持有虚引用，那么它相当于没有引用，在任何时候都可能被垃圾回收器回收。
java中== 和equals（）的区别，equals（）和hashcode的区别：
==是运算符，用于比较两个变量是否相等，而equals是Object类的方法，用于比较两个对象是否相等，默认Object类的equals方法时比较两个
对象的地址，此时和==的结果一样。换句话说：基本类型比较用==，比较的他们的值。默认下，对象用==比较时，比较的是内存地址，如果需要比较
对象内容，需要重写equal方法。
hashcode（）是Object类的一个方法，返回一个哈希值。如果两个对象根据equal方法比较相等，那么调用这两个对象中任意一个对象的hashcode方法必须产生相同的哈希值。
如果两个对象根据equal方法比较不相等，那么产生的哈希值不一定相等（碰撞的情况下还是会相等的）；
hashCode() 方法是相应对象整型的 hash 值。它常用于基于 hash 的集合类，如 Hashtable、HashMap、LinkedHashMap等等。它与 equals() 方法关系特别紧密。根据 Java 规范，使用 equal() 方法来判断两个相等的对象，必须具有相同的 hashcode。
将对象放入到集合中时，首先判断要放入对象的hashcode是否已经在集合中存在，不存在则直接放入集合。如果hashcode相等，然后通过equal()方法判断要放入对象与集合中的任意对象是否相等：如果equal()判断不相等，直接将该元素放入集合中，否则不放入。
有没有可能两个不相等的对象有相同的hashcode
有可能，两个相等的对象可能会有相同的hashcode，这就是为什么在hashmap中会有冲突。如果两个对象相等，必须有相同的hashcode值，反之不成立。
short类型在进行运算时会自动提升为int类型
short s1=1；s1+=1； +=操作符会自动对右边的表达式结果强转匹配左边的数据类型。
&和&&的区别：
&是位操作，而&&是逻辑运算符。另外逻辑运算符具有短路特性，而&不具备短路特性。
内部类的作用：
内部类可以有多个实例，每个实例都有自己的状态信息，并且与其他外围对象的信息相互独立，在单个外围类当中，可以让多个内部类以不同的方式实现同一接口，或者继承同一个类，创建内部类对象的时刻不依赖与外部类对象的创建。内部类提供了
更好的封装，除了该外围类，其他类都不能访问。
final, finalize和finally的不同之处
final 是一个修饰符，可以修饰变量、方法和类。如果 final 修饰变量，意味着该变量的值在初始化后不能被改变。finalize 方法是在对象被回收之前调用的方法，给对象自己最后一个复活的机会，但是什么时候调用 finalize 没有保证。finally 是一个关键字，
与 try 和 catch 一起用于异常的处理。finally 块一定会被执行，无论在 try 块中是否有发生异常。
深拷贝和浅拷贝的区别是什么？
浅拷贝：被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象。
    换而言之，浅拷贝仅仅复制所考虑的对象，而不复制它所引用的对象。、
深拷贝：被复制对象的所有变量都含有与原来的对象相同的值，而那些引用其他对象的变量将指向被复制的新对象，而不是原有的那些被引用的对象。
    换而言之，深拷贝要把复制的对象所引用的对象都复制一遍。
static的用法：静态变量，静态方法，静态块，静态内部类，静态导包。
final的用法：被final修饰类不可以被继承，被final修饰的方法不可以被重写，被final修饰的常量，在编译阶段会存入常量池中，被final修饰的方法，JVM会尝试将其内联，以提高运行效率，被final修饰的变量不可以被改变。
string，stringbuffer，stringbuilder的区别：
string是字符串常量，final修饰：stringbuffer字符串变量，线程安全。Stringbuilder字符串变量（线程不安全）
String和StringBuffer主要区别是性能：String是不可变对象，每次对String类型进行操作都等同于产生了一个新的String对象，然后指向新的String对象。所以尽量不在对String进行大量的拼接操作，否则会产生很多临时对象，导致GC开始工作，影响系统性能。
关于垃圾回收：
如何判断一个对象是否应该被回收
引用计数法，对象可达性分析。
简单的解释一下垃圾回收：
java垃圾回收机制最基本的做法是分代回收。内存中的区域被划分为不同的世代，对象根据其存活的时间被保存在对应世代的区域中。一般的实现是划分为3个世代：年轻，年老，永久。内存的分配是发生在年轻世代中的。
当一个对象存活时间足够长的时候，他就会被复制到年老世代中。对于不同的世代可以使用不同的垃圾回收算法。进行世代划分的出发点是对应用中对象存活时间进行研究之后得出的统计规律。一般来说，一个应用中的大
部分对象的存活时间都会短。比如局部变量的存活时间就只在方法的执行过程中。基于这一点，对于年轻世代的垃圾回收算法就可以很有针对性。
进程，线程相关：
进程，线程，协程之间的区别：
简而言之，进程是程序运行和分配的基本单元，一个程序至少有一个进程，一个进程至少有一个线程。进程在执行过程中拥有独立的内存单元，而多个线程共享内存资源，减少切换次数，从而效率更高。线程是进程的一个实体，是cpu调度和分派的基本单元，是比程序更小的能独立运行
的基本单位。同一进程中的多个线程之间可以并发执行。
守护线程：程序运行完毕，jvm会等待非守护线程完成后关闭，但是jvm不会等待守护线程。守护线程最典型的就是GC线程。
创建线程的两种方式：实现runnable或者扩展thread类。实现runnable接口的优点：java不支持多继承，因此扩展Thead类就代表这个子类不能扩展其他类，而实现接口还可能扩展另一个类。
            类可能只要求可执行即可，因此继承整个thread类的开销过大。
Thread类中的start和run方法有什么区别？
start方法被用来启动新创建的线程，而且start内部调用了run方法，这和直接调用run方法的效果不一样。当你调用run方法的时候，只会在原来的线程中调用，没有新的线程启动，start方法才会启动新线程。
产生死锁的条件：
互斥条件：一个资源每次只能被一个进程使用。
请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。
不剥夺条件：进程已获得的资源，在未使用完之前，不能强行剥夺。
循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系。
生产者消费者模型的作用是什么?
通过平衡生产者的生产能力和消费者的消费能力来提升整个系统的运行效率，这是生产者消费者模型最重要的作用。
解耦，这是生产者消费者模型附带的作用，解耦意味着生产者和消费者之间的联系少，联系越少越可以独自发展而不需要收到相互的制约。
为什么要使用线程池

避免频繁地创建和销毁线程，达到线程对象的重用。另外，使用线程池还可以根据项目灵活地控制并发的数目。
java中用到的线程调度算法是什么

抢占式。一个线程用完CPU之后，操作系统会根据线程优先级、线程饥饿情况等数据算出一个总的优先级并分配下一个时间片给某个线程执行。
什么是乐观锁和悲观锁

乐观锁：乐观锁认为竞争不总是会发生，因此它不需要持有锁，将比较-替换这两个动作作为一个原子操作尝试去修改内存中的变量，如果失败则表示发生冲突，那么就应该有相应的重试逻辑。

悲观锁：悲观锁认为竞争总是会发生，因此每次对某资源进行操作时，都会持有一个独占的锁，就像synchronized，不管三七二十一，直接上了锁就操作资源了。
ArrayList和LinkedList的区别?

最明显的区别是 ArrrayList底层的数据结构是数组，支持随机访问，而 LinkedList 的底层数据结构是双向循环链表，不支持随机访问。使用下标访问一个元素，ArrayList 的时间复杂度是 O(1)，而 LinkedList 是 O(n)。

ArrayList和Array有什么区别?

    Array可以容纳基本类型和对象，而ArrayList只能容纳对象。

    Array是指定大小的，而ArrayList大小是固定的
linkedlist是双向循环列表，是双向链表。
treemap是采用红黑树实现。
HashMap的实现原理

1. HashMap概述： HashMap是基于哈希表的Map接口的非同步实现。此实现提供所有可选的映射操作，并允许使用null值和null键。此类不保证映射的顺序，特别是它不保证该顺序恒久不变。
2. HashMap的数据结构： 在java编程语言中，最基本的结构就是两种，一个是数组，另外一个是模拟指针（引用），所有的数据结构都可以用这两个基本结构来构造的，HashMap也不例外。HashMap实际上是一个“链表散列”的数据结构，即数组和链表的结合体。

当我们往Hashmap中put元素时,首先根据key的hashcode重新计算hash值,根绝hash值得到这个元素在数组中的位置(下标),如果该数组在该位置上已经存放了其他元素,那么在这个位置上的元素将以链表的形式存放,新加入的放在链头,最先加入的放入链尾.如果数组中该位置没有元素,就直接将该元素放到数组的该位置上.

需要注意Jdk 1.8中对HashMap的实现做了优化,当链表中的节点数据超过八个之后,该链表会转为红黑树来提高查询效率
throw和throws的区别

throw用于主动抛出java.lang.Throwable 类的一个实例化对象，意思是说你可以通过关键字 throw 抛出一个 Error 或者 一个Exception，如：throw new IllegalArgumentException(“size must be multiple of 2″),
而throws 的作用是作为方法声明和签名的一部分，方法被抛出相应的异常以便调用者能处理。Java 中，任何未处理的受检查异常强制在 throws 子句中声明。

JVM特性

平台无关性.
Java语言的一个非常重要的特点就是与平台的无关性。而使用Java虚拟机是实现这一特点的关键。
一般的高级语言如果要在不同的平台上运行，至少需要编译成不同的目标代码。而引入Java语言虚拟机后，
Java语言在不同平台上运行时不需要重新编译。Java语言使用模式Java虚拟机屏蔽了与具体平台相关的信息
，使得Java语言编译程序只需生成在Java虚拟机上运行的目标代码（字节码），就可以在多种平台上不加修改地运行。
Java虚拟机在执行字节码时，把字节码解释成具体平台上的机器指令执行。
JDK 1.8特性
Lambda 表达式，允许像对象一样传递匿名函数
Stream API，充分利用现代多核 CPU，可以写出很简洁的代码
Date 与 Time API，最终，有一个稳定、简单的日期和时间库可供你使用
扩展方法，现在，接口中可以有静态、默认方法。
重复注解，现在你可以将相同的注解在同一类型上使用多次。

说说你对servlet的理解或者 servlet 是什么？
Servlet（Servlet Applet），全称Java Servlet,是用Java编写的服务器端程序。而这些Servlet都要实现Servlet这个接口。其主要功能在于交互式的浏览和修改数据，生成动态Web内容。Servlet运行于支持Java的应用服务器中。
Servlet是一个运行了面向请求/ 响应服务器中的网络模块。

请求是客户的一个调用，可能是远程的。

请求包含了客户要发送给服务器的数据。

响应是服务器返回给客户的回答该请求的数据。Servlet是一个JAVA对象，他以请求为输入，分析其数据，执行一些逻辑运算，并给客户发回一个响应。
Servlet生命周期包括三部分：

初始化：Web容器加载servlet，调用init()方法

处理请求：当请求到达时，运行其service()方法。service()自动派遣运行与请求相对应的doXXX（doGet或者doPost）方法。

销毁：服务结束，web容器会调用servlet的distroy()方法销毁servlet。
get提交和post提交有何区别

（1）get一般用于从服务器上获取数据，post一般用于向服务器传送数据

（2）请求的时候参数的位置有区别，get的参数是拼接在url后面，用户在浏览器地址栏可以看到。post是放在http包的包体中。
（3）能提交的数据有区别，get方式能提交的数据只能是文本，且大小不超过1024个字节，而post不仅可以提交文本还有二进制文件。

所以说想上传文件的话，那我们就需要使用post请求方式

（4）servlet在处理请求的时候分别对应使用doGet和doPost方式进行处理请求

springboot常用的注解：
@RestController注解，它继承自@Controller注解。4.0之前的版本，Spring MVC的组件都使用@Controller来标识当前类是一个控制器servlet。使用这个特性，我们可以开发REST服务的时候不需要使用@Controller而专门的@RestController。
第二个类级别的注解是 @EnableAutoConfiguration 。这个注解告诉Spring Boot根据添加的jar依赖猜测你想如何配置Spring。
@SpringBootApplication
很多Spring Boot开发者总是使用 @Configuration ， @EnableAutoConfiguration 和 @ComponentScan 注解他们的main类。由于这些注解被如此频繁地一块使用（特别是你遵循以上最佳实践时），Spring Boot提供一个方便的 @SpringBootApplication 选择。
@ResponseBody
表示该方法的返回结果直接写入HTTP response body中
一般在异步获取数据时使用，在使用@RequestMapping后，返回值通常解析为跳转路径，加上
@responsebody后返回结果不会被解析为跳转路径，而是直接写入HTTP response body中。比如
异步获取json数据，加上@responsebody后，会直接返回json数据。
@AutoWired
byType方式。把配置好的Bean拿来用，完成属性、方法的组装，它可以对类成员变量、方法及构
造函数进行标注，完成自动装配的工作。
@RequestParam：
用在方法的参数前面。
@PathVariable:
路径变量。

oracle和mysql的区别，比如分页
MYSQL有自动增长的数据类型，插入记录时不用操作此字段，会自动获得数据值。ORACLE没有自动增长的数据类型，需要建立一个自动增长的序列号，插入记录时要把序列号的下一个值赋于此字段。
 MYSQL里可以用双引号包起字符串，ORACLE里只可以用单引号包起字符串。
 MYSQL处理翻页的SQL语句比较简单，用LIMIT 开始位置, 记录个数；
 ORACLE处理翻页的SQL语句就比较繁琐了。每个结果集只有一个rownum字段标明它的位置, 并且只能用ROWNUM<100, 不能用ROWNUM>80。
rownum只能比较小于，不能比较大于，因为rownum是先查询后排序的，例如你的条件为rownum>1，当查询到第一条数据，rownum为1，则不符合条件。第2、3...类似，一直不符合条件，所以一直没有返回结果。所以查询的时候需要设置别名，然后查询完成之后再通过调用别名进行大于的判断。

linux常用的几个命令：
ls：展示目录列表命令；切换目录命令cd；目录的创建（mkdir）和删除（rmdir）命令；
文件的创建（touch）和删除（rm）命令；文件打包或解压命令tar；cp (复制文件或目录)；
pwd显示当前工作目录的绝对路径；touch创建新的空文件，改变已有文件的时间戳属性。；
cat用于连接多个文件并且打印到屏幕输出或重定向到指定文件中。
vi/vim命令行文本编辑器。unzip解压文件sudo以另外一个用户身份（默认root用户）执行事先在sudoers文件允许的命令。
ifconfig查看、配置、启用或禁用网络接口的命令。chmod改变文件或目录权限。
shutdown关机；reboot重启；kill终止进程。

为什么使用redis：
在特定场景中速度极快，适用于较小数据库操作。同时可以将数据缓存到本地磁盘，做到数据的持久化。
mybatis中#和$的区别：
#{}在组成sql语句的时候把参数默认为字符串。${}使用${}时的sql不会当做字符串处理，是什么就是什么