一种是 var a = new Number(0),这种是返回一个Number的对象

第二种 var a= Number(0),这种是返回一个单纯的数字0

下面是在firefox下控制台输出的两种不同的实例化方法。

>>> console.log(new Number(0));
0 {}

>>> console.log(Number(0));
0

这个知识点可以参考： http://www.w3school.com.cn/js/jsref_obj_number.asp (JavaScript Number 对象参考手册)

但是需要注意的是：如果 new Number(“xxxx”)，传入一个字符串，将返回NaN，NaN的意义是“Not a Number”，代表不是一个数字，

判断的方法不能单纯的用 “xxxx”==NaN 来判断，因为NaN本身和NaN也不相等，

>>> NaN==NaN
false

如何判断一个变量是否是NaN，需要用到isNaN(var)这个方法，例如：

>>> isNaN(Number(“xxx”))
true

>>> isNaN(Number(“134″))
false

>>> isNaN(Number(134))
false

>>> isNaN(NaN)
true

一个小数，例如1.7777777，或者1.3333333，不管后面的位数是多少，只保留到小数点后第二位，但是不是四舍五入，1.7777777处理后就是1.77，1.3333333处理后就是1.33

这个就要用到BigDecimal#setScale的方法了。

具体看如下代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

import java.math.BigDecimal;
import java.math.RoundingMode;
 
public class ScaleTest {
 
	public static void main(String[] args) {
 
		double a = 1.66728D;
		double b = 1.33333D;
		double c = 1.00000D;
 
		BigDecimal aa = new BigDecimal(a);
		BigDecimal bb = new BigDecimal(b);
		BigDecimal cc = new BigDecimal(c);
		System.out.println(aa.setScale(2, BigDecimal.ROUND_UP));
		System.out.println(aa.setScale(2, BigDecimal.ROUND_DOWN));
		System.out.println(bb.setScale(2, BigDecimal.ROUND_UP));
		System.out.println(bb.setScale(2, BigDecimal.ROUND_DOWN));
		System.out.println(cc.setScale(2, BigDecimal.ROUND_UP));
		System.out.println(cc.setScale(2, BigDecimal.ROUND_DOWN));
		System.out.println("-------------------------------------");
		System.out.println(aa.setScale(2, RoundingMode.UP));
		System.out.println(aa.setScale(2, RoundingMode.DOWN));
		System.out.println(bb.setScale(2, RoundingMode.UP));
		System.out.println(bb.setScale(2, RoundingMode.DOWN));
		System.out.println(cc.setScale(2, RoundingMode.UP));
		System.out.println(cc.setScale(2, RoundingMode.DOWN));
	}
}

输出结果如下：
1.67
1.66
1.34
1.33
1.00
1.00
————————————-
1.67
1.66
1.34
1.33
1.00
1.00

上面仅仅是根据我的需要举了BigDecimal.ROUND_UP和BigDecimal.ROUND_DOWN的例子，下面就用个表格来分析下。

ROUND_UP ROUND_DOWN
1.66728D 1.67 1.66
1.33333D 1.34 1.33
1.00000D 1.00 1.00

也就是说，ROUND_DOWN，是一个舍位取值的概念，我保留了两位小数，我不管你后面的小数值如何，也不会四舍五入，就硬生生的给阶段，相当于什么呢，就是我从小数点后面开始取两位，两位后面的都不要了，相当于一个截取字符串的操作。

而ROUND_UP那，很宽容，很大方，我不管你第三位的小数是多少，我都给你加一最小单位（比如保留两位小数，最小单位是0.01，保留三位小数，最小单位就是0.001），当然了，你保留到最后一位的数字如果是0的话，那么就不加了。

而这两个作用在咱们实际当中什么情况下不能使用四舍五入，需要用这两个呢？

用个应用题举例子吧，

一个篮子可以装10个苹果，现在有82个苹果，需要几个篮子来装？
9个，对，这是咱们的什么结果，不正是ROUND_UP的么（只不过这道题是取小数点后0位，也就是取整的区别而已），也就很好解释为什么最小单位是0不需要再加一个最小单位了，如果我只有80个苹果，8个篮子正好装下，就不需要第九个了。

那么什么时候儿需要使用ROUND_DOWN呢，再来看下面一个例子，
每个加油站相距8公里，一公里需要耗一个油，我现在车里还有90个油，请问，我最晚在第几个加油站必须得加油了？
11个，第十一个，就是在车使用88个油到达第11个加油站后需要加油，因为我还剩2个由已经撑不到第12个加油站了。这种情况，ROUND_DOWN就派上用场了。

其实，BigDecimal不光有ROUND_UP，ROUND_DOWN，还有其他的很多值，比如：ROUND_CEILING、ROUND_HALF_DOWN等等，具体的效果可以自己实验下。

这里给出篇文章地址供参考：
http://stephen830.javaeye.com/blog/260776 JAVA对double或者float的浮点数精度计算控制方法

原文如下：
JAVA对double或者float的浮点数精度计算控制方法
文章分类:Java编程关键字: java double或者float的浮点数精度
★★★ 本篇为原创，需要引用转载的朋友请注明：《 http://stephen830.javaeye.com/blog/260776 》 谢谢支持！★★★本篇介绍了在JAVA中如何对double或者float的浮点数进行精度计算，在JAVA中提供了多种参数来实现精度的不同控制方式。具体例子如下：
Java代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92

import java.math.BigDecimal;   
 
/**  
 * 与小数位精度(四舍五入等)相关的一些常用工具方法.  
 *   
 * float/double的精度取值方式分为以下几种: <br>  
 * java.math.BigDecimal.ROUND_UP <br>  
 * java.math.BigDecimal.ROUND_DOWN <br>  
 * java.math.BigDecimal.ROUND_CEILING <br>  
 * java.math.BigDecimal.ROUND_FLOOR <br>  
 * java.math.BigDecimal.ROUND_HALF_UP<br>  
 * java.math.BigDecimal.ROUND_HALF_DOWN <br>  
 * java.math.BigDecimal.ROUND_HALF_EVEN <br>  
 *   
 * @author stephen  
 * @version 1.0.0  
 */  
public final class RoundTool {   
 
    /**  
     * 对double数据进行取精度.  
     * <p>  
     * For example: <br>  
     * double value = 100.345678; <br>  
     * double ret = round(value,4,BigDecimal.ROUND_HALF_UP); <br>  
     * ret为100.3457 <br>  
     *   
     * @param value  
     *            double数据.  
     * @param scale  
     *            精度位数(保留的小数位数).  
     * @param roundingMode  
     *            精度取值方式.  
     * @return 精度计算后的数据.  
     */  
    public static double round(double value, int scale, int roundingMode) {   
        BigDecimal bd = new BigDecimal(value);   
        bd = bd.setScale(scale, roundingMode);   
        double d = bd.doubleValue();   
        bd = null;   
        return d;   
    }   
 
    /**  
     * 测试用的main方法.  
     *   
     * @param argc  
     *            运行参数.  
     */  
    public static void main(String[] argc) {   
        //下面都以保留2位小数为例   
 
        //ROUND_UP   
        //只要第2位后面存在大于0的小数，则第2位就+1   
        System.out.println(round(12.3401,2,BigDecimal.ROUND_UP));//12.35   
        System.out.println(round(-12.3401,2,BigDecimal.ROUND_UP));//-12.35   
        //ROUND_DOWN   
        //与ROUND_UP相反   
        //直接舍弃第2位后面的所有小数   
        System.out.println(round(12.349,2,BigDecimal.ROUND_DOWN));//12.34   
        System.out.println(round(-12.349,2,BigDecimal.ROUND_DOWN));//-12.34   
        //ROUND_CEILING   
        //如果数字>0 则和ROUND_UP作用一样   
        //如果数字<0 则和ROUND_DOWN作用一样   
        System.out.println(round(12.3401,2,BigDecimal.ROUND_CEILING));//12.35   
        System.out.println(round(-12.349,2,BigDecimal.ROUND_CEILING));//-12.34   
        //ROUND_FLOOR   
        //如果数字>0 则和ROUND_DOWN作用一样   
        //如果数字<0 则和ROUND_UP作用一样   
        System.out.println(round(12.349,2,BigDecimal.ROUND_FLOOR));//12.34   
        System.out.println(round(-12.3401,2,BigDecimal.ROUND_FLOOR));//-12.35   
        //ROUND_HALF_UP [这种方法最常用]   
        //如果第3位数字>=5,则第2位数字+1   
        //备注:只看第3位数字的值,不会考虑第3位之后的小数的   
        System.out.println(round(12.345,2,BigDecimal.ROUND_HALF_UP));//12.35   
        System.out.println(round(12.3449,2,BigDecimal.ROUND_HALF_UP));//12.34   
        System.out.println(round(-12.345,2,BigDecimal.ROUND_HALF_UP));//-12.35   
        System.out.println(round(-12.3449,2,BigDecimal.ROUND_HALF_UP));//-12.34   
        //ROUND_HALF_DOWN   
        //如果第3位数字>=5,则做ROUND_UP   
        //如果第3位数字<5,则做ROUND_DOWN   
        System.out.println(round(12.345,2,BigDecimal.ROUND_HALF_DOWN));//12.35   
        System.out.println(round(12.3449,2,BigDecimal.ROUND_HALF_DOWN));//12.34   
        System.out.println(round(-12.345,2,BigDecimal.ROUND_HALF_DOWN));//-12.35   
        System.out.println(round(-12.3449,2,BigDecimal.ROUND_HALF_DOWN));//-12.34   
        //ROUND_HALF_EVEN   
        //如果第3位是偶数,则做ROUND_HALF_DOWN   
        //如果第3位是奇数,则做ROUND_HALF_UP   
        System.out.println(round(12.346,2,BigDecimal.ROUND_HALF_EVEN));//12.35   
        System.out.println(round(12.345,2,BigDecimal.ROUND_HALF_EVEN));//12.35   
    }   
}

这篇文章算说的比较详细的了，供参考。

document.getElementById(‘xxx’).innerHTML 适用于 IE和Firefox浏览器

document.getElementById(‘xxx’).innerText 只适用于IE浏览器

其次：
对于同一个对象，二者返回的内容不一样：
innerHTML 返回的是这个对象内部所有的代码，包括html与非html代码
而innerText只返回这个内部的非html代码。

看个例子：

源代码如下：

页面效果如下：

点击innerHTML的效果：

点击innerText的效果：

============首先先白活一下儿有可能是众所周知的概念，各位可以忽略此段直接到下一个无敌的分割线============
之前在使用linux系统时，经常会用到创建链接的操作，所谓链接，就是创建一个符号，将这个符号指向一个文件或者目录，
个人理解，也可以说是这个符号是指向文件或者目录的一个指针。

软链接也叫符号链接，关于这两种链接的区别，将在最后说明。

我在linux经常使用软链接，主要用途下面举个例子：

比如在编译apache之后，会产生如下目录，/usr/local/apache2.0/
这时的启动apache的命令就是：
/usr/local/apache2.0/bin/apachectl start

接下来，我要将apache2.0升级到apache2.2，
那么我的启动apache2.2的命令就是：
/usr/local/apache2.2/bin/apachectl start

现在，我要将系统中所有用到/usr/local/apache2.0/bin/apachectl start的地方（例如启动脚本，crontab等）
都换成/usr/local/apache2.2/bin/apachectl start

很累，万一想从2.2版本，切换回2.0版本，还要再都改一遍。

我的方法是创建一个软链接，在最开始编译好apache2.0时，创建软链接命令如下：

ln -s /usr/local/apache2.0/ /usr/local/apache2

这样，apache2就是apache2.0的一个软链接了，
现在，我的/usr/local/目录下除了apache2.0还有了apache2.2，
那么我只要取消原来的apache2软链接：
unlink /usr/local/apache2 【这里需要特别注意的是，apache2最后不要加”/”】
再重新创建软链接：
ln -s /usr/local/apache2.2/ /usr/local/apache2

这样，我其他地方启动apache的脚本统一写成：
/usr/local/apache2/bin/apachectl start

通过切换软链接的方式，来启动不同版本的apache，方便又省事儿，而且，如果从2.0切换至2.2之后，发现有问题，还可以通过这种方式快速的切换回2.0版本。

好了，贫了这么半天，来说说windows下如何创建链接吧，
今天发现电脑的E盘只剩下200多M了，一看自己的eclipse的workspace占用了6个多G，于是乎，有了转移workspace目录的想法，C盘还有10多个G，就放在C盘吧。

============windows自带的命令行下如何创建硬链接============

先来一句话说明windows创建硬链接的方法：
命令行中执行：
fsutil hardlink create <新文件名> <现有文件名>
例如：
fsutil hardlink create e:\target.txt e:\source.txt

则在E盘根目录创建了名为”target.txt”的，指向E盘根目录的source.txt的硬链接，需要说明的是：
硬链接文件有两个限制(Unix/Linux 和 Windows 也都如此)
(1) 不允许给目录创建硬链接；
(2) 只有在同一文件系统中的文件之间才能创建链接。

在windows下，创建硬链接还必须是在同一个卷(分区)下。

很显然，这个并不能符合我转移workspace的需求，于是乎～～～～～～
为了转移workspace后，不影响现在eclipse的使用，决定采用软链接的方式。
============windows如何创建软链接============

上网上搜索了资料，得知可以使用如下三种方法来实现，Junction，GNU utilities for Win32，Total Commander
（这三个软件在下面的”本文软件网址”中，都附有链接，可以到其网站上去下载）

下面分别说说这三种的不同用法以及主要区别，

情景：workspace转移后在c:\workspace，要求访问e:\workspace等于访问c:\workspace，

首先，Junction，
命令如下：
junction -s e:\workspace c:\workspace
加-s的意思是对子目录执行递归操作，
命令行会显示：
Created: e:\workspace
Targetted at: c:\workspace
好了，现在华丽的访问e:\workspace吧，已经跟c:\workspace一模一样了，
而且，我向e:\workspace加入了200M的文件，并没有占用E盘的空间，而是占用C盘的空间。

好，现在来删除e:\workspace软链接，使用如下命令：
junction -d e:\workspace
命令行会显示：Deleted e:\workspace.
这时的e:\workspace已经没有了，c:\workspace还完好无缺。

满足要求！

【网上有人提到过：
需要注意的是，Explorer 对待 symbolic link 有一个很奇怪的行为。
那就是，在 Explorer 里一个 symbolic link 跟被它 link 的目录没有区别，
删除这个 symbolic link 将会删除被 link 的目录下的所有文件！
】

但是我在vista系统下测试，删除了e:\workspace，c:\workspace仍然好好的存在。

————————————————–

再来看看GNU utilities for Win32
先下载，下载后，是个zip压缩包，解压缩后，会看到如下的一个目录结构：
UnxUtils\usr\local\wbin
这里面的N多命令，其中的ln.exe就是咱们要使用的来，
【PS：UnxUtils\bin这个目录下有个sh.exe，我一运行就报错，不用去管它，感觉这个就是个加载器，运行后会加载到它的shell环境中，
我把UnxUtils\usr\local\wbin设置在了系统的环境变量中，也可以和方便的在cmd中直接使用每个命令。】

像在linux下一样，在cmd中执行
ln -s c:\workspace e:\workspace
命令行提示：
ln: symbolic links are not supported on this system

阿门，不支持，放弃～～～正如网上所说，这个工具包的ln只能创建硬链接。
虽然ln不支持，但是这个软件包的其他命令还是很不错滴，例如grep，可以很方便的搜索windows文件了，要比windows的垃圾搜索好很多。

————————————————–

来看看Total Commander吧，
下载下来是个安装包，最新的版本已经内置了中文，安装时可以选择中文，并且可以不安装其他的语言，以节省空间。

下载，安装，并没有发现可以做软链接的功能，忽略。
但是这个作为资源管理器的替代者倒是很强大，又发现了个很好滴工具。

————————————————–

总结：在windows下创建软链接，使用junction。

============本文软件网址============

http://technet.microsoft.com/zh-cn/sysinternals/bb896768.aspx

Windows Sysinternals > 下载 > File and Disk Utilities > Junction v1.04

http://unxutils.sourceforge.net/

GNU utilities for Win32

http://www.ghisler.com/

Total Commander

============本文windows命令部分参考============

http://www.buaaer.com/bbs/viewthread.php?tid=3183

硬链结和符号链接的区别

http://answers.google.com/answers/threadview?id=341355

Q: how to create a symbolic link under Win2K, WinXP, and above?

http://rainux.org/ntfs-hard-linksymbolic-link

NTFS 下的硬链接(hard link)与符号链接(symbolic link)

============附：硬链结和符号链接的区别============

硬连接记录的是目标的 inode,符号连接记录的是目标的 path。
软连接就像是快捷方式,而硬连接就像是备份!符号连接可以做跨分区的 link；而 硬连接由于 inode 的缘故，只能在本分区中做 link.所以,符号连接的使用频率要高的多。

存在两种不同类型的链接，软链接和硬链接。修改其中一个，硬连接指向的是节点(inode),而软连接指向的是路径(path)

软链接文件

　　软链接又叫符号链接，这个文件包含了另一个文件的路径名。可以是任意文件或目录，可以链接不同文件系统的文件。和win下的快捷方式差不多。链接文件甚至可以链接不存在的文件，这就产生一般称之为”断链”的问题(或曰“现象”)，链接文件甚至可以循环链接自己。类似于编程语言中的递归。

命令格式：
代码:
ln [-s] source_path target_path

硬链接文件

　　info ln 命令告诉您，硬链接是已存在文件的另一个名字，硬连接的命令是

代码:
ln -d existfile newfile

引用:
硬链接文件有两个限制

　　1、不允许给目录创建硬链接；
　　2、只有在同一文件系统中的文件之间才能创建链接。

　　对硬链接文件进行读写和删除操作时候，结果和软链接相同。但如果我们删除硬链接文件的源文件，硬链接文件仍然存在，而且保留了愿有的内容。这时，系统就“忘记”了它曾经是硬链接文件。而把他当成一个普通文件。修改其中一个，与其连接的文件同时被修改

代码:
$umask 022
$ cp /etc/httpd/conf/httpd.conf /usr/sam

原来前面做的试验，改变了系统默认的umask值，现在改回来为022,
举个httpd.conf文件做例 子

代码:
$ ln httpd.conf httpd1.conf
$ ln -s httpd.conf httpd2.conf

第一条为硬链接，第二条为软链接

代码:
$ ls -li

代码:
总用量 80
1077669 -rw-r–r– 2 sam adm 34890 10月 31 00:57 httpd1.conf
1077668 lrwxrwxrwx 1 sam adm 10 10月 31 00:58 httpd2.conf ->; httpd.conf
1077669 -rw-r–r– 2 sam adm 34890 10月 31 00:57 httpd.conf

可以看到，使用ls -li，软连接只产生了10字节的快捷而已，硬连接却实实在在的的拷贝。最前面的inode硬链接和源文件是一样的，而软链接不一样，具体看一下回复

对http1.conf进行编辑，可以发现httpd.conf也发生了一样的变化

代码:
$ rm httpd.conf

现在删除链接的源文件，来比较不同之处

代码:
$ ls -l
总用量 44
drw-r–r– 2 sam adm 4096 10月 30 20:14 file6
-rw-r–r– 1 sam adm 34890 10月 31 00:57 httpd1.conf
lrwxrwxrwx 1 sam adm 10 10月 31 00:58 httpd2.conf ->; httpd.conf

我的结论就是:硬链结只有全部被删除的时候，文件才无法访问，但是软链接，只要他的源文件消失了，这个文件就无法访问了。软链接就是记录了文件路径的一种特殊文件。

1.将debugrun.bat复制到如下目录：

X:\…\BuildPro\jboss-4.0.3SP1\bin

其中，前面的“X:\…”为每个人的实际物理目录

2.打开debugrun.bat，找到如下内容并进行编辑

set DEBUG_OPTS=-Xdebug -Xnoagent -Djava.compiler=NONE -Xrunjdwp:transport=dt_socket,address=9595,server=y,suspend=n

其中，address=9595是端口号，待会儿需要在eclipse中填入的，这个可以改成你想要的，也可以不进行修改

3.双击debugrun.bat启动。

4.选择你的项目，点击工具栏中的debug按钮下的”Open Debug Diaglog…”

5.在弹出的窗口中，从左侧选择”Remote Java Application”，右键点击，选择”New”，会出现如下图：

如图，把端口号修改成debugrun中实际设置的端口号9595，然后点击”Apply”应用改变，然后点击”Debug”运行。

6.然后在eclipse中会出现如下视图，

这里就是待会儿要用到的debug试图了。

7.打开你的eclipse，首先选择一个程序来设置断点，例如：

8.好了，然后运行你的程序到你设置的断点，运行后再切换到eclipse，来看看debug视图

这个是debug窗口的左侧视图

这个是debug窗口的右侧视图

这个断点结束后，可以点击左侧视图的”Resume”来继续下面程序的执行

java中，基本数据类型都是传值，比如int，double，lang，
java中，对象都是传引用，
特例，String对象是传值操作
=赋值操作是传引用操作
克隆分为影子克隆和深克隆

下面以图片来说明各个不同的操作：

new出一个新的对象a1，在内存中开辟出一块新的区域给a1使用。

new出一个新的对象a1，在内存中开辟出一块新的区域给a1使用。同时，将a1赋值给a2，这时，也会分配内存给a2，但是a2存放的不是与a1一样的对象，而是指向a1的指针，或者说a2是a1的引用。

一个很直接的克隆例子，先new一个a1出来，然后使用a1克隆的方法给a2赋值，这是内存会分配两个区域给a1和a2分别使用，二者互不相干。

下面来说说影子克隆与深度克隆
所以影子克隆与深度克隆一个主要的区别就在于，如果一个对象A里的成员变量B是另外一个对象，影子克隆只是克隆出一份A，但是克隆出来的A里面的B还是一个指向原来A中的一个指针，而深度克隆就是出来的A中的B也是一个新的B，与原来A中的B互不相干，说的有些绕口，下面来看图。

先假定咱们有如下的class：
class B {……}
class A { B b;}
A中的一个成员变量b是B对象。

这张图说明的是影子克隆，影子克隆的结果就是a1与a2分配出了一块内存区域，b1分配出了一块内存区域，b2也是占用了内存区域，但是它是指向b1的一个指针，对b2进行改变会影响到b1跟着改变。

恩，这张图说明的就是深度克隆了，给b2分配了内存，但是这时不是指向b1的一个指针了，而是实实在在的B b2对象，对b2的改变与b1没有关系。

java的深度克隆与影子克隆的实现方法，可以参考下面的资料。

参考资料：
Java基本功——Reference

http://dreamhead.blogbus.com/logs/2005/05/1189478.html

JAVA中的指针,引用及对象的clone

http://www.ibm.com/developerworks/cn/java/l-jpointer/index.html

最近在使用Iterator迭代器遍历一个List，如果List里的元素满足一些条件，就要把这个List的这个元素给remove，或者给重新设置一个新值，remove很容易，在当前迭代的对象中直接调用remove方法即可。
但是要想改变元素的值，那就不可以了。

从网上搜资料，找到了ListIterator，先来简明扼要的说说二者最大的区别吧，
ListIterator迭代器可以增加元素，更新元素，并且可以从后往前的来对List进行迭代等等。

a.ListIterator有add()方法，可以向List中添加对象，而Iterator不能；
b.ListIterator和Iterator都有hasNext()和next()方法，可以实现顺序向后遍历，但是ListIterator有hasPrevious()和previous()方法，可以实现逆向（顺序向前）遍历。Iterator就不可以；
c.ListIterator可以定位当前的索引位置，nextIndex()和previousIndex()可以实现。Iterator没有此功能；
d.都可实现删除对象，但是ListIterator可以实现对象的修改，set()方法可以实现。Iierator仅能遍历，不能修改。

因为ListIterator的这些功能，可以实现对LinkedList等List数据结构的操作。其实，数组对象也可以用迭代器来实现。

1.每周是从周日开始算的
周日算每周的第一天，周六算每周的最后一天。

十二月：
日 一 二 三 四 五 六
13 14 15 16 17 18 19
20 21 …

这个引发出的问题，如果计算12月17日这一周的周六周日的日期，咱们期望得到的是：
周六：12月19日，周日：12月20日，
但是实际呢？
周六：12月19日，周日：12月13日

为什么呢？因为周日是这周的第一天，所以就这样了，在咱们得到这个值后，还需要进行处理，才能按照咱们的习惯使用。

2.接着第一个问题，那咱们能不能把每周的周一定为每周的第一天呢？
Calendar有这样一个方法，setFirstDayOfWeek()
我曾经这样使用：
Calendar c = Calendar.getIntance();
c.setFirstDayOfWeek(Calendar.MONDAY);
从表面很好理解，设定c对象的每周的第一天是周一，其实不然！
Calendar.MONDAY这个常量值就是2，不可改变。

3.每年中的月份不是1-12月，是0-11月。

4.从Date转换到Calendar用如下方法：
Date d = new Date();
Calendar c = Calendar.getIntance();
c.setTime(d);

5.从Calendar转换到Date用如下方法：
Calendar c = Calendar.getIntance();
c.getTime();

1

UPDATE TB SET FIELDNAME='FIELDNEWVALUE' WHERE xxx;

但是今天碰到了需要更新多个字段的情况，比如需要更新10个字段，前5个字段的值来自表A，中间三个字段值来自表B，最后两个字段值来自表C，
如果要是一个一个字段的写 f=’xxx’这样太麻烦了，于是乎上网搜索，发现了另外一种写法。

1
2
3
4
5
6
7

UPDATE TB SET (field1, field2, field3, field4......)
 = 
(SELECT field1, field2, field3, field4
 FROM A
 JOIN B ON xxx
 LEFT JOIN C ON xxx
 WHERE TB.ID=A.ID [AND xxxx]);

这个sql语句的意思就有些类似insert 常用的方法了，即首先在SET关键字后面写好待更新的字段列表，然后写“=”，在“=”后可以写一个联合查询，把需要的字段按照前面的顺序进行排列，再再WHERE子句中按照一定的条件进行关联，这样，update就可以了。

【分享点1：】
SELECT field1/field2 FROM TB;
当 field1的数值 > field2的数值时，除法得出的结果是<1的，即0.xxxxxx
这个时候在DB2的环境下SELECT出来的值是0
这个有两个解决方法

方法1：
DB CFG的一个参数MIN_DEC_DIV_3，这个参数在GET DB CFG FOR DB中并不会列出，但却可以修改。
数据库配置参数MIN_DEC_DIV_3会更改涉及小数的十进制算术运算的结果小数位。
默认值为No，则小数位计算为 31-p+s-s'。
如果设置为Yes，则小数位计算为 MAX(3, 31-p+s-s')。
这会导致十进制小数部分始终至少具有3位的小数位。精度始终为31。

这个方法貌似需要通过DBA对数据库进行设置，不太靠谱儿，有另外一种方法可以曲线救国，登场：

将sql语句修改为：

1

SELECT CAST(field1 AS DOUBLE)/field2 FROM TB;

就是先把field1转换成DOUBLE类型的，这样计算出来的就会得出小数点了，会显示出0.xxxxxx

【分享点2：】
额，接下来，需要对得出的小数点位数进行约束，那就用四舍五入吧，

1

SELECT ROUND(CAST(field1 AS DOUBLE)/field2, 2) FROM TB;

这个意思就是说四舍五入，保留两位小数点

【分享点三：】
但是如果field1或者field2有一个字段为NULL的话，那么结果为NULL，这个时候根据逻辑需要进行如下的一个操作，
如果数据列的值为NULL，将其设置为0，那么sql就要这么写

1

SELECT ROUND(COALESCE(CAST(field1 AS DOUBLE), 0)/field2, 2) FROM TB;

COALESCE这个函数系统的用法如下:
a. 输入参数为字符类型，且允许为空的，可以使用COALESCE(inputParameter,”)把NULL转换成”;
b. 输入类型为整型，且允许为空的，可以使用COALESCE(inputParameter,0)，把空转换成0；
c. 输入参数为字符类型，且是非空非空格的，可以使用COALESCE(inputParameter,”)把NULL转换成”，然后判断函数返回值是否为”；
d. 输入类型为整型，且是非空的，不需要使用COALESCE函数，直接使用IS NULL进行非空判断。

好，就这么多了，OVER。。。

参考：
DECIMAL数据类型相除后的精度和小数位和数据库配置参数

http://www-01.ibm.com/support/docview.wss?uid=csc1a671ee5bc525954a4825711c002d4edb

min_dec_div_3 － 十进制分隔小数位为 3 配置参数

http://publib.boulder.ibm.com/infocenter/db2luw/v8/index.jsp?topic=/com.ibm.db2.udb.doc/admin/r0004470.htm