Java基础知识篇

面向对象和面向过程的区别

面向过程：html

　　优势：性能比面向对象高，由于类调用时须要实例化，开销比较大，比较消耗资源;好比单片机、嵌入式开发、Linux/Unix等通常采用面向过程开发，性能是最重要的因素。java

缺点：没有面向对象易维护、易复用、易扩展程序员

面向对象：web

　　优势：易维护、易复用、易扩展，因为面向对象有封装、继承、多态性的特性，能够设计出低耦合的系统，使系统更加灵活、更加易于维护面试

缺点：性能比面向过程低算法

Java语言有哪些特色？

　　1，简单易学；2，面向对象（封装，继承，多态）；3，平台无关性（Java虚拟机实现平台无关性）；4，可靠性；5，安全性；6，支持多线程（C++语言没有内置的多线程机制，所以必须调用操做系统的多线程功能来进行多线程
程序设计，而Java语言却提供了多线程支持）；7，支持网络编程而且很方便（Java语言诞生自己就是为简化网络编程设计的，所以Java语言不只支持网络编程并且很方便）；8，编译与解释并存；数据库

什么是字节码？采用字节码的最大好处是什么？什么Java是虚拟机？

先看下java中的编译器和解释器：编程

　　Java中引入了虚拟机的概念，即在机器和编译程序之间加入了一层抽象的虚拟的机器。这台虚拟的机器在任何平台上都提供给编译程序一个的共同的接口。编译程序只须要面向虚拟机，生成虚拟机可以理解的代码，而后由解释器来将虚拟机代码转换为特定系统的机器码执行。在Java中，这种供虚拟机理解的代码叫作字节码（即扩展名为.class的文件），它不面向任何特定的处理器，只面向虚拟机。每一种平台的解释器是不一样的，可是实现的虚拟机是相同的。Java源程序通过编译器编译后变成字节码，字节码由虚拟机解释执行，虚拟机将每一条要执行的字节码送给解释器，解释器将其翻译成特定机器上的机器码，而后在特定的机器上运行，这就是上面提到的Java的特色的编译与解释并存的解释。小程序

Java源代码---->编译器---->jvm可执行的Java字节码(即虚拟指令)---->jvm---->jvm中解释器----->机器可执行的二进制机器码---->程序运行。

采用字节码的好处：数组

　　Java语言经过字节码的方式，在必定程度上解决了传统解释型语言执行效率低的问题，同时又保留了解释型语言可移植的特色。因此Java程序运行时比较高效，并且，因为字节码并不专对一种特定的机器，所以，Java程序无须从新编译即可在多种不一样的计算机上运行。

什么是Java虚拟机

　　任何一种能够运行Java字节码的软件都可当作是Java的虚拟机（JVM）

什么是Java程序的主类？应用程序和小程序的主类有何不一样？

　　一个程序中能够有多个类，但只能有一个类是主类。在Java应用程序中，这个主类是指包含main（）方法的类。而在Java小程序中，这个主类是一个继承自系统类JApplet或Applet的子类。应用程序的主类不必定要求是public类，但小程序的主类要求必须是public类。主类是Java程序执行的入口点。

什么是JDK?什么是JRE？

　　JDK: 顾名思义它是给开发者提供的开发工具箱,是给程序开发者用的。它除了包括完整的JRE（Java Runtime Environment），Java运行环境，还包含了其余供开发者使用的工具包。

　　JRE:普通用户而只须要安装JRE（Java Runtime Environment）来来运行Java程序。而程序开发者必须安装JDK来编译、调试程序。

环境变量Path和ClassPath的做用是什么？如何设置这两个环境变量？

Java环境变量PATH和CLASSPATH - 简书 http://www.jianshu.com/p/d63b099cf283

Java应用程序与小程序之间有那些差异？

简单说应用程序是从主线程启动(也就是main()方法)。applet小程序没有main方法，主要是嵌在浏览器页面上运行(调用init()线程或者run()来启动)，嵌入浏览器这点跟flash的小游戏相似。

字符型常量和字符串常量的区别

1) 形式上:

字符常量是单引号引发的一个字符

字符串常量是双引号引发的若干个字符

2) 含义上:

字符常量至关于一个整形值(ASCII值),能够参加表达式运算

字符串常量表明一个地址值(该字符串在内存中存放位置)

3) 占内存大小

字符常量只占一个字节

字符串常量占若干个字节(至少一个字符结束标志)

Java语言采用何种编码方案？有何特色？

　　Java语言采用Unicode编码标准，Unicode（标准码），它为每一个字符制订了一个惟一的数值，所以在任何的语言，平台，程序均可以放心的使用。

构造器Constructor是否可被override

　　在讲继承的时候咱们就知道父类的私有属性和构造方法并不能被继承，因此Constructor也就不能被override,可是能够overload,因此你能够看到一个类中有多个构造函数的状况。

重载和重写的区别

　　重载：发生在同一个类中，方法名必须相同，参数类型不一样、个数不一样、顺序不一样，方法返回值和访问修饰符能够不一样，发生在编译时。

　　重写：发生在父子类中，方法名、参数列表必须相同，返回值小于等于父类，抛出的异常小于等于父类，访问修饰符大于等于父类；若是父类方法访问修饰符为private则子类中就不是重写。

java 面向对象编程三大特性------封装、继承、多态

http://www.javashuo.com/article/p-abefjthy-by.html

String和StringBuffer、StringBuilder的区别是什么？String为何是不可变的？

可变性
　

String类中使用字符数组保存字符串，private　final　char　value[]，因此string对象是不可变的。StringBuilder与StringBuffer都继承自AbstractStringBuilder类，在AbstractStringBuilder中也是使用字符数组保存字符串，char[]value，这两种对象都是可变的。
　　

线程安全性

String中的对象是不可变的，也就能够理解为常量，线程安全。AbstractStringBuilder是StringBuilder与StringBuffer的公共父类，定义了一些字符串的基本操做，如expandCapacity、append、insert、indexOf等公共方法。StringBuffer对方法加了同步锁或者对调用的方法加了同步锁，因此是线程安全的。StringBuilder并无对方法进行加同步锁，因此是非线程安全的。
　　

性能

每次对String 类型进行改变的时候，都会生成一个新的String对象，而后将指针指向新的String 对象。StringBuffer每次都会对StringBuffer对象自己进行操做，而不是生成新的对象并改变对象引用。相同状况下使用StirngBuilder 相比使用StringBuffer 仅能得到10%~15% 左右的性能提高，但却要冒多线程不安全的风险。

对于三者使用的总结：

若是要操做少许的数据用 = String

单线程操做字符串缓冲区下操做大量数据 = StringBuilder

多线程操做字符串缓冲区下操做大量数据 = StringBuffer

自动装箱与拆箱

装箱：将基本类型用它们对应的引用类型包装起来；

拆箱：将包装类型转换为基本数据类型；
　　

Java使用自动装箱和拆箱机制，节省了经常使用数值的内存开销和建立对象的开销，提升了效率，由编译器来完成，编译器会在编译期根据语法决定是否进行装箱和拆箱动做。

类、方法、成员变量和局部变量的可用修饰符 -

http://blog.csdn.net/yttcjj/article/details/6939239

在一个静态方法内调用一个非静态成员为何是非法的？

　　因为静态方法能够不经过对象进行调用，所以在静态方法里，不能调用其余非静态变量，也不能够访问非静态变量成员。

在Java中定义一个不作事且没有参数的构造方法的做用

　　Java程序在执行子类的构造方法以前，若是没有用super()来调用父类特定的构造方法，则会调用父类中“没有参数的构造方法”。所以，若是父类中只定义了有参数的构造方法，而在子类的构造方法中又没有用super()来调用父类中特定的构造方法，则编译时将发生错误，由于Java程序在父类中找不到没有参数的构造方法可供执行。解决办法是在父类里加上一个不作事且没有参数的构造方法。

import java和javax有什么区别

http://www.cnblogs.com/EasonJim/p/6993139.html

接口和抽象类的区别是什么？

1.接口的方法默认是public，全部方法在接口中不能有实现，抽象类能够有非抽象的方法

2.接口中的实例变量默认是final类型的，而抽象类中则不必定

3.一个类能够实现多个接口，但最多只能实现一个抽象类

4.一个类实现接口的话要实现接口的全部方法，而抽象类不必定

5.接口不能用new实例化，但能够声明，可是必须引用一个实现该接口的对象

从设计层面来讲，抽象是对类的抽象，是一种模板设计，接口是行为的抽象，是一种行为的规范。

成员变量与局部变量的区别有那些？

从语法形式上，当作员变量是属于类的，而局部变量是在方法中定义的变量或是方法的参数；成员变量能够被public,private,static等修饰符所修饰，而局部变量不能被访问控制修饰符及static所修饰；成员变量和局部变量都能被final所修饰；
从变量在内存中的存储方式来看，成员变量是对象的一部分，而对象存在于堆内存，局部变量存在于栈内存
从变量在内存中的生存时间上看，成员变量是对象的一部分，它随着对象的建立而存在，而局部变量随着方法的调用而自动消失。
成员变量若是没有被赋初值，则会自动以类型的默认值而赋值（一种状况例外被final修饰但没有被static修饰的成员变量必须显示地赋值）；而局部变量则不会自动赋值。

建立一个对象用什么运算符？对象实体与对象引用有何不一样？

　　new运算符，new建立对象实例（对象实例在堆内存中），对象引用指向对象实例（对象引用存放在栈内存中）。一个对象引用能够指向0个或1个对象（一根绳子能够不系气球，也能够系一个气球）;一个对象能够有n个引用指向它（能够用n条绳子系住一个气球）

什么是方法的返回值？返回值在类的方法里的做用是什么？

　　方法的返回值是指咱们获取到的某个方法体中的代码执行后产生的结果！（前提是该方法可能产生结果）。返回值的做用:接收出结果，使得它能够用于其余的操做！

一个类的构造方法的做用是什么？若一个类没有声明构造方法，改程序能正确执行吗？为何？

　　主要做用是完成对类对象的初始化工做。能够执行。由于一个类即便没有声明构造方法也会有默认的不带参数的构造方法。

构造方法有哪些特性？

　　1，名字与类名相同；2，没有返回值，但不能用void声明构造函数；3，生成类的对象时自动执行，无需调用。

静态方法和实例方法有何不一样？

静态方法和实例方法的区别主要体如今两个方面：

在外部调用静态方法时，可使用"类名.方法名"的方式，也可使用"对象名.方法名"的方式。而实例方法只有后面这种方式。也就是说，调用静态方法能够无需建立对象。
静态方法在访问本类的成员时，只容许访问静态成员（即静态成员变量和静态方法），而不容许访问实例成员变量和实例方法；实例方法则无此限制

对象的相等与指向他们的引用相等，二者有什么不一样？

　　对象的相等比的是内存中存放的内容是否相等而引用相等比较的是他们指向的内存地址是否相等。

在调用子类构造方法以前会先调用父类没有参数的构造方法，其目的是？

　　帮助子类作初始化工做。

什么是多态机制？Java语言是如何实现多态的？

http://blog.csdn.net/bornlili/article/details/55213563

equals 和 == 的区别？

通俗点讲：==是看看左右是否是一个东西。equals是看看左右是否是长得同样。如何记住嘛。若是单纯是想记住，==：等于。equals：相同。两个长得同样的人，只能说长的相同(equals)，可是不等于他们俩是一我的。你只要记住equals，==就不用记了。

术语来说的区别：1.==是判断两个变量或实例是否是指向同一个内存空间 equals是判断两个变量或实例所指向的内存空间的值是否是相同
2.==是指对内存地址进行比较 equals()是对字符串的内容进行比较3.==指引用是否相同 equals()指的是值是否相同

建立线程有几种不一样的方式？你喜欢哪种？为何？

继承Thread类
实现Runnable接口
应用程序可使用Executor框架来建立线程池
实现Callable接口。

我更喜欢实现Runnable接口这种方法，固然这也是如今大多程序员会选用的方法。由于一个类只能继承一个父类而能够实现多个接口。同时，线程池也是很是高效的，很容易实现和使用。

简述线程，程序、进程的基本概念。以及他们之间关系是什么？（参考书籍：《Java程序设计基础》第五版）

线程与进程类似，但线程是一个比进程更小的执行单位。一个进程在其执行的过程当中能够产生多个线程。与进程不一样的是同类的多个线程共享同一块内存空间和一组系统资源，因此系统在产生一个线程，或是在各个线程之间做切换工做时，负担要比进程小得多，也正由于如此，线程也被称为轻量级进程。

程序是含有指令和数据的文件，被存储在磁盘或其余的数据存储设备中，也就是说程序是静态的代码。

进程是程序的一次执行过程，是系统运行程序的基本单位，所以进程是动态的。系统运行一个程序便是一个进程从建立，运行到消亡的过程。简单来讲，一个进程就是一个执行中的程序，它在计算机中一个指令接着一个指令地执行着，同时，每一个进程还占有某些系统资源如CPU时间，内存空间，文件，文件，输入输出设备的使用权等等。换句话说，当程序在执行时，将会被操做系统载入内存中。
线程是进程划分红的更小的运行单位。线程和进程最大的不一样在于基本上各进程是独立的，而各线程则不必定，由于同一进程中的线程极有可能会相互影响。从另外一角度来讲，进程属于操做系统的范畴，主要是同一段时间内，能够同时执行一个以上的程序，而线程则是在同一程序内几乎同时执行一个以上的程序段。

什么是多线程？为何程序的多线程功能是必要的？

多线程就是几乎同时执行多个线程（一个处理器在某一个时间点上永远都只能是一个线程！即便这个处理器是多核的，除非有多个处理器才能实现多个线程同时运行。）。几乎同时是由于实际上多线程程序中的多个线程其实是一个线程执行一会而后其余的线程再执行，并非不少书籍所谓的同时执行。这样能够带来如下的好处：

使用线程能够把占据长时间的程序中的任务放到后台去处理
用户界面能够更加吸引人，这样好比用户点击了一个按钮去触发某些事件的处理，能够弹出一个进度条来显示处理的进度
程序的运行速度可能加快
在一些等待的任务实现上如用户输入、文件读写和网络收发数据等，线程就比较有用了。在这种状况下能够释放一些珍贵的资源如内存占用等等。
还有其余不少使用多线程的好处，这里就不一一说明了。

多线程与多任务的差别是什么？（参考书籍：《Java程序设计基础》第五版）

多任务与多线程是两个不一样的概念，
多任务是针对操做系统而言的，表示操做系统能够同时运行多个应用程序。
而多线程是针对一个进程而言的，表示在一个进程内部能够几乎同时执行多个线程

线程有哪些基本状态？这些状态是如何定义的?

新建(new)：新建立了一个线程对象。
可运行(runnable)：线程对象建立后，其余线程(好比main线程）调用了该对象的start()方法。该状态的线程位于可运行线程池中，等待被线程调度选中，获取cpu的使用权。
运行(running)：可运行状态(runnable)的线程得到了cpu时间片（timeslice），执行程序代码。
阻塞(block)：阻塞状态是指线程由于某种缘由放弃了cpu使用权，也即让出了cpu timeslice，暂时中止运行。直到线程进入可运行(runnable)状态，才有机会再次得到cpu timeslice转到运行(running)状态。阻塞的状况分三种：
(一). 等待阻塞：运行(running)的线程执行o.wait()方法，JVM会把该线程放入等待队列(waitting queue)中。
(二). 同步阻塞：运行(running)的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则JVM会把该线程放入锁池(lock pool)中。
(三). 其余阻塞: 运行(running)的线程执行Thread.sleep(long ms)或t.join()方法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态。当sleep()状态超时join()等待线程终止或者超时、或者I/O处理完毕时，线程从新转入可运行(runnable)状态。
死亡(dead)：线程run()、main()方法执行结束，或者因异常退出了run()方法，则该线程结束生命周期。死亡的线程不可再次复生。

备注：
能够用早起坐地铁来比喻这个过程：
还没起床：sleeping
起床收拾好了，随时能够坐地铁出发：Runnable
等地铁来：Waiting
地铁来了，但要排队上地铁：I/O阻塞
上了地铁，发现暂时没座位：synchronized阻塞
地铁上找到座位：Running
到达目的地：Dead

什么是线程的同步？程序中为何要实现线程的同步？是如何实现同步的？

当一个线程对共享的数据进行操做时，应使之成为一个”原子操做“，即在没有完成相关操做以前，不容许其余线程打断它，不然，就会破坏数据的完整性，必然会获得错误的处理结果，这就是线程的同步。
在多线程应用中，考虑不一样线程之间的数据同步和防止死锁。当两个或多个线程之间同时等待对方释放资源的时候就会造成线程之间的死锁。为了防止死锁的发生，须要经过同步来实现线程安全。

在监视器(Monitor)内部，是如何作线程同步的？程序应该作哪一种级别的同步？

在 java 虚拟机中, 每一个对象( Object 和 class )经过某种逻辑关联监视器,每一个监视器和一个对象引用相关联, 为了实现监视器的互斥功能, 每一个对象都关联着一把锁.
一旦方法或者代码块被 synchronized 修饰, 那么这个部分就放入了监视器的监视区域, 确保一次只能有一个线程执行该部分的代码, 线程在获取锁以前不容许执行该部分的代码
另外 java 还提供了显式监视器( Lock )和隐式监视器( synchronized )两种锁方案

什么是死锁(deadlock)？

360百科

死锁 :是指两个或两个以上的进程在执行过程当中,因争夺资源而形成的一种互相等待的现象,若无外力做用,它们都将没法推动下去。
产生缘由：

由于系统资源不足。
进程运行推动顺序不合适。
资源分配不当等。
占用资源的程序崩溃等。

若是系统资源充足，进程的资源请求都可以获得知足，死锁出现的可能性就很低，不然就会因争夺有限的资源而陷入死锁。其次，进程运行推动顺序与速度不一样，也可能产生死锁。

下面四个条件是死锁的必要条件，只要系统发生死锁，这些条件必然成立，而只要下列条件之一不知足，就不会发生死锁。

互斥条件：一个资源每次只能被一个进程使用。
请求与保持条件：一个进程因请求资源而阻塞时，对已得到的资源保持不放。
不剥夺条件:进程已得到的资源，在末使用完以前，不能强行剥夺。
循环等待条件:若干进程之间造成一种头尾相接的循环等待资源关系。
死锁的解除与预防：

理解了死锁的缘由，尤为是产生死锁的四个必要条件，就能够最大可能地避免、预防和解除死锁。因此，在系统设计、进程调度等方面注意如何不让这四个必要条件成立，如何确定资源的合理分配算法，避免进程永久占据系统资源。此外，也要防止进程在处于等待状态的状况下占用资源。所以，对资源的分配要给予合理的规划。

如何确保N个线程能够访问N个资源同时又不致使死锁？

上面一题咱们知道了发生死锁的四个必要条件。咱们只要使其中一个不成立就好了。一种很是简单的避免死锁的方式就是：指定获取锁的顺序，并强制线程按照指定的顺序获取锁。所以，若是全部的线程都是以一样的顺序加锁和释放锁，就不会出现死锁了。这也就是破坏了第四个条件循环等待条件。

Java中垃圾回收有什么目的？何时进行垃圾回收？

垃圾回收是在内存中存在没有引用的对象或超过做用域的对象时进行。

垃圾回收的目的是识别而且丢弃应用再也不使用的对象来释放和重用资源。

finalize()方法何时被调用？析构函数(finalization)的目的是什么？

1）垃圾回收器（garbage colector）决定回收某对象时，就会运行该对象的finalize()方法；
finalize是Object类的一个方法，该方法在Object类中的声明protected void finalize() throws Throwable { }
在垃圾回收器执行时会调用被回收对象的finalize()方法，能够覆盖此方法来实现对其资源的回收。注意：一旦垃圾回收器准备释放对象占用的内存，将首先调用该对象的finalize()方法，而且下一次垃圾回收动做发生时，才真正回收对象占用的内存空间

2）GC原本就是内存回收了，应用还须要在finalization作什么呢？答案是大部分时候，什么都不用作(也就是不须要重载)。只有在某些很特殊的状况下，好比你调用了一些native的方法(通常是C写的)，能够要在finaliztion里去调用C的释放函数。

若是对象的引用被置为null，垃圾收集器是否会当即释放对象占用的内存？

不会，在下一个垃圾回收周期中，这个对象将是可被回收的。

JavaWeb基础知识总结

Servlet总结：

在Java Web程序中，Servlet主要负责接收用户请求HttpServletRequest,在doGet(),doPost()中作相应的处理，并将回应HttpServletResponse反馈给用户。Servlet能够设置初始化参数，供Servlet内部使用。一个Servlet类只会有一个实例，在它初始化时调用init()方法，销毁时调用destroy()方法。Servlet须要在web.xml中配置（MyEclipse中建立Servlet会自动配置），一个Servlet能够设置多个URL访问。Servlet不是线程安全，所以要谨慎使用类变量。

阐述Servlet和CGI的区别?

CGI的不足之处：

1，须要为每一个请求启动一个操做CGI程序的系统进程。若是请求频繁，这将会带来很大的开销。

2，须要为每一个请求加载和运行一个CGI程序，这将带来很大的开销

3，须要重复编写处理网络协议的代码以及编码，这些工做都是很是耗时的。

Servlet的优势：

1，只须要启动一个操做系统进程以及加载一个JVM，大大下降了系统的开销

2，若是多个请求须要作一样处理的时候，这时候只须要加载一个类，这也大大下降了开销

3，全部动态加载的类能够实现对网络协议以及请求解码的共享，大大下降了工做量。

4，Servlet能直接和Web服务器交互，而普通的CGI程序不能。Servlet还能在各个程序之间共享数据，使数据库链接池之类的功能很容易实现。

补充：Sun Microsystems公司在1996年发布Servlet技术就是为了和CGI进行竞争，Servlet是一个特殊的Java程序，一个基于Java的Web应用一般包含一个或多个Servlet类。Servlet不可以自行建立并执行，它是在Servlet容器中运行的，容器将用户的请求传递给Servlet程序，并将Servlet的响应回传给用户。一般一个Servlet会关联一个或多个JSP页面。之前CGI常常由于性能开销上的问题被诟病，然而Fast CGI早就已经解决了CGI效率上的问题，因此面试的时候大可没必要信口开河的诟病CGI，事实上有不少你熟悉的网站都使用了CGI技术。

参考：《javaweb整合开发王者归来》P7

Servlet接口中有哪些方法及Servlet生命周期探秘

Servlet接口定义了5个方法，其中前三个方法与Servlet生命周期相关：

void init(ServletConfig config) throws ServletException
void service(ServletRequest req, ServletResponse resp) throws ServletException, java.io.IOException
void destory()
java.lang.String getServletInfo()
ServletConfig getServletConfig()

生命周期： Web容器加载Servlet并将其实例化后，Servlet生命周期开始，容器运行其init()方法进行Servlet的初始化；请求到达时调用Servlet的service()方法，service()方法会根据须要调用与请求对应的doGet或doPost等方法；当服务器关闭或项目被卸载时服务器会将Servlet实例销毁，此时会调用Servlet的destroy()方法。init方法和destory方法只会执行一次，service方法客户端每次请求Servlet都会执行。Servlet中有时会用到一些须要初始化与销毁的资源，所以能够把初始化资源的代码放入init方法中，销毁资源的代码放入destroy方法中，这样就不须要每次处理客户端的请求都要初始化与销毁资源。

参考：《javaweb整合开发王者归来》P81

get和post请求的区别？

①get请求用来从服务器上得到资源，而post是用来向服务器提交数据；

②get将表单中数据按照name=value的形式，添加到action 所指向的URL 后面，而且二者使用"?"链接，而各个变量之间使用"&"链接；post是将表单中的数据放在HTTP协议的请求头或消息体中，传递到action所指向URL；

③get传输的数据要受到URL长度限制（1024字节即256个字符）；而post能够传输大量的数据，上传文件一般要使用post方式；

④使用get时参数会显示在地址栏上，若是这些数据不是敏感数据，那么可使用get；对于敏感数据仍是应用使用post；

⑤get使用MIME类型application/x-www-form-urlencoded的URL编码（也叫百分号编码）文本的格式传递参数，保证被传送的参数由遵循规范的文本组成，例如一个空格的编码是"%20"。

补充：GET方式提交表单的典型应用是搜索引擎。GET方式就是被设计为查询用的。

什么状况下调用doGet()和doPost()?

Form标签里的method的属性为get时调用doGet()，为post时调用doPost()。

转发（Forward）和重定向（Redirect）的区别？

转发是服务器行为，重定向是客户端行为。

转发（Forword）
经过RequestDispatcher对象的forward（HttpServletRequest request,HttpServletResponse response）方法实现的。RequestDispatcher能够经过HttpServletRequest 的getRequestDispatcher()方法得到。例以下面的代码就是跳转到login_success.jsp页面。

request.getRequestDispatcher("login_success.jsp").forward(request, response);

重定向（Redirect） 是利用服务器返回的状态吗来实现的。客户端浏览器请求服务器的时候，服务器会返回一个状态码。服务器经过HttpServletRequestResponse的setStatus(int status)方法设置状态码。若是服务器返回301或者302，则浏览器会到新的网址从新请求该资源。

从地址栏显示来讲

forward是服务器请求资源,服务器直接访问目标地址的URL,把那个URL的响应内容读取过来,而后把这些内容再发给浏览器.浏览器根本不知道服务器发送的内容从哪里来的,因此它的地址栏仍是原来的地址.
redirect是服务端根据逻辑,发送一个状态码,告诉浏览器从新去请求那个地址.因此地址栏显示的是新的URL.

从数据共享来讲

forward:转发页面和转发到的页面能够共享request里面的数据.
redirect:不能共享数据.

从运用地方来讲

forward:通常用于用户登录的时候,根据角色转发到相应的模块.
redirect:通常用于用户注销登录时返回主页面和跳转到其它的网站等

从效率来讲

forward:高.
redirect:低.

自动刷新（Refresh）

自动刷新不只能够实现一段时间以后自动跳转到另外一个页面，还能够实现一段时间以后自动刷新本页面。Servlet中经过HttpServletResponse对象设置Header属性实现自动刷新例如：

Response.setHeader("Refresh","1000;URL=http://localhost:8080/servlet/example.htm");

其中1000为时间，单位为毫秒。URL指定就是要跳转的页面（若是设置本身的路径，就会实现没过一秒自动刷新本页面一次）

Servlet与线程安全

Servlet不是线程安全的，多线程并发的读写会致使数据不一样步的问题。 解决的办法是尽可能不要定义name属性，而是要把name变量分别定义在doGet()和doPost()方法内。虽然使用synchronized(name){}语句块能够解决问题，可是会形成线程的等待，不是很科学的办法。
注意：多线程的并发的读写Servlet类属性会致使数据不一样步。可是若是只是并发地读取属性而不写入，则不存在数据不一样步的问题。所以Servlet里的只读属性最好定义为final类型的。

参考：《javaweb整合开发王者归来》P92

JSP和Servlet是什么关系？

其实这个问题在上面已经阐述过了，Servlet是一个特殊的Java程序，它运行于服务器的JVM中，可以依靠服务器的支持向浏览器提供显示内容。JSP本质上是Servlet的一种简易形式，JSP会被服务器处理成一个相似于Servlet的Java程序，能够简化页面内容的生成。Servlet和JSP最主要的不一样点在于，Servlet的应用逻辑是在Java文件中，而且彻底从表示层中的HTML分离开来。而JSP的状况是Java和HTML能够组合成一个扩展名为.jsp的文件。有人说，Servlet就是在Java中写HTML，而JSP就是在HTML中写Java代码，固然这个说法是很片面且不够准确的。JSP侧重于视图，Servlet更侧重于控制逻辑，在MVC架构模式中，JSP适合充当视图（view）而Servlet适合充当控制器（controller）。

JSP工做原理：

JSP是一种Servlet，可是与HttpServlet的工做方式不太同样。HttpServlet是先由源代码编译为class文件后部署到服务器下，为先编译后部署。而JSP则是先部署后编译。JSP会在客户端第一次请求JSP文件时被编译为HttpJspPage类（接口Servlet的一个子类）。该类会被服务器临时存放在服务器工做目录里面。下面经过实例给你们介绍。
工程JspLoginDemo下有一个名为login.jsp的Jsp文件，把工程第一次部署到服务器上后访问这个Jsp文件，咱们发现这个目录下多了下图这两个东东。
.class文件即是JSP对应的Servlet。编译完毕后再运行class文件来响应客户端请求。之后客户端访问login.jsp的时候，Tomcat将再也不从新编译JSP文件，而是直接调用class文件来响应客户端请求。

因为JSP只会在客户端第一次请求的时候被编译，所以第一次请求JSP时会感受比较慢，以后就会感受快不少。若是把服务器保存的class文件删除，服务器也会从新编译JSP。

开发Web程序时常常须要修改JSP。Tomcat可以自动检测到JSP程序的改动。若是检测到JSP源代码发生了改动。Tomcat会在下次客户端请求JSP时从新编译JSP，而不须要重启Tomcat。这种自动检测功能是默认开启的，检测改动会消耗少许的时间，在部署Web应用的时候能够在web.xml中将它关掉。

参考：《javaweb整合开发王者归来》P97

JSP有哪些内置对象？做用分别是什么？

JSP内置对象 - CSDN博客

JSP有9个内置对象：

request：封装客户端的请求，其中包含来自GET或POST请求的参数；
response：封装服务器对客户端的响应；
pageContext：经过该对象能够获取其余对象；
session：封装用户会话的对象；
application：封装服务器运行环境的对象；
out：输出服务器响应的输出流对象；
config：Web应用的配置对象；
page：JSP页面自己（至关于Java程序中的this）；
exception：封装页面抛出异常的对象。

Request对象的主要方法有哪些？

setAttribute(String name,Object)：设置名字为name的request 的参数值
getAttribute(String name)：返回由name指定的属性值
getAttributeNames()：返回request 对象全部属性的名字集合，结果是一个枚举的实例
getCookies()：返回客户端的全部 Cookie 对象，结果是一个Cookie 数组
getCharacterEncoding() ：返回请求中的字符编码方式 = getContentLength() ：返回请求的 Body的长度
getHeader(String name) ：得到HTTP协议定义的文件头信息
getHeaders(String name) ：返回指定名字的request Header 的全部值，结果是一个枚举的实例
getHeaderNames() ：返回因此request Header 的名字，结果是一个枚举的实例
getInputStream() ：返回请求的输入流，用于得到请求中的数据
getMethod() ：得到客户端向服务器端传送数据的方法
getParameter(String name) ：得到客户端传送给服务器端的有 name指定的参数值
getParameterNames() ：得到客户端传送给服务器端的全部参数的名字，结果是一个枚举的实例
getParameterValues(String name)：得到有name指定的参数的全部值
getProtocol()：获取客户端向服务器端传送数据所依据的协议名称
getQueryString() ：得到查询字符串
getRequestURI() ：获取发出请求字符串的客户端地址
getRemoteAddr()：获取客户端的 IP 地址
getRemoteHost() ：获取客户端的名字
getSession([Boolean create]) ：返回和请求相关 Session
getServerName() ：获取服务器的名字
getServletPath()：获取客户端所请求的脚本文件的路径
getServerPort()：获取服务器的端口号
removeAttribute(String name)：删除请求中的一个属性

request.getAttribute()和 request.getParameter()有何区别?

从获取方向来看：

getParameter()是获取 POST/GET 传递的参数值；

getAttribute()是获取对象容器中的数据值；

从用途来看：

getParameter用于客户端重定向时，即点击了连接或提交按扭时传值用，即用于在用表单或url重定向传值时接收数据用。

getAttribute用于服务器端重定向时，即在 sevlet 中使用了 forward 函数,或 struts 中使用了
mapping.findForward。 getAttribute 只能收到程序用 setAttribute 传过来的值。

另外，能够用 setAttribute,getAttribute 发送接收对象.而 getParameter 显然只能传字符串。
setAttribute 是应用服务器把这个对象放在该页面所对应的一块内存中去，当你的页面服务器重定向到另外一个页面时，应用服务器会把这块内存拷贝另外一个页面所对应的内存中。这样getAttribute就能取得你所设下的值，固然这种方法能够传对象。session也同样，只是对象在内存中的生命周期不同而已。getParameter只是应用服务器在分析你送上来的 request页面的文本时，取得你设在表单或 url 重定向时的值。

总结：

getParameter 返回的是String,用于读取提交的表单中的值;（获取以后会根据实际须要转换为本身须要的相应类型，好比整型，日期类型啊等等）

getAttribute 返回的是Object，需进行转换,可用setAttribute 设置成任意对象，使用很灵活，可随时用

include指令include的行为的区别

include指令： JSP能够经过include指令来包含其余文件。被包含的文件能够是JSP文件、HTML文件或文本文件。包含的文件就好像是该JSP文件的一部分，会被同时编译执行。语法格式以下：
<%@ include file="文件相对 url 地址" %>

include动做：动做元素用来包含静态和动态的文件。该动做把指定文件插入正在生成的页面。语法格式以下：

JSP九大内置对象，七大动做，三大指令-

JSP九大内置对象，七大动做，三大指令总结

讲解JSP中的四种做用域

JSP中的四种做用域包括page、request、session和application，具体来讲：

page表明与一个页面相关的对象和属性。
request表明与Web客户机发出的一个请求相关的对象和属性。一个请求可能跨越多个页面，涉及多个Web组件；须要在页面显示的临时数据能够置于此做用域。
session表明与某个用户与服务器创建的一次会话相关的对象和属性。跟某个用户相关的数据应该放在用户本身的session中。
application表明与整个Web应用程序相关的对象和属性，它实质上是跨越整个Web应用程序，包括多个页面、请求和会话的一个全局做用域。

如何实现JSP或Servlet的单线程模式？

对于JSP页面，能够经过page指令进行设置。
<%@page isThreadSafe=”false”%>

对于Servlet，可让自定义的Servlet实现SingleThreadModel标识接口。

说明：若是将JSP或Servlet设置成单线程工做模式，会致使每一个请求建立一个Servlet实例，这种实践将致使严重的性能问题（服务器的内存压力很大，还会致使频繁的垃圾回收），因此一般状况下并不会这么作。

实现会话跟踪的技术有哪些？

使用Cookie

向客户端发送Cookie

Cookie c = new Cookie( "name", "value"); //建立Cookie
c.setMaxAge( 60* 60* 24); //设置最大时效，此处设置的最大时效为一天
response.addCookie(c); //把Cookie放入到HTTP响应中

从客户端读取Cookie

String name = "name";
Cookie[]cookies =request.getCookies();
if(cookies != null){
for( int i= 0;i<cookies.length;i++){
Cookie cookie =cookies[i];
if(name.equals(cookis.getName()))
//something is here.
//you can get the value
cookie.getValue();
}
}

优势: 数据能够持久保存，不须要服务器资源，简单，基于文本的Key-Value

缺点: 大小受到限制，用户能够禁用Cookie功能，因为保存在本地，有必定的安全风险。

URL 重写

在URL中添加用户会话的信息做为请求的参数，或者将惟一的会话ID添加到URL结尾以标识一个会话。

优势： 在Cookie被禁用的时候依然可使用

缺点： 必须对网站的URL进行编码，全部页面必须动态生成，不能用预先记录下来的URL进行访问。

3.隐藏的表单域

<input type="hidden" name ="session" value="..."/>

优势： Cookie被禁时可使用

缺点： 全部页面必须是表单提交以后的结果。

HttpSession

在全部会话跟踪技术中，HttpSession对象是最强大也是功能最多的。当一个用户第一次访问某个网站时会自动建立 HttpSession，每一个用户能够访问他本身的HttpSession。能够经过HttpServletRequest对象的getSession方法得到HttpSession，经过HttpSession的setAttribute方法能够将一个值放在HttpSession中，经过调用 HttpSession对象的getAttribute方法，同时传入属性名就能够获取保存在HttpSession中的对象。与上面三种方式不一样的是，HttpSession放在服务器的内存中，所以不要将过大的对象放在里面，即便目前的Servlet容器能够在内存将满时将HttpSession 中的对象移到其余存储设备中，可是这样势必影响性能。添加到HttpSession中的值能够是任意Java对象，这个对象最好实现了 Serializable接口，这样Servlet容器在必要的时候能够将其序列化到文件中，不然在序列化时就会出现异常。

Cookie和Session的的区别？

因为HTTP协议是无状态的协议，因此服务端须要记录用户的状态时，就须要用某种机制来识具体的用户，这个机制就是Session.典型的场景好比购物车，当你点击下单按钮时，因为HTTP协议无状态，因此并不知道是哪一个用户操做的，因此服务端要为特定的用户建立了特定的Session，用用于标识这个用户，而且跟踪用户，这样才知道购物车里面有几本书。这个Session是保存在服务端的，有一个惟一标识。在服务端保存Session的方法不少，内存、数据库、文件都有。集群的时候也要考虑Session的转移，在大型的网站，通常会有专门的Session服务器集群，用来保存用户会话，这个时候 Session 信息都是放在内存的，使用一些缓存服务好比Memcached之类的来放 Session。
思考一下服务端如何识别特定的客户？这个时候Cookie就登场了。每次HTTP请求的时候，客户端都会发送相应的Cookie信息到服务端。实际上大多数的应用都是用 Cookie 来实现Session跟踪的，第一次建立Session的时候，服务端会在HTTP协议中告诉客户端，须要在 Cookie 里面记录一个Session ID，之后每次请求把这个会话ID发送到服务器，我就知道你是谁了。有人问，若是客户端的浏览器禁用了 Cookie 怎么办？通常这种状况下，会使用一种叫作URL重写的技术来进行会话跟踪，即每次HTTP交互，URL后面都会被附加上一个诸如 sid=xxxxx 这样的参数，服务端据此来识别用户。
Cookie其实还能够用在一些方便用户的场景下，设想你某次登录过一个网站，下次登陆的时候不想再次输入帐号了，怎么办？这个信息能够写到Cookie里面，访问网站的时候，网站页面的脚本能够读取这个信息，就自动帮你把用户名给填了，可以方便一下用户。这也是Cookie名称的由来，给用户的一点甜头。因此，总结一下：Session是在服务端保存的一个数据结构，用来跟踪用户的状态，这个数据能够保存在集群、数据库、文件中；Cookie是客户端保存用户信息的一种机制，用来记录用户的一些信息，也是实现Session的一种方式。

Java集合篇常见问题

List，Set,Map三者的区别及总结

List：对付顺序的好帮手
List接口存储一组不惟一（能够有多个元素引用相同的对象），有序的对象
Set:注重独一无二的性质

不容许重复的集合。不会有多个元素引用相同的对象。
Map:用Key来搜索的专家

使用键值对存储。Map会维护与Key有关联的值。两个Key能够引用相同的对象，但Key不能重复，典型的Key是String类型，但也能够是任何对象。

Arraylist 与 LinkedList 区别

Arraylist底层使用的是数组（存读数据效率高，插入删除特定位置效率低），LinkedList底层使用的是双向循环链表数据结构（插入，删除效率特别高）。学过数据结构这门课后咱们就知道采用链表存储，插入，删除元素时间复杂度不受元素位置的影响，都是近似O（1）而数组为近似O（n），所以当数据特别多，并且常常须要插入删除元素时建议选用LinkedList.通常程序只用Arraylist就够用了，由于通常数据量都不会蛮大，Arraylist是使用最多的集合类。

ArrayList 与 Vector 区别（为何要用Arraylist取代Vector呢？）

Vector类的全部方法都是同步的。能够由两个线程安全地访问一个Vector对象、可是一个线程访问Vector
，代码要在同步操做上耗费大量的时间。Arraylist不是同步的，因此在不须要同步时建议使用Arraylist。

HashMap 和 Hashtable 的区别

HashMap是非线程安全的，HashTable是线程安全的；HashTable内部的方法基本都通过synchronized修饰。
由于线程安全的问题，HashMap要比HashTable效率高一点，HashTable基本被淘汰。
HashMap容许有null值的存在，而在HashTable中put进的键值只要有一个null，直接抛出NullPointerException。

Hashtable和HashMap有几个主要的不一样：线程安全以及速度。仅在你须要彻底的线程安全的时候使用Hashtable，而若是你使用Java5或以上的话，请使用ConcurrentHashMap吧

HashSet 和 HashMap 区别

HashMap 和 ConcurrentHashMap 的区别

HashMap与ConcurrentHashMap的区别

ConcurrentHashMap对整个桶数组进行了分割分段(Segment)，而后在每个分段上都用lock锁进行保护，相对于HashTable的synchronized锁的粒度更精细了一些，并发性能更好，而HashMap没有锁机制，不是线程安全的。（JDK1.8以后ConcurrentHashMap启用了一种全新的方式实现,利用CAS算法。）
HashMap的键值对容许有null，可是ConCurrentHashMap都不容许。

HashSet如何检查重复

当你把对象加入HashSet时，HashSet会先计算对象的hashcode值来判断对象加入的位置，同时也会与其余加入的对象的hashcode值做比较，若是没有相符的hashcode，HashSet会假设对象没有重复出现。可是若是发现有相同hashcode值的对象，这时会调用equals（）方法来检查hashcode相等的对象是否真的相同。若是二者相同，HashSet就不会让加入操做成功。（摘自个人Java启蒙书《Head fist java》第二版）

hashCode（）与equals（）的相关规定：

若是两个对象相等，则hashcode必定也是相同的
两个对象相等,对两个equals方法返回true
两个对象有相同的hashcode值，它们也不必定是相等的
综上，equals方法被覆盖过，则hashCode方法也必须被覆盖
hashCode()的默认行为是对堆上的对象产生独特值。若是没有重写hashCode()，则该class的两个对象不管如何都不会相等（即便这两个对象指向相同的数据）。

==与equals的区别

==是判断两个变量或实例是否是指向同一个内存空间 equals是判断两个变量或实例所指向的内存空间的值是否是相同
==是指对内存地址进行比较 equals()是对字符串的内容进行比较3.==指引用是否相同 equals()指的是值是否相同

comparable 和 comparator的区别？

comparable接口其实是出自java.lang包它有一个 compareTo(Object obj)方法用来排序
comparator接口其实是出自 java.util 包它有一个compare(Object obj1, Object obj2)方法用来排序

通常咱们须要对一个集合使用自定义排序时，咱们就要重写compareTo方法或compare方法，当咱们须要对某一个集合实现两种排序方式，好比一个song对象中的歌名和歌手名分别采用一种排序方法的话，咱们能够重写compareTo方法和使用自制的Comparator方法或者以两个Comparator来实现歌名排序和歌星名排序，第二种表明咱们只能使用两个参数版的Collections.sort().

Comparator定制排序

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
public class CollectionsSort {
public static void main(String[] args) {
ArrayList<Integer> arrayList = new ArrayList<Integer>();
arrayList.add(- 1);
arrayList.add( 3);
arrayList.add( 3);
arrayList.add(- 5);
arrayList.add( 7);
arrayList.add( 4);
arrayList.add(- 9);
arrayList.add(- 7);
System.out.println( "原始数组:");
System.out.println(arrayList);
// void reverse(List list)：反转
Collections.reverse(arrayList);
System.out.println( "Collections.reverse(arrayList):");
System.out.println(arrayList);
/*
* void rotate(List list, int distance),旋转。
* 当distance为正数时，将list后distance个元素总体移到前面。当distance为负数时，将
* list的前distance个元素总体移到后面。
Collections.rotate(arrayList, 4);
System.out.println("Collections.rotate(arrayList, 4):");
System.out.println(arrayList);*/
// void sort(List list),按天然排序的升序排序
Collections.sort(arrayList);
System.out.println( "Collections.sort(arrayList):");
System.out.println(arrayList);
// void shuffle(List list),随机排序
Collections.shuffle(arrayList);
System.out.println( "Collections.shuffle(arrayList):");
System.out.println(arrayList);
// 定制排序的用法
Collections.sort(arrayList, new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return o2.compareTo(o1);
}
});
System.out.println( "定制排序后：");
System.out.println(arrayList);
}
}

重写compareTo方法实现按年龄来排序

package map;
import java.util.Set;
import java.util.TreeMap;
public class TreeMap2 {
public static void main(String[] args) {
// TODO Auto-generated method stub
TreeMap<Person, String> pdata = new TreeMap<Person, String>();
pdata.put( new Person( "张三", 30), "zhangsan");
pdata.put( new Person( "李四", 20), "lisi");
pdata.put( new Person( "王五", 10), "wangwu");
pdata.put( new Person( "小红", 5), "xiaohong");
// 获得key的值的同时获得key所对应的值
Set<Person> keys = pdata.keySet();
for (Person key : keys) {
System.out.println(key.getAge() + "-" + key.getName());
}
}
}
// person对象没有实现Comparable接口，因此必须实现，这样才不会出错，才可使treemap中的数据按顺序排列
// 前面一个例子的String类已经默认实现了Comparable接口，详细能够查看String类的API文档，另外其余
// 像Integer类等都已经实现了Comparable接口，因此不须要另外实现了
class Person implements Comparable<Person> {
private String name;
private int age;
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
/**
* TODO重写compareTo方法实现按年龄来排序
*/
@Override
public int compareTo(Person o) {
// TODO Auto-generated method stub
if ( this.age > o.getAge()) {
return 1;
} else if ( this.age < o.getAge()) {
return - 1;
}
return age;
}
}

如何对Object的list排序？

对objects数组进行排序，咱们能够用Arrays.sort()方法
对objects的集合进行排序，须要使用Collections.sort()方法

如何实现数组与List的相互转换？

List转数组：toArray(arraylist.size()方法；数组转List:Arrays的asList(a)方法

List<String> arrayList = new ArrayList<String>();
arrayList.add( "s");
arrayList.add( "e");
arrayList.add( "n");
/**
* ArrayList转数组
*/
int size=arrayList.size();
String[] a = arrayList.toArray( new String[size]);
//输出第二个元素
System.out.println(a[ 1]); //结果：e
//输出整个数组
System.out.println(Arrays.toString(a)); //结果：[s, e, n]
/**
* 数组转list
*/
List<String> list=Arrays.asList(a);
/**
* list转Arraylist
*/
List<String> arrayList2 = new ArrayList<String>();
arrayList2.addAll(list);
System.out.println(list);

如何求ArrayList集合的交集并集差集去重复并集

须要用到List接口中定义的几个方法：

addAll(Collection<? extends E> c) :按指定集合的Iterator返回的顺序将指定集合中的全部元素追加到此列表的末尾
实例代码：
retainAll(Collection<?> c): 仅保留此列表中包含在指定集合中的元素。
removeAll(Collection<?> c) :今后列表中删除指定集合中包含的全部元素。

package list;
import java.util.ArrayList;
import java.util.List;
public class MethodDemo {
public static void main(String[] args) {
// TODO Auto-generated method stub
List<Integer> list1 = new ArrayList<Integer>();
list1.add( 1);
list1.add( 2);
list1.add( 3);
list1.add( 4);
List<Integer> list2 = new ArrayList<Integer>();
list2.add( 2);
list2.add( 3);
list2.add( 4);
list2.add( 5);
// 并集
// list1.addAll(list2);
// 交集
//list1.retainAll(list2);
// 差集
// list1.removeAll(list2);
// 无重复并集
list2.removeAll(list1);
list1.addAll(list2);
for (Integer i : list1) {
System.out.println(i);
}
}
}

HashMap 的工做原理及代码实现

集合框架源码学习之HashMap(JDK1.8)

ConcurrentHashMap 的工做原理及代码实现

ConcurrentHashMap实现原理及源码分析

最新最全的Java面试题整理（内附答案）