牛客网错题难题记录

5月11日

解析：

• 编码格式由浏览器决定，浏览器根据html中指定的编码格式进行编码，tomcat根据指定的格式进行解码，另外get请求和post请求对编码格式的处理也是不同的
• 乱码问题之所以一直存在，就是由于编码的灵活性，也就是说，编码与其他工作是解耦的。此外，Web 的编码问题与服务器所在的操作系统无关，Web 容器诸如Tomcat可以配置默认编码方式，例如，Tomcat 的默认编码方式是 iso8859-1。乱码的解决之道就是直接或间接的使客户端与Web 容器编码方式兼容。
• 补充一下，客户端（浏览器）的编码方式是我们可以人为设置的。（浏览器根据jsp页面开头声明的编码方式设置编码）

解析：

• 一个汉字等于一个字符，字符 是char ；一个汉字也等于二个字节，字节 是byte
• java的String底层是char数组，它的length()返回数组大小，而unicode中一个汉字是可以用一个char表示的

解析：

• 首先是foo(0),在try代码块中未抛出异常，finally是无论是否抛出异常必定执行的语句，所以 output += “3”;然后是 output += “4”;
• 执行foo(1)的时候，try代码块抛出异常，进入catch代码块，output += “2”;前面说过finally是必执行的，即使return也会执行output += “3”
• 由于catch代码块中有return语句，最后一个output += “4”不会执行。
  所以结果是3423

注意：谁说finally块必须执行？不服来辩
try-catch-finally块中，finally块在以下几种情况将不会执行。
（1）finally块中发生了异常。
（2）程序所在线程死亡。
（3）在前面的代码中用了System.exit（）；
（4）关闭了CPU

八进制13转十进制：18+3=11
八进制14转十进制：18+4=12
1112=132
八进制204转十进制：288+08+4=132
所以：（1x¹+3x°）* (1x¹+4x°) = 2x²+0x¹+4x°
(x+3)(x+4)=2x²+4
x²+7x+12=2x²+4
x²-7x=8
x*(x-7)=8
x₁=8 x₂=-1
解二元一次方程组 得到 8 【x代表进制】

解析：

• A.StringBuilder线程不安全，StringBuffer线程安全。
• B.同时用 abstract和final就会自相矛盾。
• C.Hashmap中的value可以之null，get(key)==null有两种情况，一是key不存在，二是该key中存的是null，所以应该使用map.containskey(key)返回的true/false来判断是否存在这个key。
• D.volatile关键字有两个作用：
  • 1.并发环境可见性：volatile修饰后的变量能够保证该变量在线程间的可见性，线程进行数据的读写操作时将绕开工作内存（CPU缓存）而直接跟主内存进行数据交互，即线程进行读操作时直接从主内存中读取，写操作时直接将修改后端变量刷新到主内存中，这样就能保证其他线程访问到的数据是最新数据
  • 2.并发环境有序性：通过对volatile变量采取内存屏障（Memory barrier）的方式来防止编译重排序和CPU指令重排序，具体方式是通过在操作volatile变量的指令前后加入内存屏障，来实现happens-before关系，保证在多线程环境下的数据交互不会出现紊乱。
• abstract修饰的类是抽象类，是可以继承的，而final修饰的类表示不能再被继承，故肯定不能共同使用。故B错。
• HashMap中提供的get(key)获取的是变量，无法判断是否存在key。所以C是错的
• volatile关键字是一种轻量级的同步机制，只保证数据的可见性，而不保证数据的原子性。故D对

BC正确，选项B解释，java核心卷I中43页有如下表述：两个数值进行二元操作时，会有如下的转换操作：
如果两个操作数其中有一个是double类型，另一个操作就会转换为double类型。
否则，如果其中一个操作数是float类型，另一个将会转换为float类型。
否则，如果其中一个操作数是long类型，另一个会转换为long类型。
否则，两个操作数都转换为int类型。
故，x==f1[0]中，x将会转换为float类型。

5月12日

解析：
类的初始化过程也就是方法执行的过程：
父类的静态域-子类的静态域 父类的非静态域-父类的构造函数-子类的非静态域-子类的构造函数 规律就是 父类先于子类 静态的先于非静态的
其中静态域包含静态代码块与静态方法，这个谁在前面，则先执行谁。
非静态域同理

解析：
A.很明显是赋值符号
B.<<=左移赋值
C.不是
D.>>>= 右移赋值，左边空出的位以0填充

<<表示左移位
>>表示带符号右移位
>>>表示无符号右移
但是没有<<<运算符

解析：

• Java标识符：
• 标识符由26个英文字符大小写（a_z，AZ）、数字-(0~9)、下划线(_)和美元符号($)组成；
• 不能以数字开头，不能是关键字；
• 严格区分大小写；
• 标识符的可以为任意长度

解析：

• String s=null;没有给s开辟任何空间，当执行length()方法时候，因为没有具体指向的内存空间，所以报出NullPointerException没有指向的错误。
• B中&&是逻辑与，前面的条件为false后面就不会执行了，所以B不会抛出错误
• D中||是逻辑或，前面的条件为true后面就不会执行，所以D不会抛出错误
• A和C中的&和|都是前后的条件都要执行，所以执行到length自然就会报错了。

解析：

5月13日

解析：

• 1.java的线程分为两类: 用户线程和daemon线程
  • A.用户线程: 用户线程可以简单的理解为用户定义的线程,当然包括main线程(以前我错误的认为main线程也是一个daemon线程,但是慢慢的发现原来main线程不是,因为如果我再main线程中创建一个用户线程,并且打出日志,我们会发现这样一个问题,main线程运行结束了,但是我们的线程任然在运行).
  • B.daemon线程: daemon线程是为我们创建的用户线程提供服务的线程,比如说jvm的GC等等,这样的线程有一个非常明显的特征: 当用户线程运行结束的时候,daemon线程将会自动退出.(由此我们可以推出下面关于daemon线程的几条基本特点)
• 2.daemon 线程的特点:
  • A.守护线程创建的过程中需要先调用setDaemon方法进行设置,然后再启动线程.否则会报出IllegalThreadStateException异常
  • B.由于daemon线程的终止条件是当前是否存在用户线程,所以我们不能指派daemon线程来进行一些业务操作,而只能服务用户线程.
  • C.daemon线程创建的子线程依然是daemon线程.

解析：
1，Configuration接口：配置Hibernate，根据其启动Hibernate，创建SessionFactory对象；
2，SessionFactory接口：初始化Hibernate，充当数据存储源的***，创建session对象，SessionFactory是
线程安全的，意味着它的同一个实例可以被应用的多个线程共享，是重量级二级缓存；
3，session接口：负责保存、更新、删除、加载和查询对象，是一个非线程安全的，避免多个线程共享一个session，是轻量级，一级缓存。
4，Transaction接口：管理事务。可以对事务进行提交和回滚；
5，Query和Criteria接口：执行数据库的查询。

解析：
ava提供了一个系统级的线程，即垃圾回收器线程。用来对每一个分配出去的内存空间进行跟踪。当JVM空闲时，自动回收每块可能被回收的内存，GC是完全自动的，不能被强制执行。程序员最多只能用System.gc()来建议执行垃圾回收器回收内存，但是具体的回收时间，是不可知的。当对象的引用变量被赋值为null，可能被当成垃圾

• 接口是一种特殊的抽象类，先说明抽象类中的抽象方法，再说明接口

• 抽象类中的抽象方法(其前有 abstract1修饰)不能用 private、 static、 synchronized、na
  tive访回修饰符修饰。原因如下:

  1. private
     抽象方法没有方法体,是用来被继承的,所以不能用 private修饰;
  2. static
     static修饰的方法可以通过类名来访间该方法(即该方法的方法体),抽象方法用sttic修饰没有意义;
  3. synchronized
     该关键字是为该方法加一个锁。而如果该关键字修饰的方法是 static方法。则使用的锁就是class变量的锁。如果是修饰类方法。则用this变量锁。
     但是抽象类不能实例化对象,因为该方法不是在该抽象类中实现的。是在其子类实现的。所以，锁应该归其子类所有。所以，抽象方法也就不能用 synchronized关键字修饰了;
  4. native
     native这个东西本身就和 abstract冲突,他们都是方法的声明,只是一个把方法实现移交给子类,另一个是移交给本地操作系统。如果同时出现,就相当于即把实现移交给子类,又把实现移交给本地操作系统,那到底谁来实现具体方法呢

• 终于说到了接口！
  接口是一种特殊的抽象类,接口中的方法全部是抽象方法(但其前的 abstract可以省略),所以抽象类中的抽象方法不能用的访间修饰符这里也不能用。同时额外说明一下protect关键词

• protect
  protected访同修饰符也不能使用,因为接口可以让所有的类去实现(非继承),不只是其子类,但是要用public去修饰。接口可以去继承一个已有的接口。

解析：

• 重写 要求两同两小一大原则， 方法名相同，参数类型相同，子类返回类型小于等于父类方法返回类型， 子类抛出异常小于等于父类方法抛出异常， 子类访问权限大于等于父类方法访问权限。［注意：这里的返回类型必须要在有继承关系的前提下比较］

• 重载 方法名必须相同，参数类型必须不同，包括但不限于一项，参数数目，参数类型，参数顺序

• 再来说说这道题 A B 都是方法名和参数相同，是重写，但是返回类型没与父类返回类型有继承关系，错误 D 返回一个类错误 c的参数类型与父类不同，所以不是重写，可以理解为广义上的重载访问权限小于父类，都会显示错误

• 虽然题目没点明一定要重载或者重写，但是当你的方法名与参数类型与父类相同时，已经是重写了，这时候如果返回类型或者异常类型比父类大，或者访问权限比父类小都会编译错误

解析：

• join()底层就是调用wait()方法的，wait()释放锁资源，故join也释放锁资源
  
• 1.在指定时间内让当前正在执行的线程暂停执行，但不会释放“锁标志”。不推荐使用。
  sleep()使当前线程进入阻塞状态，在指定时间内不会执行。
• 2.在其他线程调用对象的notify或notifyAll方法前，导致当前线程等待。线程会释放掉它所占有的“锁标志”，从而使别的线程有机会抢占该锁。
  当前线程必须拥有当前对象锁。如果当前线程不是此锁的拥有者，会抛出IllegalMonitorStateException异常。
  唤醒当前对象锁的等待线程使用notify或notifyAll方法，也必须拥有相同的对象锁，否则也会抛出IllegalMonitorStateException异常。
  waite()和notify()必须在synchronized函数或synchronized　block中进行调用。如果在non-synchronized函数或non-synchronized　block中进行调用，虽然能编译通过，但在运行时会发生IllegalMonitorStateException的异常。
• 3.wait会使当前线程回到线程池中等待，释放锁，当被其他线程使用notify，notifyAll唤醒时进入可执行状态。暂停当前正在执行的线程对象。
  yield()只是使当前线程重新回到可执行状态，所以执行yield()的线程有可能在进入到可执行状态后马上又被执行。
  yield()只能使同优先级或更高优先级的线程有执行的机会。
• 4.当前线程调用 某线程.join（）时会使当前线程等待某线程执行完毕再结束，底层调用了wait，释放锁。
  等待该线程终止。等待调用join方法的线程结束，再继续执行。如：t.join();//主要用于等待t线程运行结束，若无此句，main则会执行完毕，导致结果不可预测。

public class NameList
{
    private List names = new ArrayList();
    public synchronized void add(String name)
    {
        names.add(name);
    }
    public synchronized void printAll() {
        for (int i = 0; i < names.size(); i++)
        {
            System.out.print(names.get(i) + ””);
        }
    }

    public static void main(String[]args)
    {
        final NameList sl = new NameList();
        for (int i = 0; i < 2; i++)
        {
            new Thread()
            {
                public void run()
                {
                    sl.add(“A”);
                    sl.add(“B”);
                    sl.add(“C”);
                    sl.printAll();
                }
            } .start();
        }
    }
}

解析：
在每个线程中都是顺序执行的，所以sl.printAll();必须在前三句执行之后执行，也就是输出的内容必有（连续或非连续的）ABC。
而线程之间是穿插执行的，所以一个线程执行 sl.printAll();之前可能有另一个线程执行了前三句的前几句。
E答案相当于线程1顺序执行完然后线程2顺序执行完。
G答案则是线程1执行完前三句add之后线程2插一脚执行了一句add然后线程1再执行 sl.printAll();输出ABCA。接着线程2顺序执行完输出ABCABC
输出加起来即为ABCAABCABC。

5月14日

解析：
自增自减运算符优先级大于加减运算符的优先级
int a =100,b=50,c=a—b,d=a—b;
先考虑a–，a执行后自减操作，即先用a后再自减1，与–a先反
（1）c=a—b，先执行a-b操作，得到c=50，再执行a减1操作，得到a=99
（2）d=a—b，先执行a-b操作，得到d=49，再执行a减1操作，得到a=98

解析：
类中声明的变量有默认初始值；方法中声明的变量没有默认初始值，必须在定义时初始化，否则在访问该变量时会出错。
boolean类型默认值是false

解析：
A.文件分为文本文件和二进制文件，计算机只认识二进制，所以实际上都是二进制的不同解释方式。文本文件是以不同编码格式显示的字符，例如Ascii、Unicode等，window中文本文件的后缀名有".txt",".log",各种编程语言的源码文件等；二进制文件就是用文本文档打开是看不懂乱码，只要能用文本打开的文件都可以算是文本文件，只是显示的结果不是你想要的，二进制文件只有用特殊的应用才能读懂的文件，例如".png",".bmp"等，计算机中大部分的文件还是二进制文件。
B.File类是对文件整体或者文件属性操作的类，例如创建文件、删除文件、查看文件是否存在等功能，不能操作文件内容；文件内容是用IO流操作的。
C.当输入过程中意外到达文件或流的末尾时，抛出EOFException异常,正常情况下读取到文件末尾时，返回一个特殊值表示文件读取完成，例如read()返回-1表示文件读取完成。
D.上面A选项已经说了，不论是文本文件还是二进制文件，在计算机中都是以二进制形式存储的，所以都当做二进制文件读取。

解析：
选BD
标识符：
1. 只能由数字，字母，符号（有且仅有_和$两个）组成。
2. 数字不能作为标识符的开头。
3. 不能和关键字，保留字，显式常量一样。关键字都是小写的。
4. null，true，false都不是关键字，属于显式常量。goto，const都是保留关键字。

A. ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。 //正确，这里的所谓动态数组并不是那个“ 有多少元素就申请多少空间 ”的意思，通过查看源码，可以发现，这个动态数组是这样实现的，如果没指定数组大小，则申请默认大小为10的数组，当元素个数增加，数组无法存储时，系统会另个申请一个长度为当前长度1.5倍的数组，然后，把之前的数据拷贝到新建的数组。
B. 对于随机访问get和set，ArrayList觉得优于LinkedList，因为LinkedList要移动指针。//正确，ArrayList是数组，所以，直接定位到相应位置取元素，LinkedLIst是链表，所以需要从前往后遍历。
C. 对于新增和删除操作add和remove，LinedList比较占优势，因为ArrayList要移动数据。//正确，ArrayList的新增和删除就是数组的新增和删除，LinkedList与链表一致。

D. ArrayList的空间浪费主要体现在在list列表的结尾预留一定的容量空间，而LinkedList的空间花费则体现在它的每一个元素都需要消耗相当的空间。//正确，因为ArrayList空间的增长率为1.5倍，所以，最后很可能留下一部分空间是没有用到的，因此，会造成浪费的情况。对于LInkedList的话，由于每个节点都需要额外的指针，所以，你懂的。

解析：
Java语言中的异常处理包括声明异常、抛出异常、捕获异常和处理异常四个环节。
throw用于抛出异常。
throws关键字可以在方法上声明该方法要抛出的异常，然后在方法内部通过throw抛出异常对象。
try是用于检测被包住的语句块是否出现异常，如果有异常，则抛出异常，并执行catch语句。
cacth用于捕获从try中抛出的异常并作出处理。
finally语句块是不管有没有出现异常都要执行的内容。

解析：
B：init方法：负责初始化Servlet对象。在Servlet的整个生命周期类，init（）方法只被调用一次。
D：destroy方法：销毁Servlet对象，释放占用的资源，Servlet要被卸载时调用


解析：

解析：
wait()、notify()和notifyAll()是 Object类 中的方法
从这三个方法的文字描述可以知道以下几点信息：

1）wait()、notify()和notifyAll()方法是本地方法，并且为final方法，无法被重写。

2）调用某个对象的wait()方法能让当前线程阻塞，并且当前线程必须拥有此对象的monitor（即锁）

3）调用某个对象的notify()方法能够唤醒一个正在等待这个对象的monitor的线程，如果有多个线程都在等待这个对象的monitor，则只能唤醒其中一个线程；

4）调用notifyAll()方法能够唤醒所有正在等待这个对象的monitor的线程；

有朋友可能会有疑问：为何这三个不是Thread类声明中的方法，而是Object类中声明的方法

（当然由于Thread类继承了Object类，所以Thread也可以调用者三个方法）？其实这个问

题很简单，由于每个对象都拥有monitor（即锁），所以让当前线程等待某个对象的锁，当然

应该通过这个对象来操作了。而不是用当前线程来操作，因为当前线程可能会等待多个线程

的锁，如果通过线程来操作，就非常复杂了。

上面已经提到，如果调用某个对象的wait()方法，当前线程必须拥有这个对象的monitor（即

锁），因此调用wait()方法必须在同步块或者同步方法中进行（synchronized块或者

synchronized方法）。

调用某个对象的wait()方法，相当于让当前线程交出此对象的monitor，然后进入等待状态，

等待后续再次获得此对象的锁（Thread类中的sleep方法使当前线程暂停执行一段时间，从

而让其他线程有机会继续执行，但它并不释放对象锁）；

notify()方法能够唤醒一个正在等待该对象的monitor的线程，当有多个线程都在等待该对象

的monitor的话，则只能唤醒其中一个线程，具体唤醒哪个线程则不得而知。

同样地，调用某个对象的notify()方法，当前线程也必须拥有这个对象的monitor，因此调用

notify()方法必须在同步块或者同步方法中进行（synchronized块或者synchronized方法）。

nofityAll()方法能够唤醒所有正在等待该对象的monitor的线程，这一点与notify()方法是不同的。
Condition是在java 1.5中才出现的，它用来替代传统的Object的wait()、notify()实现线程间的协作，相比使用Object的wait()、notify()，使用Condition1的await()、signal()这种方式实现线程间协作更加安全和高效。因此通常来说比较推荐使用Condition，在阻塞队列那一篇博文中就讲述到了，阻塞队列实际上是使用了Condition来模拟线程间协作。
Condition是个接口，基本的方法就是await()和signal()方法；
Condition依赖于Lock接口，生成一个Condition的基本代码是lock.newCondition()
调用Condition的await()和signal()方法，都必须在lock保护之内，就是说必须在lock.lock()和lock.unlock之间才可以使用Conditon中的await()对应Object的wait()； Condition中的signal()对应Object的notify()； Condition中的signalAll()对应Object的notifyAll()

5月15日

解析：
web容器：给处于其中的应用程序组件（JSP，SERVLET）提供一个环境，使 JSP,SERVLET直接更容器中的环境变量接**互，不必关注其它系统问题。主要有WEB服务器来实现。例如：TOMCAT,WEBLOGIC,WEBSPHERE等。该容器提供的接口严格遵守J2EE规范中的WEB APPLICATION 标准。我们把遵守以上标准的WEB服务器就叫做J2EE中的WEB容器。

EJB容器：Enterprise java bean 容器。更具有行业领域特色。他提供给运行在其中的组件EJB各种管理功能。只要满足J2EE规范的EJB放入该容器，马上就会被容器进行高效率的管理。并且可以通过现成的接口来获得系统级别的服务。例如邮件服务、事务管理。

JNDI：（Java Naming & Directory Interface）JAVA命名目录服务。主要提供的功能是：提供一个目录系，让其它各地的应用程序在其上面留下自己的索引，从而满足快速查找和定位分布式应用程序的功能。

JMS：（Java Message Service）JAVA消息服务。主要实现各个应用程序之间的通讯。包括点对点和广播。

JTA：（Java Transaction API）JAVA事务服务。提供各种分布式事务服务。应用程序只需调用其提供的接口即可。

JAF：（Java Action FrameWork）JAVA安全认证框架。提供一些安全控制方面的框架。让开发者通过各种部署和自定义实现自己的个性安全控制策略。

RMI/IIOP:（Remote Method Invocation /internet对象请求中介协议）他们主要用于通过远程调用服务。例如，远程有一台计算机上运行一个程序，它提供股票分析服务，我们可以在本地计算机上实现对其直接调用。当然这是要通过一定的规范才能在异构的系统之间进行通信。RMI是JAVA特有的。

解析：
其实前面有几个答案说的已经很清楚了，足够我们理解这一道题。有一些东西可能还不是很清楚，导致这种题容易发生混乱。记住几点就可以了:1.为什么string字符串的值是不可变的？当我们new一个字符串，给它赋值之后，那么当前对象的值就固定了，永远不会改变。比如String str=new String(“test”)，那么str的值就是test，这是因为在String源码当中是用char数组来按顺序存储字符串中的每一个字符的，并且这个char数组是用final修饰的，这意味着一旦我们给字符串赋值之后，这个对象的值就永远不会改变。2.可是当我们在一个类当中的某个方法里面，给这个对象str赋值了一个新的字符串，它这时候的值是多少呢？比如这时str=“good”，str的值就是good，(你可以在这个方法里面写输出语句，输出这个引用，就知道怎么回事了)可不是说引用的值不可以改变么？这里改变的不是引用的值，而是引用str指向的常量不一样了而已，而这个引用的生命周期和当前方法的一样的，也就是方法结束，引用被杀死，也结束了，那么它刚才指向good的这个引用，就结束了，所以在这个方法结束之后，再输出引用str的值，自然就是引用str之前指向的值了，也就是test。

解析：

解析：
C,
static成员变量是在类加载的时候生成的
static成员函数既可以通过类名直接调用，也可以通过对象名进行调用
虚函数是C++中的，虚函数不可能是static的
static成员函数可以访问static成员变量

解析：
答案

解析：

解析：
A，Thread可以被继承，用于创建新的线程
B，Number类可以被继承，Integer，Float，Double等都继承自Number类
C，Double类的声明为
public final class Doubleextends Numberimplements Comparable
final生明的类不能被继承
D，Math类的声明为
public final class Mathextends Object
不能被继承
E，ClassLoader可以被继承，用户可以自定义类加载器

5月16日

解析：

• java规定类名首字母必须大写，这里可以直观的看出来Boolean是一个引用类型，不是基本数据类型。
• java中的基本数据类型都对应一个引用类型，如Float是float的引用类型，Integer是int的引用类型
  
  
  解析：
• 构造方法每次都是构造出新的对象，不存在多个线程同时读写同一对象中的属性的问题，所以不需要同步 。
  如果父类中的某个方法使用了 synchronized关键字，而子类中也覆盖了这个方法，默认情况下子类中的这个方法并不是同步的，必须显示的在子类的这个方法中加上 synchronized关键字才可。当然，也可以在子类中调用父类中相应的方法，这样虽然子类中的方法并不是同步的，但子类调用了父类中的同步方法，也就相当子类方法也同步了。详见：http://blog.csdn.net/welcome000yy/article/details/8941644
  接口里面的变量为常量，其实际是 public static final ；接口里面的方法为抽象方法，其实际是public abstract。

解析：
if(flag = true)的时候flag已经是true了，所以输出true；
要是为if(flag == true)输出才为false

解析：
方法调用时，会创建栈帧在栈中，调用完是程序自动出栈释放，而不是gc释放

解析：
A选项正确，Java中一般通过interrupt方法中断线程
B选项正确，线程使用了wait方法，会强行打断当前操作，进入阻塞（暂停）状态，然后需要notify方法或notifyAll方法才能进入就绪状态
C选项错误，新创建的线程不会抢占时间片，只有等当前线程把时间片用完，其他线程才有资格拿到时间片去执行。
D选项错误，调度算法未必是剥夺式的，而准备就绪但是还没有获得CPU，它的权限更高只能说明它获得CPU被执行的几率更大而已

解析：
构造方法是一种特殊的方法，具有以下特点。
（1）构造方法的方法名必须与类名相同。
（2）构造方法没有返回类型，也不能定义为void，在方法名前面不声明方法类型。
（3）构造方法的主要作用是完成对象的初始化工作，它能够把定义对象时的参数传给对象的域。
（4）一个类可以定义多个构造方法，如果在定义类时没有定义构造方法，则编译系统会自动插入一个无参数的默认构造器，这个构造器不执行任何代码。
（5）构造方法可以重载，以参数的个数，类型，顺序。

解析：
1.从地址栏显示来说
forward是服务器请求资源,服务器直接访问目标地址的URL,把那个URL的响应内容读取过来,然后把这些内容再发给浏览器.浏览器根本不知道服务器发送的内容从哪里来的,所以它的地址栏还是原来的地址.
redirect是服务端根据逻辑,发送一个状态码,告诉浏览器重新去请求那个地址.所以地址栏显示的是新的URL.
2.从数据共享来说
forward:转发页面和转发到的页面可以共享request里面的数据.
redirect:不能共享数据.
3.从运用地方来说
forward:一般用于用户登陆的时候,根据角色转发到相应的模块.
redirect:一般用于用户注销登陆时返回主页面和跳转到其它的网站等.
4.从效率来说
forward:高.
redirect:低.

5月17日

解析：
final修饰的成员变量为基本数据类型是，在赋值之后无法改变。当final修饰的成员变量为引用数据类型时，在赋值后其指向地址无法改变，但是对象内容还是可以改变的。
final修饰的成员变量在赋值时可以有三种方式。1、在声明时直接赋值。2、在构造器中赋值。3、在初始代码块中进行赋值。

解析：
动态类型语言是指在运行期间才去做数据类型检查的语言，也就是说，在用动态类型的语言编程时，永远也不用给任何变量指定数据类型，该语言会在你第一次赋值给变量时，在内部将数据类型记录下来。静态类型语言与动态类型语言刚好相反，它的数据类型是在编译其间检查的，也就是说在写程序时要声明所有变量的数据类型，C/C++是静态类型语言的典型代表，其他的静态类型语言还有C#、JAVA等。

解析：
is-a:继承关系 has-a:从属关系 like-a:组合关系

解析：

正确选项
A选项：isIDCard=/^[1-9]\d{7}((0\d)|(1[0-2]))(([0|1|2]\d)|3[0-1])\d{3}$/
C选项：isIDCard=/^[1-9]\d{5}[1-9]\d{3}((0\d)|(1[0-2]))(([0|1|2]\d)|3[0-1])\d{4}$/
^：起始符号，^x表示以x开头
$：结束符号，x$表示以x结尾
[n-m]：表示从n到m的数字
\d：表示数字，等同于[0-9]
X{m}：表示由m个X字符构成，\d{4}表示4位数字

15位身份证的构成：六位出生地区码+六位出身日期码+三位顺序码
18位身份证的构成：六位出生地区码+八位出生日期码+三位顺序码+一位校验码

C选项的构成：
[1-9]\d{5}：六位出生地区码，出生地区码没有以0开头，因此第一位为[1-9]。
[1-9]\d{3}：八位出生日期码的四位年份，同样年份没有以0开头。
((0\d)|(1[0-2]))：八位出生日期码的两位月份，| 表示或者，月份的形式为0\d或者是10、11、12。
(([0|1|2]\d)|3[0-1])：八位出生日期码的两位日期，日期由01至31。
\d{4}：三位顺序码+一位校验码，共四位。
A选项的构成：
[1-9]\d{7}：六位出生地区码+两位出生日期码的年份，这里的年份指后两位，因此没有第一位不能为0的限制，所以合并了。
后面的与C选项类似了。
好吧其实我也是第一次知道身份证还有15位的。

5月18日

解析：B
A，Java没有指针，只有引用。
C，并不是程序结束的时候进行GC，GC的时间是不确定的，且GC的过程需要经过可达性分析，一个对象只有被标记两次才会被GC。
下图是一个对象被GC的全过程。


解析：
if(flag = true)的时候flag已经是true了，所以输出true；
要是为if(flag == true)输出才为false

解析：
A选项正确，Java中一般通过interrupt方法中断线程
B选项正确，线程使用了wait方法，会强行打断当前操作，进入阻塞（暂停）状态，然后需要notify方法或notifyAll方法才能进入就绪状态
C选项错误，新创建的线程不会抢占时间片，只有等当前线程把时间片用完，其他线程才有资格拿到时间片去执行。
D选项错误，调度算法未必是剥夺式的，而准备就绪但是还没有获得CPU，它的权限更高只能说明它获得CPU被执行的几率更大而已

解析：
BC正确，选项B解释，java核心卷I中43页有如下表述：两个数值进行二元操作时，会有如下的转换操作：
如果两个操作数其中有一个是double类型，另一个操作就会转换为double类型。
否则，如果其中一个操作数是float类型，另一个将会转换为float类型。
否则，如果其中一个操作数是long类型，另一个会转换为long类型。
否则，两个操作数都转换为int类型。
故，x==f1[0]中，x将会转换为float类型

jdk1.8中，下面有关java 抽象类和接口的区别，说法错误的是？

java7中的接口和抽象类区别

解析：注意题中的java8和java7

解析看这里的抽象类和接口的区别

解析：
A.Java系统提供3种类加载器：启动类加载器（Bootstrap ClassLoader） 扩展类加载器（Extension ClassLoader） 应用程序类加载器（Application ClassLoader）. A正确
B.《深入理解Java虚拟机》P228：对于任意一个类，都需要由加载它的类加载器和这个类本身一同确立其在Java虚拟机中的唯一性，每一个类加载器，都拥有一个独立的类名称空间。这句话可以表达得更通俗一些：比较两个类是否“相等”，只有在这两个类是由同一个类加载器加载的前提下才有意义，否则，即使这两个类来源于同一个Class文件，被同一个虚拟机加载，只要加载它们的类加载器不同，那么这两个类必定不相等。接口类是一种特殊类，因此对于同一接口不同的类装载器装载所获得的类是不相同的。B错误
C.类只需加载一次就行，因此要保证类加载过程线程安全，防止类加载多次。C正确
D. Java程序的类加载器采用双亲委派模型，实现双亲委派的代码集中在java.lang.ClassLoader的loadClass()方法中，此方法实现的大致逻辑是：先检查是否已经被加载，若没有加载则调用父类加载器的loadClass()方法，若父类加载器为空则默认使用启动类加载器作为父类加载器。如果父类加载失败，抛出ClassNotFoundException异常。D错误
E.双亲委派模型的工作过程：如果一个类加载器收到了类加载的请求，它首先不会自己去尝试加载这个类，而是把这个请求委派给父类加载器去完成，每一个层次的类加载器都是如此，因此所有的加载请求最终都应该传送到顶层的启动类加载器中，只有当父加载器反馈自己无法完成这个加载请求时，子加载器才会尝试自己去加载。E正确
F.应用程序类加载器（Application ClassLoader）负责加载用户类路径（ClassPath）上所指定的类库，不是所有的ClassLoader都加载此路径。F错误

解析2：
从java虚拟机的角度讲，只有两种不同的类加载器：一种是启动类加载器（Bootstrap ClassLoader），这个类加载器使用的是c++实现的，是虚拟机的一部分，另一类是就是所有其他类加载器，这些类加载器都由java语言实现，独立于虚拟机外部，并且全都继承自抽象类。
从开发人员的角度看，类加载器还可以划分为3种系统类加载器，启动类加载器（Bootstrap ClassLoader），负责加载存放在<JAVA_HOME>/lib目录中的，或者被-Xbootclasspath参数所指定的路径中的，并且是虚拟机识别的（仅按照文件名识别，如rt.jar，名字不符的类库即使放在lib目录中也不会被加载）类库加载到虚拟机中内存中。启动类加载器无法被java程序直接引用，用户在编写自定义类加载器是，如果需要把加载请求委派给引导类加载器，那直接使用null代替即可。
扩展类加载器（Extension ClassLoader）：这个类加载器有sun.misc.Launcher$ExtClassLoader实现，负责加载<JAV{A}_{H}OME>/lib/ext目录中的，或者被java.ext.dirs系统变量所指定的路径中的所有类库，开发者可以直接使用扩展类加载器。应用类加载器（ApplicationClassLoader）：这个类加载器由sun.misc.Launcher$AppClassLoader实现。由于这个类加载器是ClassLoader中的getSystemClassLoader（）方法的返回值，所以也称它为系统类加载器（System ClassLoader）。他负责加载用户类路径（ClassPath）上所指定的类库，开发者可以直接使用这个类加载器，如果应用程序中没有自定义过自己的类加载器，一般情况下这个就是程序中默认的类加载器。对此，如果有必要开发者可以加入自己定义的类加载器。
一般对于我们java程序员来说，类的加载使用的是双亲委派模型，即当一个类需要加载时，会将类传给Application ClassLoader，但是Application ClassLoader并不会加载，不管它是否能加载，而是传给它的"父类" Extension ClassLoader，Extension ClassLoader同样不会加载，同样传给 Bootstrap ClassLoader（注意不是我们常说的那种父类，但是可以这样理解）,这时Bootstrap ClassLoader会判断它是否能加载，能加载就直接加载了，不能加载就传给Extension ClassLoader，Extension ClassLoader同样的判断是否能加载，能加载就直接加载，不能加载就传给Application ClassLoader，然后Application ClassLoader也判断能否加载，如果还是不能加载应该就是报ClassNotFoundException了。这就是双亲委托模型的简单理解了。
对于上面的"父类"为什么要打引号，因为它们并不是真的像java中继承的关系，而是组合的关系，即在"子类"中存在一个成员变量指向"父类"的引用。
所以AE对DF错了。
对于C，很容易理解，因为我们知道一个类只需要加载一次就够了，所以要保证线程安全。
难点就在B了，其实也好理解，就是体现双亲委托模型的优势的时候了，之所以使用双亲委托机制是为了保证java程序的稳定运作，比如当你使用的不是双亲委托模型的时候，然后刚好开发者又定义了一个类，一个java.lang.String这样一个类，如果不使用双亲委托模型，当类加载的时候就有可能会加载开发者定义的String类，这导致了java代码的一片混乱，可读性极差。（PS：但这并不意味着类加载器只要双亲委托模型就行了，没有完美的模型，只有最合适的模型，有不同的需求使用不同的模型。比如破坏双亲委派模型，有兴趣的牛友可以自行了解），所以可以这么说，不同的类加载器加载出来的类是不一样的，不同的类加载器加载同一个类会在方法区产生两个不同的类，彼此不可见，并且在堆中生成不同的Class实例。对于接口，其实就是一个特殊的类，和类一样，在堆中产生不同的class对象。
纯手打，个人理解，欢迎大佬指出错误。

5月19日

解析：
A.StringBuilder线程不安全，StringBuffer线程安全。
B.同时用 abstract和final就会自相矛盾。
C.Hashmap中的value可以之null，get(key)==null有两种情况，一是key不存在，二是该key中存的是null，所以应该使用map.containskey(key)返回的true/false来判断是否存在这个key。
D.volatile关键字有两个作用：
1.并发环境可见性：volatile修饰后的变量能够保证该变量在线程间的可见性，线程进行数据的读写操作时将绕开工作内存（CPU缓存）而直接跟主内存进行数据交互，即线程进行读操作时直接从主内存中读取，写操作时直接将修改后端变量刷新到主内存中，这样就能保证其他线程访问到的数据是最新数据
2.并发环境有序性：通过对volatile变量采取内存屏障（Memory barrier）的方式来防止编译重排序和CPU指令重排序，具体方式是通过在操作volatile变量的指令前后加入内存屏障，来实现happens-before关系，保证在多线程环境下的数据交互不会出现紊乱

解析：
1.final修饰变量，则等同于常量
2.final修饰方法中的参数，称为最终参数。
3.final修饰类，则类不能被继承
4.final修饰方法，则方法不能被重写。
final 不能修饰抽象类
final修饰的方法可以被重载 但不能被重写

解析：
构造方法每次都是构造出新的对象，不存在多个线程同时读写同一对象中的属性的问题，所以不需要同步 。
如果父类中的某个方法使用了 synchronized关键字，而子类中也覆盖了这个方法，默认情况下子类中的这个方法并不是同步的，必须显示的在子类的这个方法中加上 synchronized关键字才可。当然，也可以在子类中调用父类中相应的方法，这样虽然子类中的方法并不是同步的，但子类调用了父类中的同步方法，也就相当子类方法也同步了。详见：http://blog.csdn.net/welcome000yy/article/details/8941644
接口里面的变量为常量，其实际是 public static final ；接口里面的方法为抽象方法，其实际是public abstract。

解析：

• hashMap在单线程中使用大大提高效率，在多线程的情况下使用hashTable来确保安全。hashTable中使用synchronized关键字来实现安全机制，但是synchronized是对整张hash表进行锁定即让线程独享整张hash表，在安全同时造成了浪费。concurrentHashMap采用分段加锁的机制来确保安全
• Arrays.asList()
  将一个数组转化为一个List对象，这个方***返回一个ArrayList类型的对象， 这个ArrayList类并非java.util.ArrayList类，而是Arrays类的静态内部类！用这个对象对列表进行添加删除更新操作，就会报UnsupportedOperationException异常。

解析：
考察方法进栈与出栈的顺序。先进后出
有个知识点，方法在出栈的时候，执行的是return语句。因为出栈就意味着方法结束并消费，如果没有return语句，那么方法出栈的时候什么都不执行，就直接销毁。
1.执行split（12）时，执行代码System.out.print(split(number / 2))
split（12/2）进栈，此时number=6；
2.执行split（6）时，执行代码System.out.print(split(number / 2))
split（6/2）进栈，此时number=3；
3.执行split（3）时，

第1行 if (number % 2 != 0)
第2行          System.out.print(split((number + 1) / 2));
第3行    System.out.print(split(number / 2));

按照顺序执行
先执行第2行
首先split（(3+1)/2）进栈，此时number=2，
再执行split（2），那么split（2/2）进栈，此时number=1， 最后return 1，
注意此时第2行代码还没有结束
此时
split（2/2）出栈，输出1；
split（(3+1)/2）出栈，输出2；
第二行代码结束，再执行第三行，此时number=3，执行System.out.print(split(number / 2))
split（3/2）进栈，number=1，return，那么就需要出栈了
split（3/2）出栈，输出1
split（6/2）出栈，输出3
split（12/2）出栈，输出6；
最终结果12136；

split（number）方法，最终返回的是number这个值，所以split（n）出栈的输出结果就是n

整理：
split（12/2）进栈
split（6/2）进栈

split（(3+1)/2）进栈
split（2/2）进栈
split（2/2）出栈，输出1
split（(3+1)/2）出栈，输出2

split（2/2）进栈
split（2/2）出栈，输出1

split（6/2）出栈，输出3
split（12/2）出栈，输出6