Tower Jing::Thanksgiving

& Witty &

朋友们如果看下边儿有一大堆什么这个技术那个代码还有程序的看不懂，请直接自动快速的忽略，赶紧的蹂躏下边儿的内几个链接直接看我本人。
1.  减肥日记   2.  我，就TMD一俗人！！！   3.  生活 情感   4.  随来而去 随笔随想

javascript中Number的用法

javascript中，有Number这个对象，这个对象有两种用法：

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

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

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

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

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

这个知识点可以参考： 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

java BigDecimal.ROUND_UP和BigDecimal.ROUND_DOWN的用处

今天在工作中遇到了这样的一个需求，

一个小数，例如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等等，具体的效果可以自己实验下。

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

原文如下：
JAVA对double或者float的浮点数精度计算控制方法
文章分类:Java编程关键字: java double或者float的浮点数精度
★★★ 本篇为原创，需要引用转载的朋友请注明：《 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   
    }   
}

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

innerHTML 与 innerText的区别

首先，

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

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

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

看个例子：

源代码如下：

页面效果如下：

点击innerHTML的效果：

点击innerText的效果：

Windows系统创建软链接、硬链接的方法

Windows系统创建软链接、硬链接的方法

============首先先白活一下儿有可能是众所周知的概念，各位可以忽略此段直接到下一个无敌的分割线============
之前在使用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。

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

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

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

unxutils.sourceforge.net/

GNU utilities for Win32

www.ghisler.com/

Total Commander

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

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

硬链结和符号链接的区别

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

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

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

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

eclipse使用debugrun和jboss来调试断点

debugrun.zip是debugrun运行的批处理文件

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的传值与传引用

java的传值与传引用

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

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

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

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

Java中的ListIterator与Iterator的区别

Java中的ListIterator与Iterator的区别

最近在使用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数据结构的操作。其实，数组对象也可以用迭代器来实现。

java的Calendar对象需要注意的问题

java的Calendar对象需要注意的问题：

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();

db2中sql语句的另外一种update语句写法

一般的咱们常用的update语句结构如下：

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就可以了。

当遇到问题，而没有求助条件的情况下，应如何

当你遇到问题了，但是google百度都找不到解决方法，根据自己以往的经验也不能解决，想求助于人但是没有资源（比如昨天加班时别的同事都下班了），这个时候怎么办？

还是要遵守咱们的，自己思考问题的时间不能超过两个小时，以我昨天为例，一个在java application中调用jndi总是不成功，因为jndi是放在jboos或者tomcat这类容器中的，结果我就一直在试图single one解决这个问题。

其实，还有另外种方法，因为我昨天写了个添加数据库记录的service，所以要写个main方法来测试，因为没有jboos容器，一直测试不成功也解决不了jndi的调用问题，到了将近两点，已失败告终。

后来打车回家时候我在想，不应该用N多个小时来解决jndi的调用，没有求助环境，我可以先把其他的service写好，总结好遇到的问题，等到第二天上班有了同事在的时候再统一求助，这样时间规划上就会比我现在的情况要好的多。

以此为例，与大家共勉。
在时间安排上各位有什么好的建议，咱们也可以共同交流。