15原码: 　　00000000 00000000 00000000 00001111 //32位,二进制
反码： 　　 11111111 11111111 11111111 11110000 //0变1,1变O
补码： 　　 11111111 11111111 11111111 11110001 //最后位加1,-15二进制
右移2位：　 11111111 11111111 11111111 11111100 //右边丢弃2位,前面30位保留,左边补1
取反：      00000000 00000000 00000000 00000011 //0变1,1变O
＋１:                                       3+1
结果:                                     ＝－４ //负号保留,十进制

带符号左移 题: 10 << 2 = 40
10 补码:    00000000 00000000 00000000 00001010 //32位,二进制
左移2位:    00000000 00000000 00000000 00101000 //左边丢弃2位,右边补0
结果:                                        40 //十进制

无符号右移 题：－4321 >>> 30 = 3
4321原码: 　       00000000 00000000 00010000 11100011 //32位,二进制
反码： 　　        11111111 11111111 11101111 00011100 //0变1,1变O
补码： 　　        11111111 11111111 11101111 00011101 //最后位加1,-4321二进制
无符号右移30位：　 00000000 00000000 00000000 00000011 //右边丢弃30位,前面二位保留,左边补0
结果:                                                3 //十进制

& 位逻辑与 题：44 & 21 = 4
44 补码:    00000000 00000000 00000000 00101100 //32位,二进制
21 补码:    00000000 00000000 00000000 00010101 //32位,二进制
& 运算:     00000000 00000000 00000000 00000100 //对应的两个二进制位均为1时 结果位才为1 否则为0
结果:                                         4 //十进制   
                                

| 位逻辑与 题：9 | 5 = 13
9 补码:    00000000 00000000 00000000 00001001 //32位,二进制
5 补码:    00000000 00000000 00000000 00000101 //32位,二进制
| 运算:    00000000 00000000 00000000 00001101 //对应的二个二进制位有一个为1时，结果位就为1
结果:                                       13 //十进制

^ 位逻辑异或 题: 9 ^ 5 = 12
9 补码:    00000000 00000000 00000000 00001001 //32位,二进制
5 补码:    00000000 00000000 00000000 00000101 //32位,二进制
| 运算:    00000000 00000000 00000000 00001100 //对应的二进制位相异时，结果为1
结果:                                       12 //十进制

~ 位逻辑反 题: ~9 = -10
9 补码:    00000000 00000000 00000000 00001001 //32位,二进制
~ 运算:    11111111 11111111 11111111 11110110 //最高位为1表示为一个负数,则进行取反加1
取反:      00000000 00000000 00000000 00001001 //32位,二进制
＋１:                                      9+1 //32位,二进制
结果:                                      -10 //十进制

在计算机系统中，数值一律用补码来表示（存储）。
主要原因：使用补码，可以将符号位和其它位统一处理；同时，减法也可按加法来处理。另外，两个用补
码表示的数相加时，如果最高位（符号位）有进位，则进位被舍弃。
补码与原码的转换过程几乎是相同的。
数值的补码表示也分两种情况：
（1）正数的补码：与原码相同。
      例如，+9的补码是00001001。
（2）负数的补码：符号位为1，其余位为该数绝对值的原码按位取反；然后整个数加1。
      例如，-7的补码：因为是负数，则符号位为“1”,整个为10000111；其余7位为-7的绝对值+7的原码
     0000111按位取反为1111000；再加1，所以-7的补码是11111001。
已知一个数的补码，求原码的操作分两种情况：
（1）如果补码的符号位为“0”，表示是一个正数，所以补码就是该数的原码。
（2）如果补码的符号位为“1”，表示是一个负数，求原码的操作可以是：符号位为1，其余各位取反，然后再整个数加1。
     例如，已知一个补码为11111001，则原码是10000111（-7）：因为符号位为“1”，表示是一个负数，所以该位不变，仍为“1”；其余7位1111001取反后为0000110；再加1，所以是10000111。

转载：http://blog.csdn.net/zjp8023/archive/2009/05/29/4224121.aspx

IEEE 754 用科学记数法以底数为 2 的小数来表示浮点数。IEEE 浮点数用 1 位表示数字的符号，用 8 位来表示指数，用 23 位来表示尾数，即小数部分。作为有符号整数的指数可以有正负之分。小数部分用二进制（底数 2）小数来表示，这意味着最高位对应着值 ?(2 ^-1)，第二位对应着 ?(2 ^-2)，依此类推。对于双精度浮点数，用 11 位表示指数，52 位表示尾数。IEEE 浮点值的格式如图 1 所示。

因为用科学记数法可以有多种方式来表示给定数字，所以要规范化浮点数，以便用底数为 2 并且小数点左边为 1 的小数来表示，按照需要调节指数就可以得到所需的数字。所以，例如，数 1.25 可以表示为尾数为 1.01，指数为 0： (-1) 0*1.01 2*2 0

数 10.0 可以表示为尾数为 1.01，指数为 3： (-1) 0*1.01 2*2 3

一个十进制数能否用二进制浮点数精确表示，关键在于小数部分。我们来看一个最简单的小数能否精确表示。按照乘以2取整数位的方法，有：

得到一个无限循环的二进制小数，用有限位无法表示无限循环小数，因此，无法用IEEE 754浮点数精确表示。从中也可以看到：由于

，

这四个数也无法精确表示。同理：

也无法用IEEE 754浮点数精确表示。

在以0.1~0.9结尾的9个小数中，只有0.5可以精确表示：（如），而其他均无法进行精确转换。

场景一

有1，2，3，4，5个整数，分别对每个一数遍历2亿次，总共10亿次，在不同用例测试花费的时间如下

Switch测试

总共花费:20.329秒

IF测试

总共花费:20.437秒

Array测试

总共花费:20.703秒

Map测试

总共花费:56.719秒

场景二

有5百万条数据，分别对每一个数据访问10次，总共查找5千万次，在不同用例测试花费的时间如下：

Map测试

总共花费：4.047秒（自己对这结果很怀疑，但是测试几次都是这样）

内存占用：273579872字节

CPU占用：50%左右

Array Comparable测试

总共花费: 45.312秒

内存占用：160025376字节

CPU占用：50%左右

RBTree测试

总共花费：63.485秒

内存占用：320030976字节

CPU占用：50%左右


测试文件地址：http://www.blogjava.net/Files/aoneany/search.rar

forName是取得Class引用的一种方法，返回一个Class对象的引用。

如果Gum类还没有被加载就加载它，在加载过程中，Gum的静态子句被执行。

可能产生的异常：ClassNotFoundException

Class.getInterfaces("Gum")

返回对象是Class类型，表示类Gum包含的接口

如类Gum implements interface1,

则会获取到interface1的类对象

Class.newInstance()

实现“虚拟构造器”的一种途径

类字面常量

obj.Class生成对Class对象的引用，它比forName更加安全，因为它在编译时就接受检查。

注意:当使用.Class来创建Class对象的引用时，不会自动初始化Class对象。

class Initable{
    static final int staticFinal=47;
    static final int staticFinal2=ClassInitialization.rand.nextInt(1000);
    static{
        System.out.println("Initialzing Initable");
    }
}
class Initable2{
    static int staticNonFinal=147;
    static{
        System.out.println("Initialzing Initable2");
    }
}
class Initable3{
    static int staticNonFinal=74;
    static{
        System.out.println("Initialzing Initable3");
    }
}
public class ClassInitialization {
    public static Random rand=new Random(47);
    public static void main(String[] args){
        Class initable=Initable.class;
        System.out.println("After creating Initable ref");
        System.out.println(Initable.staticFinal);
        System.out.println(Initable.staticFinal2);
        System.out.println(Initable2.staticNonFinal);
        Class initable3=Class.forName("Initable3");
        System.out.println("After creating Initable3 ref");
        System.out.println(Initable3.staticNonFinal);
    }
}

输出结果为：

Initialzing Initable
After creating Initable ref
47
258
Initialzing Initable2
147
Initialzing Initable3
After creating Initable3 ref
74

结论：如果一个static final值是"编译期常量"，就象Initable.staticFinal那样，那么这个值不需要对Initable类初使化就可以读取，但是如果只是将一个域设置为static和final的，如对Initable.staticFinal2的访问将进行强制的初使化，因为它不是一个编译型常量。

如果一个static而不是final的，那么在它访问时，总是要求进行链接（为这个域分配存储空间）和初始化（初始化该存储空间），就像对Initable2.staticNonFinal那样。

泛化的Class引用

Class<Integer> iniClass=int.class

新的转型语法

case()

InstanceOf

反射

getMethods()返回Method对象的数组

getConstructors()返回Contructor对象的数组

动态代理

实现InvocationHandler接口

public Object invoke(Objct proxy,Method method,Object[] args)throws Throwable｛｝方法

通过Proxy.newProxyInstance(ClassLoader,Class[],InvocationHandler)创建动态代理

具体示例参见:

http://www.blogjava.net/aoneany/articles/271019.html

Scanner扫描字符串对象。

备注：

在java编译好的class文件中,有个区域称为Constant Pool,他是一个由数组组成的表,类型
为cp_info constant_pool[],用来存储程序中使用的各种常量,包括Class/String/Integer等各
种基本Java数据类型,详情参见The Java Virtual Machine Specification 4.4章节.

对于Constant Pool,表的基本通用结构为:
cp_info {
        u1 tag;
        u1 info[];
}

tag是一个数字,用来表示存储的常量的类型,例如8表示String类型,5表示Long类型,info[]根据
类型码tag的不同会发生相应变化.
对于String类型,表的结构为:
CONSTANT_String_info {
        u1 tag;
        u2 string_index;
}
tag固定为8,string_index是字符串内容信息,类型为:
CONSTANT_Utf8_info {
        u1 tag;
        u2 length;
        u1 bytes[length];
}
tag固定为1,length为字符串的长度,bytes[length]为字符串的内容.

代码样例
(以下代码在jdk6中编译)
为了详细理解Constant Pool的结构,我们参看一些代码:
    String s1 = "sss111";
    String s2 = "sss222";
    System.out.println(s1 + " " + s2);
由于"sss111"和"sss222"都是字符串常量,在编译期就已经创建好了存储在class文件中.
在编译后的class文件中会存在这2个常量的对应表示:
08 00 11 01 00 06 73 73 73 31 31 31 08 00 13 01 ; ......sss111....
00 06 73 73 73 32 32 32                         ; ..sss222

根据上面说的String常量结构,我们分析一下
开始的08为CONSTANT_String_info结构中的tag,而11应该是它的相对引用,01为
CONSTANT_Utf8_info的tag,06为对应字符串的长度,73 73 73 31 31 31为字符串对
应的编码,接着分析,会发现后面的是对应"sss222"的存储结构.

经过上面分析,我们知道了11和13是两个字符串的相对引用,就可以修改class文件
来修改打印的内容,把class文件中的
00 6E 00 04 00 03 00 00 00 24 12 10 4C 12 12 4D
改成
00 6E 00 04 00 03 00 00 00 24 12 10 4C 12 10 4D
程序就会输出sss111 sss111,而不是和原程序一样输出sss111 sss222,因为我
们把对"sss222"的相对引用12改成了对"sss111"的相对引用10.

------------分割线
public class Test {
    public static void main(String[] args) {
        String s1 = "sss111";
        String s2 = "sss111";
    }
}

在上面程序中存在2个相同的常量"sss111",对于n个值相同的String常量,在Constant Pool中
只会创建一个,所以在编译好的class文件中,我们只能找到一个对"sss111"的表示:
000000abh: 08 00 11 01 00 06 73 73 73 31 31 31             ; ......sss111

在程序执行的时候,Constant Pool会储存在Method Area,而不是heap中.

另外,对于""内容为空的字符串常量,会创建一个长度为0,内容为空的字符串放到Constant Pool中,
而且Constant Pool在运行期是可以动态扩展的.

关于String类的说明

1.String使用private final char value[]来实现字符串的存储,也就是说String对象创建之后,就不能
再修改此对象中存储的字符串内容,就是因为如此,才说String类型是不可变的(immutable).

2.String类有一个特殊的创建方法,就是使用""双引号来创建.例如new String("i am")实际创建了2个
String对象,一个是"i am"通过""双引号创建的,另一个是通过new创建的.只不过他们创建的时期不同,
一个是编译期,一个是运行期!

3.java对String类型重载了+操作符,可以直接使用+对两个字符串进行连接.

4.运行期调用String类的intern()方法可以向String Pool中动态添加对象.

String的创建方法

一般有如下几种
1.直接使用""引号创建.
2.使用new String()创建.
3.使用new String("someString")创建以及其他的一些重载构造函数创建.
4.使用重载的字符串连接操作符+创建.

面试题:

String s1 = new String("s1") ;
String s2 = new String("s1") ;
上面创建了几个String对象?
答案:3个 ,编译期Constant Pool中创建1个,运行期heap中创建2个.

import javax.servlet.http.HttpSession;
import javax.servlet.http.HttpSessionEvent;
import javax.servlet.http.HttpSessionListener;
import org.apache.log4j.Logger;
import org.jpxx.sw.Constants;
import org.jpxx.sw.Factory; 

/** *//**
 * 该监听器用于监听后台管理员登陆。只允许统一管理员在同一时间登陆一次。
 * @author Jun Li
 * @version  $Revision: 1.0.2 $, $Date: 2009/01/05 $
 * @since 1.0.0
 */
public class SessionListener implements HttpSessionListener { 

    Logger log = Factory.getSingletonInstance().getLogger(SessionListener.class);
    public void sessionCreated(HttpSessionEvent event) {
    } 

    public void sessionDestroyed(HttpSessionEvent event) {
        HttpSession session = event.getSession();
        // 获取存储管理员的session
        Object o = session.getAttribute(Constants.JPXX_ADMIN_LOGIN_USERNAME_SESSION);
        if(o!=null){
            String userName = o.toString();
            // 登陆的用户都存储在Hashtable中，用户退出，从Hashtable中删除该用户
            Factory.getUsers().remove(userName);
            log.error("删除用户：" + userName + "       " + new java.util.Date());
        }
    }
}

<listener>
        <listener-class>org.jpxx.sw.business.SessionListener</listener-class>
</listener>

<body scroll="no" onUnload="Jpxx.forceLogout();" onbeforeunload="Jpxx.forceLogout();">

Jpxx.forceLogout()方法通过AJAX技术来强制注销用户，即调用session.invalidate()方法。

转载:http://hi.baidu.com/e9151/blog/item/9c8d772be0319d305243c130.html

       "A dynamic proxy class (simply referred to as a proxy class below) is a class that implements a list of interfaces specified at runtime when the class is created, with behavior as described below. A proxy interface is such an interface that is implemented by a proxy class. A proxy instance is an instance of a proxy class. Each proxy instance has an associated invocation handler object, which implements the interface InvocationHandler."

        Proxy类的设计用到代理模式的设计思想，Proxy类对象实现了代理目标的所有接口，并代替目标对象进行实际的操作。但这种替代不是一种简单的替代，这样没有任何意义，代理的目的是在目标对象方法的基础上作增强，这种增强的本质通常就是对目标对象的方法进行拦截。所以，Proxy应该包括一个方法拦截器，来指示当拦截到方法调用时作何种处理。InvocationHandler就是拦截器的接口。

      InvocationHandler接口也是在java.lang.reflec

     Object invoke(Object proxy, Method method, Object[] args)

     这个接口有三个参数，其中第二和第三个参数都比较好理解，一个是被拦截的方法，一个是该方法的参数列表。关键是第一个参数。按照doc文档的解析，

      proxy - the proxy instance that the method was invoked on

      也就是说，proxy应该是一个代理实例，但为什么要传入这个参数呢？

      带着这个问题，自己编了个小程序作了一点试验。

///////////////////////////////////////

      public interface IAnimal {
           void info();
      }

////////////////////////////////////

    public class Dog implements IAnimal

    {

          public void info() {
             System.out.println("I am a dog!");
          }
    }

///////////////////////////////////////
import java.lang.reflect.*;

public class ProxyTest {
 public static void main(String[] args) throws InterruptedException {
  final IAnimal animal = new Dog();
  Object proxyObj =Proxy.newProxyInstance(
    animal.getClass().getClassLoader(),
    animal.getClass().getInterfaces(),
    new InvocationHandler()
    {
     public Object invoke(Object proxy, Method method, Object[] args)
     {
      try {
       System.out.println("被拦截的方法:" + method.getName());
       return method.invoke(animal, args);
      }
      catch (IllegalArgumentException e) {
       // TODO Auto-generated catch block
       e.printStackTrace();
       return null;
      } catch (IllegalAccessException e) {
       // TODO Auto-generated catch block
       e.printStackTrace();
       return null;
      } catch (InvocationTargetException e) {
       // TODO Auto-generated catch block
       e.printStackTrace();
       return null;
      }
     }
    });
  if(proxyObj instanceof IAnimal)
  {
   System.out.println("the proxyObj is an animal!");
  }
  else
  {
   System.out.println("the proxyObj isn't an animal!");
  }
  
  if(proxyObj instanceof Dog)
  {
   System.out.println("the proxyObj is a dog!");
  }
  else
  {
   System.out.println("the proxyObj isn't a dog!");
  }
  
  IAnimal animalProxy = (IAnimal)proxyObj;
  animalProxy.info();
  animalProxy.hashCode();
  System.out.println(animalProxy.getClass().getName().toString());
 }
}

程序执行的结果如下：

the proxyObj is an animal!
the proxyObj isn't a dog!
被拦截的方法:info
I am a dog!
被拦截的方法:hashCode
$Proxy0

从结果可以看出以下几点：

1. proxyObj 是一个实现了目标对象接口的对象，而不同于目标对象。也就是说，这种代理机制是面向接口，而不是面向类的。

2. info方法(在接口中)被成功拦截了，hashCode方法也成功被拦截了，但意外的是，getClass方法(继承自Object 类的方法)并没有被拦截！！

3. 应用调试还可以看出Invocation接口中invoke方法的传入的proxy参数确实就是代理对象实例proxyObj

为何getClass()没有被拦截？proxy参数又有何用呢？

先不管，做一个试验看看。既然这个proxy参数就是代理实例对象，它理所当然和proxyObj是一样的，可以调用info等方法。于是我们可以在invoke方法中加上如下一条语句：

((IAnimal)proxy).info();

结果是：

the proxyObj is an animal!
the proxyObj isn't a dog!
被拦截的方法:info
被拦截的方法:info

.......

被拦截的方法:info
被拦截的方法:info

然后就是栈溢出

结果是很明显的，在invoke方法中调用proxy中的方法会再一次引发invoke方法，这就陷入了死循环，最终结果当然是栈溢出的。

可以在invoke方法中调用proxy.getClass(), 程序可以正常运行。但如果调用hashCode()方法同样会导致栈溢出。

       通过上面的试验，可以得出一些初步结论，invoke 接口中的proxy参数不能用于调用所实现接口的方法。奇怪的是hashCode()和getClass()方法都是从Object中继承下来的方法，为什么一个可以另一个不可以呢？带首疑问到doc文档看一下Object中这两个方法，发现getClass()是定义为final的，而hashCode()不是。难道是这个原因，于是找到一个非final方法，如equals试了一下，真的又会导致栈溢出；找另一个final方法如wait(),试了一下，invoke又不拦截了。final 难道就是关键之处？

      还有一个问题就是proxy有什么用？既然proxy可以调用getClass()方法，我们就可以得到proxy的Class类象，从而可以获得关于proxy代理实例的所有类信息，如方法列表，Annotation等，这就为我们提供的一个分析proxy的有力工具，如通过分析Annotation分析方法的声明式事务需求。我想传入proxy参数应该是这样一个用意吧。

InvocationHandler的资料

属于包：java.lang.reflect

public interface InvocationHandler

InvocationHandler 是代理实例的调用处理程序 实现的接口。

每个代码实例都具有一个关联的调用处理程序。对代理实例调用方法时，将对方法调用进行编码并将其指派到它的调用处理程序的 invoke 方法。

从以下版本开始：

JDK1.3

invoke

Object invoke(Object proxy,

Method method,

Object[] args)

throws Throwable

在代理实例上处理方法调用并返回结果。在与方法关联的代理实例上调用方法时，将在调用处理程序上调用此方法。

 

参数：

proxy - 在其上调用方法的代理实例

method - 对应于在代理实例上调用的接口方法的 Method 实例。Method 对象的声明类将是在其中声明方法的接口，该接口可以是代理类赖以继承方法的代理接口的超接口。

args - 包含传入代理实例上方法调用的参数值的对象数组，如果接口方法不使用参数，则为 null。基本类型的参数被包装在适当基本包装器类（如 java.lang.Integer 或 java.lang.Boolean）的实例中。

返回：

从代理实例的方法调用返回的值。如果接口方法的声明返回类型是基本类型，则此方法返回的值一定是相应基本包装对象类的实例；否则，它一定是可分配到声明返回类型的类型。如果此方法返回的值为 null 并且接口方法的返回类型是基本类型，则代理实例上的方法调用将抛出 NullPointerException。否则，如果此方法返回的值与上述接口方法的声明返回类型不兼容，则代理实例上的方法调用将抛出 ClassCastException。

抛出：

Throwable - 从代理实例上的方法调用抛出的异常。该异常的类型必须可以分配到在接口方法的 throws 子句中声明的任一异常类型或未经检查的异常类型 java.lang.RuntimeException 或 java.lang.Error。如果此方法抛出经过检查的异常，该异常不可分配到在接口方法的 throws 子句中声明的任一异常类型，代理实例的方法调用将抛出包含此方法曾抛出的异常的 UndeclaredThrowableException。