<servlet>
        <servlet-name>test</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>  
            <description>加载/WEB-INF/spring-mvc/目录下的所有XML作为Spring MVC的配置文件</description>  
            <param-name>contextConfigLocation</param-name>  
            <param-value>/WEB-INF/*-servlet.xml</param-value>  
        </init-param>  
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>test</servlet-name>
        <url-pattern>*.do</url-pattern>
    </servlet-mapping>

表示加载/WEB-INF/下所有以-servlet.xml结尾的xml文件

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可以精确表示：（如），而其他均无法进行精确转换。

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个.

　　在J2SE1.3里当PrintJob的功能扩展到可以通过在java.awt包里的JobAttributes 和PageAttributes两个类设定工程和页面的属性时发生了一些额外的改变。随着J2SE1.3的发布，打印功能相应的得到了完善；但是在混合使用这两种完全不同的打印机制的时候仍然存在一些问题。比如，这两种机制使用java.awt.Graphics这个类的一个接口来展现打印内容，意味着所有要打印的东西都必须用一张图片表示。另外，完善的PrintJob提供了很有限的工程相关属性的设置；这两种机制都没有办法通过程序来选择目标打印机。

　　Java打印最大的改变来自于J2SE1.4的发布带来的Java打印服务API。这个第三代Java打印支持接口突破了先前提到的局限性。因为新的API就是以前两种旧的打印机制定义的功能函数的一个父集。

下面是我通过这些API写的定位打印示例代码，希望对用java实现打印的朋友有一定的帮助！
在CentOS4.4，jdk1.6下测试通过。

import java.awt.Color; 
import java.awt.Font; 
import java.awt.Graphics; 
import java.awt.Graphics2D; 
import java.awt.print.PageFormat; 
import java.awt.print.Printable; 
import java.awt.print.PrinterException; 

import javax.print.Doc; 
import javax.print.DocFlavor; 
import javax.print.DocPrintJob; 
import javax.print.PrintException; 
import javax.print.PrintService; 
import javax.print.PrintServiceLookup; 
import javax.print.SimpleDoc; 
import javax.print.attribute.DocAttributeSet; 
import javax.print.attribute.HashDocAttributeSet; 
import javax.print.attribute.HashPrintRequestAttributeSet; 
import javax.print.attribute.PrintRequestAttributeSet; 
import javax.print.attribute.standard.MediaSizeName; 
import javax.swing.JOptionPane; 

/** *//** 
* java定位打印，把打印内容打到指定的地方。 
* 
* @author lyb 
* 
*/ 
public class LocatePrint implements Printable { 
    private int PAGES = 0; 

    private String printStr; 

    /**//* 
     * Graphic指明打印的图形环境；PageFormat指明打印页格式（页面大小以点为计量单位， 
     * 1点为1英寸的1/72，1英寸为25.4毫米。A4纸大致为595×842点）；page指明页号 
     */ 
    public int print(Graphics gp, PageFormat pf, int page) 
            throws PrinterException { 
        Graphics2D g2 = (Graphics2D) gp; 
        g2.setPaint(Color.black); // 设置打印颜色为黑色 
        if (page >= PAGES) // 当打印页号大于需要打印的总页数时，打印工作结束 
            return Printable.NO_SUCH_PAGE; 
        g2.translate(pf.getImageableX(), pf.getImageableY());// 转换坐标，确定打印边界 
        Font font = new Font("宋体", Font.PLAIN, 24);// 创建字体 
        g2.setFont(font); 
        // 打印当前页文本 
        int printFontCount = printStr.length();// 打印字数 
        int printFontSize = font.getSize();// Font 的磅值大小 
        float printX = 595 / 2; // 给定字符点阵，X页面正中 
        float printY = 842 / 2; // 给定字符点阵，Y页面正中 
        float printMX = printX - (printFontCount * printFontSize / 2);// 打印到正中间 
        float printMY = printY - printFontSize / 2;// 打印到正中间 
        g2.drawString(printStr, printMX, printMY); // 具体打印每一行文本，同时走纸移位 
        g2.drawString(printStr, printMX - printFontSize * printFontCount, 
                printMY + printFontSize); // 具体打印每一行文本，同时走纸移位 
        g2.drawString(printStr, printMX + printFontSize * printFontCount, 
                printMY + printFontSize); // 具体打印每一行文本，同时走纸移位 
        g2.drawString(printStr, printMX, printMY + printFontSize * 2); // 具体打印每一行文本，同时走纸移位 
        return Printable.PAGE_EXISTS; // 存在打印页时，继续打印工作 
    } 

    // 打印内容到指定位置 
    public void printContent() { 
        printStr = "打印测试内容";// 获取需要打印的目标文本 
        if (printStr != null && printStr.length() > 0) // 当打印内容不为空时 
        { 
            PAGES = 1; // 获取打印总页数 
            // 指定打印输出格式 
            DocFlavor flavor = DocFlavor.SERVICE_FORMATTED.PRINTABLE; 
            // 定位默认的打印服务 
            PrintService printService = PrintServiceLookup 
                    .lookupDefaultPrintService(); 
            // 创建打印作业 
            DocPrintJob job = printService.createPrintJob(); 
            // 设置打印属性 
            PrintRequestAttributeSet pras = new HashPrintRequestAttributeSet(); 
            // 设置纸张大小,也可以新建MediaSize类来自定义大小 
            pras.add(MediaSizeName.ISO_A4); 
            DocAttributeSet das = new HashDocAttributeSet(); 
            // 指定打印内容 
            Doc doc = new SimpleDoc(this, flavor, das); 
            // 不显示打印对话框，直接进行打印工作 
            try { 
                job.print(doc, pras); // 进行每一页的具体打印操作 
            } catch (PrintException pe) { 
                pe.printStackTrace(); 
            } 
        } else { 
            // 如果打印内容为空时，提示用户打印将取消 
            JOptionPane.showConfirmDialog(null, 
                    "Sorry, Printer Job is Empty, Print Cancelled!", 

                    "Empty", JOptionPane.DEFAULT_OPTION, 
                    JOptionPane.WARNING_MESSAGE); 
        } 
    } 

    public static void main(String[] args) { 
        LocatePrint lp = new LocatePrint(); 
        lp.printContent(); 
    } 

} 

回答一:如果在application上有哪个component由于事件的触发而发生变化（比如，形状）的话，这个方法就是用来更新当前程序的界面用的，就相当于重画一下界面

回答二:The original author comments, very clear:

   JSpinner spinner = new JSpinner(new SpinnerNumberModel(value, min, max, 1));
   spinner.setBounds(x,y,width,height);
   // 控制输入
   JSpinner.NumberEditor editor = new JSpinner.NumberEditor(spinner, "0");
   spinner.setEditor(editor);
   JFormattedTextField textField = ((JSpinner.NumberEditor) spinner.getEditor())
     .getTextField();
   textField.setEditable(true);
   DefaultFormatterFactory factory = (DefaultFormatterFactory) textField
     .getFormatterFactory();
   NumberFormatter formatter = (NumberFormatter) factory.getDefaultFormatter();
   formatter.setAllowsInvalid(false);
   add(spinner);
 
这样输入就不可以输入字母了，因为设置了输入格式。超过范围的数值也是输入不进去的。
其他的格式都应该是类似的吧，呵呵。
只不过这里用的是NumberFormatter ，还有其他类型的。

转载：http://yangke1120.spaces.live.com/blog/cns!77b62010246eabc6!168.entry

如果是通过JDBC的话，在读取该字段时用getLong()来读取，或者用getObject()然后调用其toString()函数即可。   
如果是用Hibernate的话，在映射文件中将该字段映射成Long或Integer即可。

new   java.text.DecimalFormat("########").format(12345678)

转自:http://www.blogjava.net/hclown/articles/24383.html

严重: Exception starting filter struts2
java.lang.IllegalArgumentException: Wrong type at constant pool index
 at sun.reflect.ConstantPool.getClassAt0(Native Method)
 at sun.reflect.ConstantPool.getClassAt(Unknown Source)
 at sun.reflect.annotation.AnnotationParser.parseAnnotation(Unknown Source)
 at sun.reflect.annotation.AnnotationParser.parseAnnotations(Unknown Source)
 at java.lang.reflect.Method.declaredAnnotations(Unknown Source)
 at java.lang.reflect.Method.getAnnotation(Unknown Source)
 at java.lang.reflect.AccessibleObject.isAnnotationPresent(Unknown Source)
 at org.apache.catalina.util.DefaultAnnotationProcessor.processAnnotations(DefaultAnnotationProcessor.java:161)
 at org.apache.catalina.core.ApplicationFilterConfig.getFilter(ApplicationFilterConfig.java:259)
 at org.apache.catalina.core.ApplicationFilterConfig.setFilterDef(ApplicationFilterConfig.java:397)
 at org.apache.catalina.core.ApplicationFilterConfig.<init>(ApplicationFilterConfig.java:108)
 at org.apache.catalina.core.StandardContext.filterStart(StandardContext.java:3709)
 at org.apache.catalina.core.StandardContext.start(StandardContext.java:4356)
 at org.apache.catalina.core.ContainerBase.start(ContainerBase.java:1045)
 at org.apache.catalina.core.StandardHost.start(StandardHost.java:719)
 at org.apache.catalina.core.ContainerBase.start(ContainerBase.java:1045)
 at org.apache.catalina.core.StandardEngine.start(StandardEngine.java:443)
 at org.apache.catalina.core.StandardService.start(StandardService.java:516)
 at org.apache.catalina.core.StandardServer.start(StandardServer.java:710)
 at org.apache.catalina.startup.Catalina.start(Catalina.java:578)
 at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
 at sun.reflect.NativeMethodAccessorImpl.invoke(Unknown Source)
 at sun.reflect.DelegatingMethodAccessorImpl.invoke(Unknown Source)
 at java.lang.reflect.Method.invoke(Unknown Source)
 at org.apache.catalina.startup.Bootstrap.start(Bootstrap.java:288)
 at org.apache.catalina.startup.Bootstrap.main(Bootstrap.java:413)

程序

String url="http://servername?country=中国";
        String[] segment=url.split("\\?");
        StringBuilder newUrl=new StringBuilder();
        newUrl.append(segment[0]+"?");
        String[] argStr=segment[1].split("&");
        for(int i=0;i<argStr.length;i++){
            String[] args= argStr[i].split("=");
            if(args==null ||args.length==0)
                continue;
            newUrl.append(args[0]);
            if(args[1]!=null){
                try {
                    String argValue=URLEncoder.encode(args[1],"UTF-8");
                    newUrl.append("="+argValue);
                } catch (UnsupportedEncodingException e) {
                    e.printStackTrace();
                }
            }
            newUrl.append("&");
        }
        System.out.println(newUrl.toString());

原URL：http://servername?country=中国

转码后的URL：http://servername?country=%E4%B8%AD%E5%9B%BD&

File buildFile = new File("build.xml");
Project p = new Project();
DefaultLogger consoleLogger = new DefaultLogger();
consoleLogger.setErrorPrintStream(System.err);
consoleLogger.setOutputPrintStream(System.out);
consoleLogger.setMessageOutputLevel(Project.MSG_INFO);
p.addBuildListener(consoleLogger);
try {
p.fireBuildStarted();
p.init();
ProjectHelper helper = ProjectHelper.getProjectHelper();
helper.parse(p, buildFile);
p.executeTarget(p.getDefaultTarget());
p.fireBuildFinished(null);
} catch (BuildException e) {
p.fireBuildFinished(e);
}

        JDesktopPane desktop = new JDesktopPane ();
.
        JScrollPane scrollpane = new JScrollPane(desktop,
                JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED,
                JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED);
        getContentPane().add(scrollpane);

但是一运行，但内部窗口移出到边界外边时，我们预想中的滚动条并没有出现，怎么办？原来，JDesktopPane 加到JScrollPane后其大小就只是JScrollPane的viewport的大小，所以滚动条并没有出现。所以我们要想办法让JDesktopPane 的Viewport的大小跟随内部窗口的位置而改变大小，继承一个JDesktopPane 吧：

/**
 * @author Turbo Chen
 * @version 1.01
 */
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;

public class JDesktop extends JDesktopPane{
    public void paint(Graphics g){
        super.paint(g);
        Dimension d = preferredSizeOfAllFrames();
        this.setPreferredSize(d);
        this.revalidate();
    }

  /**
   * @return 返回最佳desktop尺寸..
   */
    public Dimension preferredSizeOfAllFrames(){
        JInternalFrame [] array = getAllFrames();
        int maxX = 0;
        int maxY = 0;
        for (int i = 0; i < array.length; i++){
            if ( array[ i ].isVisible() ){
                int cx;
                cx = array[i].getX();
                int x = cx + array[i].getWidth();
                if (x > maxX) maxX = x;
                int cy;
                cy = array[i].getY();
                int y = cy + array[i].getHeight();
                if (y > maxY) maxY = y;
            }
        }
        return new Dimension(maxX, maxY);
    }
}
关键是preferredSizeOfAllFrames（）方法，子窗口移动时造成JDesktop的刷新，它调用preferredSizeOfAllFrames（）方法重新计算最佳JDesktop的大小，并通过revalidate()方法来通知它的上层容器即JScrollPane，JScrollPane会根据JDesktop的大小来调整自身Viewport的大小，当Viewport的大小超出可视范围，JScrollPane就出现滚动条了.

在你的程序中，只要用这个新的JDesktop类，就可以在MDI窗口中实现滚动条了